mjs/cosmjs
mjs/cosmjs
1
0
Fork 0
mirror of https://github.com/cosmos/cosmjs.git synced 2025-03-11 14:09:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

stargate: Remove generated codec

Browse Source
This commit is contained in:
willclarktech 2021-06-03 13:21:34 +02:00
parent a4c634ddae
commit 554d23dadd
No known key found for this signature in database
GPG Key ID: 551A86E2E398ADF7
45 changed files with 0 additions and 40156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1701
packages/stargate/src/codec/confio/proofs.ts
View File

File diff suppressed because it is too large Load Diff

387
packages/stargate/src/codec/cosmos/auth/v1beta1/auth.ts
View File

@ -1,387 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
import { Any } from "../../../google/protobuf/any";
export const protobufPackage = "cosmos.auth.v1beta1";
/**
* BaseAccount defines a base account type. It contains all the necessary fields
* for basic account functionality. Any custom account type should extend this
* type for additional functionality (e.g. vesting).
*/
export interface BaseAccount {
address: string;
pubKey?: Any;
accountNumber: Long;
sequence: Long;
}
/** ModuleAccount defines an account for modules that holds coins on a pool. */
export interface ModuleAccount {
baseAccount?: BaseAccount;
name: string;
permissions: string[];
}
/** Params defines the parameters for the auth module. */
export interface Params {
maxMemoCharacters: Long;
txSigLimit: Long;
txSizeCostPerByte: Long;
sigVerifyCostEd25519: Long;
sigVerifyCostSecp256k1: Long;
}
const baseBaseAccount: object = { address: "", accountNumber: Long.UZERO, sequence: Long.UZERO };
export const BaseAccount = {
encode(message: BaseAccount, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.address !== "") {
writer.uint32(10).string(message.address);
}
if (message.pubKey !== undefined) {
Any.encode(message.pubKey, writer.uint32(18).fork()).ldelim();
}
if (!message.accountNumber.isZero()) {
writer.uint32(24).uint64(message.accountNumber);
}
if (!message.sequence.isZero()) {
writer.uint32(32).uint64(message.sequence);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): BaseAccount {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseBaseAccount } as BaseAccount;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.address = reader.string();
break;
case 2:
message.pubKey = Any.decode(reader, reader.uint32());
break;
case 3:
message.accountNumber = reader.uint64() as Long;
break;
case 4:
message.sequence = reader.uint64() as Long;
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): BaseAccount {
const message = { ...baseBaseAccount } as BaseAccount;
if (object.address !== undefined && object.address !== null) {
message.address = String(object.address);
} else {
message.address = "";
}
if (object.pubKey !== undefined && object.pubKey !== null) {
message.pubKey = Any.fromJSON(object.pubKey);
} else {
message.pubKey = undefined;
}
if (object.accountNumber !== undefined && object.accountNumber !== null) {
message.accountNumber = Long.fromString(object.accountNumber);
} else {
message.accountNumber = Long.UZERO;
}
if (object.sequence !== undefined && object.sequence !== null) {
message.sequence = Long.fromString(object.sequence);
} else {
message.sequence = Long.UZERO;
}
return message;
},
toJSON(message: BaseAccount): unknown {
const obj: any = {};
message.address !== undefined && (obj.address = message.address);
message.pubKey !== undefined && (obj.pubKey = message.pubKey ? Any.toJSON(message.pubKey) : undefined);
message.accountNumber !== undefined &&
(obj.accountNumber = (message.accountNumber || Long.UZERO).toString());
message.sequence !== undefined && (obj.sequence = (message.sequence || Long.UZERO).toString());
return obj;
},
fromPartial(object: DeepPartial<BaseAccount>): BaseAccount {
const message = { ...baseBaseAccount } as BaseAccount;
if (object.address !== undefined && object.address !== null) {
message.address = object.address;
} else {
message.address = "";
}
if (object.pubKey !== undefined && object.pubKey !== null) {
message.pubKey = Any.fromPartial(object.pubKey);
} else {
message.pubKey = undefined;
}
if (object.accountNumber !== undefined && object.accountNumber !== null) {
message.accountNumber = object.accountNumber as Long;
} else {
message.accountNumber = Long.UZERO;
}
if (object.sequence !== undefined && object.sequence !== null) {
message.sequence = object.sequence as Long;
} else {
message.sequence = Long.UZERO;
}
return message;
},
};
const baseModuleAccount: object = { name: "", permissions: "" };
export const ModuleAccount = {
encode(message: ModuleAccount, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.baseAccount !== undefined) {
BaseAccount.encode(message.baseAccount, writer.uint32(10).fork()).ldelim();
}
if (message.name !== "") {
writer.uint32(18).string(message.name);
}
for (const v of message.permissions) {
writer.uint32(26).string(v!);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): ModuleAccount {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseModuleAccount } as ModuleAccount;
message.permissions = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.baseAccount = BaseAccount.decode(reader, reader.uint32());
break;
case 2:
message.name = reader.string();
break;
case 3:
message.permissions.push(reader.string());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): ModuleAccount {
const message = { ...baseModuleAccount } as ModuleAccount;
message.permissions = [];
if (object.baseAccount !== undefined && object.baseAccount !== null) {
message.baseAccount = BaseAccount.fromJSON(object.baseAccount);
} else {
message.baseAccount = undefined;
}
if (object.name !== undefined && object.name !== null) {
message.name = String(object.name);
} else {
message.name = "";
}
if (object.permissions !== undefined && object.permissions !== null) {
for (const e of object.permissions) {
message.permissions.push(String(e));
}
}
return message;
},
toJSON(message: ModuleAccount): unknown {
const obj: any = {};
message.baseAccount !== undefined &&
(obj.baseAccount = message.baseAccount ? BaseAccount.toJSON(message.baseAccount) : undefined);
message.name !== undefined && (obj.name = message.name);
if (message.permissions) {
obj.permissions = message.permissions.map((e) => e);
} else {
obj.permissions = [];
}
return obj;
},
fromPartial(object: DeepPartial<ModuleAccount>): ModuleAccount {
const message = { ...baseModuleAccount } as ModuleAccount;
message.permissions = [];
if (object.baseAccount !== undefined && object.baseAccount !== null) {
message.baseAccount = BaseAccount.fromPartial(object.baseAccount);
} else {
message.baseAccount = undefined;
}
if (object.name !== undefined && object.name !== null) {
message.name = object.name;
} else {
message.name = "";
}
if (object.permissions !== undefined && object.permissions !== null) {
for (const e of object.permissions) {
message.permissions.push(e);
}
}
return message;
},
};
const baseParams: object = {
maxMemoCharacters: Long.UZERO,
txSigLimit: Long.UZERO,
txSizeCostPerByte: Long.UZERO,
sigVerifyCostEd25519: Long.UZERO,
sigVerifyCostSecp256k1: Long.UZERO,
};
export const Params = {
encode(message: Params, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (!message.maxMemoCharacters.isZero()) {
writer.uint32(8).uint64(message.maxMemoCharacters);
}
if (!message.txSigLimit.isZero()) {
writer.uint32(16).uint64(message.txSigLimit);
}
if (!message.txSizeCostPerByte.isZero()) {
writer.uint32(24).uint64(message.txSizeCostPerByte);
}
if (!message.sigVerifyCostEd25519.isZero()) {
writer.uint32(32).uint64(message.sigVerifyCostEd25519);
}
if (!message.sigVerifyCostSecp256k1.isZero()) {
writer.uint32(40).uint64(message.sigVerifyCostSecp256k1);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): Params {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseParams } as Params;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.maxMemoCharacters = reader.uint64() as Long;
break;
case 2:
message.txSigLimit = reader.uint64() as Long;
break;
case 3:
message.txSizeCostPerByte = reader.uint64() as Long;
break;
case 4:
message.sigVerifyCostEd25519 = reader.uint64() as Long;
break;
case 5:
message.sigVerifyCostSecp256k1 = reader.uint64() as Long;
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): Params {
const message = { ...baseParams } as Params;
if (object.maxMemoCharacters !== undefined && object.maxMemoCharacters !== null) {
message.maxMemoCharacters = Long.fromString(object.maxMemoCharacters);
} else {
message.maxMemoCharacters = Long.UZERO;
}
if (object.txSigLimit !== undefined && object.txSigLimit !== null) {
message.txSigLimit = Long.fromString(object.txSigLimit);
} else {
message.txSigLimit = Long.UZERO;
}
if (object.txSizeCostPerByte !== undefined && object.txSizeCostPerByte !== null) {
message.txSizeCostPerByte = Long.fromString(object.txSizeCostPerByte);
} else {
message.txSizeCostPerByte = Long.UZERO;
}
if (object.sigVerifyCostEd25519 !== undefined && object.sigVerifyCostEd25519 !== null) {
message.sigVerifyCostEd25519 = Long.fromString(object.sigVerifyCostEd25519);
} else {
message.sigVerifyCostEd25519 = Long.UZERO;
}
if (object.sigVerifyCostSecp256k1 !== undefined && object.sigVerifyCostSecp256k1 !== null) {
message.sigVerifyCostSecp256k1 = Long.fromString(object.sigVerifyCostSecp256k1);
} else {
message.sigVerifyCostSecp256k1 = Long.UZERO;
}
return message;
},
toJSON(message: Params): unknown {
const obj: any = {};
message.maxMemoCharacters !== undefined &&
(obj.maxMemoCharacters = (message.maxMemoCharacters || Long.UZERO).toString());
message.txSigLimit !== undefined && (obj.txSigLimit = (message.txSigLimit || Long.UZERO).toString());
message.txSizeCostPerByte !== undefined &&
(obj.txSizeCostPerByte = (message.txSizeCostPerByte || Long.UZERO).toString());
message.sigVerifyCostEd25519 !== undefined &&
(obj.sigVerifyCostEd25519 = (message.sigVerifyCostEd25519 || Long.UZERO).toString());
message.sigVerifyCostSecp256k1 !== undefined &&
(obj.sigVerifyCostSecp256k1 = (message.sigVerifyCostSecp256k1 || Long.UZERO).toString());
return obj;
},
fromPartial(object: DeepPartial<Params>): Params {
const message = { ...baseParams } as Params;
if (object.maxMemoCharacters !== undefined && object.maxMemoCharacters !== null) {
message.maxMemoCharacters = object.maxMemoCharacters as Long;
} else {
message.maxMemoCharacters = Long.UZERO;
}
if (object.txSigLimit !== undefined && object.txSigLimit !== null) {
message.txSigLimit = object.txSigLimit as Long;
} else {
message.txSigLimit = Long.UZERO;
}
if (object.txSizeCostPerByte !== undefined && object.txSizeCostPerByte !== null) {
message.txSizeCostPerByte = object.txSizeCostPerByte as Long;
} else {
message.txSizeCostPerByte = Long.UZERO;
}
if (object.sigVerifyCostEd25519 !== undefined && object.sigVerifyCostEd25519 !== null) {
message.sigVerifyCostEd25519 = object.sigVerifyCostEd25519 as Long;
} else {
message.sigVerifyCostEd25519 = Long.UZERO;
}
if (object.sigVerifyCostSecp256k1 !== undefined && object.sigVerifyCostSecp256k1 !== null) {
message.sigVerifyCostSecp256k1 = object.sigVerifyCostSecp256k1 as Long;
} else {
message.sigVerifyCostSecp256k1 = Long.UZERO;
}
return message;
},
};
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

278
packages/stargate/src/codec/cosmos/auth/v1beta1/query.ts
View File

@ -1,278 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
import { Any } from "../../../google/protobuf/any";
import { Params } from "../../../cosmos/auth/v1beta1/auth";
export const protobufPackage = "cosmos.auth.v1beta1";
/** QueryAccountRequest is the request type for the Query/Account RPC method. */
export interface QueryAccountRequest {
/** address defines the address to query for. */
address: string;
}
/** QueryAccountResponse is the response type for the Query/Account RPC method. */
export interface QueryAccountResponse {
/** account defines the account of the corresponding address. */
account?: Any;
}
/** QueryParamsRequest is the request type for the Query/Params RPC method. */
export interface QueryParamsRequest {}
/** QueryParamsResponse is the response type for the Query/Params RPC method. */
export interface QueryParamsResponse {
/** params defines the parameters of the module. */
params?: Params;
}
const baseQueryAccountRequest: object = { address: "" };
export const QueryAccountRequest = {
encode(message: QueryAccountRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.address !== "") {
writer.uint32(10).string(message.address);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): QueryAccountRequest {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseQueryAccountRequest } as QueryAccountRequest;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.address = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): QueryAccountRequest {
const message = { ...baseQueryAccountRequest } as QueryAccountRequest;
if (object.address !== undefined && object.address !== null) {
message.address = String(object.address);
} else {
message.address = "";
}
return message;
},
toJSON(message: QueryAccountRequest): unknown {
const obj: any = {};
message.address !== undefined && (obj.address = message.address);
return obj;
},
fromPartial(object: DeepPartial<QueryAccountRequest>): QueryAccountRequest {
const message = { ...baseQueryAccountRequest } as QueryAccountRequest;
if (object.address !== undefined && object.address !== null) {
message.address = object.address;
} else {
message.address = "";
}
return message;
},
};
const baseQueryAccountResponse: object = {};
export const QueryAccountResponse = {
encode(message: QueryAccountResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.account !== undefined) {
Any.encode(message.account, writer.uint32(10).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): QueryAccountResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseQueryAccountResponse } as QueryAccountResponse;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.account = Any.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): QueryAccountResponse {
const message = { ...baseQueryAccountResponse } as QueryAccountResponse;
if (object.account !== undefined && object.account !== null) {
message.account = Any.fromJSON(object.account);
} else {
message.account = undefined;
}
return message;
},
toJSON(message: QueryAccountResponse): unknown {
const obj: any = {};
message.account !== undefined &&
(obj.account = message.account ? Any.toJSON(message.account) : undefined);
return obj;
},
fromPartial(object: DeepPartial<QueryAccountResponse>): QueryAccountResponse {
const message = { ...baseQueryAccountResponse } as QueryAccountResponse;
if (object.account !== undefined && object.account !== null) {
message.account = Any.fromPartial(object.account);
} else {
message.account = undefined;
}
return message;
},
};
const baseQueryParamsRequest: object = {};
export const QueryParamsRequest = {
encode(_: QueryParamsRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): QueryParamsRequest {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseQueryParamsRequest } as QueryParamsRequest;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(_: any): QueryParamsRequest {
const message = { ...baseQueryParamsRequest } as QueryParamsRequest;
return message;
},
toJSON(_: QueryParamsRequest): unknown {
const obj: any = {};
return obj;
},
fromPartial(_: DeepPartial<QueryParamsRequest>): QueryParamsRequest {
const message = { ...baseQueryParamsRequest } as QueryParamsRequest;
return message;
},
};
const baseQueryParamsResponse: object = {};
export const QueryParamsResponse = {
encode(message: QueryParamsResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.params !== undefined) {
Params.encode(message.params, writer.uint32(10).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): QueryParamsResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseQueryParamsResponse } as QueryParamsResponse;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.params = Params.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): QueryParamsResponse {
const message = { ...baseQueryParamsResponse } as QueryParamsResponse;
if (object.params !== undefined && object.params !== null) {
message.params = Params.fromJSON(object.params);
} else {
message.params = undefined;
}
return message;
},
toJSON(message: QueryParamsResponse): unknown {
const obj: any = {};
message.params !== undefined && (obj.params = message.params ? Params.toJSON(message.params) : undefined);
return obj;
},
fromPartial(object: DeepPartial<QueryParamsResponse>): QueryParamsResponse {
const message = { ...baseQueryParamsResponse } as QueryParamsResponse;
if (object.params !== undefined && object.params !== null) {
message.params = Params.fromPartial(object.params);
} else {
message.params = undefined;
}
return message;
},
};
/** Query defines the gRPC querier service. */
export interface Query {
/** Account returns account details based on address. */
Account(request: QueryAccountRequest): Promise<QueryAccountResponse>;
/** Params queries all parameters. */
Params(request: QueryParamsRequest): Promise<QueryParamsResponse>;
}
export class QueryClientImpl implements Query {
private readonly rpc: Rpc;
constructor(rpc: Rpc) {
this.rpc = rpc;
}
Account(request: QueryAccountRequest): Promise<QueryAccountResponse> {
const data = QueryAccountRequest.encode(request).finish();
const promise = this.rpc.request("cosmos.auth.v1beta1.Query", "Account", data);
return promise.then((data) => QueryAccountResponse.decode(new _m0.Reader(data)));
}
Params(request: QueryParamsRequest): Promise<QueryParamsResponse> {
const data = QueryParamsRequest.encode(request).finish();
const promise = this.rpc.request("cosmos.auth.v1beta1.Query", "Params", data);
return promise.then((data) => QueryParamsResponse.decode(new _m0.Reader(data)));
}
}
interface Rpc {
request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
}
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

673
packages/stargate/src/codec/cosmos/bank/v1beta1/bank.ts
View File

@ -1,673 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
import { Coin } from "../../../cosmos/base/v1beta1/coin";
export const protobufPackage = "cosmos.bank.v1beta1";
/** Params defines the parameters for the bank module. */
export interface Params {
sendEnabled: SendEnabled[];
defaultSendEnabled: boolean;
}
/**
* SendEnabled maps coin denom to a send_enabled status (whether a denom is
* sendable).
*/
export interface SendEnabled {
denom: string;
enabled: boolean;
}
/** Input models transaction input. */
export interface Input {
address: string;
coins: Coin[];
}
/** Output models transaction outputs. */
export interface Output {
address: string;
coins: Coin[];
}
/**
* Supply represents a struct that passively keeps track of the total supply
* amounts in the network.
*/
export interface Supply {
total: Coin[];
}
/**
* DenomUnit represents a struct that describes a given
* denomination unit of the basic token.
*/
export interface DenomUnit {
/** denom represents the string name of the given denom unit (e.g uatom). */
denom: string;
/**
* exponent represents power of 10 exponent that one must
* raise the base_denom to in order to equal the given DenomUnit's denom
* 1 denom = 1^exponent base_denom
* (e.g. with a base_denom of uatom, one can create a DenomUnit of 'atom' with
* exponent = 6, thus: 1 atom = 10^6 uatom).
*/
exponent: number;
/** aliases is a list of string aliases for the given denom */
aliases: string[];
}
/**
* Metadata represents a struct that describes
* a basic token.
*/
export interface Metadata {
description: string;
/** denom_units represents the list of DenomUnit's for a given coin */
denomUnits: DenomUnit[];
/** base represents the base denom (should be the DenomUnit with exponent = 0). */
base: string;
/**
* display indicates the suggested denom that should be
* displayed in clients.
*/
display: string;
}
const baseParams: object = { defaultSendEnabled: false };
export const Params = {
encode(message: Params, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
for (const v of message.sendEnabled) {
SendEnabled.encode(v!, writer.uint32(10).fork()).ldelim();
}
if (message.defaultSendEnabled === true) {
writer.uint32(16).bool(message.defaultSendEnabled);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): Params {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseParams } as Params;
message.sendEnabled = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.sendEnabled.push(SendEnabled.decode(reader, reader.uint32()));
break;
case 2:
message.defaultSendEnabled = reader.bool();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): Params {
const message = { ...baseParams } as Params;
message.sendEnabled = [];
if (object.sendEnabled !== undefined && object.sendEnabled !== null) {
for (const e of object.sendEnabled) {
message.sendEnabled.push(SendEnabled.fromJSON(e));
}
}
if (object.defaultSendEnabled !== undefined && object.defaultSendEnabled !== null) {
message.defaultSendEnabled = Boolean(object.defaultSendEnabled);
} else {
message.defaultSendEnabled = false;
}
return message;
},
toJSON(message: Params): unknown {
const obj: any = {};
if (message.sendEnabled) {
obj.sendEnabled = message.sendEnabled.map((e) => (e ? SendEnabled.toJSON(e) : undefined));
} else {
obj.sendEnabled = [];
}
message.defaultSendEnabled !== undefined && (obj.defaultSendEnabled = message.defaultSendEnabled);
return obj;
},
fromPartial(object: DeepPartial<Params>): Params {
const message = { ...baseParams } as Params;
message.sendEnabled = [];
if (object.sendEnabled !== undefined && object.sendEnabled !== null) {
for (const e of object.sendEnabled) {
message.sendEnabled.push(SendEnabled.fromPartial(e));
}
}
if (object.defaultSendEnabled !== undefined && object.defaultSendEnabled !== null) {
message.defaultSendEnabled = object.defaultSendEnabled;
} else {
message.defaultSendEnabled = false;
}
return message;
},
};
const baseSendEnabled: object = { denom: "", enabled: false };
export const SendEnabled = {
encode(message: SendEnabled, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.denom !== "") {
writer.uint32(10).string(message.denom);
}
if (message.enabled === true) {
writer.uint32(16).bool(message.enabled);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): SendEnabled {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseSendEnabled } as SendEnabled;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.denom = reader.string();
break;
case 2:
message.enabled = reader.bool();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): SendEnabled {
const message = { ...baseSendEnabled } as SendEnabled;
if (object.denom !== undefined && object.denom !== null) {
message.denom = String(object.denom);
} else {
message.denom = "";
}
if (object.enabled !== undefined && object.enabled !== null) {
message.enabled = Boolean(object.enabled);
} else {
message.enabled = false;
}
return message;
},
toJSON(message: SendEnabled): unknown {
const obj: any = {};
message.denom !== undefined && (obj.denom = message.denom);
message.enabled !== undefined && (obj.enabled = message.enabled);
return obj;
},
fromPartial(object: DeepPartial<SendEnabled>): SendEnabled {
const message = { ...baseSendEnabled } as SendEnabled;
if (object.denom !== undefined && object.denom !== null) {
message.denom = object.denom;
} else {
message.denom = "";
}
if (object.enabled !== undefined && object.enabled !== null) {
message.enabled = object.enabled;
} else {
message.enabled = false;
}
return message;
},
};
const baseInput: object = { address: "" };
export const Input = {
encode(message: Input, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.address !== "") {
writer.uint32(10).string(message.address);
}
for (const v of message.coins) {
Coin.encode(v!, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): Input {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseInput } as Input;
message.coins = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.address = reader.string();
break;
case 2:
message.coins.push(Coin.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): Input {
const message = { ...baseInput } as Input;
message.coins = [];
if (object.address !== undefined && object.address !== null) {
message.address = String(object.address);
} else {
message.address = "";
}
if (object.coins !== undefined && object.coins !== null) {
for (const e of object.coins) {
message.coins.push(Coin.fromJSON(e));
}
}
return message;
},
toJSON(message: Input): unknown {
const obj: any = {};
message.address !== undefined && (obj.address = message.address);
if (message.coins) {
obj.coins = message.coins.map((e) => (e ? Coin.toJSON(e) : undefined));
} else {
obj.coins = [];
}
return obj;
},
fromPartial(object: DeepPartial<Input>): Input {
const message = { ...baseInput } as Input;
message.coins = [];
if (object.address !== undefined && object.address !== null) {
message.address = object.address;
} else {
message.address = "";
}
if (object.coins !== undefined && object.coins !== null) {
for (const e of object.coins) {
message.coins.push(Coin.fromPartial(e));
}
}
return message;
},
};
const baseOutput: object = { address: "" };
export const Output = {
encode(message: Output, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.address !== "") {
writer.uint32(10).string(message.address);
}
for (const v of message.coins) {
Coin.encode(v!, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): Output {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseOutput } as Output;
message.coins = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.address = reader.string();
break;
case 2:
message.coins.push(Coin.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): Output {
const message = { ...baseOutput } as Output;
message.coins = [];
if (object.address !== undefined && object.address !== null) {
message.address = String(object.address);
} else {
message.address = "";
}
if (object.coins !== undefined && object.coins !== null) {
for (const e of object.coins) {
message.coins.push(Coin.fromJSON(e));
}
}
return message;
},
toJSON(message: Output): unknown {
const obj: any = {};
message.address !== undefined && (obj.address = message.address);
if (message.coins) {
obj.coins = message.coins.map((e) => (e ? Coin.toJSON(e) : undefined));
} else {
obj.coins = [];
}
return obj;
},
fromPartial(object: DeepPartial<Output>): Output {
const message = { ...baseOutput } as Output;
message.coins = [];
if (object.address !== undefined && object.address !== null) {
message.address = object.address;
} else {
message.address = "";
}
if (object.coins !== undefined && object.coins !== null) {
for (const e of object.coins) {
message.coins.push(Coin.fromPartial(e));
}
}
return message;
},
};
const baseSupply: object = {};
export const Supply = {
encode(message: Supply, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
for (const v of message.total) {
Coin.encode(v!, writer.uint32(10).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): Supply {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseSupply } as Supply;
message.total = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.total.push(Coin.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): Supply {
const message = { ...baseSupply } as Supply;
message.total = [];
if (object.total !== undefined && object.total !== null) {
for (const e of object.total) {
message.total.push(Coin.fromJSON(e));
}
}
return message;
},
toJSON(message: Supply): unknown {
const obj: any = {};
if (message.total) {
obj.total = message.total.map((e) => (e ? Coin.toJSON(e) : undefined));
} else {
obj.total = [];
}
return obj;
},
fromPartial(object: DeepPartial<Supply>): Supply {
const message = { ...baseSupply } as Supply;
message.total = [];
if (object.total !== undefined && object.total !== null) {
for (const e of object.total) {
message.total.push(Coin.fromPartial(e));
}
}
return message;
},
};
const baseDenomUnit: object = { denom: "", exponent: 0, aliases: "" };
export const DenomUnit = {
encode(message: DenomUnit, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.denom !== "") {
writer.uint32(10).string(message.denom);
}
if (message.exponent !== 0) {
writer.uint32(16).uint32(message.exponent);
}
for (const v of message.aliases) {
writer.uint32(26).string(v!);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): DenomUnit {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseDenomUnit } as DenomUnit;
message.aliases = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.denom = reader.string();
break;
case 2:
message.exponent = reader.uint32();
break;
case 3:
message.aliases.push(reader.string());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): DenomUnit {
const message = { ...baseDenomUnit } as DenomUnit;
message.aliases = [];
if (object.denom !== undefined && object.denom !== null) {
message.denom = String(object.denom);
} else {
message.denom = "";
}
if (object.exponent !== undefined && object.exponent !== null) {
message.exponent = Number(object.exponent);
} else {
message.exponent = 0;
}
if (object.aliases !== undefined && object.aliases !== null) {
for (const e of object.aliases) {
message.aliases.push(String(e));
}
}
return message;
},
toJSON(message: DenomUnit): unknown {
const obj: any = {};
message.denom !== undefined && (obj.denom = message.denom);
message.exponent !== undefined && (obj.exponent = message.exponent);
if (message.aliases) {
obj.aliases = message.aliases.map((e) => e);
} else {
obj.aliases = [];
}
return obj;
},
fromPartial(object: DeepPartial<DenomUnit>): DenomUnit {
const message = { ...baseDenomUnit } as DenomUnit;
message.aliases = [];
if (object.denom !== undefined && object.denom !== null) {
message.denom = object.denom;
} else {
message.denom = "";
}
if (object.exponent !== undefined && object.exponent !== null) {
message.exponent = object.exponent;
} else {
message.exponent = 0;
}
if (object.aliases !== undefined && object.aliases !== null) {
for (const e of object.aliases) {
message.aliases.push(e);
}
}
return message;
},
};
const baseMetadata: object = { description: "", base: "", display: "" };
export const Metadata = {
encode(message: Metadata, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.description !== "") {
writer.uint32(10).string(message.description);
}
for (const v of message.denomUnits) {
DenomUnit.encode(v!, writer.uint32(18).fork()).ldelim();
}
if (message.base !== "") {
writer.uint32(26).string(message.base);
}
if (message.display !== "") {
writer.uint32(34).string(message.display);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): Metadata {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMetadata } as Metadata;
message.denomUnits = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.description = reader.string();
break;
case 2:
message.denomUnits.push(DenomUnit.decode(reader, reader.uint32()));
break;
case 3:
message.base = reader.string();
break;
case 4:
message.display = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): Metadata {
const message = { ...baseMetadata } as Metadata;
message.denomUnits = [];
if (object.description !== undefined && object.description !== null) {
message.description = String(object.description);
} else {
message.description = "";
}
if (object.denomUnits !== undefined && object.denomUnits !== null) {
for (const e of object.denomUnits) {
message.denomUnits.push(DenomUnit.fromJSON(e));
}
}
if (object.base !== undefined && object.base !== null) {
message.base = String(object.base);
} else {
message.base = "";
}
if (object.display !== undefined && object.display !== null) {
message.display = String(object.display);
} else {
message.display = "";
}
return message;
},
toJSON(message: Metadata): unknown {
const obj: any = {};
message.description !== undefined && (obj.description = message.description);
if (message.denomUnits) {
obj.denomUnits = message.denomUnits.map((e) => (e ? DenomUnit.toJSON(e) : undefined));
} else {
obj.denomUnits = [];
}
message.base !== undefined && (obj.base = message.base);
message.display !== undefined && (obj.display = message.display);
return obj;
},
fromPartial(object: DeepPartial<Metadata>): Metadata {
const message = { ...baseMetadata } as Metadata;
message.denomUnits = [];
if (object.description !== undefined && object.description !== null) {
message.description = object.description;
} else {
message.description = "";
}
if (object.denomUnits !== undefined && object.denomUnits !== null) {
for (const e of object.denomUnits) {
message.denomUnits.push(DenomUnit.fromPartial(e));
}
}
if (object.base !== undefined && object.base !== null) {
message.base = object.base;
} else {
message.base = "";
}
if (object.display !== undefined && object.display !== null) {
message.display = object.display;
} else {
message.display = "";
}
return message;
},
};
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

1025
packages/stargate/src/codec/cosmos/bank/v1beta1/query.ts
View File

File diff suppressed because it is too large Load Diff

330
packages/stargate/src/codec/cosmos/bank/v1beta1/tx.ts
View File

@ -1,330 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
import { Coin } from "../../../cosmos/base/v1beta1/coin";
import { Input, Output } from "../../../cosmos/bank/v1beta1/bank";
export const protobufPackage = "cosmos.bank.v1beta1";
/** MsgSend represents a message to send coins from one account to another. */
export interface MsgSend {
fromAddress: string;
toAddress: string;
amount: Coin[];
}
/** MsgSendResponse defines the Msg/Send response type. */
export interface MsgSendResponse {}
/** MsgMultiSend represents an arbitrary multi-in, multi-out send message. */
export interface MsgMultiSend {
inputs: Input[];
outputs: Output[];
}
/** MsgMultiSendResponse defines the Msg/MultiSend response type. */
export interface MsgMultiSendResponse {}
const baseMsgSend: object = { fromAddress: "", toAddress: "" };
export const MsgSend = {
encode(message: MsgSend, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.fromAddress !== "") {
writer.uint32(10).string(message.fromAddress);
}
if (message.toAddress !== "") {
writer.uint32(18).string(message.toAddress);
}
for (const v of message.amount) {
Coin.encode(v!, writer.uint32(26).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgSend {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgSend } as MsgSend;
message.amount = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.fromAddress = reader.string();
break;
case 2:
message.toAddress = reader.string();
break;
case 3:
message.amount.push(Coin.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): MsgSend {
const message = { ...baseMsgSend } as MsgSend;
message.amount = [];
if (object.fromAddress !== undefined && object.fromAddress !== null) {
message.fromAddress = String(object.fromAddress);
} else {
message.fromAddress = "";
}
if (object.toAddress !== undefined && object.toAddress !== null) {
message.toAddress = String(object.toAddress);
} else {
message.toAddress = "";
}
if (object.amount !== undefined && object.amount !== null) {
for (const e of object.amount) {
message.amount.push(Coin.fromJSON(e));
}
}
return message;
},
toJSON(message: MsgSend): unknown {
const obj: any = {};
message.fromAddress !== undefined && (obj.fromAddress = message.fromAddress);
message.toAddress !== undefined && (obj.toAddress = message.toAddress);
if (message.amount) {
obj.amount = message.amount.map((e) => (e ? Coin.toJSON(e) : undefined));
} else {
obj.amount = [];
}
return obj;
},
fromPartial(object: DeepPartial<MsgSend>): MsgSend {
const message = { ...baseMsgSend } as MsgSend;
message.amount = [];
if (object.fromAddress !== undefined && object.fromAddress !== null) {
message.fromAddress = object.fromAddress;
} else {
message.fromAddress = "";
}
if (object.toAddress !== undefined && object.toAddress !== null) {
message.toAddress = object.toAddress;
} else {
message.toAddress = "";
}
if (object.amount !== undefined && object.amount !== null) {
for (const e of object.amount) {
message.amount.push(Coin.fromPartial(e));
}
}
return message;
},
};
const baseMsgSendResponse: object = {};
export const MsgSendResponse = {
encode(_: MsgSendResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgSendResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgSendResponse } as MsgSendResponse;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(_: any): MsgSendResponse {
const message = { ...baseMsgSendResponse } as MsgSendResponse;
return message;
},
toJSON(_: MsgSendResponse): unknown {
const obj: any = {};
return obj;
},
fromPartial(_: DeepPartial<MsgSendResponse>): MsgSendResponse {
const message = { ...baseMsgSendResponse } as MsgSendResponse;
return message;
},
};
const baseMsgMultiSend: object = {};
export const MsgMultiSend = {
encode(message: MsgMultiSend, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
for (const v of message.inputs) {
Input.encode(v!, writer.uint32(10).fork()).ldelim();
}
for (const v of message.outputs) {
Output.encode(v!, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgMultiSend {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgMultiSend } as MsgMultiSend;
message.inputs = [];
message.outputs = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.inputs.push(Input.decode(reader, reader.uint32()));
break;
case 2:
message.outputs.push(Output.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): MsgMultiSend {
const message = { ...baseMsgMultiSend } as MsgMultiSend;
message.inputs = [];
message.outputs = [];
if (object.inputs !== undefined && object.inputs !== null) {
for (const e of object.inputs) {
message.inputs.push(Input.fromJSON(e));
}
}
if (object.outputs !== undefined && object.outputs !== null) {
for (const e of object.outputs) {
message.outputs.push(Output.fromJSON(e));
}
}
return message;
},
toJSON(message: MsgMultiSend): unknown {
const obj: any = {};
if (message.inputs) {
obj.inputs = message.inputs.map((e) => (e ? Input.toJSON(e) : undefined));
} else {
obj.inputs = [];
}
if (message.outputs) {
obj.outputs = message.outputs.map((e) => (e ? Output.toJSON(e) : undefined));
} else {
obj.outputs = [];
}
return obj;
},
fromPartial(object: DeepPartial<MsgMultiSend>): MsgMultiSend {
const message = { ...baseMsgMultiSend } as MsgMultiSend;
message.inputs = [];
message.outputs = [];
if (object.inputs !== undefined && object.inputs !== null) {
for (const e of object.inputs) {
message.inputs.push(Input.fromPartial(e));
}
}
if (object.outputs !== undefined && object.outputs !== null) {
for (const e of object.outputs) {
message.outputs.push(Output.fromPartial(e));
}
}
return message;
},
};
const baseMsgMultiSendResponse: object = {};
export const MsgMultiSendResponse = {
encode(_: MsgMultiSendResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgMultiSendResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgMultiSendResponse } as MsgMultiSendResponse;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(_: any): MsgMultiSendResponse {
const message = { ...baseMsgMultiSendResponse } as MsgMultiSendResponse;
return message;
},
toJSON(_: MsgMultiSendResponse): unknown {
const obj: any = {};
return obj;
},
fromPartial(_: DeepPartial<MsgMultiSendResponse>): MsgMultiSendResponse {
const message = { ...baseMsgMultiSendResponse } as MsgMultiSendResponse;
return message;
},
};
/** Msg defines the bank Msg service. */
export interface Msg {
/** Send defines a method for sending coins from one account to another account. */
Send(request: MsgSend): Promise<MsgSendResponse>;
/** MultiSend defines a method for sending coins from some accounts to other accounts. */
MultiSend(request: MsgMultiSend): Promise<MsgMultiSendResponse>;
}
export class MsgClientImpl implements Msg {
private readonly rpc: Rpc;
constructor(rpc: Rpc) {
this.rpc = rpc;
}
Send(request: MsgSend): Promise<MsgSendResponse> {
const data = MsgSend.encode(request).finish();
const promise = this.rpc.request("cosmos.bank.v1beta1.Msg", "Send", data);
return promise.then((data) => MsgSendResponse.decode(new _m0.Reader(data)));
}
MultiSend(request: MsgMultiSend): Promise<MsgMultiSendResponse> {
const data = MsgMultiSend.encode(request).finish();
const promise = this.rpc.request("cosmos.bank.v1beta1.Msg", "MultiSend", data);
return promise.then((data) => MsgMultiSendResponse.decode(new _m0.Reader(data)));
}
}
interface Rpc {
request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
}
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

1224
packages/stargate/src/codec/cosmos/base/abci/v1beta1/abci.ts
View File

File diff suppressed because it is too large Load Diff

290
packages/stargate/src/codec/cosmos/base/query/v1beta1/pagination.ts
View File

@ -1,290 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
export const protobufPackage = "cosmos.base.query.v1beta1";
/**
* PageRequest is to be embedded in gRPC request messages for efficient
* pagination. Ex:
*
* message SomeRequest {
* Foo some_parameter = 1;
* PageRequest pagination = 2;
* }
*/
export interface PageRequest {
/**
* key is a value returned in PageResponse.next_key to begin
* querying the next page most efficiently. Only one of offset or key
* should be set.
*/
key: Uint8Array;
/**
* offset is a numeric offset that can be used when key is unavailable.
* It is less efficient than using key. Only one of offset or key should
* be set.
*/
offset: Long;
/**
* limit is the total number of results to be returned in the result page.
* If left empty it will default to a value to be set by each app.
*/
limit: Long;
/**
* count_total is set to true to indicate that the result set should include
* a count of the total number of items available for pagination in UIs.
* count_total is only respected when offset is used. It is ignored when key
* is set.
*/
countTotal: boolean;
}
/**
* PageResponse is to be embedded in gRPC response messages where the
* corresponding request message has used PageRequest.
*
* message SomeResponse {
* repeated Bar results = 1;
* PageResponse page = 2;
* }
*/
export interface PageResponse {
/**
* next_key is the key to be passed to PageRequest.key to
* query the next page most efficiently
*/
nextKey: Uint8Array;
/**
* total is total number of results available if PageRequest.count_total
* was set, its value is undefined otherwise
*/
total: Long;
}
const basePageRequest: object = { offset: Long.UZERO, limit: Long.UZERO, countTotal: false };
export const PageRequest = {
encode(message: PageRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.key.length !== 0) {
writer.uint32(10).bytes(message.key);
}
if (!message.offset.isZero()) {
writer.uint32(16).uint64(message.offset);
}
if (!message.limit.isZero()) {
writer.uint32(24).uint64(message.limit);
}
if (message.countTotal === true) {
writer.uint32(32).bool(message.countTotal);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): PageRequest {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...basePageRequest } as PageRequest;
message.key = new Uint8Array();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.key = reader.bytes();
break;
case 2:
message.offset = reader.uint64() as Long;
break;
case 3:
message.limit = reader.uint64() as Long;
break;
case 4:
message.countTotal = reader.bool();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): PageRequest {
const message = { ...basePageRequest } as PageRequest;
message.key = new Uint8Array();
if (object.key !== undefined && object.key !== null) {
message.key = bytesFromBase64(object.key);
}
if (object.offset !== undefined && object.offset !== null) {
message.offset = Long.fromString(object.offset);
} else {
message.offset = Long.UZERO;
}
if (object.limit !== undefined && object.limit !== null) {
message.limit = Long.fromString(object.limit);
} else {
message.limit = Long.UZERO;
}
if (object.countTotal !== undefined && object.countTotal !== null) {
message.countTotal = Boolean(object.countTotal);
} else {
message.countTotal = false;
}
return message;
},
toJSON(message: PageRequest): unknown {
const obj: any = {};
message.key !== undefined &&
(obj.key = base64FromBytes(message.key !== undefined ? message.key : new Uint8Array()));
message.offset !== undefined && (obj.offset = (message.offset || Long.UZERO).toString());
message.limit !== undefined && (obj.limit = (message.limit || Long.UZERO).toString());
message.countTotal !== undefined && (obj.countTotal = message.countTotal);
return obj;
},
fromPartial(object: DeepPartial<PageRequest>): PageRequest {
const message = { ...basePageRequest } as PageRequest;
if (object.key !== undefined && object.key !== null) {
message.key = object.key;
} else {
message.key = new Uint8Array();
}
if (object.offset !== undefined && object.offset !== null) {
message.offset = object.offset as Long;
} else {
message.offset = Long.UZERO;
}
if (object.limit !== undefined && object.limit !== null) {
message.limit = object.limit as Long;
} else {
message.limit = Long.UZERO;
}
if (object.countTotal !== undefined && object.countTotal !== null) {
message.countTotal = object.countTotal;
} else {
message.countTotal = false;
}
return message;
},
};
const basePageResponse: object = { total: Long.UZERO };
export const PageResponse = {
encode(message: PageResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.nextKey.length !== 0) {
writer.uint32(10).bytes(message.nextKey);
}
if (!message.total.isZero()) {
writer.uint32(16).uint64(message.total);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): PageResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...basePageResponse } as PageResponse;
message.nextKey = new Uint8Array();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.nextKey = reader.bytes();
break;
case 2:
message.total = reader.uint64() as Long;
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): PageResponse {
const message = { ...basePageResponse } as PageResponse;
message.nextKey = new Uint8Array();
if (object.nextKey !== undefined && object.nextKey !== null) {
message.nextKey = bytesFromBase64(object.nextKey);
}
if (object.total !== undefined && object.total !== null) {
message.total = Long.fromString(object.total);
} else {
message.total = Long.UZERO;
}
return message;
},
toJSON(message: PageResponse): unknown {
const obj: any = {};
message.nextKey !== undefined &&
(obj.nextKey = base64FromBytes(message.nextKey !== undefined ? message.nextKey : new Uint8Array()));
message.total !== undefined && (obj.total = (message.total || Long.UZERO).toString());
return obj;
},
fromPartial(object: DeepPartial<PageResponse>): PageResponse {
const message = { ...basePageResponse } as PageResponse;
if (object.nextKey !== undefined && object.nextKey !== null) {
message.nextKey = object.nextKey;
} else {
message.nextKey = new Uint8Array();
}
if (object.total !== undefined && object.total !== null) {
message.total = object.total as Long;
} else {
message.total = Long.UZERO;
}
return message;
},
};
declare var self: any | undefined;
declare var window: any | undefined;
var globalThis: any = (() => {
if (typeof globalThis !== "undefined") return globalThis;
if (typeof self !== "undefined") return self;
if (typeof window !== "undefined") return window;
if (typeof global !== "undefined") return global;
throw "Unable to locate global object";
})();
const atob: (b64: string) => string =
globalThis.atob || ((b64) => globalThis.Buffer.from(b64, "base64").toString("binary"));
function bytesFromBase64(b64: string): Uint8Array {
const bin = atob(b64);
const arr = new Uint8Array(bin.length);
for (let i = 0; i < bin.length; ++i) {
arr[i] = bin.charCodeAt(i);
}
return arr;
}
const btoa: (bin: string) => string =
globalThis.btoa || ((bin) => globalThis.Buffer.from(bin, "binary").toString("base64"));
function base64FromBytes(arr: Uint8Array): string {
const bin: string[] = [];
for (let i = 0; i < arr.byteLength; ++i) {
bin.push(String.fromCharCode(arr[i]));
}
return btoa(bin.join(""));
}
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

307
packages/stargate/src/codec/cosmos/base/v1beta1/coin.ts
View File

@ -1,307 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
export const protobufPackage = "cosmos.base.v1beta1";
/**
* Coin defines a token with a denomination and an amount.
*
* NOTE: The amount field is an Int which implements the custom method
* signatures required by gogoproto.
*/
export interface Coin {
denom: string;
amount: string;
}
/**
* DecCoin defines a token with a denomination and a decimal amount.
*
* NOTE: The amount field is an Dec which implements the custom method
* signatures required by gogoproto.
*/
export interface DecCoin {
denom: string;
amount: string;
}
/** IntProto defines a Protobuf wrapper around an Int object. */
export interface IntProto {
int: string;
}
/** DecProto defines a Protobuf wrapper around a Dec object. */
export interface DecProto {
dec: string;
}
const baseCoin: object = { denom: "", amount: "" };
export const Coin = {
encode(message: Coin, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.denom !== "") {
writer.uint32(10).string(message.denom);
}
if (message.amount !== "") {
writer.uint32(18).string(message.amount);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): Coin {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseCoin } as Coin;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.denom = reader.string();
break;
case 2:
message.amount = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): Coin {
const message = { ...baseCoin } as Coin;
if (object.denom !== undefined && object.denom !== null) {
message.denom = String(object.denom);
} else {
message.denom = "";
}
if (object.amount !== undefined && object.amount !== null) {
message.amount = String(object.amount);
} else {
message.amount = "";
}
return message;
},
toJSON(message: Coin): unknown {
const obj: any = {};
message.denom !== undefined && (obj.denom = message.denom);
message.amount !== undefined && (obj.amount = message.amount);
return obj;
},
fromPartial(object: DeepPartial<Coin>): Coin {
const message = { ...baseCoin } as Coin;
if (object.denom !== undefined && object.denom !== null) {
message.denom = object.denom;
} else {
message.denom = "";
}
if (object.amount !== undefined && object.amount !== null) {
message.amount = object.amount;
} else {
message.amount = "";
}
return message;
},
};
const baseDecCoin: object = { denom: "", amount: "" };
export const DecCoin = {
encode(message: DecCoin, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.denom !== "") {
writer.uint32(10).string(message.denom);
}
if (message.amount !== "") {
writer.uint32(18).string(message.amount);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): DecCoin {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseDecCoin } as DecCoin;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.denom = reader.string();
break;
case 2:
message.amount = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): DecCoin {
const message = { ...baseDecCoin } as DecCoin;
if (object.denom !== undefined && object.denom !== null) {
message.denom = String(object.denom);
} else {
message.denom = "";
}
if (object.amount !== undefined && object.amount !== null) {
message.amount = String(object.amount);
} else {
message.amount = "";
}
return message;
},
toJSON(message: DecCoin): unknown {
const obj: any = {};
message.denom !== undefined && (obj.denom = message.denom);
message.amount !== undefined && (obj.amount = message.amount);
return obj;
},
fromPartial(object: DeepPartial<DecCoin>): DecCoin {
const message = { ...baseDecCoin } as DecCoin;
if (object.denom !== undefined && object.denom !== null) {
message.denom = object.denom;
} else {
message.denom = "";
}
if (object.amount !== undefined && object.amount !== null) {
message.amount = object.amount;
} else {
message.amount = "";
}
return message;
},
};
const baseIntProto: object = { int: "" };
export const IntProto = {
encode(message: IntProto, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.int !== "") {
writer.uint32(10).string(message.int);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): IntProto {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseIntProto } as IntProto;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.int = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): IntProto {
const message = { ...baseIntProto } as IntProto;
if (object.int !== undefined && object.int !== null) {
message.int = String(object.int);
} else {
message.int = "";
}
return message;
},
toJSON(message: IntProto): unknown {
const obj: any = {};
message.int !== undefined && (obj.int = message.int);
return obj;
},
fromPartial(object: DeepPartial<IntProto>): IntProto {
const message = { ...baseIntProto } as IntProto;
if (object.int !== undefined && object.int !== null) {
message.int = object.int;
} else {
message.int = "";
}
return message;
},
};
const baseDecProto: object = { dec: "" };
export const DecProto = {
encode(message: DecProto, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.dec !== "") {
writer.uint32(10).string(message.dec);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): DecProto {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseDecProto } as DecProto;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.dec = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): DecProto {
const message = { ...baseDecProto } as DecProto;
if (object.dec !== undefined && object.dec !== null) {
message.dec = String(object.dec);
} else {
message.dec = "";
}
return message;
},
toJSON(message: DecProto): unknown {
const obj: any = {};
message.dec !== undefined && (obj.dec = message.dec);
return obj;
},
fromPartial(object: DeepPartial<DecProto>): DecProto {
const message = { ...baseDecProto } as DecProto;
if (object.dec !== undefined && object.dec !== null) {
message.dec = object.dec;
} else {
message.dec = "";
}
return message;
},
};
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

207
packages/stargate/src/codec/cosmos/crypto/multisig/v1beta1/multisig.ts
View File

@ -1,207 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
export const protobufPackage = "cosmos.crypto.multisig.v1beta1";
/**
* MultiSignature wraps the signatures from a multisig.LegacyAminoPubKey.
* See cosmos.tx.v1betata1.ModeInfo.Multi for how to specify which signers
* signed and with which modes.
*/
export interface MultiSignature {
signatures: Uint8Array[];
}
/**
* CompactBitArray is an implementation of a space efficient bit array.
* This is used to ensure that the encoded data takes up a minimal amount of
* space after proto encoding.
* This is not thread safe, and is not intended for concurrent usage.
*/
export interface CompactBitArray {
extraBitsStored: number;
elems: Uint8Array;
}
const baseMultiSignature: object = {};
export const MultiSignature = {
encode(message: MultiSignature, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
for (const v of message.signatures) {
writer.uint32(10).bytes(v!);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MultiSignature {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMultiSignature } as MultiSignature;
message.signatures = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.signatures.push(reader.bytes());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): MultiSignature {
const message = { ...baseMultiSignature } as MultiSignature;
message.signatures = [];
if (object.signatures !== undefined && object.signatures !== null) {
for (const e of object.signatures) {
message.signatures.push(bytesFromBase64(e));
}
}
return message;
},
toJSON(message: MultiSignature): unknown {
const obj: any = {};
if (message.signatures) {
obj.signatures = message.signatures.map((e) => base64FromBytes(e !== undefined ? e : new Uint8Array()));
} else {
obj.signatures = [];
}
return obj;
},
fromPartial(object: DeepPartial<MultiSignature>): MultiSignature {
const message = { ...baseMultiSignature } as MultiSignature;
message.signatures = [];
if (object.signatures !== undefined && object.signatures !== null) {
for (const e of object.signatures) {
message.signatures.push(e);
}
}
return message;
},
};
const baseCompactBitArray: object = { extraBitsStored: 0 };
export const CompactBitArray = {
encode(message: CompactBitArray, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.extraBitsStored !== 0) {
writer.uint32(8).uint32(message.extraBitsStored);
}
if (message.elems.length !== 0) {
writer.uint32(18).bytes(message.elems);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): CompactBitArray {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseCompactBitArray } as CompactBitArray;
message.elems = new Uint8Array();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.extraBitsStored = reader.uint32();
break;
case 2:
message.elems = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): CompactBitArray {
const message = { ...baseCompactBitArray } as CompactBitArray;
message.elems = new Uint8Array();
if (object.extraBitsStored !== undefined && object.extraBitsStored !== null) {
message.extraBitsStored = Number(object.extraBitsStored);
} else {
message.extraBitsStored = 0;
}
if (object.elems !== undefined && object.elems !== null) {
message.elems = bytesFromBase64(object.elems);
}
return message;
},
toJSON(message: CompactBitArray): unknown {
const obj: any = {};
message.extraBitsStored !== undefined && (obj.extraBitsStored = message.extraBitsStored);
message.elems !== undefined &&
(obj.elems = base64FromBytes(message.elems !== undefined ? message.elems : new Uint8Array()));
return obj;
},
fromPartial(object: DeepPartial<CompactBitArray>): CompactBitArray {
const message = { ...baseCompactBitArray } as CompactBitArray;
if (object.extraBitsStored !== undefined && object.extraBitsStored !== null) {
message.extraBitsStored = object.extraBitsStored;
} else {
message.extraBitsStored = 0;
}
if (object.elems !== undefined && object.elems !== null) {
message.elems = object.elems;
} else {
message.elems = new Uint8Array();
}
return message;
},
};
declare var self: any | undefined;
declare var window: any | undefined;
var globalThis: any = (() => {
if (typeof globalThis !== "undefined") return globalThis;
if (typeof self !== "undefined") return self;
if (typeof window !== "undefined") return window;
if (typeof global !== "undefined") return global;
throw "Unable to locate global object";
})();
const atob: (b64: string) => string =
globalThis.atob || ((b64) => globalThis.Buffer.from(b64, "base64").toString("binary"));
function bytesFromBase64(b64: string): Uint8Array {
const bin = atob(b64);
const arr = new Uint8Array(bin.length);
for (let i = 0; i < bin.length; ++i) {
arr[i] = bin.charCodeAt(i);
}
return arr;
}
const btoa: (bin: string) => string =
globalThis.btoa || ((bin) => globalThis.Buffer.from(bin, "binary").toString("base64"));
function base64FromBytes(arr: Uint8Array): string {
const bin: string[] = [];
for (let i = 0; i < arr.byteLength; ++i) {
bin.push(String.fromCharCode(arr[i]));
}
return btoa(bin.join(""));
}
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

180
packages/stargate/src/codec/cosmos/crypto/secp256k1/keys.ts
View File

@ -1,180 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
export const protobufPackage = "cosmos.crypto.secp256k1";
/**
* PubKey defines a secp256k1 public key
* Key is the compressed form of the pubkey. The first byte depends is a 0x02 byte
* if the y-coordinate is the lexicographically largest of the two associated with
* the x-coordinate. Otherwise the first byte is a 0x03.
* This prefix is followed with the x-coordinate.
*/
export interface PubKey {
key: Uint8Array;
}
/** PrivKey defines a secp256k1 private key. */
export interface PrivKey {
key: Uint8Array;
}
const basePubKey: object = {};
export const PubKey = {
encode(message: PubKey, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.key.length !== 0) {
writer.uint32(10).bytes(message.key);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): PubKey {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...basePubKey } as PubKey;
message.key = new Uint8Array();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.key = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): PubKey {
const message = { ...basePubKey } as PubKey;
message.key = new Uint8Array();
if (object.key !== undefined && object.key !== null) {
message.key = bytesFromBase64(object.key);
}
return message;
},
toJSON(message: PubKey): unknown {
const obj: any = {};
message.key !== undefined &&
(obj.key = base64FromBytes(message.key !== undefined ? message.key : new Uint8Array()));
return obj;
},
fromPartial(object: DeepPartial<PubKey>): PubKey {
const message = { ...basePubKey } as PubKey;
if (object.key !== undefined && object.key !== null) {
message.key = object.key;
} else {
message.key = new Uint8Array();
}
return message;
},
};
const basePrivKey: object = {};
export const PrivKey = {
encode(message: PrivKey, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.key.length !== 0) {
writer.uint32(10).bytes(message.key);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): PrivKey {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...basePrivKey } as PrivKey;
message.key = new Uint8Array();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.key = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): PrivKey {
const message = { ...basePrivKey } as PrivKey;
message.key = new Uint8Array();
if (object.key !== undefined && object.key !== null) {
message.key = bytesFromBase64(object.key);
}
return message;
},
toJSON(message: PrivKey): unknown {
const obj: any = {};
message.key !== undefined &&
(obj.key = base64FromBytes(message.key !== undefined ? message.key : new Uint8Array()));
return obj;
},
fromPartial(object: DeepPartial<PrivKey>): PrivKey {
const message = { ...basePrivKey } as PrivKey;
if (object.key !== undefined && object.key !== null) {
message.key = object.key;
} else {
message.key = new Uint8Array();
}
return message;
},
};
declare var self: any | undefined;
declare var window: any | undefined;
var globalThis: any = (() => {
if (typeof globalThis !== "undefined") return globalThis;
if (typeof self !== "undefined") return self;
if (typeof window !== "undefined") return window;
if (typeof global !== "undefined") return global;
throw "Unable to locate global object";
})();
const atob: (b64: string) => string =
globalThis.atob || ((b64) => globalThis.Buffer.from(b64, "base64").toString("binary"));
function bytesFromBase64(b64: string): Uint8Array {
const bin = atob(b64);
const arr = new Uint8Array(bin.length);
for (let i = 0; i < bin.length; ++i) {
arr[i] = bin.charCodeAt(i);
}
return arr;
}
const btoa: (bin: string) => string =
globalThis.btoa || ((bin) => globalThis.Buffer.from(bin, "binary").toString("base64"));
function base64FromBytes(arr: Uint8Array): string {
const bin: string[] = [];
for (let i = 0; i < arr.byteLength; ++i) {
bin.push(String.fromCharCode(arr[i]));
}
return btoa(bin.join(""));
}
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

1153
packages/stargate/src/codec/cosmos/distribution/v1beta1/distribution.ts
View File

File diff suppressed because it is too large Load Diff

1440
packages/stargate/src/codec/cosmos/distribution/v1beta1/query.ts
View File

File diff suppressed because it is too large Load Diff

569
packages/stargate/src/codec/cosmos/distribution/v1beta1/tx.ts
View File

@ -1,569 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
import { Coin } from "../../../cosmos/base/v1beta1/coin";
export const protobufPackage = "cosmos.distribution.v1beta1";
/**
* MsgSetWithdrawAddress sets the withdraw address for
* a delegator (or validator self-delegation).
*/
export interface MsgSetWithdrawAddress {
delegatorAddress: string;
withdrawAddress: string;
}
/** MsgSetWithdrawAddressResponse defines the Msg/SetWithdrawAddress response type. */
export interface MsgSetWithdrawAddressResponse {}
/**
* MsgWithdrawDelegatorReward represents delegation withdrawal to a delegator
* from a single validator.
*/
export interface MsgWithdrawDelegatorReward {
delegatorAddress: string;
validatorAddress: string;
}
/** MsgWithdrawDelegatorRewardResponse defines the Msg/WithdrawDelegatorReward response type. */
export interface MsgWithdrawDelegatorRewardResponse {}
/**
* MsgWithdrawValidatorCommission withdraws the full commission to the validator
* address.
*/
export interface MsgWithdrawValidatorCommission {
validatorAddress: string;
}
/** MsgWithdrawValidatorCommissionResponse defines the Msg/WithdrawValidatorCommission response type. */
export interface MsgWithdrawValidatorCommissionResponse {}
/**
* MsgFundCommunityPool allows an account to directly
* fund the community pool.
*/
export interface MsgFundCommunityPool {
amount: Coin[];
depositor: string;
}
/** MsgFundCommunityPoolResponse defines the Msg/FundCommunityPool response type. */
export interface MsgFundCommunityPoolResponse {}
const baseMsgSetWithdrawAddress: object = { delegatorAddress: "", withdrawAddress: "" };
export const MsgSetWithdrawAddress = {
encode(message: MsgSetWithdrawAddress, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.delegatorAddress !== "") {
writer.uint32(10).string(message.delegatorAddress);
}
if (message.withdrawAddress !== "") {
writer.uint32(18).string(message.withdrawAddress);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgSetWithdrawAddress {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgSetWithdrawAddress } as MsgSetWithdrawAddress;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.delegatorAddress = reader.string();
break;
case 2:
message.withdrawAddress = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): MsgSetWithdrawAddress {
const message = { ...baseMsgSetWithdrawAddress } as MsgSetWithdrawAddress;
if (object.delegatorAddress !== undefined && object.delegatorAddress !== null) {
message.delegatorAddress = String(object.delegatorAddress);
} else {
message.delegatorAddress = "";
}
if (object.withdrawAddress !== undefined && object.withdrawAddress !== null) {
message.withdrawAddress = String(object.withdrawAddress);
} else {
message.withdrawAddress = "";
}
return message;
},
toJSON(message: MsgSetWithdrawAddress): unknown {
const obj: any = {};
message.delegatorAddress !== undefined && (obj.delegatorAddress = message.delegatorAddress);
message.withdrawAddress !== undefined && (obj.withdrawAddress = message.withdrawAddress);
return obj;
},
fromPartial(object: DeepPartial<MsgSetWithdrawAddress>): MsgSetWithdrawAddress {
const message = { ...baseMsgSetWithdrawAddress } as MsgSetWithdrawAddress;
if (object.delegatorAddress !== undefined && object.delegatorAddress !== null) {
message.delegatorAddress = object.delegatorAddress;
} else {
message.delegatorAddress = "";
}
if (object.withdrawAddress !== undefined && object.withdrawAddress !== null) {
message.withdrawAddress = object.withdrawAddress;
} else {
message.withdrawAddress = "";
}
return message;
},
};
const baseMsgSetWithdrawAddressResponse: object = {};
export const MsgSetWithdrawAddressResponse = {
encode(_: MsgSetWithdrawAddressResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgSetWithdrawAddressResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgSetWithdrawAddressResponse } as MsgSetWithdrawAddressResponse;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(_: any): MsgSetWithdrawAddressResponse {
const message = { ...baseMsgSetWithdrawAddressResponse } as MsgSetWithdrawAddressResponse;
return message;
},
toJSON(_: MsgSetWithdrawAddressResponse): unknown {
const obj: any = {};
return obj;
},
fromPartial(_: DeepPartial<MsgSetWithdrawAddressResponse>): MsgSetWithdrawAddressResponse {
const message = { ...baseMsgSetWithdrawAddressResponse } as MsgSetWithdrawAddressResponse;
return message;
},
};
const baseMsgWithdrawDelegatorReward: object = { delegatorAddress: "", validatorAddress: "" };
export const MsgWithdrawDelegatorReward = {
encode(message: MsgWithdrawDelegatorReward, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.delegatorAddress !== "") {
writer.uint32(10).string(message.delegatorAddress);
}
if (message.validatorAddress !== "") {
writer.uint32(18).string(message.validatorAddress);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgWithdrawDelegatorReward {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgWithdrawDelegatorReward } as MsgWithdrawDelegatorReward;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.delegatorAddress = reader.string();
break;
case 2:
message.validatorAddress = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): MsgWithdrawDelegatorReward {
const message = { ...baseMsgWithdrawDelegatorReward } as MsgWithdrawDelegatorReward;
if (object.delegatorAddress !== undefined && object.delegatorAddress !== null) {
message.delegatorAddress = String(object.delegatorAddress);
} else {
message.delegatorAddress = "";
}
if (object.validatorAddress !== undefined && object.validatorAddress !== null) {
message.validatorAddress = String(object.validatorAddress);
} else {
message.validatorAddress = "";
}
return message;
},
toJSON(message: MsgWithdrawDelegatorReward): unknown {
const obj: any = {};
message.delegatorAddress !== undefined && (obj.delegatorAddress = message.delegatorAddress);
message.validatorAddress !== undefined && (obj.validatorAddress = message.validatorAddress);
return obj;
},
fromPartial(object: DeepPartial<MsgWithdrawDelegatorReward>): MsgWithdrawDelegatorReward {
const message = { ...baseMsgWithdrawDelegatorReward } as MsgWithdrawDelegatorReward;
if (object.delegatorAddress !== undefined && object.delegatorAddress !== null) {
message.delegatorAddress = object.delegatorAddress;
} else {
message.delegatorAddress = "";
}
if (object.validatorAddress !== undefined && object.validatorAddress !== null) {
message.validatorAddress = object.validatorAddress;
} else {
message.validatorAddress = "";
}
return message;
},
};
const baseMsgWithdrawDelegatorRewardResponse: object = {};
export const MsgWithdrawDelegatorRewardResponse = {
encode(_: MsgWithdrawDelegatorRewardResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgWithdrawDelegatorRewardResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgWithdrawDelegatorRewardResponse } as MsgWithdrawDelegatorRewardResponse;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(_: any): MsgWithdrawDelegatorRewardResponse {
const message = { ...baseMsgWithdrawDelegatorRewardResponse } as MsgWithdrawDelegatorRewardResponse;
return message;
},
toJSON(_: MsgWithdrawDelegatorRewardResponse): unknown {
const obj: any = {};
return obj;
},
fromPartial(_: DeepPartial<MsgWithdrawDelegatorRewardResponse>): MsgWithdrawDelegatorRewardResponse {
const message = { ...baseMsgWithdrawDelegatorRewardResponse } as MsgWithdrawDelegatorRewardResponse;
return message;
},
};
const baseMsgWithdrawValidatorCommission: object = { validatorAddress: "" };
export const MsgWithdrawValidatorCommission = {
encode(message: MsgWithdrawValidatorCommission, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.validatorAddress !== "") {
writer.uint32(10).string(message.validatorAddress);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgWithdrawValidatorCommission {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgWithdrawValidatorCommission } as MsgWithdrawValidatorCommission;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.validatorAddress = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): MsgWithdrawValidatorCommission {
const message = { ...baseMsgWithdrawValidatorCommission } as MsgWithdrawValidatorCommission;
if (object.validatorAddress !== undefined && object.validatorAddress !== null) {
message.validatorAddress = String(object.validatorAddress);
} else {
message.validatorAddress = "";
}
return message;
},
toJSON(message: MsgWithdrawValidatorCommission): unknown {
const obj: any = {};
message.validatorAddress !== undefined && (obj.validatorAddress = message.validatorAddress);
return obj;
},
fromPartial(object: DeepPartial<MsgWithdrawValidatorCommission>): MsgWithdrawValidatorCommission {
const message = { ...baseMsgWithdrawValidatorCommission } as MsgWithdrawValidatorCommission;
if (object.validatorAddress !== undefined && object.validatorAddress !== null) {
message.validatorAddress = object.validatorAddress;
} else {
message.validatorAddress = "";
}
return message;
},
};
const baseMsgWithdrawValidatorCommissionResponse: object = {};
export const MsgWithdrawValidatorCommissionResponse = {
encode(_: MsgWithdrawValidatorCommissionResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgWithdrawValidatorCommissionResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = {
...baseMsgWithdrawValidatorCommissionResponse,
} as MsgWithdrawValidatorCommissionResponse;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(_: any): MsgWithdrawValidatorCommissionResponse {
const message = {
...baseMsgWithdrawValidatorCommissionResponse,
} as MsgWithdrawValidatorCommissionResponse;
return message;
},
toJSON(_: MsgWithdrawValidatorCommissionResponse): unknown {
const obj: any = {};
return obj;
},
fromPartial(
_: DeepPartial<MsgWithdrawValidatorCommissionResponse>,
): MsgWithdrawValidatorCommissionResponse {
const message = {
...baseMsgWithdrawValidatorCommissionResponse,
} as MsgWithdrawValidatorCommissionResponse;
return message;
},
};
const baseMsgFundCommunityPool: object = { depositor: "" };
export const MsgFundCommunityPool = {
encode(message: MsgFundCommunityPool, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
for (const v of message.amount) {
Coin.encode(v!, writer.uint32(10).fork()).ldelim();
}
if (message.depositor !== "") {
writer.uint32(18).string(message.depositor);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgFundCommunityPool {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgFundCommunityPool } as MsgFundCommunityPool;
message.amount = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.amount.push(Coin.decode(reader, reader.uint32()));
break;
case 2:
message.depositor = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): MsgFundCommunityPool {
const message = { ...baseMsgFundCommunityPool } as MsgFundCommunityPool;
message.amount = [];
if (object.amount !== undefined && object.amount !== null) {
for (const e of object.amount) {
message.amount.push(Coin.fromJSON(e));
}
}
if (object.depositor !== undefined && object.depositor !== null) {
message.depositor = String(object.depositor);
} else {
message.depositor = "";
}
return message;
},
toJSON(message: MsgFundCommunityPool): unknown {
const obj: any = {};
if (message.amount) {
obj.amount = message.amount.map((e) => (e ? Coin.toJSON(e) : undefined));
} else {
obj.amount = [];
}
message.depositor !== undefined && (obj.depositor = message.depositor);
return obj;
},
fromPartial(object: DeepPartial<MsgFundCommunityPool>): MsgFundCommunityPool {
const message = { ...baseMsgFundCommunityPool } as MsgFundCommunityPool;
message.amount = [];
if (object.amount !== undefined && object.amount !== null) {
for (const e of object.amount) {
message.amount.push(Coin.fromPartial(e));
}
}
if (object.depositor !== undefined && object.depositor !== null) {
message.depositor = object.depositor;
} else {
message.depositor = "";
}
return message;
},
};
const baseMsgFundCommunityPoolResponse: object = {};
export const MsgFundCommunityPoolResponse = {
encode(_: MsgFundCommunityPoolResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgFundCommunityPoolResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgFundCommunityPoolResponse } as MsgFundCommunityPoolResponse;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(_: any): MsgFundCommunityPoolResponse {
const message = { ...baseMsgFundCommunityPoolResponse } as MsgFundCommunityPoolResponse;
return message;
},
toJSON(_: MsgFundCommunityPoolResponse): unknown {
const obj: any = {};
return obj;
},
fromPartial(_: DeepPartial<MsgFundCommunityPoolResponse>): MsgFundCommunityPoolResponse {
const message = { ...baseMsgFundCommunityPoolResponse } as MsgFundCommunityPoolResponse;
return message;
},
};
/** Msg defines the distribution Msg service. */
export interface Msg {
/**
* SetWithdrawAddress defines a method to change the withdraw address
* for a delegator (or validator self-delegation).
*/
SetWithdrawAddress(request: MsgSetWithdrawAddress): Promise<MsgSetWithdrawAddressResponse>;
/**
* WithdrawDelegatorReward defines a method to withdraw rewards of delegator
* from a single validator.
*/
WithdrawDelegatorReward(request: MsgWithdrawDelegatorReward): Promise<MsgWithdrawDelegatorRewardResponse>;
/**
* WithdrawValidatorCommission defines a method to withdraw the
* full commission to the validator address.
*/
WithdrawValidatorCommission(
request: MsgWithdrawValidatorCommission,
): Promise<MsgWithdrawValidatorCommissionResponse>;
/**
* FundCommunityPool defines a method to allow an account to directly
* fund the community pool.
*/
FundCommunityPool(request: MsgFundCommunityPool): Promise<MsgFundCommunityPoolResponse>;
}
export class MsgClientImpl implements Msg {
private readonly rpc: Rpc;
constructor(rpc: Rpc) {
this.rpc = rpc;
}
SetWithdrawAddress(request: MsgSetWithdrawAddress): Promise<MsgSetWithdrawAddressResponse> {
const data = MsgSetWithdrawAddress.encode(request).finish();
const promise = this.rpc.request("cosmos.distribution.v1beta1.Msg", "SetWithdrawAddress", data);
return promise.then((data) => MsgSetWithdrawAddressResponse.decode(new _m0.Reader(data)));
}
WithdrawDelegatorReward(request: MsgWithdrawDelegatorReward): Promise<MsgWithdrawDelegatorRewardResponse> {
const data = MsgWithdrawDelegatorReward.encode(request).finish();
const promise = this.rpc.request("cosmos.distribution.v1beta1.Msg", "WithdrawDelegatorReward", data);
return promise.then((data) => MsgWithdrawDelegatorRewardResponse.decode(new _m0.Reader(data)));
}
WithdrawValidatorCommission(
request: MsgWithdrawValidatorCommission,
): Promise<MsgWithdrawValidatorCommissionResponse> {
const data = MsgWithdrawValidatorCommission.encode(request).finish();
const promise = this.rpc.request("cosmos.distribution.v1beta1.Msg", "WithdrawValidatorCommission", data);
return promise.then((data) => MsgWithdrawValidatorCommissionResponse.decode(new _m0.Reader(data)));
}
FundCommunityPool(request: MsgFundCommunityPool): Promise<MsgFundCommunityPoolResponse> {
const data = MsgFundCommunityPool.encode(request).finish();
const promise = this.rpc.request("cosmos.distribution.v1beta1.Msg", "FundCommunityPool", data);
return promise.then((data) => MsgFundCommunityPoolResponse.decode(new _m0.Reader(data)));
}
}
interface Rpc {
request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
}
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

2387
packages/stargate/src/codec/cosmos/staking/v1beta1/query.ts
View File

File diff suppressed because it is too large Load Diff

2224
packages/stargate/src/codec/cosmos/staking/v1beta1/staking.ts
View File

File diff suppressed because it is too large Load Diff

967
packages/stargate/src/codec/cosmos/staking/v1beta1/tx.ts
View File

@ -1,967 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
import { Description, CommissionRates } from "../../../cosmos/staking/v1beta1/staking";
import { Any } from "../../../google/protobuf/any";
import { Coin } from "../../../cosmos/base/v1beta1/coin";
import { Timestamp } from "../../../google/protobuf/timestamp";
export const protobufPackage = "cosmos.staking.v1beta1";
/** MsgCreateValidator defines a SDK message for creating a new validator. */
export interface MsgCreateValidator {
description?: Description;
commission?: CommissionRates;
minSelfDelegation: string;
delegatorAddress: string;
validatorAddress: string;
pubkey?: Any;
value?: Coin;
}
/** MsgCreateValidatorResponse defines the Msg/CreateValidator response type. */
export interface MsgCreateValidatorResponse {}
/** MsgEditValidator defines a SDK message for editing an existing validator. */
export interface MsgEditValidator {
description?: Description;
validatorAddress: string;
/**
* We pass a reference to the new commission rate and min self delegation as
* it's not mandatory to update. If not updated, the deserialized rate will be
* zero with no way to distinguish if an update was intended.
* REF: #2373
*/
commissionRate: string;
minSelfDelegation: string;
}
/** MsgEditValidatorResponse defines the Msg/EditValidator response type. */
export interface MsgEditValidatorResponse {}
/**
* MsgDelegate defines a SDK message for performing a delegation of coins
* from a delegator to a validator.
*/
export interface MsgDelegate {
delegatorAddress: string;
validatorAddress: string;
amount?: Coin;
}
/** MsgDelegateResponse defines the Msg/Delegate response type. */
export interface MsgDelegateResponse {}
/**
* MsgBeginRedelegate defines a SDK message for performing a redelegation
* of coins from a delegator and source validator to a destination validator.
*/
export interface MsgBeginRedelegate {
delegatorAddress: string;
validatorSrcAddress: string;
validatorDstAddress: string;
amount?: Coin;
}
/** MsgBeginRedelegateResponse defines the Msg/BeginRedelegate response type. */
export interface MsgBeginRedelegateResponse {
completionTime?: Date;
}
/**
* MsgUndelegate defines a SDK message for performing an undelegation from a
* delegate and a validator.
*/
export interface MsgUndelegate {
delegatorAddress: string;
validatorAddress: string;
amount?: Coin;
}
/** MsgUndelegateResponse defines the Msg/Undelegate response type. */
export interface MsgUndelegateResponse {
completionTime?: Date;
}
const baseMsgCreateValidator: object = { minSelfDelegation: "", delegatorAddress: "", validatorAddress: "" };
export const MsgCreateValidator = {
encode(message: MsgCreateValidator, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.description !== undefined) {
Description.encode(message.description, writer.uint32(10).fork()).ldelim();
}
if (message.commission !== undefined) {
CommissionRates.encode(message.commission, writer.uint32(18).fork()).ldelim();
}
if (message.minSelfDelegation !== "") {
writer.uint32(26).string(message.minSelfDelegation);
}
if (message.delegatorAddress !== "") {
writer.uint32(34).string(message.delegatorAddress);
}
if (message.validatorAddress !== "") {
writer.uint32(42).string(message.validatorAddress);
}
if (message.pubkey !== undefined) {
Any.encode(message.pubkey, writer.uint32(50).fork()).ldelim();
}
if (message.value !== undefined) {
Coin.encode(message.value, writer.uint32(58).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgCreateValidator {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgCreateValidator } as MsgCreateValidator;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.description = Description.decode(reader, reader.uint32());
break;
case 2:
message.commission = CommissionRates.decode(reader, reader.uint32());
break;
case 3:
message.minSelfDelegation = reader.string();
break;
case 4:
message.delegatorAddress = reader.string();
break;
case 5:
message.validatorAddress = reader.string();
break;
case 6:
message.pubkey = Any.decode(reader, reader.uint32());
break;
case 7:
message.value = Coin.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): MsgCreateValidator {
const message = { ...baseMsgCreateValidator } as MsgCreateValidator;
if (object.description !== undefined && object.description !== null) {
message.description = Description.fromJSON(object.description);
} else {
message.description = undefined;
}
if (object.commission !== undefined && object.commission !== null) {
message.commission = CommissionRates.fromJSON(object.commission);
} else {
message.commission = undefined;
}
if (object.minSelfDelegation !== undefined && object.minSelfDelegation !== null) {
message.minSelfDelegation = String(object.minSelfDelegation);
} else {
message.minSelfDelegation = "";
}
if (object.delegatorAddress !== undefined && object.delegatorAddress !== null) {
message.delegatorAddress = String(object.delegatorAddress);
} else {
message.delegatorAddress = "";
}
if (object.validatorAddress !== undefined && object.validatorAddress !== null) {
message.validatorAddress = String(object.validatorAddress);
} else {
message.validatorAddress = "";
}
if (object.pubkey !== undefined && object.pubkey !== null) {
message.pubkey = Any.fromJSON(object.pubkey);
} else {
message.pubkey = undefined;
}
if (object.value !== undefined && object.value !== null) {
message.value = Coin.fromJSON(object.value);
} else {
message.value = undefined;
}
return message;
},
toJSON(message: MsgCreateValidator): unknown {
const obj: any = {};
message.description !== undefined &&
(obj.description = message.description ? Description.toJSON(message.description) : undefined);
message.commission !== undefined &&
(obj.commission = message.commission ? CommissionRates.toJSON(message.commission) : undefined);
message.minSelfDelegation !== undefined && (obj.minSelfDelegation = message.minSelfDelegation);
message.delegatorAddress !== undefined && (obj.delegatorAddress = message.delegatorAddress);
message.validatorAddress !== undefined && (obj.validatorAddress = message.validatorAddress);
message.pubkey !== undefined && (obj.pubkey = message.pubkey ? Any.toJSON(message.pubkey) : undefined);
message.value !== undefined && (obj.value = message.value ? Coin.toJSON(message.value) : undefined);
return obj;
},
fromPartial(object: DeepPartial<MsgCreateValidator>): MsgCreateValidator {
const message = { ...baseMsgCreateValidator } as MsgCreateValidator;
if (object.description !== undefined && object.description !== null) {
message.description = Description.fromPartial(object.description);
} else {
message.description = undefined;
}
if (object.commission !== undefined && object.commission !== null) {
message.commission = CommissionRates.fromPartial(object.commission);
} else {
message.commission = undefined;
}
if (object.minSelfDelegation !== undefined && object.minSelfDelegation !== null) {
message.minSelfDelegation = object.minSelfDelegation;
} else {
message.minSelfDelegation = "";
}
if (object.delegatorAddress !== undefined && object.delegatorAddress !== null) {
message.delegatorAddress = object.delegatorAddress;
} else {
message.delegatorAddress = "";
}
if (object.validatorAddress !== undefined && object.validatorAddress !== null) {
message.validatorAddress = object.validatorAddress;
} else {
message.validatorAddress = "";
}
if (object.pubkey !== undefined && object.pubkey !== null) {
message.pubkey = Any.fromPartial(object.pubkey);
} else {
message.pubkey = undefined;
}
if (object.value !== undefined && object.value !== null) {
message.value = Coin.fromPartial(object.value);
} else {
message.value = undefined;
}
return message;
},
};
const baseMsgCreateValidatorResponse: object = {};
export const MsgCreateValidatorResponse = {
encode(_: MsgCreateValidatorResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgCreateValidatorResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgCreateValidatorResponse } as MsgCreateValidatorResponse;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(_: any): MsgCreateValidatorResponse {
const message = { ...baseMsgCreateValidatorResponse } as MsgCreateValidatorResponse;
return message;
},
toJSON(_: MsgCreateValidatorResponse): unknown {
const obj: any = {};
return obj;
},
fromPartial(_: DeepPartial<MsgCreateValidatorResponse>): MsgCreateValidatorResponse {
const message = { ...baseMsgCreateValidatorResponse } as MsgCreateValidatorResponse;
return message;
},
};
const baseMsgEditValidator: object = { validatorAddress: "", commissionRate: "", minSelfDelegation: "" };
export const MsgEditValidator = {
encode(message: MsgEditValidator, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.description !== undefined) {
Description.encode(message.description, writer.uint32(10).fork()).ldelim();
}
if (message.validatorAddress !== "") {
writer.uint32(18).string(message.validatorAddress);
}
if (message.commissionRate !== "") {
writer.uint32(26).string(message.commissionRate);
}
if (message.minSelfDelegation !== "") {
writer.uint32(34).string(message.minSelfDelegation);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgEditValidator {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgEditValidator } as MsgEditValidator;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.description = Description.decode(reader, reader.uint32());
break;
case 2:
message.validatorAddress = reader.string();
break;
case 3:
message.commissionRate = reader.string();
break;
case 4:
message.minSelfDelegation = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): MsgEditValidator {
const message = { ...baseMsgEditValidator } as MsgEditValidator;
if (object.description !== undefined && object.description !== null) {
message.description = Description.fromJSON(object.description);
} else {
message.description = undefined;
}
if (object.validatorAddress !== undefined && object.validatorAddress !== null) {
message.validatorAddress = String(object.validatorAddress);
} else {
message.validatorAddress = "";
}
if (object.commissionRate !== undefined && object.commissionRate !== null) {
message.commissionRate = String(object.commissionRate);
} else {
message.commissionRate = "";
}
if (object.minSelfDelegation !== undefined && object.minSelfDelegation !== null) {
message.minSelfDelegation = String(object.minSelfDelegation);
} else {
message.minSelfDelegation = "";
}
return message;
},
toJSON(message: MsgEditValidator): unknown {
const obj: any = {};
message.description !== undefined &&
(obj.description = message.description ? Description.toJSON(message.description) : undefined);
message.validatorAddress !== undefined && (obj.validatorAddress = message.validatorAddress);
message.commissionRate !== undefined && (obj.commissionRate = message.commissionRate);
message.minSelfDelegation !== undefined && (obj.minSelfDelegation = message.minSelfDelegation);
return obj;
},
fromPartial(object: DeepPartial<MsgEditValidator>): MsgEditValidator {
const message = { ...baseMsgEditValidator } as MsgEditValidator;
if (object.description !== undefined && object.description !== null) {
message.description = Description.fromPartial(object.description);
} else {
message.description = undefined;
}
if (object.validatorAddress !== undefined && object.validatorAddress !== null) {
message.validatorAddress = object.validatorAddress;
} else {
message.validatorAddress = "";
}
if (object.commissionRate !== undefined && object.commissionRate !== null) {
message.commissionRate = object.commissionRate;
} else {
message.commissionRate = "";
}
if (object.minSelfDelegation !== undefined && object.minSelfDelegation !== null) {
message.minSelfDelegation = object.minSelfDelegation;
} else {
message.minSelfDelegation = "";
}
return message;
},
};
const baseMsgEditValidatorResponse: object = {};
export const MsgEditValidatorResponse = {
encode(_: MsgEditValidatorResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgEditValidatorResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgEditValidatorResponse } as MsgEditValidatorResponse;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(_: any): MsgEditValidatorResponse {
const message = { ...baseMsgEditValidatorResponse } as MsgEditValidatorResponse;
return message;
},
toJSON(_: MsgEditValidatorResponse): unknown {
const obj: any = {};
return obj;
},
fromPartial(_: DeepPartial<MsgEditValidatorResponse>): MsgEditValidatorResponse {
const message = { ...baseMsgEditValidatorResponse } as MsgEditValidatorResponse;
return message;
},
};
const baseMsgDelegate: object = { delegatorAddress: "", validatorAddress: "" };
export const MsgDelegate = {
encode(message: MsgDelegate, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.delegatorAddress !== "") {
writer.uint32(10).string(message.delegatorAddress);
}
if (message.validatorAddress !== "") {
writer.uint32(18).string(message.validatorAddress);
}
if (message.amount !== undefined) {
Coin.encode(message.amount, writer.uint32(26).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgDelegate {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgDelegate } as MsgDelegate;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.delegatorAddress = reader.string();
break;
case 2:
message.validatorAddress = reader.string();
break;
case 3:
message.amount = Coin.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): MsgDelegate {
const message = { ...baseMsgDelegate } as MsgDelegate;
if (object.delegatorAddress !== undefined && object.delegatorAddress !== null) {
message.delegatorAddress = String(object.delegatorAddress);
} else {
message.delegatorAddress = "";
}
if (object.validatorAddress !== undefined && object.validatorAddress !== null) {
message.validatorAddress = String(object.validatorAddress);
} else {
message.validatorAddress = "";
}
if (object.amount !== undefined && object.amount !== null) {
message.amount = Coin.fromJSON(object.amount);
} else {
message.amount = undefined;
}
return message;
},
toJSON(message: MsgDelegate): unknown {
const obj: any = {};
message.delegatorAddress !== undefined && (obj.delegatorAddress = message.delegatorAddress);
message.validatorAddress !== undefined && (obj.validatorAddress = message.validatorAddress);
message.amount !== undefined && (obj.amount = message.amount ? Coin.toJSON(message.amount) : undefined);
return obj;
},
fromPartial(object: DeepPartial<MsgDelegate>): MsgDelegate {
const message = { ...baseMsgDelegate } as MsgDelegate;
if (object.delegatorAddress !== undefined && object.delegatorAddress !== null) {
message.delegatorAddress = object.delegatorAddress;
} else {
message.delegatorAddress = "";
}
if (object.validatorAddress !== undefined && object.validatorAddress !== null) {
message.validatorAddress = object.validatorAddress;
} else {
message.validatorAddress = "";
}
if (object.amount !== undefined && object.amount !== null) {
message.amount = Coin.fromPartial(object.amount);
} else {
message.amount = undefined;
}
return message;
},
};
const baseMsgDelegateResponse: object = {};
export const MsgDelegateResponse = {
encode(_: MsgDelegateResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgDelegateResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgDelegateResponse } as MsgDelegateResponse;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(_: any): MsgDelegateResponse {
const message = { ...baseMsgDelegateResponse } as MsgDelegateResponse;
return message;
},
toJSON(_: MsgDelegateResponse): unknown {
const obj: any = {};
return obj;
},
fromPartial(_: DeepPartial<MsgDelegateResponse>): MsgDelegateResponse {
const message = { ...baseMsgDelegateResponse } as MsgDelegateResponse;
return message;
},
};
const baseMsgBeginRedelegate: object = {
delegatorAddress: "",
validatorSrcAddress: "",
validatorDstAddress: "",
};
export const MsgBeginRedelegate = {
encode(message: MsgBeginRedelegate, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.delegatorAddress !== "") {
writer.uint32(10).string(message.delegatorAddress);
}
if (message.validatorSrcAddress !== "") {
writer.uint32(18).string(message.validatorSrcAddress);
}
if (message.validatorDstAddress !== "") {
writer.uint32(26).string(message.validatorDstAddress);
}
if (message.amount !== undefined) {
Coin.encode(message.amount, writer.uint32(34).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgBeginRedelegate {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgBeginRedelegate } as MsgBeginRedelegate;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.delegatorAddress = reader.string();
break;
case 2:
message.validatorSrcAddress = reader.string();
break;
case 3:
message.validatorDstAddress = reader.string();
break;
case 4:
message.amount = Coin.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): MsgBeginRedelegate {
const message = { ...baseMsgBeginRedelegate } as MsgBeginRedelegate;
if (object.delegatorAddress !== undefined && object.delegatorAddress !== null) {
message.delegatorAddress = String(object.delegatorAddress);
} else {
message.delegatorAddress = "";
}
if (object.validatorSrcAddress !== undefined && object.validatorSrcAddress !== null) {
message.validatorSrcAddress = String(object.validatorSrcAddress);
} else {
message.validatorSrcAddress = "";
}
if (object.validatorDstAddress !== undefined && object.validatorDstAddress !== null) {
message.validatorDstAddress = String(object.validatorDstAddress);
} else {
message.validatorDstAddress = "";
}
if (object.amount !== undefined && object.amount !== null) {
message.amount = Coin.fromJSON(object.amount);
} else {
message.amount = undefined;
}
return message;
},
toJSON(message: MsgBeginRedelegate): unknown {
const obj: any = {};
message.delegatorAddress !== undefined && (obj.delegatorAddress = message.delegatorAddress);
message.validatorSrcAddress !== undefined && (obj.validatorSrcAddress = message.validatorSrcAddress);
message.validatorDstAddress !== undefined && (obj.validatorDstAddress = message.validatorDstAddress);
message.amount !== undefined && (obj.amount = message.amount ? Coin.toJSON(message.amount) : undefined);
return obj;
},
fromPartial(object: DeepPartial<MsgBeginRedelegate>): MsgBeginRedelegate {
const message = { ...baseMsgBeginRedelegate } as MsgBeginRedelegate;
if (object.delegatorAddress !== undefined && object.delegatorAddress !== null) {
message.delegatorAddress = object.delegatorAddress;
} else {
message.delegatorAddress = "";
}
if (object.validatorSrcAddress !== undefined && object.validatorSrcAddress !== null) {
message.validatorSrcAddress = object.validatorSrcAddress;
} else {
message.validatorSrcAddress = "";
}
if (object.validatorDstAddress !== undefined && object.validatorDstAddress !== null) {
message.validatorDstAddress = object.validatorDstAddress;
} else {
message.validatorDstAddress = "";
}
if (object.amount !== undefined && object.amount !== null) {
message.amount = Coin.fromPartial(object.amount);
} else {
message.amount = undefined;
}
return message;
},
};
const baseMsgBeginRedelegateResponse: object = {};
export const MsgBeginRedelegateResponse = {
encode(message: MsgBeginRedelegateResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.completionTime !== undefined) {
Timestamp.encode(toTimestamp(message.completionTime), writer.uint32(10).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgBeginRedelegateResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgBeginRedelegateResponse } as MsgBeginRedelegateResponse;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.completionTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): MsgBeginRedelegateResponse {
const message = { ...baseMsgBeginRedelegateResponse } as MsgBeginRedelegateResponse;
if (object.completionTime !== undefined && object.completionTime !== null) {
message.completionTime = fromJsonTimestamp(object.completionTime);
} else {
message.completionTime = undefined;
}
return message;
},
toJSON(message: MsgBeginRedelegateResponse): unknown {
const obj: any = {};
message.completionTime !== undefined && (obj.completionTime = message.completionTime.toISOString());
return obj;
},
fromPartial(object: DeepPartial<MsgBeginRedelegateResponse>): MsgBeginRedelegateResponse {
const message = { ...baseMsgBeginRedelegateResponse } as MsgBeginRedelegateResponse;
if (object.completionTime !== undefined && object.completionTime !== null) {
message.completionTime = object.completionTime;
} else {
message.completionTime = undefined;
}
return message;
},
};
const baseMsgUndelegate: object = { delegatorAddress: "", validatorAddress: "" };
export const MsgUndelegate = {
encode(message: MsgUndelegate, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.delegatorAddress !== "") {
writer.uint32(10).string(message.delegatorAddress);
}
if (message.validatorAddress !== "") {
writer.uint32(18).string(message.validatorAddress);
}
if (message.amount !== undefined) {
Coin.encode(message.amount, writer.uint32(26).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgUndelegate {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgUndelegate } as MsgUndelegate;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.delegatorAddress = reader.string();
break;
case 2:
message.validatorAddress = reader.string();
break;
case 3:
message.amount = Coin.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): MsgUndelegate {
const message = { ...baseMsgUndelegate } as MsgUndelegate;
if (object.delegatorAddress !== undefined && object.delegatorAddress !== null) {
message.delegatorAddress = String(object.delegatorAddress);
} else {
message.delegatorAddress = "";
}
if (object.validatorAddress !== undefined && object.validatorAddress !== null) {
message.validatorAddress = String(object.validatorAddress);
} else {
message.validatorAddress = "";
}
if (object.amount !== undefined && object.amount !== null) {
message.amount = Coin.fromJSON(object.amount);
} else {
message.amount = undefined;
}
return message;
},
toJSON(message: MsgUndelegate): unknown {
const obj: any = {};
message.delegatorAddress !== undefined && (obj.delegatorAddress = message.delegatorAddress);
message.validatorAddress !== undefined && (obj.validatorAddress = message.validatorAddress);
message.amount !== undefined && (obj.amount = message.amount ? Coin.toJSON(message.amount) : undefined);
return obj;
},
fromPartial(object: DeepPartial<MsgUndelegate>): MsgUndelegate {
const message = { ...baseMsgUndelegate } as MsgUndelegate;
if (object.delegatorAddress !== undefined && object.delegatorAddress !== null) {
message.delegatorAddress = object.delegatorAddress;
} else {
message.delegatorAddress = "";
}
if (object.validatorAddress !== undefined && object.validatorAddress !== null) {
message.validatorAddress = object.validatorAddress;
} else {
message.validatorAddress = "";
}
if (object.amount !== undefined && object.amount !== null) {
message.amount = Coin.fromPartial(object.amount);
} else {
message.amount = undefined;
}
return message;
},
};
const baseMsgUndelegateResponse: object = {};
export const MsgUndelegateResponse = {
encode(message: MsgUndelegateResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.completionTime !== undefined) {
Timestamp.encode(toTimestamp(message.completionTime), writer.uint32(10).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgUndelegateResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgUndelegateResponse } as MsgUndelegateResponse;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.completionTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): MsgUndelegateResponse {
const message = { ...baseMsgUndelegateResponse } as MsgUndelegateResponse;
if (object.completionTime !== undefined && object.completionTime !== null) {
message.completionTime = fromJsonTimestamp(object.completionTime);
} else {
message.completionTime = undefined;
}
return message;
},
toJSON(message: MsgUndelegateResponse): unknown {
const obj: any = {};
message.completionTime !== undefined && (obj.completionTime = message.completionTime.toISOString());
return obj;
},
fromPartial(object: DeepPartial<MsgUndelegateResponse>): MsgUndelegateResponse {
const message = { ...baseMsgUndelegateResponse } as MsgUndelegateResponse;
if (object.completionTime !== undefined && object.completionTime !== null) {
message.completionTime = object.completionTime;
} else {
message.completionTime = undefined;
}
return message;
},
};
/** Msg defines the staking Msg service. */
export interface Msg {
/** CreateValidator defines a method for creating a new validator. */
CreateValidator(request: MsgCreateValidator): Promise<MsgCreateValidatorResponse>;
/** EditValidator defines a method for editing an existing validator. */
EditValidator(request: MsgEditValidator): Promise<MsgEditValidatorResponse>;
/**
* Delegate defines a method for performing a delegation of coins
* from a delegator to a validator.
*/
Delegate(request: MsgDelegate): Promise<MsgDelegateResponse>;
/**
* BeginRedelegate defines a method for performing a redelegation
* of coins from a delegator and source validator to a destination validator.
*/
BeginRedelegate(request: MsgBeginRedelegate): Promise<MsgBeginRedelegateResponse>;
/**
* Undelegate defines a method for performing an undelegation from a
* delegate and a validator.
*/
Undelegate(request: MsgUndelegate): Promise<MsgUndelegateResponse>;
}
export class MsgClientImpl implements Msg {
private readonly rpc: Rpc;
constructor(rpc: Rpc) {
this.rpc = rpc;
}
CreateValidator(request: MsgCreateValidator): Promise<MsgCreateValidatorResponse> {
const data = MsgCreateValidator.encode(request).finish();
const promise = this.rpc.request("cosmos.staking.v1beta1.Msg", "CreateValidator", data);
return promise.then((data) => MsgCreateValidatorResponse.decode(new _m0.Reader(data)));
}
EditValidator(request: MsgEditValidator): Promise<MsgEditValidatorResponse> {
const data = MsgEditValidator.encode(request).finish();
const promise = this.rpc.request("cosmos.staking.v1beta1.Msg", "EditValidator", data);
return promise.then((data) => MsgEditValidatorResponse.decode(new _m0.Reader(data)));
}
Delegate(request: MsgDelegate): Promise<MsgDelegateResponse> {
const data = MsgDelegate.encode(request).finish();
const promise = this.rpc.request("cosmos.staking.v1beta1.Msg", "Delegate", data);
return promise.then((data) => MsgDelegateResponse.decode(new _m0.Reader(data)));
}
BeginRedelegate(request: MsgBeginRedelegate): Promise<MsgBeginRedelegateResponse> {
const data = MsgBeginRedelegate.encode(request).finish();
const promise = this.rpc.request("cosmos.staking.v1beta1.Msg", "BeginRedelegate", data);
return promise.then((data) => MsgBeginRedelegateResponse.decode(new _m0.Reader(data)));
}
Undelegate(request: MsgUndelegate): Promise<MsgUndelegateResponse> {
const data = MsgUndelegate.encode(request).finish();
const promise = this.rpc.request("cosmos.staking.v1beta1.Msg", "Undelegate", data);
return promise.then((data) => MsgUndelegateResponse.decode(new _m0.Reader(data)));
}
}
interface Rpc {
request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
}
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
function toTimestamp(date: Date): Timestamp {
const seconds = numberToLong(date.getTime() / 1_000);
const nanos = (date.getTime() % 1_000) * 1_000_000;
return { seconds, nanos };
}
function fromTimestamp(t: Timestamp): Date {
let millis = t.seconds.toNumber() * 1_000;
millis += t.nanos / 1_000_000;
return new Date(millis);
}
function fromJsonTimestamp(o: any): Date {
if (o instanceof Date) {
return o;
} else if (typeof o === "string") {
return new Date(o);
} else {
return fromTimestamp(Timestamp.fromJSON(o));
}
}
function numberToLong(number: number) {
return Long.fromNumber(number);
}
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

546
packages/stargate/src/codec/cosmos/tx/signing/v1beta1/signing.ts
View File

@ -1,546 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
import { Any } from "../../../../google/protobuf/any";
import { CompactBitArray } from "../../../../cosmos/crypto/multisig/v1beta1/multisig";
export const protobufPackage = "cosmos.tx.signing.v1beta1";
/** SignMode represents a signing mode with its own security guarantees. */
export enum SignMode {
/**
* SIGN_MODE_UNSPECIFIED - SIGN_MODE_UNSPECIFIED specifies an unknown signing mode and will be
* rejected
*/
SIGN_MODE_UNSPECIFIED = 0,
/**
* SIGN_MODE_DIRECT - SIGN_MODE_DIRECT specifies a signing mode which uses SignDoc and is
* verified with raw bytes from Tx
*/
SIGN_MODE_DIRECT = 1,
/**
* SIGN_MODE_TEXTUAL - SIGN_MODE_TEXTUAL is a future signing mode that will verify some
* human-readable textual representation on top of the binary representation
* from SIGN_MODE_DIRECT
*/
SIGN_MODE_TEXTUAL = 2,
/**
* SIGN_MODE_LEGACY_AMINO_JSON - SIGN_MODE_LEGACY_AMINO_JSON is a backwards compatibility mode which uses
* Amino JSON and will be removed in the future
*/
SIGN_MODE_LEGACY_AMINO_JSON = 127,
UNRECOGNIZED = -1,
}
export function signModeFromJSON(object: any): SignMode {
switch (object) {
case 0:
case "SIGN_MODE_UNSPECIFIED":
return SignMode.SIGN_MODE_UNSPECIFIED;
case 1:
case "SIGN_MODE_DIRECT":
return SignMode.SIGN_MODE_DIRECT;
case 2:
case "SIGN_MODE_TEXTUAL":
return SignMode.SIGN_MODE_TEXTUAL;
case 127:
case "SIGN_MODE_LEGACY_AMINO_JSON":
return SignMode.SIGN_MODE_LEGACY_AMINO_JSON;
case -1:
case "UNRECOGNIZED":
default:
return SignMode.UNRECOGNIZED;
}
}
export function signModeToJSON(object: SignMode): string {
switch (object) {
case SignMode.SIGN_MODE_UNSPECIFIED:
return "SIGN_MODE_UNSPECIFIED";
case SignMode.SIGN_MODE_DIRECT:
return "SIGN_MODE_DIRECT";
case SignMode.SIGN_MODE_TEXTUAL:
return "SIGN_MODE_TEXTUAL";
case SignMode.SIGN_MODE_LEGACY_AMINO_JSON:
return "SIGN_MODE_LEGACY_AMINO_JSON";
default:
return "UNKNOWN";
}
}
/** SignatureDescriptors wraps multiple SignatureDescriptor's. */
export interface SignatureDescriptors {
/** signatures are the signature descriptors */
signatures: SignatureDescriptor[];
}
/**
* SignatureDescriptor is a convenience type which represents the full data for
* a signature including the public key of the signer, signing modes and the
* signature itself. It is primarily used for coordinating signatures between
* clients.
*/
export interface SignatureDescriptor {
/** public_key is the public key of the signer */
publicKey?: Any;
data?: SignatureDescriptor_Data;
/**
* sequence is the sequence of the account, which describes the
* number of committed transactions signed by a given address. It is used to prevent
* replay attacks.
*/
sequence: Long;
}
/** Data represents signature data */
export interface SignatureDescriptor_Data {
/** single represents a single signer */
single?: SignatureDescriptor_Data_Single | undefined;
/** multi represents a multisig signer */
multi?: SignatureDescriptor_Data_Multi | undefined;
}
/** Single is the signature data for a single signer */
export interface SignatureDescriptor_Data_Single {
/** mode is the signing mode of the single signer */
mode: SignMode;
/** signature is the raw signature bytes */
signature: Uint8Array;
}
/** Multi is the signature data for a multisig public key */
export interface SignatureDescriptor_Data_Multi {
/** bitarray specifies which keys within the multisig are signing */
bitarray?: CompactBitArray;
/** signatures is the signatures of the multi-signature */
signatures: SignatureDescriptor_Data[];
}
const baseSignatureDescriptors: object = {};
export const SignatureDescriptors = {
encode(message: SignatureDescriptors, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
for (const v of message.signatures) {
SignatureDescriptor.encode(v!, writer.uint32(10).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): SignatureDescriptors {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseSignatureDescriptors } as SignatureDescriptors;
message.signatures = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.signatures.push(SignatureDescriptor.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): SignatureDescriptors {
const message = { ...baseSignatureDescriptors } as SignatureDescriptors;
message.signatures = [];
if (object.signatures !== undefined && object.signatures !== null) {
for (const e of object.signatures) {
message.signatures.push(SignatureDescriptor.fromJSON(e));
}
}
return message;
},
toJSON(message: SignatureDescriptors): unknown {
const obj: any = {};
if (message.signatures) {
obj.signatures = message.signatures.map((e) => (e ? SignatureDescriptor.toJSON(e) : undefined));
} else {
obj.signatures = [];
}
return obj;
},
fromPartial(object: DeepPartial<SignatureDescriptors>): SignatureDescriptors {
const message = { ...baseSignatureDescriptors } as SignatureDescriptors;
message.signatures = [];
if (object.signatures !== undefined && object.signatures !== null) {
for (const e of object.signatures) {
message.signatures.push(SignatureDescriptor.fromPartial(e));
}
}
return message;
},
};
const baseSignatureDescriptor: object = { sequence: Long.UZERO };
export const SignatureDescriptor = {
encode(message: SignatureDescriptor, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.publicKey !== undefined) {
Any.encode(message.publicKey, writer.uint32(10).fork()).ldelim();
}
if (message.data !== undefined) {
SignatureDescriptor_Data.encode(message.data, writer.uint32(18).fork()).ldelim();
}
if (!message.sequence.isZero()) {
writer.uint32(24).uint64(message.sequence);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): SignatureDescriptor {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseSignatureDescriptor } as SignatureDescriptor;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.publicKey = Any.decode(reader, reader.uint32());
break;
case 2:
message.data = SignatureDescriptor_Data.decode(reader, reader.uint32());
break;
case 3:
message.sequence = reader.uint64() as Long;
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): SignatureDescriptor {
const message = { ...baseSignatureDescriptor } as SignatureDescriptor;
if (object.publicKey !== undefined && object.publicKey !== null) {
message.publicKey = Any.fromJSON(object.publicKey);
} else {
message.publicKey = undefined;
}
if (object.data !== undefined && object.data !== null) {
message.data = SignatureDescriptor_Data.fromJSON(object.data);
} else {
message.data = undefined;
}
if (object.sequence !== undefined && object.sequence !== null) {
message.sequence = Long.fromString(object.sequence);
} else {
message.sequence = Long.UZERO;
}
return message;
},
toJSON(message: SignatureDescriptor): unknown {
const obj: any = {};
message.publicKey !== undefined &&
(obj.publicKey = message.publicKey ? Any.toJSON(message.publicKey) : undefined);
message.data !== undefined &&
(obj.data = message.data ? SignatureDescriptor_Data.toJSON(message.data) : undefined);
message.sequence !== undefined && (obj.sequence = (message.sequence || Long.UZERO).toString());
return obj;
},
fromPartial(object: DeepPartial<SignatureDescriptor>): SignatureDescriptor {
const message = { ...baseSignatureDescriptor } as SignatureDescriptor;
if (object.publicKey !== undefined && object.publicKey !== null) {
message.publicKey = Any.fromPartial(object.publicKey);
} else {
message.publicKey = undefined;
}
if (object.data !== undefined && object.data !== null) {
message.data = SignatureDescriptor_Data.fromPartial(object.data);
} else {
message.data = undefined;
}
if (object.sequence !== undefined && object.sequence !== null) {
message.sequence = object.sequence as Long;
} else {
message.sequence = Long.UZERO;
}
return message;
},
};
const baseSignatureDescriptor_Data: object = {};
export const SignatureDescriptor_Data = {
encode(message: SignatureDescriptor_Data, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.single !== undefined) {
SignatureDescriptor_Data_Single.encode(message.single, writer.uint32(10).fork()).ldelim();
}
if (message.multi !== undefined) {
SignatureDescriptor_Data_Multi.encode(message.multi, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): SignatureDescriptor_Data {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseSignatureDescriptor_Data } as SignatureDescriptor_Data;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.single = SignatureDescriptor_Data_Single.decode(reader, reader.uint32());
break;
case 2:
message.multi = SignatureDescriptor_Data_Multi.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): SignatureDescriptor_Data {
const message = { ...baseSignatureDescriptor_Data } as SignatureDescriptor_Data;
if (object.single !== undefined && object.single !== null) {
message.single = SignatureDescriptor_Data_Single.fromJSON(object.single);
} else {
message.single = undefined;
}
if (object.multi !== undefined && object.multi !== null) {
message.multi = SignatureDescriptor_Data_Multi.fromJSON(object.multi);
} else {
message.multi = undefined;
}
return message;
},
toJSON(message: SignatureDescriptor_Data): unknown {
const obj: any = {};
message.single !== undefined &&
(obj.single = message.single ? SignatureDescriptor_Data_Single.toJSON(message.single) : undefined);
message.multi !== undefined &&
(obj.multi = message.multi ? SignatureDescriptor_Data_Multi.toJSON(message.multi) : undefined);
return obj;
},
fromPartial(object: DeepPartial<SignatureDescriptor_Data>): SignatureDescriptor_Data {
const message = { ...baseSignatureDescriptor_Data } as SignatureDescriptor_Data;
if (object.single !== undefined && object.single !== null) {
message.single = SignatureDescriptor_Data_Single.fromPartial(object.single);
} else {
message.single = undefined;
}
if (object.multi !== undefined && object.multi !== null) {
message.multi = SignatureDescriptor_Data_Multi.fromPartial(object.multi);
} else {
message.multi = undefined;
}
return message;
},
};
const baseSignatureDescriptor_Data_Single: object = { mode: 0 };
export const SignatureDescriptor_Data_Single = {
encode(message: SignatureDescriptor_Data_Single, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.mode !== 0) {
writer.uint32(8).int32(message.mode);
}
if (message.signature.length !== 0) {
writer.uint32(18).bytes(message.signature);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): SignatureDescriptor_Data_Single {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseSignatureDescriptor_Data_Single } as SignatureDescriptor_Data_Single;
message.signature = new Uint8Array();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.mode = reader.int32() as any;
break;
case 2:
message.signature = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): SignatureDescriptor_Data_Single {
const message = { ...baseSignatureDescriptor_Data_Single } as SignatureDescriptor_Data_Single;
message.signature = new Uint8Array();
if (object.mode !== undefined && object.mode !== null) {
message.mode = signModeFromJSON(object.mode);
} else {
message.mode = 0;
}
if (object.signature !== undefined && object.signature !== null) {
message.signature = bytesFromBase64(object.signature);
}
return message;
},
toJSON(message: SignatureDescriptor_Data_Single): unknown {
const obj: any = {};
message.mode !== undefined && (obj.mode = signModeToJSON(message.mode));
message.signature !== undefined &&
(obj.signature = base64FromBytes(
message.signature !== undefined ? message.signature : new Uint8Array(),
));
return obj;
},
fromPartial(object: DeepPartial<SignatureDescriptor_Data_Single>): SignatureDescriptor_Data_Single {
const message = { ...baseSignatureDescriptor_Data_Single } as SignatureDescriptor_Data_Single;
if (object.mode !== undefined && object.mode !== null) {
message.mode = object.mode;
} else {
message.mode = 0;
}
if (object.signature !== undefined && object.signature !== null) {
message.signature = object.signature;
} else {
message.signature = new Uint8Array();
}
return message;
},
};
const baseSignatureDescriptor_Data_Multi: object = {};
export const SignatureDescriptor_Data_Multi = {
encode(message: SignatureDescriptor_Data_Multi, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.bitarray !== undefined) {
CompactBitArray.encode(message.bitarray, writer.uint32(10).fork()).ldelim();
}
for (const v of message.signatures) {
SignatureDescriptor_Data.encode(v!, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): SignatureDescriptor_Data_Multi {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseSignatureDescriptor_Data_Multi } as SignatureDescriptor_Data_Multi;
message.signatures = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.bitarray = CompactBitArray.decode(reader, reader.uint32());
break;
case 2:
message.signatures.push(SignatureDescriptor_Data.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): SignatureDescriptor_Data_Multi {
const message = { ...baseSignatureDescriptor_Data_Multi } as SignatureDescriptor_Data_Multi;
message.signatures = [];
if (object.bitarray !== undefined && object.bitarray !== null) {
message.bitarray = CompactBitArray.fromJSON(object.bitarray);
} else {
message.bitarray = undefined;
}
if (object.signatures !== undefined && object.signatures !== null) {
for (const e of object.signatures) {
message.signatures.push(SignatureDescriptor_Data.fromJSON(e));
}
}
return message;
},
toJSON(message: SignatureDescriptor_Data_Multi): unknown {
const obj: any = {};
message.bitarray !== undefined &&
(obj.bitarray = message.bitarray ? CompactBitArray.toJSON(message.bitarray) : undefined);
if (message.signatures) {
obj.signatures = message.signatures.map((e) => (e ? SignatureDescriptor_Data.toJSON(e) : undefined));
} else {
obj.signatures = [];
}
return obj;
},
fromPartial(object: DeepPartial<SignatureDescriptor_Data_Multi>): SignatureDescriptor_Data_Multi {
const message = { ...baseSignatureDescriptor_Data_Multi } as SignatureDescriptor_Data_Multi;
message.signatures = [];
if (object.bitarray !== undefined && object.bitarray !== null) {
message.bitarray = CompactBitArray.fromPartial(object.bitarray);
} else {
message.bitarray = undefined;
}
if (object.signatures !== undefined && object.signatures !== null) {
for (const e of object.signatures) {
message.signatures.push(SignatureDescriptor_Data.fromPartial(e));
}
}
return message;
},
};
declare var self: any | undefined;
declare var window: any | undefined;
var globalThis: any = (() => {
if (typeof globalThis !== "undefined") return globalThis;
if (typeof self !== "undefined") return self;
if (typeof window !== "undefined") return window;
if (typeof global !== "undefined") return global;
throw "Unable to locate global object";
})();
const atob: (b64: string) => string =
globalThis.atob || ((b64) => globalThis.Buffer.from(b64, "base64").toString("binary"));
function bytesFromBase64(b64: string): Uint8Array {
const bin = atob(b64);
const arr = new Uint8Array(bin.length);
for (let i = 0; i < bin.length; ++i) {
arr[i] = bin.charCodeAt(i);
}
return arr;
}
const btoa: (bin: string) => string =
globalThis.btoa || ((bin) => globalThis.Buffer.from(bin, "binary").toString("base64"));
function base64FromBytes(arr: Uint8Array): string {
const bin: string[] = [];
for (let i = 0; i < arr.byteLength; ++i) {
bin.push(String.fromCharCode(arr[i]));
}
return btoa(bin.join(""));
}
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

1206
packages/stargate/src/codec/cosmos/tx/v1beta1/tx.ts
View File

File diff suppressed because it is too large Load Diff

525
packages/stargate/src/codec/cosmos/vesting/v1beta1/vesting.ts
View File

@ -1,525 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
import { BaseAccount } from "../../../cosmos/auth/v1beta1/auth";
import { Coin } from "../../../cosmos/base/v1beta1/coin";
export const protobufPackage = "cosmos.vesting.v1beta1";
/**
* BaseVestingAccount implements the VestingAccount interface. It contains all
* the necessary fields needed for any vesting account implementation.
*/
export interface BaseVestingAccount {
baseAccount?: BaseAccount;
originalVesting: Coin[];
delegatedFree: Coin[];
delegatedVesting: Coin[];
endTime: Long;
}
/**
* ContinuousVestingAccount implements the VestingAccount interface. It
* continuously vests by unlocking coins linearly with respect to time.
*/
export interface ContinuousVestingAccount {
baseVestingAccount?: BaseVestingAccount;
startTime: Long;
}
/**
* DelayedVestingAccount implements the VestingAccount interface. It vests all
* coins after a specific time, but non prior. In other words, it keeps them
* locked until a specified time.
*/
export interface DelayedVestingAccount {
baseVestingAccount?: BaseVestingAccount;
}
/** Period defines a length of time and amount of coins that will vest. */
export interface Period {
length: Long;
amount: Coin[];
}
/**
* PeriodicVestingAccount implements the VestingAccount interface. It
* periodically vests by unlocking coins during each specified period.
*/
export interface PeriodicVestingAccount {
baseVestingAccount?: BaseVestingAccount;
startTime: Long;
vestingPeriods: Period[];
}
const baseBaseVestingAccount: object = { endTime: Long.ZERO };
export const BaseVestingAccount = {
encode(message: BaseVestingAccount, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.baseAccount !== undefined) {
BaseAccount.encode(message.baseAccount, writer.uint32(10).fork()).ldelim();
}
for (const v of message.originalVesting) {
Coin.encode(v!, writer.uint32(18).fork()).ldelim();
}
for (const v of message.delegatedFree) {
Coin.encode(v!, writer.uint32(26).fork()).ldelim();
}
for (const v of message.delegatedVesting) {
Coin.encode(v!, writer.uint32(34).fork()).ldelim();
}
if (!message.endTime.isZero()) {
writer.uint32(40).int64(message.endTime);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): BaseVestingAccount {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseBaseVestingAccount } as BaseVestingAccount;
message.originalVesting = [];
message.delegatedFree = [];
message.delegatedVesting = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.baseAccount = BaseAccount.decode(reader, reader.uint32());
break;
case 2:
message.originalVesting.push(Coin.decode(reader, reader.uint32()));
break;
case 3:
message.delegatedFree.push(Coin.decode(reader, reader.uint32()));
break;
case 4:
message.delegatedVesting.push(Coin.decode(reader, reader.uint32()));
break;
case 5:
message.endTime = reader.int64() as Long;
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): BaseVestingAccount {
const message = { ...baseBaseVestingAccount } as BaseVestingAccount;
message.originalVesting = [];
message.delegatedFree = [];
message.delegatedVesting = [];
if (object.baseAccount !== undefined && object.baseAccount !== null) {
message.baseAccount = BaseAccount.fromJSON(object.baseAccount);
} else {
message.baseAccount = undefined;
}
if (object.originalVesting !== undefined && object.originalVesting !== null) {
for (const e of object.originalVesting) {
message.originalVesting.push(Coin.fromJSON(e));
}
}
if (object.delegatedFree !== undefined && object.delegatedFree !== null) {
for (const e of object.delegatedFree) {
message.delegatedFree.push(Coin.fromJSON(e));
}
}
if (object.delegatedVesting !== undefined && object.delegatedVesting !== null) {
for (const e of object.delegatedVesting) {
message.delegatedVesting.push(Coin.fromJSON(e));
}
}
if (object.endTime !== undefined && object.endTime !== null) {
message.endTime = Long.fromString(object.endTime);
} else {
message.endTime = Long.ZERO;
}
return message;
},
toJSON(message: BaseVestingAccount): unknown {
const obj: any = {};
message.baseAccount !== undefined &&
(obj.baseAccount = message.baseAccount ? BaseAccount.toJSON(message.baseAccount) : undefined);
if (message.originalVesting) {
obj.originalVesting = message.originalVesting.map((e) => (e ? Coin.toJSON(e) : undefined));
} else {
obj.originalVesting = [];
}
if (message.delegatedFree) {
obj.delegatedFree = message.delegatedFree.map((e) => (e ? Coin.toJSON(e) : undefined));
} else {
obj.delegatedFree = [];
}
if (message.delegatedVesting) {
obj.delegatedVesting = message.delegatedVesting.map((e) => (e ? Coin.toJSON(e) : undefined));
} else {
obj.delegatedVesting = [];
}
message.endTime !== undefined && (obj.endTime = (message.endTime || Long.ZERO).toString());
return obj;
},
fromPartial(object: DeepPartial<BaseVestingAccount>): BaseVestingAccount {
const message = { ...baseBaseVestingAccount } as BaseVestingAccount;
message.originalVesting = [];
message.delegatedFree = [];
message.delegatedVesting = [];
if (object.baseAccount !== undefined && object.baseAccount !== null) {
message.baseAccount = BaseAccount.fromPartial(object.baseAccount);
} else {
message.baseAccount = undefined;
}
if (object.originalVesting !== undefined && object.originalVesting !== null) {
for (const e of object.originalVesting) {
message.originalVesting.push(Coin.fromPartial(e));
}
}
if (object.delegatedFree !== undefined && object.delegatedFree !== null) {
for (const e of object.delegatedFree) {
message.delegatedFree.push(Coin.fromPartial(e));
}
}
if (object.delegatedVesting !== undefined && object.delegatedVesting !== null) {
for (const e of object.delegatedVesting) {
message.delegatedVesting.push(Coin.fromPartial(e));
}
}
if (object.endTime !== undefined && object.endTime !== null) {
message.endTime = object.endTime as Long;
} else {
message.endTime = Long.ZERO;
}
return message;
},
};
const baseContinuousVestingAccount: object = { startTime: Long.ZERO };
export const ContinuousVestingAccount = {
encode(message: ContinuousVestingAccount, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.baseVestingAccount !== undefined) {
BaseVestingAccount.encode(message.baseVestingAccount, writer.uint32(10).fork()).ldelim();
}
if (!message.startTime.isZero()) {
writer.uint32(16).int64(message.startTime);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): ContinuousVestingAccount {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseContinuousVestingAccount } as ContinuousVestingAccount;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.baseVestingAccount = BaseVestingAccount.decode(reader, reader.uint32());
break;
case 2:
message.startTime = reader.int64() as Long;
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): ContinuousVestingAccount {
const message = { ...baseContinuousVestingAccount } as ContinuousVestingAccount;
if (object.baseVestingAccount !== undefined && object.baseVestingAccount !== null) {
message.baseVestingAccount = BaseVestingAccount.fromJSON(object.baseVestingAccount);
} else {
message.baseVestingAccount = undefined;
}
if (object.startTime !== undefined && object.startTime !== null) {
message.startTime = Long.fromString(object.startTime);
} else {
message.startTime = Long.ZERO;
}
return message;
},
toJSON(message: ContinuousVestingAccount): unknown {
const obj: any = {};
message.baseVestingAccount !== undefined &&
(obj.baseVestingAccount = message.baseVestingAccount
? BaseVestingAccount.toJSON(message.baseVestingAccount)
: undefined);
message.startTime !== undefined && (obj.startTime = (message.startTime || Long.ZERO).toString());
return obj;
},
fromPartial(object: DeepPartial<ContinuousVestingAccount>): ContinuousVestingAccount {
const message = { ...baseContinuousVestingAccount } as ContinuousVestingAccount;
if (object.baseVestingAccount !== undefined && object.baseVestingAccount !== null) {
message.baseVestingAccount = BaseVestingAccount.fromPartial(object.baseVestingAccount);
} else {
message.baseVestingAccount = undefined;
}
if (object.startTime !== undefined && object.startTime !== null) {
message.startTime = object.startTime as Long;
} else {
message.startTime = Long.ZERO;
}
return message;
},
};
const baseDelayedVestingAccount: object = {};
export const DelayedVestingAccount = {
encode(message: DelayedVestingAccount, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.baseVestingAccount !== undefined) {
BaseVestingAccount.encode(message.baseVestingAccount, writer.uint32(10).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): DelayedVestingAccount {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseDelayedVestingAccount } as DelayedVestingAccount;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.baseVestingAccount = BaseVestingAccount.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): DelayedVestingAccount {
const message = { ...baseDelayedVestingAccount } as DelayedVestingAccount;
if (object.baseVestingAccount !== undefined && object.baseVestingAccount !== null) {
message.baseVestingAccount = BaseVestingAccount.fromJSON(object.baseVestingAccount);
} else {
message.baseVestingAccount = undefined;
}
return message;
},
toJSON(message: DelayedVestingAccount): unknown {
const obj: any = {};
message.baseVestingAccount !== undefined &&
(obj.baseVestingAccount = message.baseVestingAccount
? BaseVestingAccount.toJSON(message.baseVestingAccount)
: undefined);
return obj;
},
fromPartial(object: DeepPartial<DelayedVestingAccount>): DelayedVestingAccount {
const message = { ...baseDelayedVestingAccount } as DelayedVestingAccount;
if (object.baseVestingAccount !== undefined && object.baseVestingAccount !== null) {
message.baseVestingAccount = BaseVestingAccount.fromPartial(object.baseVestingAccount);
} else {
message.baseVestingAccount = undefined;
}
return message;
},
};
const basePeriod: object = { length: Long.ZERO };
export const Period = {
encode(message: Period, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (!message.length.isZero()) {
writer.uint32(8).int64(message.length);
}
for (const v of message.amount) {
Coin.encode(v!, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): Period {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...basePeriod } as Period;
message.amount = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.length = reader.int64() as Long;
break;
case 2:
message.amount.push(Coin.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): Period {
const message = { ...basePeriod } as Period;
message.amount = [];
if (object.length !== undefined && object.length !== null) {
message.length = Long.fromString(object.length);
} else {
message.length = Long.ZERO;
}
if (object.amount !== undefined && object.amount !== null) {
for (const e of object.amount) {
message.amount.push(Coin.fromJSON(e));
}
}
return message;
},
toJSON(message: Period): unknown {
const obj: any = {};
message.length !== undefined && (obj.length = (message.length || Long.ZERO).toString());
if (message.amount) {
obj.amount = message.amount.map((e) => (e ? Coin.toJSON(e) : undefined));
} else {
obj.amount = [];
}
return obj;
},
fromPartial(object: DeepPartial<Period>): Period {
const message = { ...basePeriod } as Period;
message.amount = [];
if (object.length !== undefined && object.length !== null) {
message.length = object.length as Long;
} else {
message.length = Long.ZERO;
}
if (object.amount !== undefined && object.amount !== null) {
for (const e of object.amount) {
message.amount.push(Coin.fromPartial(e));
}
}
return message;
},
};
const basePeriodicVestingAccount: object = { startTime: Long.ZERO };
export const PeriodicVestingAccount = {
encode(message: PeriodicVestingAccount, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.baseVestingAccount !== undefined) {
BaseVestingAccount.encode(message.baseVestingAccount, writer.uint32(10).fork()).ldelim();
}
if (!message.startTime.isZero()) {
writer.uint32(16).int64(message.startTime);
}
for (const v of message.vestingPeriods) {
Period.encode(v!, writer.uint32(26).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): PeriodicVestingAccount {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...basePeriodicVestingAccount } as PeriodicVestingAccount;
message.vestingPeriods = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.baseVestingAccount = BaseVestingAccount.decode(reader, reader.uint32());
break;
case 2:
message.startTime = reader.int64() as Long;
break;
case 3:
message.vestingPeriods.push(Period.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): PeriodicVestingAccount {
const message = { ...basePeriodicVestingAccount } as PeriodicVestingAccount;
message.vestingPeriods = [];
if (object.baseVestingAccount !== undefined && object.baseVestingAccount !== null) {
message.baseVestingAccount = BaseVestingAccount.fromJSON(object.baseVestingAccount);
} else {
message.baseVestingAccount = undefined;
}
if (object.startTime !== undefined && object.startTime !== null) {
message.startTime = Long.fromString(object.startTime);
} else {
message.startTime = Long.ZERO;
}
if (object.vestingPeriods !== undefined && object.vestingPeriods !== null) {
for (const e of object.vestingPeriods) {
message.vestingPeriods.push(Period.fromJSON(e));
}
}
return message;
},
toJSON(message: PeriodicVestingAccount): unknown {
const obj: any = {};
message.baseVestingAccount !== undefined &&
(obj.baseVestingAccount = message.baseVestingAccount
? BaseVestingAccount.toJSON(message.baseVestingAccount)
: undefined);
message.startTime !== undefined && (obj.startTime = (message.startTime || Long.ZERO).toString());
if (message.vestingPeriods) {
obj.vestingPeriods = message.vestingPeriods.map((e) => (e ? Period.toJSON(e) : undefined));
} else {
obj.vestingPeriods = [];
}
return obj;
},
fromPartial(object: DeepPartial<PeriodicVestingAccount>): PeriodicVestingAccount {
const message = { ...basePeriodicVestingAccount } as PeriodicVestingAccount;
message.vestingPeriods = [];
if (object.baseVestingAccount !== undefined && object.baseVestingAccount !== null) {
message.baseVestingAccount = BaseVestingAccount.fromPartial(object.baseVestingAccount);
} else {
message.baseVestingAccount = undefined;
}
if (object.startTime !== undefined && object.startTime !== null) {
message.startTime = object.startTime as Long;
} else {
message.startTime = Long.ZERO;
}
if (object.vestingPeriods !== undefined && object.vestingPeriods !== null) {
for (const e of object.vestingPeriods) {
message.vestingPeriods.push(Period.fromPartial(e));
}
}
return message;
},
};
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

241
packages/stargate/src/codec/google/protobuf/any.ts
View File

@ -1,241 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
export const protobufPackage = "google.protobuf";
/**
* `Any` contains an arbitrary serialized protocol buffer message along with a
* URL that describes the type of the serialized message.
*
* Protobuf library provides support to pack/unpack Any values in the form
* of utility functions or additional generated methods of the Any type.
*
* Example 1: Pack and unpack a message in C++.
*
* Foo foo = ...;
* Any any;
* any.PackFrom(foo);
* ...
* if (any.UnpackTo(&foo)) {
* ...
* }
*
* Example 2: Pack and unpack a message in Java.
*
* Foo foo = ...;
* Any any = Any.pack(foo);
* ...
* if (any.is(Foo.class)) {
* foo = any.unpack(Foo.class);
* }
*
* Example 3: Pack and unpack a message in Python.
*
* foo = Foo(...)
* any = Any()
* any.Pack(foo)
* ...
* if any.Is(Foo.DESCRIPTOR):
* any.Unpack(foo)
* ...
*
* Example 4: Pack and unpack a message in Go
*
* foo := &pb.Foo{...}
* any, err := ptypes.MarshalAny(foo)
* ...
* foo := &pb.Foo{}
* if err := ptypes.UnmarshalAny(any, foo); err != nil {
* ...
* }
*
* The pack methods provided by protobuf library will by default use
* 'type.googleapis.com/full.type.name' as the type URL and the unpack
* methods only use the fully qualified type name after the last '/'
* in the type URL, for example "foo.bar.com/x/y.z" will yield type
* name "y.z".
*
*
* JSON
* ====
* The JSON representation of an `Any` value uses the regular
* representation of the deserialized, embedded message, with an
* additional field `@type` which contains the type URL. Example:
*
* package google.profile;
* message Person {
* string first_name = 1;
* string last_name = 2;
* }
*
* {
* "@type": "type.googleapis.com/google.profile.Person",
* "firstName": <string>,
* "lastName": <string>
* }
*
* If the embedded message type is well-known and has a custom JSON
* representation, that representation will be embedded adding a field
* `value` which holds the custom JSON in addition to the `@type`
* field. Example (for message [google.protobuf.Duration][]):
*
* {
* "@type": "type.googleapis.com/google.protobuf.Duration",
* "value": "1.212s"
* }
*/
export interface Any {
/**
* A URL/resource name that uniquely identifies the type of the serialized
* protocol buffer message. This string must contain at least
* one "/" character. The last segment of the URL's path must represent
* the fully qualified name of the type (as in
* `path/google.protobuf.Duration`). The name should be in a canonical form
* (e.g., leading "." is not accepted).
*
* In practice, teams usually precompile into the binary all types that they
* expect it to use in the context of Any. However, for URLs which use the
* scheme `http`, `https`, or no scheme, one can optionally set up a type
* server that maps type URLs to message definitions as follows:
*
* * If no scheme is provided, `https` is assumed.
* * An HTTP GET on the URL must yield a [google.protobuf.Type][]
* value in binary format, or produce an error.
* * Applications are allowed to cache lookup results based on the
* URL, or have them precompiled into a binary to avoid any
* lookup. Therefore, binary compatibility needs to be preserved
* on changes to types. (Use versioned type names to manage
* breaking changes.)
*
* Note: this functionality is not currently available in the official
* protobuf release, and it is not used for type URLs beginning with
* type.googleapis.com.
*
* Schemes other than `http`, `https` (or the empty scheme) might be
* used with implementation specific semantics.
*/
typeUrl: string;
/** Must be a valid serialized protocol buffer of the above specified type. */
value: Uint8Array;
}
const baseAny: object = { typeUrl: "" };
export const Any = {
encode(message: Any, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.typeUrl !== "") {
writer.uint32(10).string(message.typeUrl);
}
if (message.value.length !== 0) {
writer.uint32(18).bytes(message.value);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): Any {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseAny } as Any;
message.value = new Uint8Array();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.typeUrl = reader.string();
break;
case 2:
message.value = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): Any {
const message = { ...baseAny } as Any;
message.value = new Uint8Array();
if (object.typeUrl !== undefined && object.typeUrl !== null) {
message.typeUrl = String(object.typeUrl);
} else {
message.typeUrl = "";
}
if (object.value !== undefined && object.value !== null) {
message.value = bytesFromBase64(object.value);
}
return message;
},
toJSON(message: Any): unknown {
const obj: any = {};
message.typeUrl !== undefined && (obj.typeUrl = message.typeUrl);
message.value !== undefined &&
(obj.value = base64FromBytes(message.value !== undefined ? message.value : new Uint8Array()));
return obj;
},
fromPartial(object: DeepPartial<Any>): Any {
const message = { ...baseAny } as Any;
if (object.typeUrl !== undefined && object.typeUrl !== null) {
message.typeUrl = object.typeUrl;
} else {
message.typeUrl = "";
}
if (object.value !== undefined && object.value !== null) {
message.value = object.value;
} else {
message.value = new Uint8Array();
}
return message;
},
};
declare var self: any | undefined;
declare var window: any | undefined;
var globalThis: any = (() => {
if (typeof globalThis !== "undefined") return globalThis;
if (typeof self !== "undefined") return self;
if (typeof window !== "undefined") return window;
if (typeof global !== "undefined") return global;
throw "Unable to locate global object";
})();
const atob: (b64: string) => string =
globalThis.atob || ((b64) => globalThis.Buffer.from(b64, "base64").toString("binary"));
function bytesFromBase64(b64: string): Uint8Array {
const bin = atob(b64);
const arr = new Uint8Array(bin.length);
for (let i = 0; i < bin.length; ++i) {
arr[i] = bin.charCodeAt(i);
}
return arr;
}
const btoa: (bin: string) => string =
globalThis.btoa || ((bin) => globalThis.Buffer.from(bin, "binary").toString("base64"));
function base64FromBytes(arr: Uint8Array): string {
const bin: string[] = [];
for (let i = 0; i < arr.byteLength; ++i) {
bin.push(String.fromCharCode(arr[i]));
}
return btoa(bin.join(""));
}
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

171
packages/stargate/src/codec/google/protobuf/duration.ts
View File

@ -1,171 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
export const protobufPackage = "google.protobuf";
/**
* A Duration represents a signed, fixed-length span of time represented
* as a count of seconds and fractions of seconds at nanosecond
* resolution. It is independent of any calendar and concepts like "day"
* or "month". It is related to Timestamp in that the difference between
* two Timestamp values is a Duration and it can be added or subtracted
* from a Timestamp. Range is approximately +-10,000 years.
*
* # Examples
*
* Example 1: Compute Duration from two Timestamps in pseudo code.
*
* Timestamp start = ...;
* Timestamp end = ...;
* Duration duration = ...;
*
* duration.seconds = end.seconds - start.seconds;
* duration.nanos = end.nanos - start.nanos;
*
* if (duration.seconds < 0 && duration.nanos > 0) {
* duration.seconds += 1;
* duration.nanos -= 1000000000;
* } else if (duration.seconds > 0 && duration.nanos < 0) {
* duration.seconds -= 1;
* duration.nanos += 1000000000;
* }
*
* Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
*
* Timestamp start = ...;
* Duration duration = ...;
* Timestamp end = ...;
*
* end.seconds = start.seconds + duration.seconds;
* end.nanos = start.nanos + duration.nanos;
*
* if (end.nanos < 0) {
* end.seconds -= 1;
* end.nanos += 1000000000;
* } else if (end.nanos >= 1000000000) {
* end.seconds += 1;
* end.nanos -= 1000000000;
* }
*
* Example 3: Compute Duration from datetime.timedelta in Python.
*
* td = datetime.timedelta(days=3, minutes=10)
* duration = Duration()
* duration.FromTimedelta(td)
*
* # JSON Mapping
*
* In JSON format, the Duration type is encoded as a string rather than an
* object, where the string ends in the suffix "s" (indicating seconds) and
* is preceded by the number of seconds, with nanoseconds expressed as
* fractional seconds. For example, 3 seconds with 0 nanoseconds should be
* encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
* be expressed in JSON format as "3.000000001s", and 3 seconds and 1
* microsecond should be expressed in JSON format as "3.000001s".
*/
export interface Duration {
/**
* Signed seconds of the span of time. Must be from -315,576,000,000
* to +315,576,000,000 inclusive. Note: these bounds are computed from:
* 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
*/
seconds: Long;
/**
* Signed fractions of a second at nanosecond resolution of the span
* of time. Durations less than one second are represented with a 0
* `seconds` field and a positive or negative `nanos` field. For durations
* of one second or more, a non-zero value for the `nanos` field must be
* of the same sign as the `seconds` field. Must be from -999,999,999
* to +999,999,999 inclusive.
*/
nanos: number;
}
const baseDuration: object = { seconds: Long.ZERO, nanos: 0 };
export const Duration = {
encode(message: Duration, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (!message.seconds.isZero()) {
writer.uint32(8).int64(message.seconds);
}
if (message.nanos !== 0) {
writer.uint32(16).int32(message.nanos);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): Duration {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseDuration } as Duration;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.seconds = reader.int64() as Long;
break;
case 2:
message.nanos = reader.int32();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): Duration {
const message = { ...baseDuration } as Duration;
if (object.seconds !== undefined && object.seconds !== null) {
message.seconds = Long.fromString(object.seconds);
} else {
message.seconds = Long.ZERO;
}
if (object.nanos !== undefined && object.nanos !== null) {
message.nanos = Number(object.nanos);
} else {
message.nanos = 0;
}
return message;
},
toJSON(message: Duration): unknown {
const obj: any = {};
message.seconds !== undefined && (obj.seconds = (message.seconds || Long.ZERO).toString());
message.nanos !== undefined && (obj.nanos = message.nanos);
return obj;
},
fromPartial(object: DeepPartial<Duration>): Duration {
const message = { ...baseDuration } as Duration;
if (object.seconds !== undefined && object.seconds !== null) {
message.seconds = object.seconds as Long;
} else {
message.seconds = Long.ZERO;
}
if (object.nanos !== undefined && object.nanos !== null) {
message.nanos = object.nanos;
} else {
message.nanos = 0;
}
return message;
},
};
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

202
packages/stargate/src/codec/google/protobuf/timestamp.ts
View File

@ -1,202 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
export const protobufPackage = "google.protobuf";
/**
* A Timestamp represents a point in time independent of any time zone or local
* calendar, encoded as a count of seconds and fractions of seconds at
* nanosecond resolution. The count is relative to an epoch at UTC midnight on
* January 1, 1970, in the proleptic Gregorian calendar which extends the
* Gregorian calendar backwards to year one.
*
* All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
* second table is needed for interpretation, using a [24-hour linear
* smear](https://developers.google.com/time/smear).
*
* The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
* restricting to that range, we ensure that we can convert to and from [RFC
* 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
*
* # Examples
*
* Example 1: Compute Timestamp from POSIX `time()`.
*
* Timestamp timestamp;
* timestamp.set_seconds(time(NULL));
* timestamp.set_nanos(0);
*
* Example 2: Compute Timestamp from POSIX `gettimeofday()`.
*
* struct timeval tv;
* gettimeofday(&tv, NULL);
*
* Timestamp timestamp;
* timestamp.set_seconds(tv.tv_sec);
* timestamp.set_nanos(tv.tv_usec * 1000);
*
* Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
*
* FILETIME ft;
* GetSystemTimeAsFileTime(&ft);
* UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
*
* // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
* // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
* Timestamp timestamp;
* timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
* timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
*
* Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
*
* long millis = System.currentTimeMillis();
*
* Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
* .setNanos((int) ((millis % 1000) * 1000000)).build();
*
*
* Example 5: Compute Timestamp from Java `Instant.now()`.
*
* Instant now = Instant.now();
*
* Timestamp timestamp =
* Timestamp.newBuilder().setSeconds(now.getEpochSecond())
* .setNanos(now.getNano()).build();
*
*
* Example 6: Compute Timestamp from current time in Python.
*
* timestamp = Timestamp()
* timestamp.GetCurrentTime()
*
* # JSON Mapping
*
* In JSON format, the Timestamp type is encoded as a string in the
* [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
* format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
* where {year} is always expressed using four digits while {month}, {day},
* {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
* seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
* are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
* is required. A proto3 JSON serializer should always use UTC (as indicated by
* "Z") when printing the Timestamp type and a proto3 JSON parser should be
* able to accept both UTC and other timezones (as indicated by an offset).
*
* For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
* 01:30 UTC on January 15, 2017.
*
* In JavaScript, one can convert a Date object to this format using the
* standard
* [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
* method. In Python, a standard `datetime.datetime` object can be converted
* to this format using
* [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
* the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
* the Joda Time's [`ISODateTimeFormat.dateTime()`](
* http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D
* ) to obtain a formatter capable of generating timestamps in this format.
*/
export interface Timestamp {
/**
* Represents seconds of UTC time since Unix epoch
* 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
* 9999-12-31T23:59:59Z inclusive.
*/
seconds: Long;
/**
* Non-negative fractions of a second at nanosecond resolution. Negative
* second values with fractions must still have non-negative nanos values
* that count forward in time. Must be from 0 to 999,999,999
* inclusive.
*/
nanos: number;
}
const baseTimestamp: object = { seconds: Long.ZERO, nanos: 0 };
export const Timestamp = {
encode(message: Timestamp, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (!message.seconds.isZero()) {
writer.uint32(8).int64(message.seconds);
}
if (message.nanos !== 0) {
writer.uint32(16).int32(message.nanos);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): Timestamp {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseTimestamp } as Timestamp;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.seconds = reader.int64() as Long;
break;
case 2:
message.nanos = reader.int32();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): Timestamp {
const message = { ...baseTimestamp } as Timestamp;
if (object.seconds !== undefined && object.seconds !== null) {
message.seconds = Long.fromString(object.seconds);
} else {
message.seconds = Long.ZERO;
}
if (object.nanos !== undefined && object.nanos !== null) {
message.nanos = Number(object.nanos);
} else {
message.nanos = 0;
}
return message;
},
toJSON(message: Timestamp): unknown {
const obj: any = {};
message.seconds !== undefined && (obj.seconds = (message.seconds || Long.ZERO).toString());
message.nanos !== undefined && (obj.nanos = message.nanos);
return obj;
},
fromPartial(object: DeepPartial<Timestamp>): Timestamp {
const message = { ...baseTimestamp } as Timestamp;
if (object.seconds !== undefined && object.seconds !== null) {
message.seconds = object.seconds as Long;
} else {
message.seconds = Long.ZERO;
}
if (object.nanos !== undefined && object.nanos !== null) {
message.nanos = object.nanos;
} else {
message.nanos = 0;
}
return message;
},
};
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

448
packages/stargate/src/codec/ibc/applications/transfer/v1/query.ts
View File

@ -1,448 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
import { DenomTrace, Params } from "../../../../ibc/applications/transfer/v1/transfer";
import { PageRequest, PageResponse } from "../../../../cosmos/base/query/v1beta1/pagination";
export const protobufPackage = "ibc.applications.transfer.v1";
/**
* QueryDenomTraceRequest is the request type for the Query/DenomTrace RPC
* method
*/
export interface QueryDenomTraceRequest {
/** hash (in hex format) of the denomination trace information. */
hash: string;
}
/**
* QueryDenomTraceResponse is the response type for the Query/DenomTrace RPC
* method.
*/
export interface QueryDenomTraceResponse {
/** denom_trace returns the requested denomination trace information. */
denomTrace?: DenomTrace;
}
/**
* QueryConnectionsRequest is the request type for the Query/DenomTraces RPC
* method
*/
export interface QueryDenomTracesRequest {
/** pagination defines an optional pagination for the request. */
pagination?: PageRequest;
}
/**
* QueryConnectionsResponse is the response type for the Query/DenomTraces RPC
* method.
*/
export interface QueryDenomTracesResponse {
/** denom_traces returns all denominations trace information. */
denomTraces: DenomTrace[];
/** pagination defines the pagination in the response. */
pagination?: PageResponse;
}
/** QueryParamsRequest is the request type for the Query/Params RPC method. */
export interface QueryParamsRequest {}
/** QueryParamsResponse is the response type for the Query/Params RPC method. */
export interface QueryParamsResponse {
/** params defines the parameters of the module. */
params?: Params;
}
const baseQueryDenomTraceRequest: object = { hash: "" };
export const QueryDenomTraceRequest = {
encode(message: QueryDenomTraceRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.hash !== "") {
writer.uint32(10).string(message.hash);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): QueryDenomTraceRequest {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseQueryDenomTraceRequest } as QueryDenomTraceRequest;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.hash = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): QueryDenomTraceRequest {
const message = { ...baseQueryDenomTraceRequest } as QueryDenomTraceRequest;
if (object.hash !== undefined && object.hash !== null) {
message.hash = String(object.hash);
} else {
message.hash = "";
}
return message;
},
toJSON(message: QueryDenomTraceRequest): unknown {
const obj: any = {};
message.hash !== undefined && (obj.hash = message.hash);
return obj;
},
fromPartial(object: DeepPartial<QueryDenomTraceRequest>): QueryDenomTraceRequest {
const message = { ...baseQueryDenomTraceRequest } as QueryDenomTraceRequest;
if (object.hash !== undefined && object.hash !== null) {
message.hash = object.hash;
} else {
message.hash = "";
}
return message;
},
};
const baseQueryDenomTraceResponse: object = {};
export const QueryDenomTraceResponse = {
encode(message: QueryDenomTraceResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.denomTrace !== undefined) {
DenomTrace.encode(message.denomTrace, writer.uint32(10).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): QueryDenomTraceResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseQueryDenomTraceResponse } as QueryDenomTraceResponse;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.denomTrace = DenomTrace.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): QueryDenomTraceResponse {
const message = { ...baseQueryDenomTraceResponse } as QueryDenomTraceResponse;
if (object.denomTrace !== undefined && object.denomTrace !== null) {
message.denomTrace = DenomTrace.fromJSON(object.denomTrace);
} else {
message.denomTrace = undefined;
}
return message;
},
toJSON(message: QueryDenomTraceResponse): unknown {
const obj: any = {};
message.denomTrace !== undefined &&
(obj.denomTrace = message.denomTrace ? DenomTrace.toJSON(message.denomTrace) : undefined);
return obj;
},
fromPartial(object: DeepPartial<QueryDenomTraceResponse>): QueryDenomTraceResponse {
const message = { ...baseQueryDenomTraceResponse } as QueryDenomTraceResponse;
if (object.denomTrace !== undefined && object.denomTrace !== null) {
message.denomTrace = DenomTrace.fromPartial(object.denomTrace);
} else {
message.denomTrace = undefined;
}
return message;
},
};
const baseQueryDenomTracesRequest: object = {};
export const QueryDenomTracesRequest = {
encode(message: QueryDenomTracesRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.pagination !== undefined) {
PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): QueryDenomTracesRequest {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseQueryDenomTracesRequest } as QueryDenomTracesRequest;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.pagination = PageRequest.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): QueryDenomTracesRequest {
const message = { ...baseQueryDenomTracesRequest } as QueryDenomTracesRequest;
if (object.pagination !== undefined && object.pagination !== null) {
message.pagination = PageRequest.fromJSON(object.pagination);
} else {
message.pagination = undefined;
}
return message;
},
toJSON(message: QueryDenomTracesRequest): unknown {
const obj: any = {};
message.pagination !== undefined &&
(obj.pagination = message.pagination ? PageRequest.toJSON(message.pagination) : undefined);
return obj;
},
fromPartial(object: DeepPartial<QueryDenomTracesRequest>): QueryDenomTracesRequest {
const message = { ...baseQueryDenomTracesRequest } as QueryDenomTracesRequest;
if (object.pagination !== undefined && object.pagination !== null) {
message.pagination = PageRequest.fromPartial(object.pagination);
} else {
message.pagination = undefined;
}
return message;
},
};
const baseQueryDenomTracesResponse: object = {};
export const QueryDenomTracesResponse = {
encode(message: QueryDenomTracesResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
for (const v of message.denomTraces) {
DenomTrace.encode(v!, writer.uint32(10).fork()).ldelim();
}
if (message.pagination !== undefined) {
PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): QueryDenomTracesResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseQueryDenomTracesResponse } as QueryDenomTracesResponse;
message.denomTraces = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.denomTraces.push(DenomTrace.decode(reader, reader.uint32()));
break;
case 2:
message.pagination = PageResponse.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): QueryDenomTracesResponse {
const message = { ...baseQueryDenomTracesResponse } as QueryDenomTracesResponse;
message.denomTraces = [];
if (object.denomTraces !== undefined && object.denomTraces !== null) {
for (const e of object.denomTraces) {
message.denomTraces.push(DenomTrace.fromJSON(e));
}
}
if (object.pagination !== undefined && object.pagination !== null) {
message.pagination = PageResponse.fromJSON(object.pagination);
} else {
message.pagination = undefined;
}
return message;
},
toJSON(message: QueryDenomTracesResponse): unknown {
const obj: any = {};
if (message.denomTraces) {
obj.denomTraces = message.denomTraces.map((e) => (e ? DenomTrace.toJSON(e) : undefined));
} else {
obj.denomTraces = [];
}
message.pagination !== undefined &&
(obj.pagination = message.pagination ? PageResponse.toJSON(message.pagination) : undefined);
return obj;
},
fromPartial(object: DeepPartial<QueryDenomTracesResponse>): QueryDenomTracesResponse {
const message = { ...baseQueryDenomTracesResponse } as QueryDenomTracesResponse;
message.denomTraces = [];
if (object.denomTraces !== undefined && object.denomTraces !== null) {
for (const e of object.denomTraces) {
message.denomTraces.push(DenomTrace.fromPartial(e));
}
}
if (object.pagination !== undefined && object.pagination !== null) {
message.pagination = PageResponse.fromPartial(object.pagination);
} else {
message.pagination = undefined;
}
return message;
},
};
const baseQueryParamsRequest: object = {};
export const QueryParamsRequest = {
encode(_: QueryParamsRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): QueryParamsRequest {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseQueryParamsRequest } as QueryParamsRequest;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(_: any): QueryParamsRequest {
const message = { ...baseQueryParamsRequest } as QueryParamsRequest;
return message;
},
toJSON(_: QueryParamsRequest): unknown {
const obj: any = {};
return obj;
},
fromPartial(_: DeepPartial<QueryParamsRequest>): QueryParamsRequest {
const message = { ...baseQueryParamsRequest } as QueryParamsRequest;
return message;
},
};
const baseQueryParamsResponse: object = {};
export const QueryParamsResponse = {
encode(message: QueryParamsResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.params !== undefined) {
Params.encode(message.params, writer.uint32(10).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): QueryParamsResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseQueryParamsResponse } as QueryParamsResponse;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.params = Params.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): QueryParamsResponse {
const message = { ...baseQueryParamsResponse } as QueryParamsResponse;
if (object.params !== undefined && object.params !== null) {
message.params = Params.fromJSON(object.params);
} else {
message.params = undefined;
}
return message;
},
toJSON(message: QueryParamsResponse): unknown {
const obj: any = {};
message.params !== undefined && (obj.params = message.params ? Params.toJSON(message.params) : undefined);
return obj;
},
fromPartial(object: DeepPartial<QueryParamsResponse>): QueryParamsResponse {
const message = { ...baseQueryParamsResponse } as QueryParamsResponse;
if (object.params !== undefined && object.params !== null) {
message.params = Params.fromPartial(object.params);
} else {
message.params = undefined;
}
return message;
},
};
/** Query provides defines the gRPC querier service. */
export interface Query {
/** DenomTrace queries a denomination trace information. */
DenomTrace(request: QueryDenomTraceRequest): Promise<QueryDenomTraceResponse>;
/** DenomTraces queries all denomination traces. */
DenomTraces(request: QueryDenomTracesRequest): Promise<QueryDenomTracesResponse>;
/** Params queries all parameters of the ibc-transfer module. */
Params(request: QueryParamsRequest): Promise<QueryParamsResponse>;
}
export class QueryClientImpl implements Query {
private readonly rpc: Rpc;
constructor(rpc: Rpc) {
this.rpc = rpc;
}
DenomTrace(request: QueryDenomTraceRequest): Promise<QueryDenomTraceResponse> {
const data = QueryDenomTraceRequest.encode(request).finish();
const promise = this.rpc.request("ibc.applications.transfer.v1.Query", "DenomTrace", data);
return promise.then((data) => QueryDenomTraceResponse.decode(new _m0.Reader(data)));
}
DenomTraces(request: QueryDenomTracesRequest): Promise<QueryDenomTracesResponse> {
const data = QueryDenomTracesRequest.encode(request).finish();
const promise = this.rpc.request("ibc.applications.transfer.v1.Query", "DenomTraces", data);
return promise.then((data) => QueryDenomTracesResponse.decode(new _m0.Reader(data)));
}
Params(request: QueryParamsRequest): Promise<QueryParamsResponse> {
const data = QueryParamsRequest.encode(request).finish();
const promise = this.rpc.request("ibc.applications.transfer.v1.Query", "Params", data);
return promise.then((data) => QueryParamsResponse.decode(new _m0.Reader(data)));
}
}
interface Rpc {
request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
}
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

320
packages/stargate/src/codec/ibc/applications/transfer/v1/transfer.ts
View File

@ -1,320 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
export const protobufPackage = "ibc.applications.transfer.v1";
/**
* FungibleTokenPacketData defines a struct for the packet payload
* See FungibleTokenPacketData spec:
* https://github.com/cosmos/ics/tree/master/spec/ics-020-fungible-token-transfer#data-structures
*/
export interface FungibleTokenPacketData {
/** the token denomination to be transferred */
denom: string;
/** the token amount to be transferred */
amount: Long;
/** the sender address */
sender: string;
/** the recipient address on the destination chain */
receiver: string;
}
/**
* DenomTrace contains the base denomination for ICS20 fungible tokens and the
* source tracing information path.
*/
export interface DenomTrace {
/**
* path defines the chain of port/channel identifiers used for tracing the
* source of the fungible token.
*/
path: string;
/** base denomination of the relayed fungible token. */
baseDenom: string;
}
/**
* Params defines the set of IBC transfer parameters.
* NOTE: To prevent a single token from being transferred, set the
* TransfersEnabled parameter to true and then set the bank module's SendEnabled
* parameter for the denomination to false.
*/
export interface Params {
/**
* send_enabled enables or disables all cross-chain token transfers from this
* chain.
*/
sendEnabled: boolean;
/**
* receive_enabled enables or disables all cross-chain token transfers to this
* chain.
*/
receiveEnabled: boolean;
}
const baseFungibleTokenPacketData: object = { denom: "", amount: Long.UZERO, sender: "", receiver: "" };
export const FungibleTokenPacketData = {
encode(message: FungibleTokenPacketData, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.denom !== "") {
writer.uint32(10).string(message.denom);
}
if (!message.amount.isZero()) {
writer.uint32(16).uint64(message.amount);
}
if (message.sender !== "") {
writer.uint32(26).string(message.sender);
}
if (message.receiver !== "") {
writer.uint32(34).string(message.receiver);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): FungibleTokenPacketData {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseFungibleTokenPacketData } as FungibleTokenPacketData;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.denom = reader.string();
break;
case 2:
message.amount = reader.uint64() as Long;
break;
case 3:
message.sender = reader.string();
break;
case 4:
message.receiver = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): FungibleTokenPacketData {
const message = { ...baseFungibleTokenPacketData } as FungibleTokenPacketData;
if (object.denom !== undefined && object.denom !== null) {
message.denom = String(object.denom);
} else {
message.denom = "";
}
if (object.amount !== undefined && object.amount !== null) {
message.amount = Long.fromString(object.amount);
} else {
message.amount = Long.UZERO;
}
if (object.sender !== undefined && object.sender !== null) {
message.sender = String(object.sender);
} else {
message.sender = "";
}
if (object.receiver !== undefined && object.receiver !== null) {
message.receiver = String(object.receiver);
} else {
message.receiver = "";
}
return message;
},
toJSON(message: FungibleTokenPacketData): unknown {
const obj: any = {};
message.denom !== undefined && (obj.denom = message.denom);
message.amount !== undefined && (obj.amount = (message.amount || Long.UZERO).toString());
message.sender !== undefined && (obj.sender = message.sender);
message.receiver !== undefined && (obj.receiver = message.receiver);
return obj;
},
fromPartial(object: DeepPartial<FungibleTokenPacketData>): FungibleTokenPacketData {
const message = { ...baseFungibleTokenPacketData } as FungibleTokenPacketData;
if (object.denom !== undefined && object.denom !== null) {
message.denom = object.denom;
} else {
message.denom = "";
}
if (object.amount !== undefined && object.amount !== null) {
message.amount = object.amount as Long;
} else {
message.amount = Long.UZERO;
}
if (object.sender !== undefined && object.sender !== null) {
message.sender = object.sender;
} else {
message.sender = "";
}
if (object.receiver !== undefined && object.receiver !== null) {
message.receiver = object.receiver;
} else {
message.receiver = "";
}
return message;
},
};
const baseDenomTrace: object = { path: "", baseDenom: "" };
export const DenomTrace = {
encode(message: DenomTrace, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.path !== "") {
writer.uint32(10).string(message.path);
}
if (message.baseDenom !== "") {
writer.uint32(18).string(message.baseDenom);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): DenomTrace {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseDenomTrace } as DenomTrace;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.path = reader.string();
break;
case 2:
message.baseDenom = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): DenomTrace {
const message = { ...baseDenomTrace } as DenomTrace;
if (object.path !== undefined && object.path !== null) {
message.path = String(object.path);
} else {
message.path = "";
}
if (object.baseDenom !== undefined && object.baseDenom !== null) {
message.baseDenom = String(object.baseDenom);
} else {
message.baseDenom = "";
}
return message;
},
toJSON(message: DenomTrace): unknown {
const obj: any = {};
message.path !== undefined && (obj.path = message.path);
message.baseDenom !== undefined && (obj.baseDenom = message.baseDenom);
return obj;
},
fromPartial(object: DeepPartial<DenomTrace>): DenomTrace {
const message = { ...baseDenomTrace } as DenomTrace;
if (object.path !== undefined && object.path !== null) {
message.path = object.path;
} else {
message.path = "";
}
if (object.baseDenom !== undefined && object.baseDenom !== null) {
message.baseDenom = object.baseDenom;
} else {
message.baseDenom = "";
}
return message;
},
};
const baseParams: object = { sendEnabled: false, receiveEnabled: false };
export const Params = {
encode(message: Params, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.sendEnabled === true) {
writer.uint32(8).bool(message.sendEnabled);
}
if (message.receiveEnabled === true) {
writer.uint32(16).bool(message.receiveEnabled);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): Params {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseParams } as Params;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.sendEnabled = reader.bool();
break;
case 2:
message.receiveEnabled = reader.bool();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): Params {
const message = { ...baseParams } as Params;
if (object.sendEnabled !== undefined && object.sendEnabled !== null) {
message.sendEnabled = Boolean(object.sendEnabled);
} else {
message.sendEnabled = false;
}
if (object.receiveEnabled !== undefined && object.receiveEnabled !== null) {
message.receiveEnabled = Boolean(object.receiveEnabled);
} else {
message.receiveEnabled = false;
}
return message;
},
toJSON(message: Params): unknown {
const obj: any = {};
message.sendEnabled !== undefined && (obj.sendEnabled = message.sendEnabled);
message.receiveEnabled !== undefined && (obj.receiveEnabled = message.receiveEnabled);
return obj;
},
fromPartial(object: DeepPartial<Params>): Params {
const message = { ...baseParams } as Params;
if (object.sendEnabled !== undefined && object.sendEnabled !== null) {
message.sendEnabled = object.sendEnabled;
} else {
message.sendEnabled = false;
}
if (object.receiveEnabled !== undefined && object.receiveEnabled !== null) {
message.receiveEnabled = object.receiveEnabled;
} else {
message.receiveEnabled = false;
}
return message;
},
};
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

279
packages/stargate/src/codec/ibc/applications/transfer/v1/tx.ts
View File

@ -1,279 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
import { Coin } from "../../../../cosmos/base/v1beta1/coin";
import { Height } from "../../../../ibc/core/client/v1/client";
export const protobufPackage = "ibc.applications.transfer.v1";
/**
* MsgTransfer defines a msg to transfer fungible tokens (i.e Coins) between
* ICS20 enabled chains. See ICS Spec here:
* https://github.com/cosmos/ics/tree/master/spec/ics-020-fungible-token-transfer#data-structures
*/
export interface MsgTransfer {
/** the port on which the packet will be sent */
sourcePort: string;
/** the channel by which the packet will be sent */
sourceChannel: string;
/** the tokens to be transferred */
token?: Coin;
/** the sender address */
sender: string;
/** the recipient address on the destination chain */
receiver: string;
/**
* Timeout height relative to the current block height.
* The timeout is disabled when set to 0.
*/
timeoutHeight?: Height;
/**
* Timeout timestamp (in nanoseconds) relative to the current block timestamp.
* The timeout is disabled when set to 0.
*/
timeoutTimestamp: Long;
}
/** MsgTransferResponse defines the Msg/Transfer response type. */
export interface MsgTransferResponse {}
const baseMsgTransfer: object = {
sourcePort: "",
sourceChannel: "",
sender: "",
receiver: "",
timeoutTimestamp: Long.UZERO,
};
export const MsgTransfer = {
encode(message: MsgTransfer, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.sourcePort !== "") {
writer.uint32(10).string(message.sourcePort);
}
if (message.sourceChannel !== "") {
writer.uint32(18).string(message.sourceChannel);
}
if (message.token !== undefined) {
Coin.encode(message.token, writer.uint32(26).fork()).ldelim();
}
if (message.sender !== "") {
writer.uint32(34).string(message.sender);
}
if (message.receiver !== "") {
writer.uint32(42).string(message.receiver);
}
if (message.timeoutHeight !== undefined) {
Height.encode(message.timeoutHeight, writer.uint32(50).fork()).ldelim();
}
if (!message.timeoutTimestamp.isZero()) {
writer.uint32(56).uint64(message.timeoutTimestamp);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgTransfer {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgTransfer } as MsgTransfer;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.sourcePort = reader.string();
break;
case 2:
message.sourceChannel = reader.string();
break;
case 3:
message.token = Coin.decode(reader, reader.uint32());
break;
case 4:
message.sender = reader.string();
break;
case 5:
message.receiver = reader.string();
break;
case 6:
message.timeoutHeight = Height.decode(reader, reader.uint32());
break;
case 7:
message.timeoutTimestamp = reader.uint64() as Long;
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): MsgTransfer {
const message = { ...baseMsgTransfer } as MsgTransfer;
if (object.sourcePort !== undefined && object.sourcePort !== null) {
message.sourcePort = String(object.sourcePort);
} else {
message.sourcePort = "";
}
if (object.sourceChannel !== undefined && object.sourceChannel !== null) {
message.sourceChannel = String(object.sourceChannel);
} else {
message.sourceChannel = "";
}
if (object.token !== undefined && object.token !== null) {
message.token = Coin.fromJSON(object.token);
} else {
message.token = undefined;
}
if (object.sender !== undefined && object.sender !== null) {
message.sender = String(object.sender);
} else {
message.sender = "";
}
if (object.receiver !== undefined && object.receiver !== null) {
message.receiver = String(object.receiver);
} else {
message.receiver = "";
}
if (object.timeoutHeight !== undefined && object.timeoutHeight !== null) {
message.timeoutHeight = Height.fromJSON(object.timeoutHeight);
} else {
message.timeoutHeight = undefined;
}
if (object.timeoutTimestamp !== undefined && object.timeoutTimestamp !== null) {
message.timeoutTimestamp = Long.fromString(object.timeoutTimestamp);
} else {
message.timeoutTimestamp = Long.UZERO;
}
return message;
},
toJSON(message: MsgTransfer): unknown {
const obj: any = {};
message.sourcePort !== undefined && (obj.sourcePort = message.sourcePort);
message.sourceChannel !== undefined && (obj.sourceChannel = message.sourceChannel);
message.token !== undefined && (obj.token = message.token ? Coin.toJSON(message.token) : undefined);
message.sender !== undefined && (obj.sender = message.sender);
message.receiver !== undefined && (obj.receiver = message.receiver);
message.timeoutHeight !== undefined &&
(obj.timeoutHeight = message.timeoutHeight ? Height.toJSON(message.timeoutHeight) : undefined);
message.timeoutTimestamp !== undefined &&
(obj.timeoutTimestamp = (message.timeoutTimestamp || Long.UZERO).toString());
return obj;
},
fromPartial(object: DeepPartial<MsgTransfer>): MsgTransfer {
const message = { ...baseMsgTransfer } as MsgTransfer;
if (object.sourcePort !== undefined && object.sourcePort !== null) {
message.sourcePort = object.sourcePort;
} else {
message.sourcePort = "";
}
if (object.sourceChannel !== undefined && object.sourceChannel !== null) {
message.sourceChannel = object.sourceChannel;
} else {
message.sourceChannel = "";
}
if (object.token !== undefined && object.token !== null) {
message.token = Coin.fromPartial(object.token);
} else {
message.token = undefined;
}
if (object.sender !== undefined && object.sender !== null) {
message.sender = object.sender;
} else {
message.sender = "";
}
if (object.receiver !== undefined && object.receiver !== null) {
message.receiver = object.receiver;
} else {
message.receiver = "";
}
if (object.timeoutHeight !== undefined && object.timeoutHeight !== null) {
message.timeoutHeight = Height.fromPartial(object.timeoutHeight);
} else {
message.timeoutHeight = undefined;
}
if (object.timeoutTimestamp !== undefined && object.timeoutTimestamp !== null) {
message.timeoutTimestamp = object.timeoutTimestamp as Long;
} else {
message.timeoutTimestamp = Long.UZERO;
}
return message;
},
};
const baseMsgTransferResponse: object = {};
export const MsgTransferResponse = {
encode(_: MsgTransferResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgTransferResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgTransferResponse } as MsgTransferResponse;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(_: any): MsgTransferResponse {
const message = { ...baseMsgTransferResponse } as MsgTransferResponse;
return message;
},
toJSON(_: MsgTransferResponse): unknown {
const obj: any = {};
return obj;
},
fromPartial(_: DeepPartial<MsgTransferResponse>): MsgTransferResponse {
const message = { ...baseMsgTransferResponse } as MsgTransferResponse;
return message;
},
};
/** Msg defines the ibc/transfer Msg service. */
export interface Msg {
/** Transfer defines a rpc handler method for MsgTransfer. */
Transfer(request: MsgTransfer): Promise<MsgTransferResponse>;
}
export class MsgClientImpl implements Msg {
private readonly rpc: Rpc;
constructor(rpc: Rpc) {
this.rpc = rpc;
}
Transfer(request: MsgTransfer): Promise<MsgTransferResponse> {
const data = MsgTransfer.encode(request).finish();
const promise = this.rpc.request("ibc.applications.transfer.v1.Msg", "Transfer", data);
return promise.then((data) => MsgTransferResponse.decode(new _m0.Reader(data)));
}
}
interface Rpc {
request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
}
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

1008
packages/stargate/src/codec/ibc/core/channel/v1/channel.ts
View File

File diff suppressed because it is too large Load Diff

2877
packages/stargate/src/codec/ibc/core/channel/v1/query.ts
View File

File diff suppressed because it is too large Load Diff

1950
packages/stargate/src/codec/ibc/core/channel/v1/tx.ts
View File

File diff suppressed because it is too large Load Diff

561
packages/stargate/src/codec/ibc/core/client/v1/client.ts
View File

@ -1,561 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
import { Any } from "../../../../google/protobuf/any";
export const protobufPackage = "ibc.core.client.v1";
/**
* IdentifiedClientState defines a client state with an additional client
* identifier field.
*/
export interface IdentifiedClientState {
/** client identifier */
clientId: string;
/** client state */
clientState?: Any;
}
/** ConsensusStateWithHeight defines a consensus state with an additional height field. */
export interface ConsensusStateWithHeight {
/** consensus state height */
height?: Height;
/** consensus state */
consensusState?: Any;
}
/**
* ClientConsensusStates defines all the stored consensus states for a given
* client.
*/
export interface ClientConsensusStates {
/** client identifier */
clientId: string;
/** consensus states and their heights associated with the client */
consensusStates: ConsensusStateWithHeight[];
}
/**
* ClientUpdateProposal is a governance proposal. If it passes, the client is
* updated with the provided header. The update may fail if the header is not
* valid given certain conditions specified by the client implementation.
*/
export interface ClientUpdateProposal {
/** the title of the update proposal */
title: string;
/** the description of the proposal */
description: string;
/** the client identifier for the client to be updated if the proposal passes */
clientId: string;
/** the header used to update the client if the proposal passes */
header?: Any;
}
/**
* Height is a monotonically increasing data type
* that can be compared against another Height for the purposes of updating and
* freezing clients
*
* Normally the RevisionHeight is incremented at each height while keeping RevisionNumber
* the same. However some consensus algorithms may choose to reset the
* height in certain conditions e.g. hard forks, state-machine breaking changes
* In these cases, the RevisionNumber is incremented so that height continues to
* be monitonically increasing even as the RevisionHeight gets reset
*/
export interface Height {
/** the revision that the client is currently on */
revisionNumber: Long;
/** the height within the given revision */
revisionHeight: Long;
}
/** Params defines the set of IBC light client parameters. */
export interface Params {
/** allowed_clients defines the list of allowed client state types. */
allowedClients: string[];
}
const baseIdentifiedClientState: object = { clientId: "" };
export const IdentifiedClientState = {
encode(message: IdentifiedClientState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.clientId !== "") {
writer.uint32(10).string(message.clientId);
}
if (message.clientState !== undefined) {
Any.encode(message.clientState, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): IdentifiedClientState {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseIdentifiedClientState } as IdentifiedClientState;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.clientId = reader.string();
break;
case 2:
message.clientState = Any.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): IdentifiedClientState {
const message = { ...baseIdentifiedClientState } as IdentifiedClientState;
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = String(object.clientId);
} else {
message.clientId = "";
}
if (object.clientState !== undefined && object.clientState !== null) {
message.clientState = Any.fromJSON(object.clientState);
} else {
message.clientState = undefined;
}
return message;
},
toJSON(message: IdentifiedClientState): unknown {
const obj: any = {};
message.clientId !== undefined && (obj.clientId = message.clientId);
message.clientState !== undefined &&
(obj.clientState = message.clientState ? Any.toJSON(message.clientState) : undefined);
return obj;
},
fromPartial(object: DeepPartial<IdentifiedClientState>): IdentifiedClientState {
const message = { ...baseIdentifiedClientState } as IdentifiedClientState;
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = object.clientId;
} else {
message.clientId = "";
}
if (object.clientState !== undefined && object.clientState !== null) {
message.clientState = Any.fromPartial(object.clientState);
} else {
message.clientState = undefined;
}
return message;
},
};
const baseConsensusStateWithHeight: object = {};
export const ConsensusStateWithHeight = {
encode(message: ConsensusStateWithHeight, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.height !== undefined) {
Height.encode(message.height, writer.uint32(10).fork()).ldelim();
}
if (message.consensusState !== undefined) {
Any.encode(message.consensusState, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): ConsensusStateWithHeight {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseConsensusStateWithHeight } as ConsensusStateWithHeight;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.height = Height.decode(reader, reader.uint32());
break;
case 2:
message.consensusState = Any.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): ConsensusStateWithHeight {
const message = { ...baseConsensusStateWithHeight } as ConsensusStateWithHeight;
if (object.height !== undefined && object.height !== null) {
message.height = Height.fromJSON(object.height);
} else {
message.height = undefined;
}
if (object.consensusState !== undefined && object.consensusState !== null) {
message.consensusState = Any.fromJSON(object.consensusState);
} else {
message.consensusState = undefined;
}
return message;
},
toJSON(message: ConsensusStateWithHeight): unknown {
const obj: any = {};
message.height !== undefined && (obj.height = message.height ? Height.toJSON(message.height) : undefined);
message.consensusState !== undefined &&
(obj.consensusState = message.consensusState ? Any.toJSON(message.consensusState) : undefined);
return obj;
},
fromPartial(object: DeepPartial<ConsensusStateWithHeight>): ConsensusStateWithHeight {
const message = { ...baseConsensusStateWithHeight } as ConsensusStateWithHeight;
if (object.height !== undefined && object.height !== null) {
message.height = Height.fromPartial(object.height);
} else {
message.height = undefined;
}
if (object.consensusState !== undefined && object.consensusState !== null) {
message.consensusState = Any.fromPartial(object.consensusState);
} else {
message.consensusState = undefined;
}
return message;
},
};
const baseClientConsensusStates: object = { clientId: "" };
export const ClientConsensusStates = {
encode(message: ClientConsensusStates, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.clientId !== "") {
writer.uint32(10).string(message.clientId);
}
for (const v of message.consensusStates) {
ConsensusStateWithHeight.encode(v!, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): ClientConsensusStates {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseClientConsensusStates } as ClientConsensusStates;
message.consensusStates = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.clientId = reader.string();
break;
case 2:
message.consensusStates.push(ConsensusStateWithHeight.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): ClientConsensusStates {
const message = { ...baseClientConsensusStates } as ClientConsensusStates;
message.consensusStates = [];
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = String(object.clientId);
} else {
message.clientId = "";
}
if (object.consensusStates !== undefined && object.consensusStates !== null) {
for (const e of object.consensusStates) {
message.consensusStates.push(ConsensusStateWithHeight.fromJSON(e));
}
}
return message;
},
toJSON(message: ClientConsensusStates): unknown {
const obj: any = {};
message.clientId !== undefined && (obj.clientId = message.clientId);
if (message.consensusStates) {
obj.consensusStates = message.consensusStates.map((e) =>
e ? ConsensusStateWithHeight.toJSON(e) : undefined,
);
} else {
obj.consensusStates = [];
}
return obj;
},
fromPartial(object: DeepPartial<ClientConsensusStates>): ClientConsensusStates {
const message = { ...baseClientConsensusStates } as ClientConsensusStates;
message.consensusStates = [];
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = object.clientId;
} else {
message.clientId = "";
}
if (object.consensusStates !== undefined && object.consensusStates !== null) {
for (const e of object.consensusStates) {
message.consensusStates.push(ConsensusStateWithHeight.fromPartial(e));
}
}
return message;
},
};
const baseClientUpdateProposal: object = { title: "", description: "", clientId: "" };
export const ClientUpdateProposal = {
encode(message: ClientUpdateProposal, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.title !== "") {
writer.uint32(10).string(message.title);
}
if (message.description !== "") {
writer.uint32(18).string(message.description);
}
if (message.clientId !== "") {
writer.uint32(26).string(message.clientId);
}
if (message.header !== undefined) {
Any.encode(message.header, writer.uint32(34).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): ClientUpdateProposal {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseClientUpdateProposal } as ClientUpdateProposal;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.title = reader.string();
break;
case 2:
message.description = reader.string();
break;
case 3:
message.clientId = reader.string();
break;
case 4:
message.header = Any.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): ClientUpdateProposal {
const message = { ...baseClientUpdateProposal } as ClientUpdateProposal;
if (object.title !== undefined && object.title !== null) {
message.title = String(object.title);
} else {
message.title = "";
}
if (object.description !== undefined && object.description !== null) {
message.description = String(object.description);
} else {
message.description = "";
}
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = String(object.clientId);
} else {
message.clientId = "";
}
if (object.header !== undefined && object.header !== null) {
message.header = Any.fromJSON(object.header);
} else {
message.header = undefined;
}
return message;
},
toJSON(message: ClientUpdateProposal): unknown {
const obj: any = {};
message.title !== undefined && (obj.title = message.title);
message.description !== undefined && (obj.description = message.description);
message.clientId !== undefined && (obj.clientId = message.clientId);
message.header !== undefined && (obj.header = message.header ? Any.toJSON(message.header) : undefined);
return obj;
},
fromPartial(object: DeepPartial<ClientUpdateProposal>): ClientUpdateProposal {
const message = { ...baseClientUpdateProposal } as ClientUpdateProposal;
if (object.title !== undefined && object.title !== null) {
message.title = object.title;
} else {
message.title = "";
}
if (object.description !== undefined && object.description !== null) {
message.description = object.description;
} else {
message.description = "";
}
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = object.clientId;
} else {
message.clientId = "";
}
if (object.header !== undefined && object.header !== null) {
message.header = Any.fromPartial(object.header);
} else {
message.header = undefined;
}
return message;
},
};
const baseHeight: object = { revisionNumber: Long.UZERO, revisionHeight: Long.UZERO };
export const Height = {
encode(message: Height, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (!message.revisionNumber.isZero()) {
writer.uint32(8).uint64(message.revisionNumber);
}
if (!message.revisionHeight.isZero()) {
writer.uint32(16).uint64(message.revisionHeight);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): Height {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseHeight } as Height;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.revisionNumber = reader.uint64() as Long;
break;
case 2:
message.revisionHeight = reader.uint64() as Long;
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): Height {
const message = { ...baseHeight } as Height;
if (object.revisionNumber !== undefined && object.revisionNumber !== null) {
message.revisionNumber = Long.fromString(object.revisionNumber);
} else {
message.revisionNumber = Long.UZERO;
}
if (object.revisionHeight !== undefined && object.revisionHeight !== null) {
message.revisionHeight = Long.fromString(object.revisionHeight);
} else {
message.revisionHeight = Long.UZERO;
}
return message;
},
toJSON(message: Height): unknown {
const obj: any = {};
message.revisionNumber !== undefined &&
(obj.revisionNumber = (message.revisionNumber || Long.UZERO).toString());
message.revisionHeight !== undefined &&
(obj.revisionHeight = (message.revisionHeight || Long.UZERO).toString());
return obj;
},
fromPartial(object: DeepPartial<Height>): Height {
const message = { ...baseHeight } as Height;
if (object.revisionNumber !== undefined && object.revisionNumber !== null) {
message.revisionNumber = object.revisionNumber as Long;
} else {
message.revisionNumber = Long.UZERO;
}
if (object.revisionHeight !== undefined && object.revisionHeight !== null) {
message.revisionHeight = object.revisionHeight as Long;
} else {
message.revisionHeight = Long.UZERO;
}
return message;
},
};
const baseParams: object = { allowedClients: "" };
export const Params = {
encode(message: Params, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
for (const v of message.allowedClients) {
writer.uint32(10).string(v!);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): Params {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseParams } as Params;
message.allowedClients = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.allowedClients.push(reader.string());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): Params {
const message = { ...baseParams } as Params;
message.allowedClients = [];
if (object.allowedClients !== undefined && object.allowedClients !== null) {
for (const e of object.allowedClients) {
message.allowedClients.push(String(e));
}
}
return message;
},
toJSON(message: Params): unknown {
const obj: any = {};
if (message.allowedClients) {
obj.allowedClients = message.allowedClients.map((e) => e);
} else {
obj.allowedClients = [];
}
return obj;
},
fromPartial(object: DeepPartial<Params>): Params {
const message = { ...baseParams } as Params;
message.allowedClients = [];
if (object.allowedClients !== undefined && object.allowedClients !== null) {
for (const e of object.allowedClients) {
message.allowedClients.push(e);
}
}
return message;
},
};
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

962
packages/stargate/src/codec/ibc/core/client/v1/query.ts
View File

@ -1,962 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
import { Any } from "../../../../google/protobuf/any";
import {
Height,
Params,
IdentifiedClientState,
ConsensusStateWithHeight,
} from "../../../../ibc/core/client/v1/client";
import { PageRequest, PageResponse } from "../../../../cosmos/base/query/v1beta1/pagination";
export const protobufPackage = "ibc.core.client.v1";
/**
* QueryClientStateRequest is the request type for the Query/ClientState RPC
* method
*/
export interface QueryClientStateRequest {
/** client state unique identifier */
clientId: string;
}
/**
* QueryClientStateResponse is the response type for the Query/ClientState RPC
* method. Besides the client state, it includes a proof and the height from
* which the proof was retrieved.
*/
export interface QueryClientStateResponse {
/** client state associated with the request identifier */
clientState?: Any;
/** merkle proof of existence */
proof: Uint8Array;
/** height at which the proof was retrieved */
proofHeight?: Height;
}
/**
* QueryClientStatesRequest is the request type for the Query/ClientStates RPC
* method
*/
export interface QueryClientStatesRequest {
/** pagination request */
pagination?: PageRequest;
}
/**
* QueryClientStatesResponse is the response type for the Query/ClientStates RPC
* method.
*/
export interface QueryClientStatesResponse {
/** list of stored ClientStates of the chain. */
clientStates: IdentifiedClientState[];
/** pagination response */
pagination?: PageResponse;
}
/**
* QueryConsensusStateRequest is the request type for the Query/ConsensusState
* RPC method. Besides the consensus state, it includes a proof and the height
* from which the proof was retrieved.
*/
export interface QueryConsensusStateRequest {
/** client identifier */
clientId: string;
/** consensus state revision number */
revisionNumber: Long;
/** consensus state revision height */
revisionHeight: Long;
/**
* latest_height overrrides the height field and queries the latest stored
* ConsensusState
*/
latestHeight: boolean;
}
/**
* QueryConsensusStateResponse is the response type for the Query/ConsensusState
* RPC method
*/
export interface QueryConsensusStateResponse {
/** consensus state associated with the client identifier at the given height */
consensusState?: Any;
/** merkle proof of existence */
proof: Uint8Array;
/** height at which the proof was retrieved */
proofHeight?: Height;
}
/**
* QueryConsensusStatesRequest is the request type for the Query/ConsensusStates
* RPC method.
*/
export interface QueryConsensusStatesRequest {
/** client identifier */
clientId: string;
/** pagination request */
pagination?: PageRequest;
}
/**
* QueryConsensusStatesResponse is the response type for the
* Query/ConsensusStates RPC method
*/
export interface QueryConsensusStatesResponse {
/** consensus states associated with the identifier */
consensusStates: ConsensusStateWithHeight[];
/** pagination response */
pagination?: PageResponse;
}
/** QueryClientParamsRequest is the request type for the Query/ClientParams RPC method. */
export interface QueryClientParamsRequest {}
/** QueryClientParamsResponse is the response type for the Query/ClientParams RPC method. */
export interface QueryClientParamsResponse {
/** params defines the parameters of the module. */
params?: Params;
}
const baseQueryClientStateRequest: object = { clientId: "" };
export const QueryClientStateRequest = {
encode(message: QueryClientStateRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.clientId !== "") {
writer.uint32(10).string(message.clientId);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): QueryClientStateRequest {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseQueryClientStateRequest } as QueryClientStateRequest;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.clientId = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): QueryClientStateRequest {
const message = { ...baseQueryClientStateRequest } as QueryClientStateRequest;
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = String(object.clientId);
} else {
message.clientId = "";
}
return message;
},
toJSON(message: QueryClientStateRequest): unknown {
const obj: any = {};
message.clientId !== undefined && (obj.clientId = message.clientId);
return obj;
},
fromPartial(object: DeepPartial<QueryClientStateRequest>): QueryClientStateRequest {
const message = { ...baseQueryClientStateRequest } as QueryClientStateRequest;
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = object.clientId;
} else {
message.clientId = "";
}
return message;
},
};
const baseQueryClientStateResponse: object = {};
export const QueryClientStateResponse = {
encode(message: QueryClientStateResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.clientState !== undefined) {
Any.encode(message.clientState, writer.uint32(10).fork()).ldelim();
}
if (message.proof.length !== 0) {
writer.uint32(18).bytes(message.proof);
}
if (message.proofHeight !== undefined) {
Height.encode(message.proofHeight, writer.uint32(26).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): QueryClientStateResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseQueryClientStateResponse } as QueryClientStateResponse;
message.proof = new Uint8Array();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.clientState = Any.decode(reader, reader.uint32());
break;
case 2:
message.proof = reader.bytes();
break;
case 3:
message.proofHeight = Height.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): QueryClientStateResponse {
const message = { ...baseQueryClientStateResponse } as QueryClientStateResponse;
message.proof = new Uint8Array();
if (object.clientState !== undefined && object.clientState !== null) {
message.clientState = Any.fromJSON(object.clientState);
} else {
message.clientState = undefined;
}
if (object.proof !== undefined && object.proof !== null) {
message.proof = bytesFromBase64(object.proof);
}
if (object.proofHeight !== undefined && object.proofHeight !== null) {
message.proofHeight = Height.fromJSON(object.proofHeight);
} else {
message.proofHeight = undefined;
}
return message;
},
toJSON(message: QueryClientStateResponse): unknown {
const obj: any = {};
message.clientState !== undefined &&
(obj.clientState = message.clientState ? Any.toJSON(message.clientState) : undefined);
message.proof !== undefined &&
(obj.proof = base64FromBytes(message.proof !== undefined ? message.proof : new Uint8Array()));
message.proofHeight !== undefined &&
(obj.proofHeight = message.proofHeight ? Height.toJSON(message.proofHeight) : undefined);
return obj;
},
fromPartial(object: DeepPartial<QueryClientStateResponse>): QueryClientStateResponse {
const message = { ...baseQueryClientStateResponse } as QueryClientStateResponse;
if (object.clientState !== undefined && object.clientState !== null) {
message.clientState = Any.fromPartial(object.clientState);
} else {
message.clientState = undefined;
}
if (object.proof !== undefined && object.proof !== null) {
message.proof = object.proof;
} else {
message.proof = new Uint8Array();
}
if (object.proofHeight !== undefined && object.proofHeight !== null) {
message.proofHeight = Height.fromPartial(object.proofHeight);
} else {
message.proofHeight = undefined;
}
return message;
},
};
const baseQueryClientStatesRequest: object = {};
export const QueryClientStatesRequest = {
encode(message: QueryClientStatesRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.pagination !== undefined) {
PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): QueryClientStatesRequest {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseQueryClientStatesRequest } as QueryClientStatesRequest;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.pagination = PageRequest.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): QueryClientStatesRequest {
const message = { ...baseQueryClientStatesRequest } as QueryClientStatesRequest;
if (object.pagination !== undefined && object.pagination !== null) {
message.pagination = PageRequest.fromJSON(object.pagination);
} else {
message.pagination = undefined;
}
return message;
},
toJSON(message: QueryClientStatesRequest): unknown {
const obj: any = {};
message.pagination !== undefined &&
(obj.pagination = message.pagination ? PageRequest.toJSON(message.pagination) : undefined);
return obj;
},
fromPartial(object: DeepPartial<QueryClientStatesRequest>): QueryClientStatesRequest {
const message = { ...baseQueryClientStatesRequest } as QueryClientStatesRequest;
if (object.pagination !== undefined && object.pagination !== null) {
message.pagination = PageRequest.fromPartial(object.pagination);
} else {
message.pagination = undefined;
}
return message;
},
};
const baseQueryClientStatesResponse: object = {};
export const QueryClientStatesResponse = {
encode(message: QueryClientStatesResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
for (const v of message.clientStates) {
IdentifiedClientState.encode(v!, writer.uint32(10).fork()).ldelim();
}
if (message.pagination !== undefined) {
PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): QueryClientStatesResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseQueryClientStatesResponse } as QueryClientStatesResponse;
message.clientStates = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.clientStates.push(IdentifiedClientState.decode(reader, reader.uint32()));
break;
case 2:
message.pagination = PageResponse.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): QueryClientStatesResponse {
const message = { ...baseQueryClientStatesResponse } as QueryClientStatesResponse;
message.clientStates = [];
if (object.clientStates !== undefined && object.clientStates !== null) {
for (const e of object.clientStates) {
message.clientStates.push(IdentifiedClientState.fromJSON(e));
}
}
if (object.pagination !== undefined && object.pagination !== null) {
message.pagination = PageResponse.fromJSON(object.pagination);
} else {
message.pagination = undefined;
}
return message;
},
toJSON(message: QueryClientStatesResponse): unknown {
const obj: any = {};
if (message.clientStates) {
obj.clientStates = message.clientStates.map((e) => (e ? IdentifiedClientState.toJSON(e) : undefined));
} else {
obj.clientStates = [];
}
message.pagination !== undefined &&
(obj.pagination = message.pagination ? PageResponse.toJSON(message.pagination) : undefined);
return obj;
},
fromPartial(object: DeepPartial<QueryClientStatesResponse>): QueryClientStatesResponse {
const message = { ...baseQueryClientStatesResponse } as QueryClientStatesResponse;
message.clientStates = [];
if (object.clientStates !== undefined && object.clientStates !== null) {
for (const e of object.clientStates) {
message.clientStates.push(IdentifiedClientState.fromPartial(e));
}
}
if (object.pagination !== undefined && object.pagination !== null) {
message.pagination = PageResponse.fromPartial(object.pagination);
} else {
message.pagination = undefined;
}
return message;
},
};
const baseQueryConsensusStateRequest: object = {
clientId: "",
revisionNumber: Long.UZERO,
revisionHeight: Long.UZERO,
latestHeight: false,
};
export const QueryConsensusStateRequest = {
encode(message: QueryConsensusStateRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.clientId !== "") {
writer.uint32(10).string(message.clientId);
}
if (!message.revisionNumber.isZero()) {
writer.uint32(16).uint64(message.revisionNumber);
}
if (!message.revisionHeight.isZero()) {
writer.uint32(24).uint64(message.revisionHeight);
}
if (message.latestHeight === true) {
writer.uint32(32).bool(message.latestHeight);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): QueryConsensusStateRequest {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseQueryConsensusStateRequest } as QueryConsensusStateRequest;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.clientId = reader.string();
break;
case 2:
message.revisionNumber = reader.uint64() as Long;
break;
case 3:
message.revisionHeight = reader.uint64() as Long;
break;
case 4:
message.latestHeight = reader.bool();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): QueryConsensusStateRequest {
const message = { ...baseQueryConsensusStateRequest } as QueryConsensusStateRequest;
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = String(object.clientId);
} else {
message.clientId = "";
}
if (object.revisionNumber !== undefined && object.revisionNumber !== null) {
message.revisionNumber = Long.fromString(object.revisionNumber);
} else {
message.revisionNumber = Long.UZERO;
}
if (object.revisionHeight !== undefined && object.revisionHeight !== null) {
message.revisionHeight = Long.fromString(object.revisionHeight);
} else {
message.revisionHeight = Long.UZERO;
}
if (object.latestHeight !== undefined && object.latestHeight !== null) {
message.latestHeight = Boolean(object.latestHeight);
} else {
message.latestHeight = false;
}
return message;
},
toJSON(message: QueryConsensusStateRequest): unknown {
const obj: any = {};
message.clientId !== undefined && (obj.clientId = message.clientId);
message.revisionNumber !== undefined &&
(obj.revisionNumber = (message.revisionNumber || Long.UZERO).toString());
message.revisionHeight !== undefined &&
(obj.revisionHeight = (message.revisionHeight || Long.UZERO).toString());
message.latestHeight !== undefined && (obj.latestHeight = message.latestHeight);
return obj;
},
fromPartial(object: DeepPartial<QueryConsensusStateRequest>): QueryConsensusStateRequest {
const message = { ...baseQueryConsensusStateRequest } as QueryConsensusStateRequest;
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = object.clientId;
} else {
message.clientId = "";
}
if (object.revisionNumber !== undefined && object.revisionNumber !== null) {
message.revisionNumber = object.revisionNumber as Long;
} else {
message.revisionNumber = Long.UZERO;
}
if (object.revisionHeight !== undefined && object.revisionHeight !== null) {
message.revisionHeight = object.revisionHeight as Long;
} else {
message.revisionHeight = Long.UZERO;
}
if (object.latestHeight !== undefined && object.latestHeight !== null) {
message.latestHeight = object.latestHeight;
} else {
message.latestHeight = false;
}
return message;
},
};
const baseQueryConsensusStateResponse: object = {};
export const QueryConsensusStateResponse = {
encode(message: QueryConsensusStateResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.consensusState !== undefined) {
Any.encode(message.consensusState, writer.uint32(10).fork()).ldelim();
}
if (message.proof.length !== 0) {
writer.uint32(18).bytes(message.proof);
}
if (message.proofHeight !== undefined) {
Height.encode(message.proofHeight, writer.uint32(26).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): QueryConsensusStateResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseQueryConsensusStateResponse } as QueryConsensusStateResponse;
message.proof = new Uint8Array();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.consensusState = Any.decode(reader, reader.uint32());
break;
case 2:
message.proof = reader.bytes();
break;
case 3:
message.proofHeight = Height.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): QueryConsensusStateResponse {
const message = { ...baseQueryConsensusStateResponse } as QueryConsensusStateResponse;
message.proof = new Uint8Array();
if (object.consensusState !== undefined && object.consensusState !== null) {
message.consensusState = Any.fromJSON(object.consensusState);
} else {
message.consensusState = undefined;
}
if (object.proof !== undefined && object.proof !== null) {
message.proof = bytesFromBase64(object.proof);
}
if (object.proofHeight !== undefined && object.proofHeight !== null) {
message.proofHeight = Height.fromJSON(object.proofHeight);
} else {
message.proofHeight = undefined;
}
return message;
},
toJSON(message: QueryConsensusStateResponse): unknown {
const obj: any = {};
message.consensusState !== undefined &&
(obj.consensusState = message.consensusState ? Any.toJSON(message.consensusState) : undefined);
message.proof !== undefined &&
(obj.proof = base64FromBytes(message.proof !== undefined ? message.proof : new Uint8Array()));
message.proofHeight !== undefined &&
(obj.proofHeight = message.proofHeight ? Height.toJSON(message.proofHeight) : undefined);
return obj;
},
fromPartial(object: DeepPartial<QueryConsensusStateResponse>): QueryConsensusStateResponse {
const message = { ...baseQueryConsensusStateResponse } as QueryConsensusStateResponse;
if (object.consensusState !== undefined && object.consensusState !== null) {
message.consensusState = Any.fromPartial(object.consensusState);
} else {
message.consensusState = undefined;
}
if (object.proof !== undefined && object.proof !== null) {
message.proof = object.proof;
} else {
message.proof = new Uint8Array();
}
if (object.proofHeight !== undefined && object.proofHeight !== null) {
message.proofHeight = Height.fromPartial(object.proofHeight);
} else {
message.proofHeight = undefined;
}
return message;
},
};
const baseQueryConsensusStatesRequest: object = { clientId: "" };
export const QueryConsensusStatesRequest = {
encode(message: QueryConsensusStatesRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.clientId !== "") {
writer.uint32(10).string(message.clientId);
}
if (message.pagination !== undefined) {
PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): QueryConsensusStatesRequest {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseQueryConsensusStatesRequest } as QueryConsensusStatesRequest;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.clientId = reader.string();
break;
case 2:
message.pagination = PageRequest.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): QueryConsensusStatesRequest {
const message = { ...baseQueryConsensusStatesRequest } as QueryConsensusStatesRequest;
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = String(object.clientId);
} else {
message.clientId = "";
}
if (object.pagination !== undefined && object.pagination !== null) {
message.pagination = PageRequest.fromJSON(object.pagination);
} else {
message.pagination = undefined;
}
return message;
},
toJSON(message: QueryConsensusStatesRequest): unknown {
const obj: any = {};
message.clientId !== undefined && (obj.clientId = message.clientId);
message.pagination !== undefined &&
(obj.pagination = message.pagination ? PageRequest.toJSON(message.pagination) : undefined);
return obj;
},
fromPartial(object: DeepPartial<QueryConsensusStatesRequest>): QueryConsensusStatesRequest {
const message = { ...baseQueryConsensusStatesRequest } as QueryConsensusStatesRequest;
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = object.clientId;
} else {
message.clientId = "";
}
if (object.pagination !== undefined && object.pagination !== null) {
message.pagination = PageRequest.fromPartial(object.pagination);
} else {
message.pagination = undefined;
}
return message;
},
};
const baseQueryConsensusStatesResponse: object = {};
export const QueryConsensusStatesResponse = {
encode(message: QueryConsensusStatesResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
for (const v of message.consensusStates) {
ConsensusStateWithHeight.encode(v!, writer.uint32(10).fork()).ldelim();
}
if (message.pagination !== undefined) {
PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): QueryConsensusStatesResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseQueryConsensusStatesResponse } as QueryConsensusStatesResponse;
message.consensusStates = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.consensusStates.push(ConsensusStateWithHeight.decode(reader, reader.uint32()));
break;
case 2:
message.pagination = PageResponse.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): QueryConsensusStatesResponse {
const message = { ...baseQueryConsensusStatesResponse } as QueryConsensusStatesResponse;
message.consensusStates = [];
if (object.consensusStates !== undefined && object.consensusStates !== null) {
for (const e of object.consensusStates) {
message.consensusStates.push(ConsensusStateWithHeight.fromJSON(e));
}
}
if (object.pagination !== undefined && object.pagination !== null) {
message.pagination = PageResponse.fromJSON(object.pagination);
} else {
message.pagination = undefined;
}
return message;
},
toJSON(message: QueryConsensusStatesResponse): unknown {
const obj: any = {};
if (message.consensusStates) {
obj.consensusStates = message.consensusStates.map((e) =>
e ? ConsensusStateWithHeight.toJSON(e) : undefined,
);
} else {
obj.consensusStates = [];
}
message.pagination !== undefined &&
(obj.pagination = message.pagination ? PageResponse.toJSON(message.pagination) : undefined);
return obj;
},
fromPartial(object: DeepPartial<QueryConsensusStatesResponse>): QueryConsensusStatesResponse {
const message = { ...baseQueryConsensusStatesResponse } as QueryConsensusStatesResponse;
message.consensusStates = [];
if (object.consensusStates !== undefined && object.consensusStates !== null) {
for (const e of object.consensusStates) {
message.consensusStates.push(ConsensusStateWithHeight.fromPartial(e));
}
}
if (object.pagination !== undefined && object.pagination !== null) {
message.pagination = PageResponse.fromPartial(object.pagination);
} else {
message.pagination = undefined;
}
return message;
},
};
const baseQueryClientParamsRequest: object = {};
export const QueryClientParamsRequest = {
encode(_: QueryClientParamsRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): QueryClientParamsRequest {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseQueryClientParamsRequest } as QueryClientParamsRequest;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(_: any): QueryClientParamsRequest {
const message = { ...baseQueryClientParamsRequest } as QueryClientParamsRequest;
return message;
},
toJSON(_: QueryClientParamsRequest): unknown {
const obj: any = {};
return obj;
},
fromPartial(_: DeepPartial<QueryClientParamsRequest>): QueryClientParamsRequest {
const message = { ...baseQueryClientParamsRequest } as QueryClientParamsRequest;
return message;
},
};
const baseQueryClientParamsResponse: object = {};
export const QueryClientParamsResponse = {
encode(message: QueryClientParamsResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.params !== undefined) {
Params.encode(message.params, writer.uint32(10).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): QueryClientParamsResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseQueryClientParamsResponse } as QueryClientParamsResponse;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.params = Params.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): QueryClientParamsResponse {
const message = { ...baseQueryClientParamsResponse } as QueryClientParamsResponse;
if (object.params !== undefined && object.params !== null) {
message.params = Params.fromJSON(object.params);
} else {
message.params = undefined;
}
return message;
},
toJSON(message: QueryClientParamsResponse): unknown {
const obj: any = {};
message.params !== undefined && (obj.params = message.params ? Params.toJSON(message.params) : undefined);
return obj;
},
fromPartial(object: DeepPartial<QueryClientParamsResponse>): QueryClientParamsResponse {
const message = { ...baseQueryClientParamsResponse } as QueryClientParamsResponse;
if (object.params !== undefined && object.params !== null) {
message.params = Params.fromPartial(object.params);
} else {
message.params = undefined;
}
return message;
},
};
/** Query provides defines the gRPC querier service */
export interface Query {
/** ClientState queries an IBC light client. */
ClientState(request: QueryClientStateRequest): Promise<QueryClientStateResponse>;
/** ClientStates queries all the IBC light clients of a chain. */
ClientStates(request: QueryClientStatesRequest): Promise<QueryClientStatesResponse>;
/**
* ConsensusState queries a consensus state associated with a client state at
* a given height.
*/
ConsensusState(request: QueryConsensusStateRequest): Promise<QueryConsensusStateResponse>;
/**
* ConsensusStates queries all the consensus state associated with a given
* client.
*/
ConsensusStates(request: QueryConsensusStatesRequest): Promise<QueryConsensusStatesResponse>;
/** ClientParams queries all parameters of the ibc client. */
ClientParams(request: QueryClientParamsRequest): Promise<QueryClientParamsResponse>;
}
export class QueryClientImpl implements Query {
private readonly rpc: Rpc;
constructor(rpc: Rpc) {
this.rpc = rpc;
}
ClientState(request: QueryClientStateRequest): Promise<QueryClientStateResponse> {
const data = QueryClientStateRequest.encode(request).finish();
const promise = this.rpc.request("ibc.core.client.v1.Query", "ClientState", data);
return promise.then((data) => QueryClientStateResponse.decode(new _m0.Reader(data)));
}
ClientStates(request: QueryClientStatesRequest): Promise<QueryClientStatesResponse> {
const data = QueryClientStatesRequest.encode(request).finish();
const promise = this.rpc.request("ibc.core.client.v1.Query", "ClientStates", data);
return promise.then((data) => QueryClientStatesResponse.decode(new _m0.Reader(data)));
}
ConsensusState(request: QueryConsensusStateRequest): Promise<QueryConsensusStateResponse> {
const data = QueryConsensusStateRequest.encode(request).finish();
const promise = this.rpc.request("ibc.core.client.v1.Query", "ConsensusState", data);
return promise.then((data) => QueryConsensusStateResponse.decode(new _m0.Reader(data)));
}
ConsensusStates(request: QueryConsensusStatesRequest): Promise<QueryConsensusStatesResponse> {
const data = QueryConsensusStatesRequest.encode(request).finish();
const promise = this.rpc.request("ibc.core.client.v1.Query", "ConsensusStates", data);
return promise.then((data) => QueryConsensusStatesResponse.decode(new _m0.Reader(data)));
}
ClientParams(request: QueryClientParamsRequest): Promise<QueryClientParamsResponse> {
const data = QueryClientParamsRequest.encode(request).finish();
const promise = this.rpc.request("ibc.core.client.v1.Query", "ClientParams", data);
return promise.then((data) => QueryClientParamsResponse.decode(new _m0.Reader(data)));
}
}
interface Rpc {
request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
}
declare var self: any | undefined;
declare var window: any | undefined;
var globalThis: any = (() => {
if (typeof globalThis !== "undefined") return globalThis;
if (typeof self !== "undefined") return self;
if (typeof window !== "undefined") return window;
if (typeof global !== "undefined") return global;
throw "Unable to locate global object";
})();
const atob: (b64: string) => string =
globalThis.atob || ((b64) => globalThis.Buffer.from(b64, "base64").toString("binary"));
function bytesFromBase64(b64: string): Uint8Array {
const bin = atob(b64);
const arr = new Uint8Array(bin.length);
for (let i = 0; i < bin.length; ++i) {
arr[i] = bin.charCodeAt(i);
}
return arr;
}
const btoa: (bin: string) => string =
globalThis.btoa || ((bin) => globalThis.Buffer.from(bin, "binary").toString("base64"));
function base64FromBytes(arr: Uint8Array): string {
const bin: string[] = [];
for (let i = 0; i < arr.byteLength; ++i) {
bin.push(String.fromCharCode(arr[i]));
}
return btoa(bin.join(""));
}
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

738
packages/stargate/src/codec/ibc/core/client/v1/tx.ts
View File

@ -1,738 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
import { Any } from "../../../../google/protobuf/any";
export const protobufPackage = "ibc.core.client.v1";
/** MsgCreateClient defines a message to create an IBC client */
export interface MsgCreateClient {
/** light client state */
clientState?: Any;
/**
* consensus state associated with the client that corresponds to a given
* height.
*/
consensusState?: Any;
/** signer address */
signer: string;
}
/** MsgCreateClientResponse defines the Msg/CreateClient response type. */
export interface MsgCreateClientResponse {}
/**
* MsgUpdateClient defines an sdk.Msg to update a IBC client state using
* the given header.
*/
export interface MsgUpdateClient {
/** client unique identifier */
clientId: string;
/** header to update the light client */
header?: Any;
/** signer address */
signer: string;
}
/** MsgUpdateClientResponse defines the Msg/UpdateClient response type. */
export interface MsgUpdateClientResponse {}
/** MsgUpgradeClient defines an sdk.Msg to upgrade an IBC client to a new client state */
export interface MsgUpgradeClient {
/** client unique identifier */
clientId: string;
/** upgraded client state */
clientState?: Any;
/** upgraded consensus state, only contains enough information to serve as a basis of trust in update logic */
consensusState?: Any;
/** proof that old chain committed to new client */
proofUpgradeClient: Uint8Array;
/** proof that old chain committed to new consensus state */
proofUpgradeConsensusState: Uint8Array;
/** signer address */
signer: string;
}
/** MsgUpgradeClientResponse defines the Msg/UpgradeClient response type. */
export interface MsgUpgradeClientResponse {}
/**
* MsgSubmitMisbehaviour defines an sdk.Msg type that submits Evidence for
* light client misbehaviour.
*/
export interface MsgSubmitMisbehaviour {
/** client unique identifier */
clientId: string;
/** misbehaviour used for freezing the light client */
misbehaviour?: Any;
/** signer address */
signer: string;
}
/** MsgSubmitMisbehaviourResponse defines the Msg/SubmitMisbehaviour response type. */
export interface MsgSubmitMisbehaviourResponse {}
const baseMsgCreateClient: object = { signer: "" };
export const MsgCreateClient = {
encode(message: MsgCreateClient, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.clientState !== undefined) {
Any.encode(message.clientState, writer.uint32(10).fork()).ldelim();
}
if (message.consensusState !== undefined) {
Any.encode(message.consensusState, writer.uint32(18).fork()).ldelim();
}
if (message.signer !== "") {
writer.uint32(26).string(message.signer);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgCreateClient {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgCreateClient } as MsgCreateClient;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.clientState = Any.decode(reader, reader.uint32());
break;
case 2:
message.consensusState = Any.decode(reader, reader.uint32());
break;
case 3:
message.signer = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): MsgCreateClient {
const message = { ...baseMsgCreateClient } as MsgCreateClient;
if (object.clientState !== undefined && object.clientState !== null) {
message.clientState = Any.fromJSON(object.clientState);
} else {
message.clientState = undefined;
}
if (object.consensusState !== undefined && object.consensusState !== null) {
message.consensusState = Any.fromJSON(object.consensusState);
} else {
message.consensusState = undefined;
}
if (object.signer !== undefined && object.signer !== null) {
message.signer = String(object.signer);
} else {
message.signer = "";
}
return message;
},
toJSON(message: MsgCreateClient): unknown {
const obj: any = {};
message.clientState !== undefined &&
(obj.clientState = message.clientState ? Any.toJSON(message.clientState) : undefined);
message.consensusState !== undefined &&
(obj.consensusState = message.consensusState ? Any.toJSON(message.consensusState) : undefined);
message.signer !== undefined && (obj.signer = message.signer);
return obj;
},
fromPartial(object: DeepPartial<MsgCreateClient>): MsgCreateClient {
const message = { ...baseMsgCreateClient } as MsgCreateClient;
if (object.clientState !== undefined && object.clientState !== null) {
message.clientState = Any.fromPartial(object.clientState);
} else {
message.clientState = undefined;
}
if (object.consensusState !== undefined && object.consensusState !== null) {
message.consensusState = Any.fromPartial(object.consensusState);
} else {
message.consensusState = undefined;
}
if (object.signer !== undefined && object.signer !== null) {
message.signer = object.signer;
} else {
message.signer = "";
}
return message;
},
};
const baseMsgCreateClientResponse: object = {};
export const MsgCreateClientResponse = {
encode(_: MsgCreateClientResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgCreateClientResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgCreateClientResponse } as MsgCreateClientResponse;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(_: any): MsgCreateClientResponse {
const message = { ...baseMsgCreateClientResponse } as MsgCreateClientResponse;
return message;
},
toJSON(_: MsgCreateClientResponse): unknown {
const obj: any = {};
return obj;
},
fromPartial(_: DeepPartial<MsgCreateClientResponse>): MsgCreateClientResponse {
const message = { ...baseMsgCreateClientResponse } as MsgCreateClientResponse;
return message;
},
};
const baseMsgUpdateClient: object = { clientId: "", signer: "" };
export const MsgUpdateClient = {
encode(message: MsgUpdateClient, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.clientId !== "") {
writer.uint32(10).string(message.clientId);
}
if (message.header !== undefined) {
Any.encode(message.header, writer.uint32(18).fork()).ldelim();
}
if (message.signer !== "") {
writer.uint32(26).string(message.signer);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateClient {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgUpdateClient } as MsgUpdateClient;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.clientId = reader.string();
break;
case 2:
message.header = Any.decode(reader, reader.uint32());
break;
case 3:
message.signer = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): MsgUpdateClient {
const message = { ...baseMsgUpdateClient } as MsgUpdateClient;
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = String(object.clientId);
} else {
message.clientId = "";
}
if (object.header !== undefined && object.header !== null) {
message.header = Any.fromJSON(object.header);
} else {
message.header = undefined;
}
if (object.signer !== undefined && object.signer !== null) {
message.signer = String(object.signer);
} else {
message.signer = "";
}
return message;
},
toJSON(message: MsgUpdateClient): unknown {
const obj: any = {};
message.clientId !== undefined && (obj.clientId = message.clientId);
message.header !== undefined && (obj.header = message.header ? Any.toJSON(message.header) : undefined);
message.signer !== undefined && (obj.signer = message.signer);
return obj;
},
fromPartial(object: DeepPartial<MsgUpdateClient>): MsgUpdateClient {
const message = { ...baseMsgUpdateClient } as MsgUpdateClient;
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = object.clientId;
} else {
message.clientId = "";
}
if (object.header !== undefined && object.header !== null) {
message.header = Any.fromPartial(object.header);
} else {
message.header = undefined;
}
if (object.signer !== undefined && object.signer !== null) {
message.signer = object.signer;
} else {
message.signer = "";
}
return message;
},
};
const baseMsgUpdateClientResponse: object = {};
export const MsgUpdateClientResponse = {
encode(_: MsgUpdateClientResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateClientResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgUpdateClientResponse } as MsgUpdateClientResponse;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(_: any): MsgUpdateClientResponse {
const message = { ...baseMsgUpdateClientResponse } as MsgUpdateClientResponse;
return message;
},
toJSON(_: MsgUpdateClientResponse): unknown {
const obj: any = {};
return obj;
},
fromPartial(_: DeepPartial<MsgUpdateClientResponse>): MsgUpdateClientResponse {
const message = { ...baseMsgUpdateClientResponse } as MsgUpdateClientResponse;
return message;
},
};
const baseMsgUpgradeClient: object = { clientId: "", signer: "" };
export const MsgUpgradeClient = {
encode(message: MsgUpgradeClient, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.clientId !== "") {
writer.uint32(10).string(message.clientId);
}
if (message.clientState !== undefined) {
Any.encode(message.clientState, writer.uint32(18).fork()).ldelim();
}
if (message.consensusState !== undefined) {
Any.encode(message.consensusState, writer.uint32(26).fork()).ldelim();
}
if (message.proofUpgradeClient.length !== 0) {
writer.uint32(34).bytes(message.proofUpgradeClient);
}
if (message.proofUpgradeConsensusState.length !== 0) {
writer.uint32(42).bytes(message.proofUpgradeConsensusState);
}
if (message.signer !== "") {
writer.uint32(50).string(message.signer);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpgradeClient {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgUpgradeClient } as MsgUpgradeClient;
message.proofUpgradeClient = new Uint8Array();
message.proofUpgradeConsensusState = new Uint8Array();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.clientId = reader.string();
break;
case 2:
message.clientState = Any.decode(reader, reader.uint32());
break;
case 3:
message.consensusState = Any.decode(reader, reader.uint32());
break;
case 4:
message.proofUpgradeClient = reader.bytes();
break;
case 5:
message.proofUpgradeConsensusState = reader.bytes();
break;
case 6:
message.signer = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): MsgUpgradeClient {
const message = { ...baseMsgUpgradeClient } as MsgUpgradeClient;
message.proofUpgradeClient = new Uint8Array();
message.proofUpgradeConsensusState = new Uint8Array();
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = String(object.clientId);
} else {
message.clientId = "";
}
if (object.clientState !== undefined && object.clientState !== null) {
message.clientState = Any.fromJSON(object.clientState);
} else {
message.clientState = undefined;
}
if (object.consensusState !== undefined && object.consensusState !== null) {
message.consensusState = Any.fromJSON(object.consensusState);
} else {
message.consensusState = undefined;
}
if (object.proofUpgradeClient !== undefined && object.proofUpgradeClient !== null) {
message.proofUpgradeClient = bytesFromBase64(object.proofUpgradeClient);
}
if (object.proofUpgradeConsensusState !== undefined && object.proofUpgradeConsensusState !== null) {
message.proofUpgradeConsensusState = bytesFromBase64(object.proofUpgradeConsensusState);
}
if (object.signer !== undefined && object.signer !== null) {
message.signer = String(object.signer);
} else {
message.signer = "";
}
return message;
},
toJSON(message: MsgUpgradeClient): unknown {
const obj: any = {};
message.clientId !== undefined && (obj.clientId = message.clientId);
message.clientState !== undefined &&
(obj.clientState = message.clientState ? Any.toJSON(message.clientState) : undefined);
message.consensusState !== undefined &&
(obj.consensusState = message.consensusState ? Any.toJSON(message.consensusState) : undefined);
message.proofUpgradeClient !== undefined &&
(obj.proofUpgradeClient = base64FromBytes(
message.proofUpgradeClient !== undefined ? message.proofUpgradeClient : new Uint8Array(),
));
message.proofUpgradeConsensusState !== undefined &&
(obj.proofUpgradeConsensusState = base64FromBytes(
message.proofUpgradeConsensusState !== undefined
? message.proofUpgradeConsensusState
: new Uint8Array(),
));
message.signer !== undefined && (obj.signer = message.signer);
return obj;
},
fromPartial(object: DeepPartial<MsgUpgradeClient>): MsgUpgradeClient {
const message = { ...baseMsgUpgradeClient } as MsgUpgradeClient;
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = object.clientId;
} else {
message.clientId = "";
}
if (object.clientState !== undefined && object.clientState !== null) {
message.clientState = Any.fromPartial(object.clientState);
} else {
message.clientState = undefined;
}
if (object.consensusState !== undefined && object.consensusState !== null) {
message.consensusState = Any.fromPartial(object.consensusState);
} else {
message.consensusState = undefined;
}
if (object.proofUpgradeClient !== undefined && object.proofUpgradeClient !== null) {
message.proofUpgradeClient = object.proofUpgradeClient;
} else {
message.proofUpgradeClient = new Uint8Array();
}
if (object.proofUpgradeConsensusState !== undefined && object.proofUpgradeConsensusState !== null) {
message.proofUpgradeConsensusState = object.proofUpgradeConsensusState;
} else {
message.proofUpgradeConsensusState = new Uint8Array();
}
if (object.signer !== undefined && object.signer !== null) {
message.signer = object.signer;
} else {
message.signer = "";
}
return message;
},
};
const baseMsgUpgradeClientResponse: object = {};
export const MsgUpgradeClientResponse = {
encode(_: MsgUpgradeClientResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpgradeClientResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgUpgradeClientResponse } as MsgUpgradeClientResponse;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(_: any): MsgUpgradeClientResponse {
const message = { ...baseMsgUpgradeClientResponse } as MsgUpgradeClientResponse;
return message;
},
toJSON(_: MsgUpgradeClientResponse): unknown {
const obj: any = {};
return obj;
},
fromPartial(_: DeepPartial<MsgUpgradeClientResponse>): MsgUpgradeClientResponse {
const message = { ...baseMsgUpgradeClientResponse } as MsgUpgradeClientResponse;
return message;
},
};
const baseMsgSubmitMisbehaviour: object = { clientId: "", signer: "" };
export const MsgSubmitMisbehaviour = {
encode(message: MsgSubmitMisbehaviour, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.clientId !== "") {
writer.uint32(10).string(message.clientId);
}
if (message.misbehaviour !== undefined) {
Any.encode(message.misbehaviour, writer.uint32(18).fork()).ldelim();
}
if (message.signer !== "") {
writer.uint32(26).string(message.signer);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgSubmitMisbehaviour {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgSubmitMisbehaviour } as MsgSubmitMisbehaviour;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.clientId = reader.string();
break;
case 2:
message.misbehaviour = Any.decode(reader, reader.uint32());
break;
case 3:
message.signer = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): MsgSubmitMisbehaviour {
const message = { ...baseMsgSubmitMisbehaviour } as MsgSubmitMisbehaviour;
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = String(object.clientId);
} else {
message.clientId = "";
}
if (object.misbehaviour !== undefined && object.misbehaviour !== null) {
message.misbehaviour = Any.fromJSON(object.misbehaviour);
} else {
message.misbehaviour = undefined;
}
if (object.signer !== undefined && object.signer !== null) {
message.signer = String(object.signer);
} else {
message.signer = "";
}
return message;
},
toJSON(message: MsgSubmitMisbehaviour): unknown {
const obj: any = {};
message.clientId !== undefined && (obj.clientId = message.clientId);
message.misbehaviour !== undefined &&
(obj.misbehaviour = message.misbehaviour ? Any.toJSON(message.misbehaviour) : undefined);
message.signer !== undefined && (obj.signer = message.signer);
return obj;
},
fromPartial(object: DeepPartial<MsgSubmitMisbehaviour>): MsgSubmitMisbehaviour {
const message = { ...baseMsgSubmitMisbehaviour } as MsgSubmitMisbehaviour;
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = object.clientId;
} else {
message.clientId = "";
}
if (object.misbehaviour !== undefined && object.misbehaviour !== null) {
message.misbehaviour = Any.fromPartial(object.misbehaviour);
} else {
message.misbehaviour = undefined;
}
if (object.signer !== undefined && object.signer !== null) {
message.signer = object.signer;
} else {
message.signer = "";
}
return message;
},
};
const baseMsgSubmitMisbehaviourResponse: object = {};
export const MsgSubmitMisbehaviourResponse = {
encode(_: MsgSubmitMisbehaviourResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MsgSubmitMisbehaviourResponse {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMsgSubmitMisbehaviourResponse } as MsgSubmitMisbehaviourResponse;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(_: any): MsgSubmitMisbehaviourResponse {
const message = { ...baseMsgSubmitMisbehaviourResponse } as MsgSubmitMisbehaviourResponse;
return message;
},
toJSON(_: MsgSubmitMisbehaviourResponse): unknown {
const obj: any = {};
return obj;
},
fromPartial(_: DeepPartial<MsgSubmitMisbehaviourResponse>): MsgSubmitMisbehaviourResponse {
const message = { ...baseMsgSubmitMisbehaviourResponse } as MsgSubmitMisbehaviourResponse;
return message;
},
};
/** Msg defines the ibc/client Msg service. */
export interface Msg {
/** CreateClient defines a rpc handler method for MsgCreateClient. */
CreateClient(request: MsgCreateClient): Promise<MsgCreateClientResponse>;
/** UpdateClient defines a rpc handler method for MsgUpdateClient. */
UpdateClient(request: MsgUpdateClient): Promise<MsgUpdateClientResponse>;
/** UpgradeClient defines a rpc handler method for MsgUpgradeClient. */
UpgradeClient(request: MsgUpgradeClient): Promise<MsgUpgradeClientResponse>;
/** SubmitMisbehaviour defines a rpc handler method for MsgSubmitMisbehaviour. */
SubmitMisbehaviour(request: MsgSubmitMisbehaviour): Promise<MsgSubmitMisbehaviourResponse>;
}
export class MsgClientImpl implements Msg {
private readonly rpc: Rpc;
constructor(rpc: Rpc) {
this.rpc = rpc;
}
CreateClient(request: MsgCreateClient): Promise<MsgCreateClientResponse> {
const data = MsgCreateClient.encode(request).finish();
const promise = this.rpc.request("ibc.core.client.v1.Msg", "CreateClient", data);
return promise.then((data) => MsgCreateClientResponse.decode(new _m0.Reader(data)));
}
UpdateClient(request: MsgUpdateClient): Promise<MsgUpdateClientResponse> {
const data = MsgUpdateClient.encode(request).finish();
const promise = this.rpc.request("ibc.core.client.v1.Msg", "UpdateClient", data);
return promise.then((data) => MsgUpdateClientResponse.decode(new _m0.Reader(data)));
}
UpgradeClient(request: MsgUpgradeClient): Promise<MsgUpgradeClientResponse> {
const data = MsgUpgradeClient.encode(request).finish();
const promise = this.rpc.request("ibc.core.client.v1.Msg", "UpgradeClient", data);
return promise.then((data) => MsgUpgradeClientResponse.decode(new _m0.Reader(data)));
}
SubmitMisbehaviour(request: MsgSubmitMisbehaviour): Promise<MsgSubmitMisbehaviourResponse> {
const data = MsgSubmitMisbehaviour.encode(request).finish();
const promise = this.rpc.request("ibc.core.client.v1.Msg", "SubmitMisbehaviour", data);
return promise.then((data) => MsgSubmitMisbehaviourResponse.decode(new _m0.Reader(data)));
}
}
interface Rpc {
request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
}
declare var self: any | undefined;
declare var window: any | undefined;
var globalThis: any = (() => {
if (typeof globalThis !== "undefined") return globalThis;
if (typeof self !== "undefined") return self;
if (typeof window !== "undefined") return window;
if (typeof global !== "undefined") return global;
throw "Unable to locate global object";
})();
const atob: (b64: string) => string =
globalThis.atob || ((b64) => globalThis.Buffer.from(b64, "base64").toString("binary"));
function bytesFromBase64(b64: string): Uint8Array {
const bin = atob(b64);
const arr = new Uint8Array(bin.length);
for (let i = 0; i < bin.length; ++i) {
arr[i] = bin.charCodeAt(i);
}
return arr;
}
const btoa: (bin: string) => string =
globalThis.btoa || ((bin) => globalThis.Buffer.from(bin, "binary").toString("base64"));
function base64FromBytes(arr: Uint8Array): string {
const bin: string[] = [];
for (let i = 0; i < arr.byteLength; ++i) {
bin.push(String.fromCharCode(arr[i]));
}
return btoa(bin.join(""));
}
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

328
packages/stargate/src/codec/ibc/core/commitment/v1/commitment.ts
View File

@ -1,328 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
import { CommitmentProof } from "../../../../confio/proofs";
export const protobufPackage = "ibc.core.commitment.v1";
/**
* MerkleRoot defines a merkle root hash.
* In the Cosmos SDK, the AppHash of a block header becomes the root.
*/
export interface MerkleRoot {
hash: Uint8Array;
}
/**
* MerklePrefix is merkle path prefixed to the key.
* The constructed key from the Path and the key will be append(Path.KeyPath,
* append(Path.KeyPrefix, key...))
*/
export interface MerklePrefix {
keyPrefix: Uint8Array;
}
/**
* MerklePath is the path used to verify commitment proofs, which can be an
* arbitrary structured object (defined by a commitment type).
* MerklePath is represented from root-to-leaf
*/
export interface MerklePath {
keyPath: string[];
}
/**
* MerkleProof is a wrapper type over a chain of CommitmentProofs.
* It demonstrates membership or non-membership for an element or set of
* elements, verifiable in conjunction with a known commitment root. Proofs
* should be succinct.
* MerkleProofs are ordered from leaf-to-root
*/
export interface MerkleProof {
proofs: CommitmentProof[];
}
const baseMerkleRoot: object = {};
export const MerkleRoot = {
encode(message: MerkleRoot, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.hash.length !== 0) {
writer.uint32(10).bytes(message.hash);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MerkleRoot {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMerkleRoot } as MerkleRoot;
message.hash = new Uint8Array();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.hash = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): MerkleRoot {
const message = { ...baseMerkleRoot } as MerkleRoot;
message.hash = new Uint8Array();
if (object.hash !== undefined && object.hash !== null) {
message.hash = bytesFromBase64(object.hash);
}
return message;
},
toJSON(message: MerkleRoot): unknown {
const obj: any = {};
message.hash !== undefined &&
(obj.hash = base64FromBytes(message.hash !== undefined ? message.hash : new Uint8Array()));
return obj;
},
fromPartial(object: DeepPartial<MerkleRoot>): MerkleRoot {
const message = { ...baseMerkleRoot } as MerkleRoot;
if (object.hash !== undefined && object.hash !== null) {
message.hash = object.hash;
} else {
message.hash = new Uint8Array();
}
return message;
},
};
const baseMerklePrefix: object = {};
export const MerklePrefix = {
encode(message: MerklePrefix, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.keyPrefix.length !== 0) {
writer.uint32(10).bytes(message.keyPrefix);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MerklePrefix {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMerklePrefix } as MerklePrefix;
message.keyPrefix = new Uint8Array();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.keyPrefix = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): MerklePrefix {
const message = { ...baseMerklePrefix } as MerklePrefix;
message.keyPrefix = new Uint8Array();
if (object.keyPrefix !== undefined && object.keyPrefix !== null) {
message.keyPrefix = bytesFromBase64(object.keyPrefix);
}
return message;
},
toJSON(message: MerklePrefix): unknown {
const obj: any = {};
message.keyPrefix !== undefined &&
(obj.keyPrefix = base64FromBytes(
message.keyPrefix !== undefined ? message.keyPrefix : new Uint8Array(),
));
return obj;
},
fromPartial(object: DeepPartial<MerklePrefix>): MerklePrefix {
const message = { ...baseMerklePrefix } as MerklePrefix;
if (object.keyPrefix !== undefined && object.keyPrefix !== null) {
message.keyPrefix = object.keyPrefix;
} else {
message.keyPrefix = new Uint8Array();
}
return message;
},
};
const baseMerklePath: object = { keyPath: "" };
export const MerklePath = {
encode(message: MerklePath, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
for (const v of message.keyPath) {
writer.uint32(10).string(v!);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MerklePath {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMerklePath } as MerklePath;
message.keyPath = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.keyPath.push(reader.string());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): MerklePath {
const message = { ...baseMerklePath } as MerklePath;
message.keyPath = [];
if (object.keyPath !== undefined && object.keyPath !== null) {
for (const e of object.keyPath) {
message.keyPath.push(String(e));
}
}
return message;
},
toJSON(message: MerklePath): unknown {
const obj: any = {};
if (message.keyPath) {
obj.keyPath = message.keyPath.map((e) => e);
} else {
obj.keyPath = [];
}
return obj;
},
fromPartial(object: DeepPartial<MerklePath>): MerklePath {
const message = { ...baseMerklePath } as MerklePath;
message.keyPath = [];
if (object.keyPath !== undefined && object.keyPath !== null) {
for (const e of object.keyPath) {
message.keyPath.push(e);
}
}
return message;
},
};
const baseMerkleProof: object = {};
export const MerkleProof = {
encode(message: MerkleProof, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
for (const v of message.proofs) {
CommitmentProof.encode(v!, writer.uint32(10).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): MerkleProof {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMerkleProof } as MerkleProof;
message.proofs = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.proofs.push(CommitmentProof.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): MerkleProof {
const message = { ...baseMerkleProof } as MerkleProof;
message.proofs = [];
if (object.proofs !== undefined && object.proofs !== null) {
for (const e of object.proofs) {
message.proofs.push(CommitmentProof.fromJSON(e));
}
}
return message;
},
toJSON(message: MerkleProof): unknown {
const obj: any = {};
if (message.proofs) {
obj.proofs = message.proofs.map((e) => (e ? CommitmentProof.toJSON(e) : undefined));
} else {
obj.proofs = [];
}
return obj;
},
fromPartial(object: DeepPartial<MerkleProof>): MerkleProof {
const message = { ...baseMerkleProof } as MerkleProof;
message.proofs = [];
if (object.proofs !== undefined && object.proofs !== null) {
for (const e of object.proofs) {
message.proofs.push(CommitmentProof.fromPartial(e));
}
}
return message;
},
};
declare var self: any | undefined;
declare var window: any | undefined;
var globalThis: any = (() => {
if (typeof globalThis !== "undefined") return globalThis;
if (typeof self !== "undefined") return self;
if (typeof window !== "undefined") return window;
if (typeof global !== "undefined") return global;
throw "Unable to locate global object";
})();
const atob: (b64: string) => string =
globalThis.atob || ((b64) => globalThis.Buffer.from(b64, "base64").toString("binary"));
function bytesFromBase64(b64: string): Uint8Array {
const bin = atob(b64);
const arr = new Uint8Array(bin.length);
for (let i = 0; i < bin.length; ++i) {
arr[i] = bin.charCodeAt(i);
}
return arr;
}
const btoa: (bin: string) => string =
globalThis.btoa || ((bin) => globalThis.Buffer.from(bin, "binary").toString("base64"));
function base64FromBytes(arr: Uint8Array): string {
const bin: string[] = [];
for (let i = 0; i < arr.byteLength; ++i) {
bin.push(String.fromCharCode(arr[i]));
}
return btoa(bin.join(""));
}
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

754
packages/stargate/src/codec/ibc/core/connection/v1/connection.ts
View File

@ -1,754 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
import { MerklePrefix } from "../../../../ibc/core/commitment/v1/commitment";
export const protobufPackage = "ibc.core.connection.v1";
/**
* State defines if a connection is in one of the following states:
* INIT, TRYOPEN, OPEN or UNINITIALIZED.
*/
export enum State {
/** STATE_UNINITIALIZED_UNSPECIFIED - Default State */
STATE_UNINITIALIZED_UNSPECIFIED = 0,
/** STATE_INIT - A connection end has just started the opening handshake. */
STATE_INIT = 1,
/**
* STATE_TRYOPEN - A connection end has acknowledged the handshake step on the counterparty
* chain.
*/
STATE_TRYOPEN = 2,
/** STATE_OPEN - A connection end has completed the handshake. */
STATE_OPEN = 3,
UNRECOGNIZED = -1,
}
export function stateFromJSON(object: any): State {
switch (object) {
case 0:
case "STATE_UNINITIALIZED_UNSPECIFIED":
return State.STATE_UNINITIALIZED_UNSPECIFIED;
case 1:
case "STATE_INIT":
return State.STATE_INIT;
case 2:
case "STATE_TRYOPEN":
return State.STATE_TRYOPEN;
case 3:
case "STATE_OPEN":
return State.STATE_OPEN;
case -1:
case "UNRECOGNIZED":
default:
return State.UNRECOGNIZED;
}
}
export function stateToJSON(object: State): string {
switch (object) {
case State.STATE_UNINITIALIZED_UNSPECIFIED:
return "STATE_UNINITIALIZED_UNSPECIFIED";
case State.STATE_INIT:
return "STATE_INIT";
case State.STATE_TRYOPEN:
return "STATE_TRYOPEN";
case State.STATE_OPEN:
return "STATE_OPEN";
default:
return "UNKNOWN";
}
}
/**
* ConnectionEnd defines a stateful object on a chain connected to another
* separate one.
* NOTE: there must only be 2 defined ConnectionEnds to establish
* a connection between two chains.
*/
export interface ConnectionEnd {
/** client associated with this connection. */
clientId: string;
/**
* IBC version which can be utilised to determine encodings or protocols for
* channels or packets utilising this connection.
*/
versions: Version[];
/** current state of the connection end. */
state: State;
/** counterparty chain associated with this connection. */
counterparty?: Counterparty;
/**
* delay period that must pass before a consensus state can be used for packet-verification
* NOTE: delay period logic is only implemented by some clients.
*/
delayPeriod: Long;
}
/**
* IdentifiedConnection defines a connection with additional connection
* identifier field.
*/
export interface IdentifiedConnection {
/** connection identifier. */
id: string;
/** client associated with this connection. */
clientId: string;
/**
* IBC version which can be utilised to determine encodings or protocols for
* channels or packets utilising this connection
*/
versions: Version[];
/** current state of the connection end. */
state: State;
/** counterparty chain associated with this connection. */
counterparty?: Counterparty;
/** delay period associated with this connection. */
delayPeriod: Long;
}
/** Counterparty defines the counterparty chain associated with a connection end. */
export interface Counterparty {
/**
* identifies the client on the counterparty chain associated with a given
* connection.
*/
clientId: string;
/**
* identifies the connection end on the counterparty chain associated with a
* given connection.
*/
connectionId: string;
/** commitment merkle prefix of the counterparty chain. */
prefix?: MerklePrefix;
}
/** ClientPaths define all the connection paths for a client state. */
export interface ClientPaths {
/** list of connection paths */
paths: string[];
}
/** ConnectionPaths define all the connection paths for a given client state. */
export interface ConnectionPaths {
/** client state unique identifier */
clientId: string;
/** list of connection paths */
paths: string[];
}
/**
* Version defines the versioning scheme used to negotiate the IBC verison in
* the connection handshake.
*/
export interface Version {
/** unique version identifier */
identifier: string;
/** list of features compatible with the specified identifier */
features: string[];
}
const baseConnectionEnd: object = { clientId: "", state: 0, delayPeriod: Long.UZERO };
export const ConnectionEnd = {
encode(message: ConnectionEnd, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.clientId !== "") {
writer.uint32(10).string(message.clientId);
}
for (const v of message.versions) {
Version.encode(v!, writer.uint32(18).fork()).ldelim();
}
if (message.state !== 0) {
writer.uint32(24).int32(message.state);
}
if (message.counterparty !== undefined) {
Counterparty.encode(message.counterparty, writer.uint32(34).fork()).ldelim();
}
if (!message.delayPeriod.isZero()) {
writer.uint32(40).uint64(message.delayPeriod);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): ConnectionEnd {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseConnectionEnd } as ConnectionEnd;
message.versions = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.clientId = reader.string();
break;
case 2:
message.versions.push(Version.decode(reader, reader.uint32()));
break;
case 3:
message.state = reader.int32() as any;
break;
case 4:
message.counterparty = Counterparty.decode(reader, reader.uint32());
break;
case 5:
message.delayPeriod = reader.uint64() as Long;
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): ConnectionEnd {
const message = { ...baseConnectionEnd } as ConnectionEnd;
message.versions = [];
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = String(object.clientId);
} else {
message.clientId = "";
}
if (object.versions !== undefined && object.versions !== null) {
for (const e of object.versions) {
message.versions.push(Version.fromJSON(e));
}
}
if (object.state !== undefined && object.state !== null) {
message.state = stateFromJSON(object.state);
} else {
message.state = 0;
}
if (object.counterparty !== undefined && object.counterparty !== null) {
message.counterparty = Counterparty.fromJSON(object.counterparty);
} else {
message.counterparty = undefined;
}
if (object.delayPeriod !== undefined && object.delayPeriod !== null) {
message.delayPeriod = Long.fromString(object.delayPeriod);
} else {
message.delayPeriod = Long.UZERO;
}
return message;
},
toJSON(message: ConnectionEnd): unknown {
const obj: any = {};
message.clientId !== undefined && (obj.clientId = message.clientId);
if (message.versions) {
obj.versions = message.versions.map((e) => (e ? Version.toJSON(e) : undefined));
} else {
obj.versions = [];
}
message.state !== undefined && (obj.state = stateToJSON(message.state));
message.counterparty !== undefined &&
(obj.counterparty = message.counterparty ? Counterparty.toJSON(message.counterparty) : undefined);
message.delayPeriod !== undefined && (obj.delayPeriod = (message.delayPeriod || Long.UZERO).toString());
return obj;
},
fromPartial(object: DeepPartial<ConnectionEnd>): ConnectionEnd {
const message = { ...baseConnectionEnd } as ConnectionEnd;
message.versions = [];
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = object.clientId;
} else {
message.clientId = "";
}
if (object.versions !== undefined && object.versions !== null) {
for (const e of object.versions) {
message.versions.push(Version.fromPartial(e));
}
}
if (object.state !== undefined && object.state !== null) {
message.state = object.state;
} else {
message.state = 0;
}
if (object.counterparty !== undefined && object.counterparty !== null) {
message.counterparty = Counterparty.fromPartial(object.counterparty);
} else {
message.counterparty = undefined;
}
if (object.delayPeriod !== undefined && object.delayPeriod !== null) {
message.delayPeriod = object.delayPeriod as Long;
} else {
message.delayPeriod = Long.UZERO;
}
return message;
},
};
const baseIdentifiedConnection: object = { id: "", clientId: "", state: 0, delayPeriod: Long.UZERO };
export const IdentifiedConnection = {
encode(message: IdentifiedConnection, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.id !== "") {
writer.uint32(10).string(message.id);
}
if (message.clientId !== "") {
writer.uint32(18).string(message.clientId);
}
for (const v of message.versions) {
Version.encode(v!, writer.uint32(26).fork()).ldelim();
}
if (message.state !== 0) {
writer.uint32(32).int32(message.state);
}
if (message.counterparty !== undefined) {
Counterparty.encode(message.counterparty, writer.uint32(42).fork()).ldelim();
}
if (!message.delayPeriod.isZero()) {
writer.uint32(48).uint64(message.delayPeriod);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): IdentifiedConnection {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseIdentifiedConnection } as IdentifiedConnection;
message.versions = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.id = reader.string();
break;
case 2:
message.clientId = reader.string();
break;
case 3:
message.versions.push(Version.decode(reader, reader.uint32()));
break;
case 4:
message.state = reader.int32() as any;
break;
case 5:
message.counterparty = Counterparty.decode(reader, reader.uint32());
break;
case 6:
message.delayPeriod = reader.uint64() as Long;
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): IdentifiedConnection {
const message = { ...baseIdentifiedConnection } as IdentifiedConnection;
message.versions = [];
if (object.id !== undefined && object.id !== null) {
message.id = String(object.id);
} else {
message.id = "";
}
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = String(object.clientId);
} else {
message.clientId = "";
}
if (object.versions !== undefined && object.versions !== null) {
for (const e of object.versions) {
message.versions.push(Version.fromJSON(e));
}
}
if (object.state !== undefined && object.state !== null) {
message.state = stateFromJSON(object.state);
} else {
message.state = 0;
}
if (object.counterparty !== undefined && object.counterparty !== null) {
message.counterparty = Counterparty.fromJSON(object.counterparty);
} else {
message.counterparty = undefined;
}
if (object.delayPeriod !== undefined && object.delayPeriod !== null) {
message.delayPeriod = Long.fromString(object.delayPeriod);
} else {
message.delayPeriod = Long.UZERO;
}
return message;
},
toJSON(message: IdentifiedConnection): unknown {
const obj: any = {};
message.id !== undefined && (obj.id = message.id);
message.clientId !== undefined && (obj.clientId = message.clientId);
if (message.versions) {
obj.versions = message.versions.map((e) => (e ? Version.toJSON(e) : undefined));
} else {
obj.versions = [];
}
message.state !== undefined && (obj.state = stateToJSON(message.state));
message.counterparty !== undefined &&
(obj.counterparty = message.counterparty ? Counterparty.toJSON(message.counterparty) : undefined);
message.delayPeriod !== undefined && (obj.delayPeriod = (message.delayPeriod || Long.UZERO).toString());
return obj;
},
fromPartial(object: DeepPartial<IdentifiedConnection>): IdentifiedConnection {
const message = { ...baseIdentifiedConnection } as IdentifiedConnection;
message.versions = [];
if (object.id !== undefined && object.id !== null) {
message.id = object.id;
} else {
message.id = "";
}
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = object.clientId;
} else {
message.clientId = "";
}
if (object.versions !== undefined && object.versions !== null) {
for (const e of object.versions) {
message.versions.push(Version.fromPartial(e));
}
}
if (object.state !== undefined && object.state !== null) {
message.state = object.state;
} else {
message.state = 0;
}
if (object.counterparty !== undefined && object.counterparty !== null) {
message.counterparty = Counterparty.fromPartial(object.counterparty);
} else {
message.counterparty = undefined;
}
if (object.delayPeriod !== undefined && object.delayPeriod !== null) {
message.delayPeriod = object.delayPeriod as Long;
} else {
message.delayPeriod = Long.UZERO;
}
return message;
},
};
const baseCounterparty: object = { clientId: "", connectionId: "" };
export const Counterparty = {
encode(message: Counterparty, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.clientId !== "") {
writer.uint32(10).string(message.clientId);
}
if (message.connectionId !== "") {
writer.uint32(18).string(message.connectionId);
}
if (message.prefix !== undefined) {
MerklePrefix.encode(message.prefix, writer.uint32(26).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): Counterparty {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseCounterparty } as Counterparty;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.clientId = reader.string();
break;
case 2:
message.connectionId = reader.string();
break;
case 3:
message.prefix = MerklePrefix.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): Counterparty {
const message = { ...baseCounterparty } as Counterparty;
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = String(object.clientId);
} else {
message.clientId = "";
}
if (object.connectionId !== undefined && object.connectionId !== null) {
message.connectionId = String(object.connectionId);
} else {
message.connectionId = "";
}
if (object.prefix !== undefined && object.prefix !== null) {
message.prefix = MerklePrefix.fromJSON(object.prefix);
} else {
message.prefix = undefined;
}
return message;
},
toJSON(message: Counterparty): unknown {
const obj: any = {};
message.clientId !== undefined && (obj.clientId = message.clientId);
message.connectionId !== undefined && (obj.connectionId = message.connectionId);
message.prefix !== undefined &&
(obj.prefix = message.prefix ? MerklePrefix.toJSON(message.prefix) : undefined);
return obj;
},
fromPartial(object: DeepPartial<Counterparty>): Counterparty {
const message = { ...baseCounterparty } as Counterparty;
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = object.clientId;
} else {
message.clientId = "";
}
if (object.connectionId !== undefined && object.connectionId !== null) {
message.connectionId = object.connectionId;
} else {
message.connectionId = "";
}
if (object.prefix !== undefined && object.prefix !== null) {
message.prefix = MerklePrefix.fromPartial(object.prefix);
} else {
message.prefix = undefined;
}
return message;
},
};
const baseClientPaths: object = { paths: "" };
export const ClientPaths = {
encode(message: ClientPaths, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
for (const v of message.paths) {
writer.uint32(10).string(v!);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): ClientPaths {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseClientPaths } as ClientPaths;
message.paths = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.paths.push(reader.string());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): ClientPaths {
const message = { ...baseClientPaths } as ClientPaths;
message.paths = [];
if (object.paths !== undefined && object.paths !== null) {
for (const e of object.paths) {
message.paths.push(String(e));
}
}
return message;
},
toJSON(message: ClientPaths): unknown {
const obj: any = {};
if (message.paths) {
obj.paths = message.paths.map((e) => e);
} else {
obj.paths = [];
}
return obj;
},
fromPartial(object: DeepPartial<ClientPaths>): ClientPaths {
const message = { ...baseClientPaths } as ClientPaths;
message.paths = [];
if (object.paths !== undefined && object.paths !== null) {
for (const e of object.paths) {
message.paths.push(e);
}
}
return message;
},
};
const baseConnectionPaths: object = { clientId: "", paths: "" };
export const ConnectionPaths = {
encode(message: ConnectionPaths, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.clientId !== "") {
writer.uint32(10).string(message.clientId);
}
for (const v of message.paths) {
writer.uint32(18).string(v!);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): ConnectionPaths {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseConnectionPaths } as ConnectionPaths;
message.paths = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.clientId = reader.string();
break;
case 2:
message.paths.push(reader.string());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): ConnectionPaths {
const message = { ...baseConnectionPaths } as ConnectionPaths;
message.paths = [];
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = String(object.clientId);
} else {
message.clientId = "";
}
if (object.paths !== undefined && object.paths !== null) {
for (const e of object.paths) {
message.paths.push(String(e));
}
}
return message;
},
toJSON(message: ConnectionPaths): unknown {
const obj: any = {};
message.clientId !== undefined && (obj.clientId = message.clientId);
if (message.paths) {
obj.paths = message.paths.map((e) => e);
} else {
obj.paths = [];
}
return obj;
},
fromPartial(object: DeepPartial<ConnectionPaths>): ConnectionPaths {
const message = { ...baseConnectionPaths } as ConnectionPaths;
message.paths = [];
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = object.clientId;
} else {
message.clientId = "";
}
if (object.paths !== undefined && object.paths !== null) {
for (const e of object.paths) {
message.paths.push(e);
}
}
return message;
},
};
const baseVersion: object = { identifier: "", features: "" };
export const Version = {
encode(message: Version, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.identifier !== "") {
writer.uint32(10).string(message.identifier);
}
for (const v of message.features) {
writer.uint32(18).string(v!);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): Version {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseVersion } as Version;
message.features = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.identifier = reader.string();
break;
case 2:
message.features.push(reader.string());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): Version {
const message = { ...baseVersion } as Version;
message.features = [];
if (object.identifier !== undefined && object.identifier !== null) {
message.identifier = String(object.identifier);
} else {
message.identifier = "";
}
if (object.features !== undefined && object.features !== null) {
for (const e of object.features) {
message.features.push(String(e));
}
}
return message;
},
toJSON(message: Version): unknown {
const obj: any = {};
message.identifier !== undefined && (obj.identifier = message.identifier);
if (message.features) {
obj.features = message.features.map((e) => e);
} else {
obj.features = [];
}
return obj;
},
fromPartial(object: DeepPartial<Version>): Version {
const message = { ...baseVersion } as Version;
message.features = [];
if (object.identifier !== undefined && object.identifier !== null) {
message.identifier = object.identifier;
} else {
message.identifier = "";
}
if (object.features !== undefined && object.features !== null) {
for (const e of object.features) {
message.features.push(e);
}
}
return message;
},
};
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

1057
packages/stargate/src/codec/ibc/core/connection/v1/query.ts
View File

File diff suppressed because it is too large Load Diff

1061
packages/stargate/src/codec/ibc/core/connection/v1/tx.ts
View File

File diff suppressed because it is too large Load Diff

795
packages/stargate/src/codec/ibc/lightclients/tendermint/v1/tendermint.ts
View File

@ -1,795 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
import { Duration } from "../../../../google/protobuf/duration";
import { Height } from "../../../../ibc/core/client/v1/client";
import { MerkleRoot } from "../../../../ibc/core/commitment/v1/commitment";
import { SignedHeader } from "../../../../tendermint/types/types";
import { ValidatorSet } from "../../../../tendermint/types/validator";
import { Timestamp } from "../../../../google/protobuf/timestamp";
import { ProofSpec } from "../../../../confio/proofs";
export const protobufPackage = "ibc.lightclients.tendermint.v1";
/**
* ClientState from Tendermint tracks the current validator set, latest height,
* and a possible frozen height.
*/
export interface ClientState {
chainId: string;
trustLevel?: Fraction;
/**
* duration of the period since the LastestTimestamp during which the
* submitted headers are valid for upgrade
*/
trustingPeriod?: Duration;
/** duration of the staking unbonding period */
unbondingPeriod?: Duration;
/** defines how much new (untrusted) header's Time can drift into the future. */
maxClockDrift?: Duration;
/** Block height when the client was frozen due to a misbehaviour */
frozenHeight?: Height;
/** Latest height the client was updated to */
latestHeight?: Height;
/** Proof specifications used in verifying counterparty state */
proofSpecs: ProofSpec[];
/**
* Path at which next upgraded client will be committed.
* Each element corresponds to the key for a single CommitmentProof in the chained proof.
* NOTE: ClientState must stored under `{upgradePath}/{upgradeHeight}/clientState`
* ConsensusState must be stored under `{upgradepath}/{upgradeHeight}/consensusState`
* For SDK chains using the default upgrade module, upgrade_path should be []string{"upgrade", "upgradedIBCState"}`
*/
upgradePath: string[];
/**
* This flag, when set to true, will allow governance to recover a client
* which has expired
*/
allowUpdateAfterExpiry: boolean;
/**
* This flag, when set to true, will allow governance to unfreeze a client
* whose chain has experienced a misbehaviour event
*/
allowUpdateAfterMisbehaviour: boolean;
}
/** ConsensusState defines the consensus state from Tendermint. */
export interface ConsensusState {
/**
* timestamp that corresponds to the block height in which the ConsensusState
* was stored.
*/
timestamp?: Date;
/** commitment root (i.e app hash) */
root?: MerkleRoot;
nextValidatorsHash: Uint8Array;
}
/**
* Misbehaviour is a wrapper over two conflicting Headers
* that implements Misbehaviour interface expected by ICS-02
*/
export interface Misbehaviour {
clientId: string;
header1?: Header;
header2?: Header;
}
/**
* Header defines the Tendermint client consensus Header.
* It encapsulates all the information necessary to update from a trusted
* Tendermint ConsensusState. The inclusion of TrustedHeight and
* TrustedValidators allows this update to process correctly, so long as the
* ConsensusState for the TrustedHeight exists, this removes race conditions
* among relayers The SignedHeader and ValidatorSet are the new untrusted update
* fields for the client. The TrustedHeight is the height of a stored
* ConsensusState on the client that will be used to verify the new untrusted
* header. The Trusted ConsensusState must be within the unbonding period of
* current time in order to correctly verify, and the TrustedValidators must
* hash to TrustedConsensusState.NextValidatorsHash since that is the last
* trusted validator set at the TrustedHeight.
*/
export interface Header {
signedHeader?: SignedHeader;
validatorSet?: ValidatorSet;
trustedHeight?: Height;
trustedValidators?: ValidatorSet;
}
/** Fraction defines the protobuf message type for tmmath.Fraction that only supports positive values. */
export interface Fraction {
numerator: Long;
denominator: Long;
}
const baseClientState: object = {
chainId: "",
upgradePath: "",
allowUpdateAfterExpiry: false,
allowUpdateAfterMisbehaviour: false,
};
export const ClientState = {
encode(message: ClientState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.chainId !== "") {
writer.uint32(10).string(message.chainId);
}
if (message.trustLevel !== undefined) {
Fraction.encode(message.trustLevel, writer.uint32(18).fork()).ldelim();
}
if (message.trustingPeriod !== undefined) {
Duration.encode(message.trustingPeriod, writer.uint32(26).fork()).ldelim();
}
if (message.unbondingPeriod !== undefined) {
Duration.encode(message.unbondingPeriod, writer.uint32(34).fork()).ldelim();
}
if (message.maxClockDrift !== undefined) {
Duration.encode(message.maxClockDrift, writer.uint32(42).fork()).ldelim();
}
if (message.frozenHeight !== undefined) {
Height.encode(message.frozenHeight, writer.uint32(50).fork()).ldelim();
}
if (message.latestHeight !== undefined) {
Height.encode(message.latestHeight, writer.uint32(58).fork()).ldelim();
}
for (const v of message.proofSpecs) {
ProofSpec.encode(v!, writer.uint32(66).fork()).ldelim();
}
for (const v of message.upgradePath) {
writer.uint32(74).string(v!);
}
if (message.allowUpdateAfterExpiry === true) {
writer.uint32(80).bool(message.allowUpdateAfterExpiry);
}
if (message.allowUpdateAfterMisbehaviour === true) {
writer.uint32(88).bool(message.allowUpdateAfterMisbehaviour);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): ClientState {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseClientState } as ClientState;
message.proofSpecs = [];
message.upgradePath = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.chainId = reader.string();
break;
case 2:
message.trustLevel = Fraction.decode(reader, reader.uint32());
break;
case 3:
message.trustingPeriod = Duration.decode(reader, reader.uint32());
break;
case 4:
message.unbondingPeriod = Duration.decode(reader, reader.uint32());
break;
case 5:
message.maxClockDrift = Duration.decode(reader, reader.uint32());
break;
case 6:
message.frozenHeight = Height.decode(reader, reader.uint32());
break;
case 7:
message.latestHeight = Height.decode(reader, reader.uint32());
break;
case 8:
message.proofSpecs.push(ProofSpec.decode(reader, reader.uint32()));
break;
case 9:
message.upgradePath.push(reader.string());
break;
case 10:
message.allowUpdateAfterExpiry = reader.bool();
break;
case 11:
message.allowUpdateAfterMisbehaviour = reader.bool();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): ClientState {
const message = { ...baseClientState } as ClientState;
message.proofSpecs = [];
message.upgradePath = [];
if (object.chainId !== undefined && object.chainId !== null) {
message.chainId = String(object.chainId);
} else {
message.chainId = "";
}
if (object.trustLevel !== undefined && object.trustLevel !== null) {
message.trustLevel = Fraction.fromJSON(object.trustLevel);
} else {
message.trustLevel = undefined;
}
if (object.trustingPeriod !== undefined && object.trustingPeriod !== null) {
message.trustingPeriod = Duration.fromJSON(object.trustingPeriod);
} else {
message.trustingPeriod = undefined;
}
if (object.unbondingPeriod !== undefined && object.unbondingPeriod !== null) {
message.unbondingPeriod = Duration.fromJSON(object.unbondingPeriod);
} else {
message.unbondingPeriod = undefined;
}
if (object.maxClockDrift !== undefined && object.maxClockDrift !== null) {
message.maxClockDrift = Duration.fromJSON(object.maxClockDrift);
} else {
message.maxClockDrift = undefined;
}
if (object.frozenHeight !== undefined && object.frozenHeight !== null) {
message.frozenHeight = Height.fromJSON(object.frozenHeight);
} else {
message.frozenHeight = undefined;
}
if (object.latestHeight !== undefined && object.latestHeight !== null) {
message.latestHeight = Height.fromJSON(object.latestHeight);
} else {
message.latestHeight = undefined;
}
if (object.proofSpecs !== undefined && object.proofSpecs !== null) {
for (const e of object.proofSpecs) {
message.proofSpecs.push(ProofSpec.fromJSON(e));
}
}
if (object.upgradePath !== undefined && object.upgradePath !== null) {
for (const e of object.upgradePath) {
message.upgradePath.push(String(e));
}
}
if (object.allowUpdateAfterExpiry !== undefined && object.allowUpdateAfterExpiry !== null) {
message.allowUpdateAfterExpiry = Boolean(object.allowUpdateAfterExpiry);
} else {
message.allowUpdateAfterExpiry = false;
}
if (object.allowUpdateAfterMisbehaviour !== undefined && object.allowUpdateAfterMisbehaviour !== null) {
message.allowUpdateAfterMisbehaviour = Boolean(object.allowUpdateAfterMisbehaviour);
} else {
message.allowUpdateAfterMisbehaviour = false;
}
return message;
},
toJSON(message: ClientState): unknown {
const obj: any = {};
message.chainId !== undefined && (obj.chainId = message.chainId);
message.trustLevel !== undefined &&
(obj.trustLevel = message.trustLevel ? Fraction.toJSON(message.trustLevel) : undefined);
message.trustingPeriod !== undefined &&
(obj.trustingPeriod = message.trustingPeriod ? Duration.toJSON(message.trustingPeriod) : undefined);
message.unbondingPeriod !== undefined &&
(obj.unbondingPeriod = message.unbondingPeriod ? Duration.toJSON(message.unbondingPeriod) : undefined);
message.maxClockDrift !== undefined &&
(obj.maxClockDrift = message.maxClockDrift ? Duration.toJSON(message.maxClockDrift) : undefined);
message.frozenHeight !== undefined &&
(obj.frozenHeight = message.frozenHeight ? Height.toJSON(message.frozenHeight) : undefined);
message.latestHeight !== undefined &&
(obj.latestHeight = message.latestHeight ? Height.toJSON(message.latestHeight) : undefined);
if (message.proofSpecs) {
obj.proofSpecs = message.proofSpecs.map((e) => (e ? ProofSpec.toJSON(e) : undefined));
} else {
obj.proofSpecs = [];
}
if (message.upgradePath) {
obj.upgradePath = message.upgradePath.map((e) => e);
} else {
obj.upgradePath = [];
}
message.allowUpdateAfterExpiry !== undefined &&
(obj.allowUpdateAfterExpiry = message.allowUpdateAfterExpiry);
message.allowUpdateAfterMisbehaviour !== undefined &&
(obj.allowUpdateAfterMisbehaviour = message.allowUpdateAfterMisbehaviour);
return obj;
},
fromPartial(object: DeepPartial<ClientState>): ClientState {
const message = { ...baseClientState } as ClientState;
message.proofSpecs = [];
message.upgradePath = [];
if (object.chainId !== undefined && object.chainId !== null) {
message.chainId = object.chainId;
} else {
message.chainId = "";
}
if (object.trustLevel !== undefined && object.trustLevel !== null) {
message.trustLevel = Fraction.fromPartial(object.trustLevel);
} else {
message.trustLevel = undefined;
}
if (object.trustingPeriod !== undefined && object.trustingPeriod !== null) {
message.trustingPeriod = Duration.fromPartial(object.trustingPeriod);
} else {
message.trustingPeriod = undefined;
}
if (object.unbondingPeriod !== undefined && object.unbondingPeriod !== null) {
message.unbondingPeriod = Duration.fromPartial(object.unbondingPeriod);
} else {
message.unbondingPeriod = undefined;
}
if (object.maxClockDrift !== undefined && object.maxClockDrift !== null) {
message.maxClockDrift = Duration.fromPartial(object.maxClockDrift);
} else {
message.maxClockDrift = undefined;
}
if (object.frozenHeight !== undefined && object.frozenHeight !== null) {
message.frozenHeight = Height.fromPartial(object.frozenHeight);
} else {
message.frozenHeight = undefined;
}
if (object.latestHeight !== undefined && object.latestHeight !== null) {
message.latestHeight = Height.fromPartial(object.latestHeight);
} else {
message.latestHeight = undefined;
}
if (object.proofSpecs !== undefined && object.proofSpecs !== null) {
for (const e of object.proofSpecs) {
message.proofSpecs.push(ProofSpec.fromPartial(e));
}
}
if (object.upgradePath !== undefined && object.upgradePath !== null) {
for (const e of object.upgradePath) {
message.upgradePath.push(e);
}
}
if (object.allowUpdateAfterExpiry !== undefined && object.allowUpdateAfterExpiry !== null) {
message.allowUpdateAfterExpiry = object.allowUpdateAfterExpiry;
} else {
message.allowUpdateAfterExpiry = false;
}
if (object.allowUpdateAfterMisbehaviour !== undefined && object.allowUpdateAfterMisbehaviour !== null) {
message.allowUpdateAfterMisbehaviour = object.allowUpdateAfterMisbehaviour;
} else {
message.allowUpdateAfterMisbehaviour = false;
}
return message;
},
};
const baseConsensusState: object = {};
export const ConsensusState = {
encode(message: ConsensusState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.timestamp !== undefined) {
Timestamp.encode(toTimestamp(message.timestamp), writer.uint32(10).fork()).ldelim();
}
if (message.root !== undefined) {
MerkleRoot.encode(message.root, writer.uint32(18).fork()).ldelim();
}
if (message.nextValidatorsHash.length !== 0) {
writer.uint32(26).bytes(message.nextValidatorsHash);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): ConsensusState {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseConsensusState } as ConsensusState;
message.nextValidatorsHash = new Uint8Array();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.timestamp = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
break;
case 2:
message.root = MerkleRoot.decode(reader, reader.uint32());
break;
case 3:
message.nextValidatorsHash = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): ConsensusState {
const message = { ...baseConsensusState } as ConsensusState;
message.nextValidatorsHash = new Uint8Array();
if (object.timestamp !== undefined && object.timestamp !== null) {
message.timestamp = fromJsonTimestamp(object.timestamp);
} else {
message.timestamp = undefined;
}
if (object.root !== undefined && object.root !== null) {
message.root = MerkleRoot.fromJSON(object.root);
} else {
message.root = undefined;
}
if (object.nextValidatorsHash !== undefined && object.nextValidatorsHash !== null) {
message.nextValidatorsHash = bytesFromBase64(object.nextValidatorsHash);
}
return message;
},
toJSON(message: ConsensusState): unknown {
const obj: any = {};
message.timestamp !== undefined && (obj.timestamp = message.timestamp.toISOString());
message.root !== undefined && (obj.root = message.root ? MerkleRoot.toJSON(message.root) : undefined);
message.nextValidatorsHash !== undefined &&
(obj.nextValidatorsHash = base64FromBytes(
message.nextValidatorsHash !== undefined ? message.nextValidatorsHash : new Uint8Array(),
));
return obj;
},
fromPartial(object: DeepPartial<ConsensusState>): ConsensusState {
const message = { ...baseConsensusState } as ConsensusState;
if (object.timestamp !== undefined && object.timestamp !== null) {
message.timestamp = object.timestamp;
} else {
message.timestamp = undefined;
}
if (object.root !== undefined && object.root !== null) {
message.root = MerkleRoot.fromPartial(object.root);
} else {
message.root = undefined;
}
if (object.nextValidatorsHash !== undefined && object.nextValidatorsHash !== null) {
message.nextValidatorsHash = object.nextValidatorsHash;
} else {
message.nextValidatorsHash = new Uint8Array();
}
return message;
},
};
const baseMisbehaviour: object = { clientId: "" };
export const Misbehaviour = {
encode(message: Misbehaviour, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.clientId !== "") {
writer.uint32(10).string(message.clientId);
}
if (message.header1 !== undefined) {
Header.encode(message.header1, writer.uint32(18).fork()).ldelim();
}
if (message.header2 !== undefined) {
Header.encode(message.header2, writer.uint32(26).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): Misbehaviour {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseMisbehaviour } as Misbehaviour;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.clientId = reader.string();
break;
case 2:
message.header1 = Header.decode(reader, reader.uint32());
break;
case 3:
message.header2 = Header.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): Misbehaviour {
const message = { ...baseMisbehaviour } as Misbehaviour;
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = String(object.clientId);
} else {
message.clientId = "";
}
if (object.header1 !== undefined && object.header1 !== null) {
message.header1 = Header.fromJSON(object.header1);
} else {
message.header1 = undefined;
}
if (object.header2 !== undefined && object.header2 !== null) {
message.header2 = Header.fromJSON(object.header2);
} else {
message.header2 = undefined;
}
return message;
},
toJSON(message: Misbehaviour): unknown {
const obj: any = {};
message.clientId !== undefined && (obj.clientId = message.clientId);
message.header1 !== undefined &&
(obj.header1 = message.header1 ? Header.toJSON(message.header1) : undefined);
message.header2 !== undefined &&
(obj.header2 = message.header2 ? Header.toJSON(message.header2) : undefined);
return obj;
},
fromPartial(object: DeepPartial<Misbehaviour>): Misbehaviour {
const message = { ...baseMisbehaviour } as Misbehaviour;
if (object.clientId !== undefined && object.clientId !== null) {
message.clientId = object.clientId;
} else {
message.clientId = "";
}
if (object.header1 !== undefined && object.header1 !== null) {
message.header1 = Header.fromPartial(object.header1);
} else {
message.header1 = undefined;
}
if (object.header2 !== undefined && object.header2 !== null) {
message.header2 = Header.fromPartial(object.header2);
} else {
message.header2 = undefined;
}
return message;
},
};
const baseHeader: object = {};
export const Header = {
encode(message: Header, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.signedHeader !== undefined) {
SignedHeader.encode(message.signedHeader, writer.uint32(10).fork()).ldelim();
}
if (message.validatorSet !== undefined) {
ValidatorSet.encode(message.validatorSet, writer.uint32(18).fork()).ldelim();
}
if (message.trustedHeight !== undefined) {
Height.encode(message.trustedHeight, writer.uint32(26).fork()).ldelim();
}
if (message.trustedValidators !== undefined) {
ValidatorSet.encode(message.trustedValidators, writer.uint32(34).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): Header {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseHeader } as Header;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.signedHeader = SignedHeader.decode(reader, reader.uint32());
break;
case 2:
message.validatorSet = ValidatorSet.decode(reader, reader.uint32());
break;
case 3:
message.trustedHeight = Height.decode(reader, reader.uint32());
break;
case 4:
message.trustedValidators = ValidatorSet.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): Header {
const message = { ...baseHeader } as Header;
if (object.signedHeader !== undefined && object.signedHeader !== null) {
message.signedHeader = SignedHeader.fromJSON(object.signedHeader);
} else {
message.signedHeader = undefined;
}
if (object.validatorSet !== undefined && object.validatorSet !== null) {
message.validatorSet = ValidatorSet.fromJSON(object.validatorSet);
} else {
message.validatorSet = undefined;
}
if (object.trustedHeight !== undefined && object.trustedHeight !== null) {
message.trustedHeight = Height.fromJSON(object.trustedHeight);
} else {
message.trustedHeight = undefined;
}
if (object.trustedValidators !== undefined && object.trustedValidators !== null) {
message.trustedValidators = ValidatorSet.fromJSON(object.trustedValidators);
} else {
message.trustedValidators = undefined;
}
return message;
},
toJSON(message: Header): unknown {
const obj: any = {};
message.signedHeader !== undefined &&
(obj.signedHeader = message.signedHeader ? SignedHeader.toJSON(message.signedHeader) : undefined);
message.validatorSet !== undefined &&
(obj.validatorSet = message.validatorSet ? ValidatorSet.toJSON(message.validatorSet) : undefined);
message.trustedHeight !== undefined &&
(obj.trustedHeight = message.trustedHeight ? Height.toJSON(message.trustedHeight) : undefined);
message.trustedValidators !== undefined &&
(obj.trustedValidators = message.trustedValidators
? ValidatorSet.toJSON(message.trustedValidators)
: undefined);
return obj;
},
fromPartial(object: DeepPartial<Header>): Header {
const message = { ...baseHeader } as Header;
if (object.signedHeader !== undefined && object.signedHeader !== null) {
message.signedHeader = SignedHeader.fromPartial(object.signedHeader);
} else {
message.signedHeader = undefined;
}
if (object.validatorSet !== undefined && object.validatorSet !== null) {
message.validatorSet = ValidatorSet.fromPartial(object.validatorSet);
} else {
message.validatorSet = undefined;
}
if (object.trustedHeight !== undefined && object.trustedHeight !== null) {
message.trustedHeight = Height.fromPartial(object.trustedHeight);
} else {
message.trustedHeight = undefined;
}
if (object.trustedValidators !== undefined && object.trustedValidators !== null) {
message.trustedValidators = ValidatorSet.fromPartial(object.trustedValidators);
} else {
message.trustedValidators = undefined;
}
return message;
},
};
const baseFraction: object = { numerator: Long.UZERO, denominator: Long.UZERO };
export const Fraction = {
encode(message: Fraction, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (!message.numerator.isZero()) {
writer.uint32(8).uint64(message.numerator);
}
if (!message.denominator.isZero()) {
writer.uint32(16).uint64(message.denominator);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): Fraction {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseFraction } as Fraction;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.numerator = reader.uint64() as Long;
break;
case 2:
message.denominator = reader.uint64() as Long;
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): Fraction {
const message = { ...baseFraction } as Fraction;
if (object.numerator !== undefined && object.numerator !== null) {
message.numerator = Long.fromString(object.numerator);
} else {
message.numerator = Long.UZERO;
}
if (object.denominator !== undefined && object.denominator !== null) {
message.denominator = Long.fromString(object.denominator);
} else {
message.denominator = Long.UZERO;
}
return message;
},
toJSON(message: Fraction): unknown {
const obj: any = {};
message.numerator !== undefined && (obj.numerator = (message.numerator || Long.UZERO).toString());
message.denominator !== undefined && (obj.denominator = (message.denominator || Long.UZERO).toString());
return obj;
},
fromPartial(object: DeepPartial<Fraction>): Fraction {
const message = { ...baseFraction } as Fraction;
if (object.numerator !== undefined && object.numerator !== null) {
message.numerator = object.numerator as Long;
} else {
message.numerator = Long.UZERO;
}
if (object.denominator !== undefined && object.denominator !== null) {
message.denominator = object.denominator as Long;
} else {
message.denominator = Long.UZERO;
}
return message;
},
};
declare var self: any | undefined;
declare var window: any | undefined;
var globalThis: any = (() => {
if (typeof globalThis !== "undefined") return globalThis;
if (typeof self !== "undefined") return self;
if (typeof window !== "undefined") return window;
if (typeof global !== "undefined") return global;
throw "Unable to locate global object";
})();
const atob: (b64: string) => string =
globalThis.atob || ((b64) => globalThis.Buffer.from(b64, "base64").toString("binary"));
function bytesFromBase64(b64: string): Uint8Array {
const bin = atob(b64);
const arr = new Uint8Array(bin.length);
for (let i = 0; i < bin.length; ++i) {
arr[i] = bin.charCodeAt(i);
}
return arr;
}
const btoa: (bin: string) => string =
globalThis.btoa || ((bin) => globalThis.Buffer.from(bin, "binary").toString("base64"));
function base64FromBytes(arr: Uint8Array): string {
const bin: string[] = [];
for (let i = 0; i < arr.byteLength; ++i) {
bin.push(String.fromCharCode(arr[i]));
}
return btoa(bin.join(""));
}
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
function toTimestamp(date: Date): Timestamp {
const seconds = numberToLong(date.getTime() / 1_000);
const nanos = (date.getTime() % 1_000) * 1_000_000;
return { seconds, nanos };
}
function fromTimestamp(t: Timestamp): Date {
let millis = t.seconds.toNumber() * 1_000;
millis += t.nanos / 1_000_000;
return new Date(millis);
}
function fromJsonTimestamp(o: any): Date {
if (o instanceof Date) {
return o;
} else if (typeof o === "string") {
return new Date(o);
} else {
return fromTimestamp(Timestamp.fromJSON(o));
}
}
function numberToLong(number: number) {
return Long.fromNumber(number);
}
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

5099
packages/stargate/src/codec/tendermint/abci/types.ts
View File

File diff suppressed because it is too large Load Diff

128
packages/stargate/src/codec/tendermint/crypto/keys.ts
View File

@ -1,128 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
export const protobufPackage = "tendermint.crypto";
/** PublicKey defines the keys available for use with Tendermint Validators */
export interface PublicKey {
ed25519: Uint8Array | undefined;
secp256k1: Uint8Array | undefined;
}
const basePublicKey: object = {};
export const PublicKey = {
encode(message: PublicKey, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.ed25519 !== undefined) {
writer.uint32(10).bytes(message.ed25519);
}
if (message.secp256k1 !== undefined) {
writer.uint32(18).bytes(message.secp256k1);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): PublicKey {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...basePublicKey } as PublicKey;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.ed25519 = reader.bytes();
break;
case 2:
message.secp256k1 = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): PublicKey {
const message = { ...basePublicKey } as PublicKey;
if (object.ed25519 !== undefined && object.ed25519 !== null) {
message.ed25519 = bytesFromBase64(object.ed25519);
}
if (object.secp256k1 !== undefined && object.secp256k1 !== null) {
message.secp256k1 = bytesFromBase64(object.secp256k1);
}
return message;
},
toJSON(message: PublicKey): unknown {
const obj: any = {};
message.ed25519 !== undefined &&
(obj.ed25519 = message.ed25519 !== undefined ? base64FromBytes(message.ed25519) : undefined);
message.secp256k1 !== undefined &&
(obj.secp256k1 = message.secp256k1 !== undefined ? base64FromBytes(message.secp256k1) : undefined);
return obj;
},
fromPartial(object: DeepPartial<PublicKey>): PublicKey {
const message = { ...basePublicKey } as PublicKey;
if (object.ed25519 !== undefined && object.ed25519 !== null) {
message.ed25519 = object.ed25519;
} else {
message.ed25519 = undefined;
}
if (object.secp256k1 !== undefined && object.secp256k1 !== null) {
message.secp256k1 = object.secp256k1;
} else {
message.secp256k1 = undefined;
}
return message;
},
};
declare var self: any | undefined;
declare var window: any | undefined;
var globalThis: any = (() => {
if (typeof globalThis !== "undefined") return globalThis;
if (typeof self !== "undefined") return self;
if (typeof window !== "undefined") return window;
if (typeof global !== "undefined") return global;
throw "Unable to locate global object";
})();
const atob: (b64: string) => string =
globalThis.atob || ((b64) => globalThis.Buffer.from(b64, "base64").toString("binary"));
function bytesFromBase64(b64: string): Uint8Array {
const bin = atob(b64);
const arr = new Uint8Array(bin.length);
for (let i = 0; i < bin.length; ++i) {
arr[i] = bin.charCodeAt(i);
}
return arr;
}
const btoa: (bin: string) => string =
globalThis.btoa || ((bin) => globalThis.Buffer.from(bin, "binary").toString("base64"));
function base64FromBytes(arr: Uint8Array): string {
const bin: string[] = [];
for (let i = 0; i < arr.byteLength; ++i) {
bin.push(String.fromCharCode(arr[i]));
}
return btoa(bin.join(""));
}
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

517
packages/stargate/src/codec/tendermint/crypto/proof.ts
View File

@ -1,517 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
export const protobufPackage = "tendermint.crypto";
export interface Proof {
total: Long;
index: Long;
leafHash: Uint8Array;
aunts: Uint8Array[];
}
export interface ValueOp {
/** Encoded in ProofOp.Key. */
key: Uint8Array;
/** To encode in ProofOp.Data */
proof?: Proof;
}
export interface DominoOp {
key: string;
input: string;
output: string;
}
/**
* ProofOp defines an operation used for calculating Merkle root
* The data could be arbitrary format, providing nessecary data
* for example neighbouring node hash
*/
export interface ProofOp {
type: string;
key: Uint8Array;
data: Uint8Array;
}
/** ProofOps is Merkle proof defined by the list of ProofOps */
export interface ProofOps {
ops: ProofOp[];
}
const baseProof: object = { total: Long.ZERO, index: Long.ZERO };
export const Proof = {
encode(message: Proof, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (!message.total.isZero()) {
writer.uint32(8).int64(message.total);
}
if (!message.index.isZero()) {
writer.uint32(16).int64(message.index);
}
if (message.leafHash.length !== 0) {
writer.uint32(26).bytes(message.leafHash);
}
for (const v of message.aunts) {
writer.uint32(34).bytes(v!);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): Proof {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseProof } as Proof;
message.aunts = [];
message.leafHash = new Uint8Array();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.total = reader.int64() as Long;
break;
case 2:
message.index = reader.int64() as Long;
break;
case 3:
message.leafHash = reader.bytes();
break;
case 4:
message.aunts.push(reader.bytes());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): Proof {
const message = { ...baseProof } as Proof;
message.aunts = [];
message.leafHash = new Uint8Array();
if (object.total !== undefined && object.total !== null) {
message.total = Long.fromString(object.total);
} else {
message.total = Long.ZERO;
}
if (object.index !== undefined && object.index !== null) {
message.index = Long.fromString(object.index);
} else {
message.index = Long.ZERO;
}
if (object.leafHash !== undefined && object.leafHash !== null) {
message.leafHash = bytesFromBase64(object.leafHash);
}
if (object.aunts !== undefined && object.aunts !== null) {
for (const e of object.aunts) {
message.aunts.push(bytesFromBase64(e));
}
}
return message;
},
toJSON(message: Proof): unknown {
const obj: any = {};
message.total !== undefined && (obj.total = (message.total || Long.ZERO).toString());
message.index !== undefined && (obj.index = (message.index || Long.ZERO).toString());
message.leafHash !== undefined &&
(obj.leafHash = base64FromBytes(message.leafHash !== undefined ? message.leafHash : new Uint8Array()));
if (message.aunts) {
obj.aunts = message.aunts.map((e) => base64FromBytes(e !== undefined ? e : new Uint8Array()));
} else {
obj.aunts = [];
}
return obj;
},
fromPartial(object: DeepPartial<Proof>): Proof {
const message = { ...baseProof } as Proof;
message.aunts = [];
if (object.total !== undefined && object.total !== null) {
message.total = object.total as Long;
} else {
message.total = Long.ZERO;
}
if (object.index !== undefined && object.index !== null) {
message.index = object.index as Long;
} else {
message.index = Long.ZERO;
}
if (object.leafHash !== undefined && object.leafHash !== null) {
message.leafHash = object.leafHash;
} else {
message.leafHash = new Uint8Array();
}
if (object.aunts !== undefined && object.aunts !== null) {
for (const e of object.aunts) {
message.aunts.push(e);
}
}
return message;
},
};
const baseValueOp: object = {};
export const ValueOp = {
encode(message: ValueOp, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.key.length !== 0) {
writer.uint32(10).bytes(message.key);
}
if (message.proof !== undefined) {
Proof.encode(message.proof, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): ValueOp {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseValueOp } as ValueOp;
message.key = new Uint8Array();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.key = reader.bytes();
break;
case 2:
message.proof = Proof.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): ValueOp {
const message = { ...baseValueOp } as ValueOp;
message.key = new Uint8Array();
if (object.key !== undefined && object.key !== null) {
message.key = bytesFromBase64(object.key);
}
if (object.proof !== undefined && object.proof !== null) {
message.proof = Proof.fromJSON(object.proof);
} else {
message.proof = undefined;
}
return message;
},
toJSON(message: ValueOp): unknown {
const obj: any = {};
message.key !== undefined &&
(obj.key = base64FromBytes(message.key !== undefined ? message.key : new Uint8Array()));
message.proof !== undefined && (obj.proof = message.proof ? Proof.toJSON(message.proof) : undefined);
return obj;
},
fromPartial(object: DeepPartial<ValueOp>): ValueOp {
const message = { ...baseValueOp } as ValueOp;
if (object.key !== undefined && object.key !== null) {
message.key = object.key;
} else {
message.key = new Uint8Array();
}
if (object.proof !== undefined && object.proof !== null) {
message.proof = Proof.fromPartial(object.proof);
} else {
message.proof = undefined;
}
return message;
},
};
const baseDominoOp: object = { key: "", input: "", output: "" };
export const DominoOp = {
encode(message: DominoOp, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.key !== "") {
writer.uint32(10).string(message.key);
}
if (message.input !== "") {
writer.uint32(18).string(message.input);
}
if (message.output !== "") {
writer.uint32(26).string(message.output);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): DominoOp {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseDominoOp } as DominoOp;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.key = reader.string();
break;
case 2:
message.input = reader.string();
break;
case 3:
message.output = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): DominoOp {
const message = { ...baseDominoOp } as DominoOp;
if (object.key !== undefined && object.key !== null) {
message.key = String(object.key);
} else {
message.key = "";
}
if (object.input !== undefined && object.input !== null) {
message.input = String(object.input);
} else {
message.input = "";
}
if (object.output !== undefined && object.output !== null) {
message.output = String(object.output);
} else {
message.output = "";
}
return message;
},
toJSON(message: DominoOp): unknown {
const obj: any = {};
message.key !== undefined && (obj.key = message.key);
message.input !== undefined && (obj.input = message.input);
message.output !== undefined && (obj.output = message.output);
return obj;
},
fromPartial(object: DeepPartial<DominoOp>): DominoOp {
const message = { ...baseDominoOp } as DominoOp;
if (object.key !== undefined && object.key !== null) {
message.key = object.key;
} else {
message.key = "";
}
if (object.input !== undefined && object.input !== null) {
message.input = object.input;
} else {
message.input = "";
}
if (object.output !== undefined && object.output !== null) {
message.output = object.output;
} else {
message.output = "";
}
return message;
},
};
const baseProofOp: object = { type: "" };
export const ProofOp = {
encode(message: ProofOp, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.type !== "") {
writer.uint32(10).string(message.type);
}
if (message.key.length !== 0) {
writer.uint32(18).bytes(message.key);
}
if (message.data.length !== 0) {
writer.uint32(26).bytes(message.data);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): ProofOp {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseProofOp } as ProofOp;
message.key = new Uint8Array();
message.data = new Uint8Array();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.type = reader.string();
break;
case 2:
message.key = reader.bytes();
break;
case 3:
message.data = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): ProofOp {
const message = { ...baseProofOp } as ProofOp;
message.key = new Uint8Array();
message.data = new Uint8Array();
if (object.type !== undefined && object.type !== null) {
message.type = String(object.type);
} else {
message.type = "";
}
if (object.key !== undefined && object.key !== null) {
message.key = bytesFromBase64(object.key);
}
if (object.data !== undefined && object.data !== null) {
message.data = bytesFromBase64(object.data);
}
return message;
},
toJSON(message: ProofOp): unknown {
const obj: any = {};
message.type !== undefined && (obj.type = message.type);
message.key !== undefined &&
(obj.key = base64FromBytes(message.key !== undefined ? message.key : new Uint8Array()));
message.data !== undefined &&
(obj.data = base64FromBytes(message.data !== undefined ? message.data : new Uint8Array()));
return obj;
},
fromPartial(object: DeepPartial<ProofOp>): ProofOp {
const message = { ...baseProofOp } as ProofOp;
if (object.type !== undefined && object.type !== null) {
message.type = object.type;
} else {
message.type = "";
}
if (object.key !== undefined && object.key !== null) {
message.key = object.key;
} else {
message.key = new Uint8Array();
}
if (object.data !== undefined && object.data !== null) {
message.data = object.data;
} else {
message.data = new Uint8Array();
}
return message;
},
};
const baseProofOps: object = {};
export const ProofOps = {
encode(message: ProofOps, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
for (const v of message.ops) {
ProofOp.encode(v!, writer.uint32(10).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): ProofOps {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseProofOps } as ProofOps;
message.ops = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.ops.push(ProofOp.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): ProofOps {
const message = { ...baseProofOps } as ProofOps;
message.ops = [];
if (object.ops !== undefined && object.ops !== null) {
for (const e of object.ops) {
message.ops.push(ProofOp.fromJSON(e));
}
}
return message;
},
toJSON(message: ProofOps): unknown {
const obj: any = {};
if (message.ops) {
obj.ops = message.ops.map((e) => (e ? ProofOp.toJSON(e) : undefined));
} else {
obj.ops = [];
}
return obj;
},
fromPartial(object: DeepPartial<ProofOps>): ProofOps {
const message = { ...baseProofOps } as ProofOps;
message.ops = [];
if (object.ops !== undefined && object.ops !== null) {
for (const e of object.ops) {
message.ops.push(ProofOp.fromPartial(e));
}
}
return message;
},
};
declare var self: any | undefined;
declare var window: any | undefined;
var globalThis: any = (() => {
if (typeof globalThis !== "undefined") return globalThis;
if (typeof self !== "undefined") return self;
if (typeof window !== "undefined") return window;
if (typeof global !== "undefined") return global;
throw "Unable to locate global object";
})();
const atob: (b64: string) => string =
globalThis.atob || ((b64) => globalThis.Buffer.from(b64, "base64").toString("binary"));
function bytesFromBase64(b64: string): Uint8Array {
const bin = atob(b64);
const arr = new Uint8Array(bin.length);
for (let i = 0; i < bin.length; ++i) {
arr[i] = bin.charCodeAt(i);
}
return arr;
}
const btoa: (bin: string) => string =
globalThis.btoa || ((bin) => globalThis.Buffer.from(bin, "binary").toString("base64"));
function base64FromBytes(arr: Uint8Array): string {
const bin: string[] = [];
for (let i = 0; i < arr.byteLength; ++i) {
bin.push(String.fromCharCode(arr[i]));
}
return btoa(bin.join(""));
}
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

114
packages/stargate/src/codec/tendermint/libs/bits/types.ts
View File

@ -1,114 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
export const protobufPackage = "tendermint.libs.bits";
export interface BitArray {
bits: Long;
elems: Long[];
}
const baseBitArray: object = { bits: Long.ZERO, elems: Long.UZERO };
export const BitArray = {
encode(message: BitArray, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (!message.bits.isZero()) {
writer.uint32(8).int64(message.bits);
}
writer.uint32(18).fork();
for (const v of message.elems) {
writer.uint64(v);
}
writer.ldelim();
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): BitArray {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseBitArray } as BitArray;
message.elems = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.bits = reader.int64() as Long;
break;
case 2:
if ((tag & 7) === 2) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.elems.push(reader.uint64() as Long);
}
} else {
message.elems.push(reader.uint64() as Long);
}
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): BitArray {
const message = { ...baseBitArray } as BitArray;
message.elems = [];
if (object.bits !== undefined && object.bits !== null) {
message.bits = Long.fromString(object.bits);
} else {
message.bits = Long.ZERO;
}
if (object.elems !== undefined && object.elems !== null) {
for (const e of object.elems) {
message.elems.push(Long.fromString(e));
}
}
return message;
},
toJSON(message: BitArray): unknown {
const obj: any = {};
message.bits !== undefined && (obj.bits = (message.bits || Long.ZERO).toString());
if (message.elems) {
obj.elems = message.elems.map((e) => (e || Long.UZERO).toString());
} else {
obj.elems = [];
}
return obj;
},
fromPartial(object: DeepPartial<BitArray>): BitArray {
const message = { ...baseBitArray } as BitArray;
message.elems = [];
if (object.bits !== undefined && object.bits !== null) {
message.bits = object.bits as Long;
} else {
message.bits = Long.ZERO;
}
if (object.elems !== undefined && object.elems !== null) {
for (const e of object.elems) {
message.elems.push(e);
}
}
return message;
},
};
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

582
packages/stargate/src/codec/tendermint/types/params.ts
View File

@ -1,582 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
import { Duration } from "../../google/protobuf/duration";
export const protobufPackage = "tendermint.types";
/**
* ConsensusParams contains consensus critical parameters that determine the
* validity of blocks.
*/
export interface ConsensusParams {
block?: BlockParams;
evidence?: EvidenceParams;
validator?: ValidatorParams;
version?: VersionParams;
}
/** BlockParams contains limits on the block size. */
export interface BlockParams {
/**
* Max block size, in bytes.
* Note: must be greater than 0
*/
maxBytes: Long;
/**
* Max gas per block.
* Note: must be greater or equal to -1
*/
maxGas: Long;
/**
* Minimum time increment between consecutive blocks (in milliseconds) If the
* block header timestamp is ahead of the system clock, decrease this value.
*
* Not exposed to the application.
*/
timeIotaMs: Long;
}
/** EvidenceParams determine how we handle evidence of malfeasance. */
export interface EvidenceParams {
/**
* Max age of evidence, in blocks.
*
* The basic formula for calculating this is: MaxAgeDuration / {average block
* time}.
*/
maxAgeNumBlocks: Long;
/**
* Max age of evidence, in time.
*
* It should correspond with an app's "unbonding period" or other similar
* mechanism for handling [Nothing-At-Stake
* attacks](https://github.com/ethereum/wiki/wiki/Proof-of-Stake-FAQ#what-is-the-nothing-at-stake-problem-and-how-can-it-be-fixed).
*/
maxAgeDuration?: Duration;
/**
* This sets the maximum size of total evidence in bytes that can be committed in a single block.
* and should fall comfortably under the max block bytes.
* Default is 1048576 or 1MB
*/
maxBytes: Long;
}
/**
* ValidatorParams restrict the public key types validators can use.
* NOTE: uses ABCI pubkey naming, not Amino names.
*/
export interface ValidatorParams {
pubKeyTypes: string[];
}
/** VersionParams contains the ABCI application version. */
export interface VersionParams {
appVersion: Long;
}
/**
* HashedParams is a subset of ConsensusParams.
*
* It is hashed into the Header.ConsensusHash.
*/
export interface HashedParams {
blockMaxBytes: Long;
blockMaxGas: Long;
}
const baseConsensusParams: object = {};
export const ConsensusParams = {
encode(message: ConsensusParams, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.block !== undefined) {
BlockParams.encode(message.block, writer.uint32(10).fork()).ldelim();
}
if (message.evidence !== undefined) {
EvidenceParams.encode(message.evidence, writer.uint32(18).fork()).ldelim();
}
if (message.validator !== undefined) {
ValidatorParams.encode(message.validator, writer.uint32(26).fork()).ldelim();
}
if (message.version !== undefined) {
VersionParams.encode(message.version, writer.uint32(34).fork()).ldelim();
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): ConsensusParams {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseConsensusParams } as ConsensusParams;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.block = BlockParams.decode(reader, reader.uint32());
break;
case 2:
message.evidence = EvidenceParams.decode(reader, reader.uint32());
break;
case 3:
message.validator = ValidatorParams.decode(reader, reader.uint32());
break;
case 4:
message.version = VersionParams.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): ConsensusParams {
const message = { ...baseConsensusParams } as ConsensusParams;
if (object.block !== undefined && object.block !== null) {
message.block = BlockParams.fromJSON(object.block);
} else {
message.block = undefined;
}
if (object.evidence !== undefined && object.evidence !== null) {
message.evidence = EvidenceParams.fromJSON(object.evidence);
} else {
message.evidence = undefined;
}
if (object.validator !== undefined && object.validator !== null) {
message.validator = ValidatorParams.fromJSON(object.validator);
} else {
message.validator = undefined;
}
if (object.version !== undefined && object.version !== null) {
message.version = VersionParams.fromJSON(object.version);
} else {
message.version = undefined;
}
return message;
},
toJSON(message: ConsensusParams): unknown {
const obj: any = {};
message.block !== undefined &&
(obj.block = message.block ? BlockParams.toJSON(message.block) : undefined);
message.evidence !== undefined &&
(obj.evidence = message.evidence ? EvidenceParams.toJSON(message.evidence) : undefined);
message.validator !== undefined &&
(obj.validator = message.validator ? ValidatorParams.toJSON(message.validator) : undefined);
message.version !== undefined &&
(obj.version = message.version ? VersionParams.toJSON(message.version) : undefined);
return obj;
},
fromPartial(object: DeepPartial<ConsensusParams>): ConsensusParams {
const message = { ...baseConsensusParams } as ConsensusParams;
if (object.block !== undefined && object.block !== null) {
message.block = BlockParams.fromPartial(object.block);
} else {
message.block = undefined;
}
if (object.evidence !== undefined && object.evidence !== null) {
message.evidence = EvidenceParams.fromPartial(object.evidence);
} else {
message.evidence = undefined;
}
if (object.validator !== undefined && object.validator !== null) {
message.validator = ValidatorParams.fromPartial(object.validator);
} else {
message.validator = undefined;
}
if (object.version !== undefined && object.version !== null) {
message.version = VersionParams.fromPartial(object.version);
} else {
message.version = undefined;
}
return message;
},
};
const baseBlockParams: object = { maxBytes: Long.ZERO, maxGas: Long.ZERO, timeIotaMs: Long.ZERO };
export const BlockParams = {
encode(message: BlockParams, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (!message.maxBytes.isZero()) {
writer.uint32(8).int64(message.maxBytes);
}
if (!message.maxGas.isZero()) {
writer.uint32(16).int64(message.maxGas);
}
if (!message.timeIotaMs.isZero()) {
writer.uint32(24).int64(message.timeIotaMs);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): BlockParams {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseBlockParams } as BlockParams;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.maxBytes = reader.int64() as Long;
break;
case 2:
message.maxGas = reader.int64() as Long;
break;
case 3:
message.timeIotaMs = reader.int64() as Long;
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): BlockParams {
const message = { ...baseBlockParams } as BlockParams;
if (object.maxBytes !== undefined && object.maxBytes !== null) {
message.maxBytes = Long.fromString(object.maxBytes);
} else {
message.maxBytes = Long.ZERO;
}
if (object.maxGas !== undefined && object.maxGas !== null) {
message.maxGas = Long.fromString(object.maxGas);
} else {
message.maxGas = Long.ZERO;
}
if (object.timeIotaMs !== undefined && object.timeIotaMs !== null) {
message.timeIotaMs = Long.fromString(object.timeIotaMs);
} else {
message.timeIotaMs = Long.ZERO;
}
return message;
},
toJSON(message: BlockParams): unknown {
const obj: any = {};
message.maxBytes !== undefined && (obj.maxBytes = (message.maxBytes || Long.ZERO).toString());
message.maxGas !== undefined && (obj.maxGas = (message.maxGas || Long.ZERO).toString());
message.timeIotaMs !== undefined && (obj.timeIotaMs = (message.timeIotaMs || Long.ZERO).toString());
return obj;
},
fromPartial(object: DeepPartial<BlockParams>): BlockParams {
const message = { ...baseBlockParams } as BlockParams;
if (object.maxBytes !== undefined && object.maxBytes !== null) {
message.maxBytes = object.maxBytes as Long;
} else {
message.maxBytes = Long.ZERO;
}
if (object.maxGas !== undefined && object.maxGas !== null) {
message.maxGas = object.maxGas as Long;
} else {
message.maxGas = Long.ZERO;
}
if (object.timeIotaMs !== undefined && object.timeIotaMs !== null) {
message.timeIotaMs = object.timeIotaMs as Long;
} else {
message.timeIotaMs = Long.ZERO;
}
return message;
},
};
const baseEvidenceParams: object = { maxAgeNumBlocks: Long.ZERO, maxBytes: Long.ZERO };
export const EvidenceParams = {
encode(message: EvidenceParams, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (!message.maxAgeNumBlocks.isZero()) {
writer.uint32(8).int64(message.maxAgeNumBlocks);
}
if (message.maxAgeDuration !== undefined) {
Duration.encode(message.maxAgeDuration, writer.uint32(18).fork()).ldelim();
}
if (!message.maxBytes.isZero()) {
writer.uint32(24).int64(message.maxBytes);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): EvidenceParams {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseEvidenceParams } as EvidenceParams;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.maxAgeNumBlocks = reader.int64() as Long;
break;
case 2:
message.maxAgeDuration = Duration.decode(reader, reader.uint32());
break;
case 3:
message.maxBytes = reader.int64() as Long;
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): EvidenceParams {
const message = { ...baseEvidenceParams } as EvidenceParams;
if (object.maxAgeNumBlocks !== undefined && object.maxAgeNumBlocks !== null) {
message.maxAgeNumBlocks = Long.fromString(object.maxAgeNumBlocks);
} else {
message.maxAgeNumBlocks = Long.ZERO;
}
if (object.maxAgeDuration !== undefined && object.maxAgeDuration !== null) {
message.maxAgeDuration = Duration.fromJSON(object.maxAgeDuration);
} else {
message.maxAgeDuration = undefined;
}
if (object.maxBytes !== undefined && object.maxBytes !== null) {
message.maxBytes = Long.fromString(object.maxBytes);
} else {
message.maxBytes = Long.ZERO;
}
return message;
},
toJSON(message: EvidenceParams): unknown {
const obj: any = {};
message.maxAgeNumBlocks !== undefined &&
(obj.maxAgeNumBlocks = (message.maxAgeNumBlocks || Long.ZERO).toString());
message.maxAgeDuration !== undefined &&
(obj.maxAgeDuration = message.maxAgeDuration ? Duration.toJSON(message.maxAgeDuration) : undefined);
message.maxBytes !== undefined && (obj.maxBytes = (message.maxBytes || Long.ZERO).toString());
return obj;
},
fromPartial(object: DeepPartial<EvidenceParams>): EvidenceParams {
const message = { ...baseEvidenceParams } as EvidenceParams;
if (object.maxAgeNumBlocks !== undefined && object.maxAgeNumBlocks !== null) {
message.maxAgeNumBlocks = object.maxAgeNumBlocks as Long;
} else {
message.maxAgeNumBlocks = Long.ZERO;
}
if (object.maxAgeDuration !== undefined && object.maxAgeDuration !== null) {
message.maxAgeDuration = Duration.fromPartial(object.maxAgeDuration);
} else {
message.maxAgeDuration = undefined;
}
if (object.maxBytes !== undefined && object.maxBytes !== null) {
message.maxBytes = object.maxBytes as Long;
} else {
message.maxBytes = Long.ZERO;
}
return message;
},
};
const baseValidatorParams: object = { pubKeyTypes: "" };
export const ValidatorParams = {
encode(message: ValidatorParams, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
for (const v of message.pubKeyTypes) {
writer.uint32(10).string(v!);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): ValidatorParams {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseValidatorParams } as ValidatorParams;
message.pubKeyTypes = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.pubKeyTypes.push(reader.string());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): ValidatorParams {
const message = { ...baseValidatorParams } as ValidatorParams;
message.pubKeyTypes = [];
if (object.pubKeyTypes !== undefined && object.pubKeyTypes !== null) {
for (const e of object.pubKeyTypes) {
message.pubKeyTypes.push(String(e));
}
}
return message;
},
toJSON(message: ValidatorParams): unknown {
const obj: any = {};
if (message.pubKeyTypes) {
obj.pubKeyTypes = message.pubKeyTypes.map((e) => e);
} else {
obj.pubKeyTypes = [];
}
return obj;
},
fromPartial(object: DeepPartial<ValidatorParams>): ValidatorParams {
const message = { ...baseValidatorParams } as ValidatorParams;
message.pubKeyTypes = [];
if (object.pubKeyTypes !== undefined && object.pubKeyTypes !== null) {
for (const e of object.pubKeyTypes) {
message.pubKeyTypes.push(e);
}
}
return message;
},
};
const baseVersionParams: object = { appVersion: Long.UZERO };
export const VersionParams = {
encode(message: VersionParams, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (!message.appVersion.isZero()) {
writer.uint32(8).uint64(message.appVersion);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): VersionParams {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseVersionParams } as VersionParams;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.appVersion = reader.uint64() as Long;
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): VersionParams {
const message = { ...baseVersionParams } as VersionParams;
if (object.appVersion !== undefined && object.appVersion !== null) {
message.appVersion = Long.fromString(object.appVersion);
} else {
message.appVersion = Long.UZERO;
}
return message;
},
toJSON(message: VersionParams): unknown {
const obj: any = {};
message.appVersion !== undefined && (obj.appVersion = (message.appVersion || Long.UZERO).toString());
return obj;
},
fromPartial(object: DeepPartial<VersionParams>): VersionParams {
const message = { ...baseVersionParams } as VersionParams;
if (object.appVersion !== undefined && object.appVersion !== null) {
message.appVersion = object.appVersion as Long;
} else {
message.appVersion = Long.UZERO;
}
return message;
},
};
const baseHashedParams: object = { blockMaxBytes: Long.ZERO, blockMaxGas: Long.ZERO };
export const HashedParams = {
encode(message: HashedParams, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (!message.blockMaxBytes.isZero()) {
writer.uint32(8).int64(message.blockMaxBytes);
}
if (!message.blockMaxGas.isZero()) {
writer.uint32(16).int64(message.blockMaxGas);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): HashedParams {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseHashedParams } as HashedParams;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.blockMaxBytes = reader.int64() as Long;
break;
case 2:
message.blockMaxGas = reader.int64() as Long;
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): HashedParams {
const message = { ...baseHashedParams } as HashedParams;
if (object.blockMaxBytes !== undefined && object.blockMaxBytes !== null) {
message.blockMaxBytes = Long.fromString(object.blockMaxBytes);
} else {
message.blockMaxBytes = Long.ZERO;
}
if (object.blockMaxGas !== undefined && object.blockMaxGas !== null) {
message.blockMaxGas = Long.fromString(object.blockMaxGas);
} else {
message.blockMaxGas = Long.ZERO;
}
return message;
},
toJSON(message: HashedParams): unknown {
const obj: any = {};
message.blockMaxBytes !== undefined &&
(obj.blockMaxBytes = (message.blockMaxBytes || Long.ZERO).toString());
message.blockMaxGas !== undefined && (obj.blockMaxGas = (message.blockMaxGas || Long.ZERO).toString());
return obj;
},
fromPartial(object: DeepPartial<HashedParams>): HashedParams {
const message = { ...baseHashedParams } as HashedParams;
if (object.blockMaxBytes !== undefined && object.blockMaxBytes !== null) {
message.blockMaxBytes = object.blockMaxBytes as Long;
} else {
message.blockMaxBytes = Long.ZERO;
}
if (object.blockMaxGas !== undefined && object.blockMaxGas !== null) {
message.blockMaxGas = object.blockMaxGas as Long;
} else {
message.blockMaxGas = Long.ZERO;
}
return message;
},
};
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

1809
packages/stargate/src/codec/tendermint/types/types.ts
View File

File diff suppressed because it is too large Load Diff

351
packages/stargate/src/codec/tendermint/types/validator.ts
View File

@ -1,351 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
import { PublicKey } from "../../tendermint/crypto/keys";
export const protobufPackage = "tendermint.types";
export interface ValidatorSet {
validators: Validator[];
proposer?: Validator;
totalVotingPower: Long;
}
export interface Validator {
address: Uint8Array;
pubKey?: PublicKey;
votingPower: Long;
proposerPriority: Long;
}
export interface SimpleValidator {
pubKey?: PublicKey;
votingPower: Long;
}
const baseValidatorSet: object = { totalVotingPower: Long.ZERO };
export const ValidatorSet = {
encode(message: ValidatorSet, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
for (const v of message.validators) {
Validator.encode(v!, writer.uint32(10).fork()).ldelim();
}
if (message.proposer !== undefined) {
Validator.encode(message.proposer, writer.uint32(18).fork()).ldelim();
}
if (!message.totalVotingPower.isZero()) {
writer.uint32(24).int64(message.totalVotingPower);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): ValidatorSet {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseValidatorSet } as ValidatorSet;
message.validators = [];
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.validators.push(Validator.decode(reader, reader.uint32()));
break;
case 2:
message.proposer = Validator.decode(reader, reader.uint32());
break;
case 3:
message.totalVotingPower = reader.int64() as Long;
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): ValidatorSet {
const message = { ...baseValidatorSet } as ValidatorSet;
message.validators = [];
if (object.validators !== undefined && object.validators !== null) {
for (const e of object.validators) {
message.validators.push(Validator.fromJSON(e));
}
}
if (object.proposer !== undefined && object.proposer !== null) {
message.proposer = Validator.fromJSON(object.proposer);
} else {
message.proposer = undefined;
}
if (object.totalVotingPower !== undefined && object.totalVotingPower !== null) {
message.totalVotingPower = Long.fromString(object.totalVotingPower);
} else {
message.totalVotingPower = Long.ZERO;
}
return message;
},
toJSON(message: ValidatorSet): unknown {
const obj: any = {};
if (message.validators) {
obj.validators = message.validators.map((e) => (e ? Validator.toJSON(e) : undefined));
} else {
obj.validators = [];
}
message.proposer !== undefined &&
(obj.proposer = message.proposer ? Validator.toJSON(message.proposer) : undefined);
message.totalVotingPower !== undefined &&
(obj.totalVotingPower = (message.totalVotingPower || Long.ZERO).toString());
return obj;
},
fromPartial(object: DeepPartial<ValidatorSet>): ValidatorSet {
const message = { ...baseValidatorSet } as ValidatorSet;
message.validators = [];
if (object.validators !== undefined && object.validators !== null) {
for (const e of object.validators) {
message.validators.push(Validator.fromPartial(e));
}
}
if (object.proposer !== undefined && object.proposer !== null) {
message.proposer = Validator.fromPartial(object.proposer);
} else {
message.proposer = undefined;
}
if (object.totalVotingPower !== undefined && object.totalVotingPower !== null) {
message.totalVotingPower = object.totalVotingPower as Long;
} else {
message.totalVotingPower = Long.ZERO;
}
return message;
},
};
const baseValidator: object = { votingPower: Long.ZERO, proposerPriority: Long.ZERO };
export const Validator = {
encode(message: Validator, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.address.length !== 0) {
writer.uint32(10).bytes(message.address);
}
if (message.pubKey !== undefined) {
PublicKey.encode(message.pubKey, writer.uint32(18).fork()).ldelim();
}
if (!message.votingPower.isZero()) {
writer.uint32(24).int64(message.votingPower);
}
if (!message.proposerPriority.isZero()) {
writer.uint32(32).int64(message.proposerPriority);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): Validator {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseValidator } as Validator;
message.address = new Uint8Array();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.address = reader.bytes();
break;
case 2:
message.pubKey = PublicKey.decode(reader, reader.uint32());
break;
case 3:
message.votingPower = reader.int64() as Long;
break;
case 4:
message.proposerPriority = reader.int64() as Long;
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): Validator {
const message = { ...baseValidator } as Validator;
message.address = new Uint8Array();
if (object.address !== undefined && object.address !== null) {
message.address = bytesFromBase64(object.address);
}
if (object.pubKey !== undefined && object.pubKey !== null) {
message.pubKey = PublicKey.fromJSON(object.pubKey);
} else {
message.pubKey = undefined;
}
if (object.votingPower !== undefined && object.votingPower !== null) {
message.votingPower = Long.fromString(object.votingPower);
} else {
message.votingPower = Long.ZERO;
}
if (object.proposerPriority !== undefined && object.proposerPriority !== null) {
message.proposerPriority = Long.fromString(object.proposerPriority);
} else {
message.proposerPriority = Long.ZERO;
}
return message;
},
toJSON(message: Validator): unknown {
const obj: any = {};
message.address !== undefined &&
(obj.address = base64FromBytes(message.address !== undefined ? message.address : new Uint8Array()));
message.pubKey !== undefined &&
(obj.pubKey = message.pubKey ? PublicKey.toJSON(message.pubKey) : undefined);
message.votingPower !== undefined && (obj.votingPower = (message.votingPower || Long.ZERO).toString());
message.proposerPriority !== undefined &&
(obj.proposerPriority = (message.proposerPriority || Long.ZERO).toString());
return obj;
},
fromPartial(object: DeepPartial<Validator>): Validator {
const message = { ...baseValidator } as Validator;
if (object.address !== undefined && object.address !== null) {
message.address = object.address;
} else {
message.address = new Uint8Array();
}
if (object.pubKey !== undefined && object.pubKey !== null) {
message.pubKey = PublicKey.fromPartial(object.pubKey);
} else {
message.pubKey = undefined;
}
if (object.votingPower !== undefined && object.votingPower !== null) {
message.votingPower = object.votingPower as Long;
} else {
message.votingPower = Long.ZERO;
}
if (object.proposerPriority !== undefined && object.proposerPriority !== null) {
message.proposerPriority = object.proposerPriority as Long;
} else {
message.proposerPriority = Long.ZERO;
}
return message;
},
};
const baseSimpleValidator: object = { votingPower: Long.ZERO };
export const SimpleValidator = {
encode(message: SimpleValidator, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (message.pubKey !== undefined) {
PublicKey.encode(message.pubKey, writer.uint32(10).fork()).ldelim();
}
if (!message.votingPower.isZero()) {
writer.uint32(16).int64(message.votingPower);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): SimpleValidator {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseSimpleValidator } as SimpleValidator;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.pubKey = PublicKey.decode(reader, reader.uint32());
break;
case 2:
message.votingPower = reader.int64() as Long;
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): SimpleValidator {
const message = { ...baseSimpleValidator } as SimpleValidator;
if (object.pubKey !== undefined && object.pubKey !== null) {
message.pubKey = PublicKey.fromJSON(object.pubKey);
} else {
message.pubKey = undefined;
}
if (object.votingPower !== undefined && object.votingPower !== null) {
message.votingPower = Long.fromString(object.votingPower);
} else {
message.votingPower = Long.ZERO;
}
return message;
},
toJSON(message: SimpleValidator): unknown {
const obj: any = {};
message.pubKey !== undefined &&
(obj.pubKey = message.pubKey ? PublicKey.toJSON(message.pubKey) : undefined);
message.votingPower !== undefined && (obj.votingPower = (message.votingPower || Long.ZERO).toString());
return obj;
},
fromPartial(object: DeepPartial<SimpleValidator>): SimpleValidator {
const message = { ...baseSimpleValidator } as SimpleValidator;
if (object.pubKey !== undefined && object.pubKey !== null) {
message.pubKey = PublicKey.fromPartial(object.pubKey);
} else {
message.pubKey = undefined;
}
if (object.votingPower !== undefined && object.votingPower !== null) {
message.votingPower = object.votingPower as Long;
} else {
message.votingPower = Long.ZERO;
}
return message;
},
};
declare var self: any | undefined;
declare var window: any | undefined;
var globalThis: any = (() => {
if (typeof globalThis !== "undefined") return globalThis;
if (typeof self !== "undefined") return self;
if (typeof window !== "undefined") return window;
if (typeof global !== "undefined") return global;
throw "Unable to locate global object";
})();
const atob: (b64: string) => string =
globalThis.atob || ((b64) => globalThis.Buffer.from(b64, "base64").toString("binary"));
function bytesFromBase64(b64: string): Uint8Array {
const bin = atob(b64);
const arr = new Uint8Array(bin.length);
for (let i = 0; i < bin.length; ++i) {
arr[i] = bin.charCodeAt(i);
}
return arr;
}
const btoa: (bin: string) => string =
globalThis.btoa || ((bin) => globalThis.Buffer.from(bin, "binary").toString("base64"));
function base64FromBytes(arr: Uint8Array): string {
const bin: string[] = [];
for (let i = 0; i < arr.byteLength; ++i) {
bin.push(String.fromCharCode(arr[i]));
}
return btoa(bin.join(""));
}
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}

185
packages/stargate/src/codec/tendermint/version/types.ts
View File

@ -1,185 +0,0 @@
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
export const protobufPackage = "tendermint.version";
/**
* App includes the protocol and software version for the application.
* This information is included in ResponseInfo. The App.Protocol can be
* updated in ResponseEndBlock.
*/
export interface App {
protocol: Long;
software: string;
}
/**
* Consensus captures the consensus rules for processing a block in the blockchain,
* including all blockchain data structures and the rules of the application's
* state transition machine.
*/
export interface Consensus {
block: Long;
app: Long;
}
const baseApp: object = { protocol: Long.UZERO, software: "" };
export const App = {
encode(message: App, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (!message.protocol.isZero()) {
writer.uint32(8).uint64(message.protocol);
}
if (message.software !== "") {
writer.uint32(18).string(message.software);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): App {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseApp } as App;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.protocol = reader.uint64() as Long;
break;
case 2:
message.software = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): App {
const message = { ...baseApp } as App;
if (object.protocol !== undefined && object.protocol !== null) {
message.protocol = Long.fromString(object.protocol);
} else {
message.protocol = Long.UZERO;
}
if (object.software !== undefined && object.software !== null) {
message.software = String(object.software);
} else {
message.software = "";
}
return message;
},
toJSON(message: App): unknown {
const obj: any = {};
message.protocol !== undefined && (obj.protocol = (message.protocol || Long.UZERO).toString());
message.software !== undefined && (obj.software = message.software);
return obj;
},
fromPartial(object: DeepPartial<App>): App {
const message = { ...baseApp } as App;
if (object.protocol !== undefined && object.protocol !== null) {
message.protocol = object.protocol as Long;
} else {
message.protocol = Long.UZERO;
}
if (object.software !== undefined && object.software !== null) {
message.software = object.software;
} else {
message.software = "";
}
return message;
},
};
const baseConsensus: object = { block: Long.UZERO, app: Long.UZERO };
export const Consensus = {
encode(message: Consensus, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
if (!message.block.isZero()) {
writer.uint32(8).uint64(message.block);
}
if (!message.app.isZero()) {
writer.uint32(16).uint64(message.app);
}
return writer;
},
decode(input: _m0.Reader | Uint8Array, length?: number): Consensus {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = { ...baseConsensus } as Consensus;
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.block = reader.uint64() as Long;
break;
case 2:
message.app = reader.uint64() as Long;
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object: any): Consensus {
const message = { ...baseConsensus } as Consensus;
if (object.block !== undefined && object.block !== null) {
message.block = Long.fromString(object.block);
} else {
message.block = Long.UZERO;
}
if (object.app !== undefined && object.app !== null) {
message.app = Long.fromString(object.app);
} else {
message.app = Long.UZERO;
}
return message;
},
toJSON(message: Consensus): unknown {
const obj: any = {};
message.block !== undefined && (obj.block = (message.block || Long.UZERO).toString());
message.app !== undefined && (obj.app = (message.app || Long.UZERO).toString());
return obj;
},
fromPartial(object: DeepPartial<Consensus>): Consensus {
const message = { ...baseConsensus } as Consensus;
if (object.block !== undefined && object.block !== null) {
message.block = object.block as Long;
} else {
message.block = Long.UZERO;
}
if (object.app !== undefined && object.app !== null) {
message.app = object.app as Long;
} else {
message.app = Long.UZERO;
}
return message;
},
};
type Builtin = Date | Function | Uint8Array | string | number | undefined | Long;
export type DeepPartial<T> = T extends Builtin
? T
: T extends Array<infer U>
? Array<DeepPartial<U>>
: T extends ReadonlyArray<infer U>
? ReadonlyArray<DeepPartial<U>>
: T extends {}
? { [K in keyof T]?: DeepPartial<T[K]> }
: Partial<T>;
if (_m0.util.Long !== Long) {
_m0.util.Long = Long as any;
_m0.configure();
}