From b785dd2e5eea6b857f6a21ff388d64e068dcdebe Mon Sep 17 00:00:00 2001 From: Fabrice Bascoulergue Date: Wed, 15 Sep 2021 16:19:54 +0200 Subject: [PATCH 1/4] Refactor implementation by implementing extensions on site --- scripts/define-proto.sh | 1 + src/client/LumClient.ts | 73 +-- .../ibc/applications/transfer/v1/query.ts | 445 +++++++++++++++++ .../ibc/applications/transfer/v1/transfer.ts | 320 ++++++++++++ src/extensions/auth.ts | 25 + src/extensions/bank.ts | 45 ++ src/extensions/beam.ts | 4 +- src/extensions/distribution.ts | 94 ++++ src/extensions/gov.ts | 95 ++++ src/extensions/ibc.ts | 461 ++++++++++++++++++ src/extensions/index.ts | 8 +- src/extensions/staking.ts | 146 ++++++ src/extensions/utils.ts | 34 ++ tests/client.test.ts | 28 +- tests/ledger.test.ts | 19 +- tests/utils.ts | 39 ++ 16 files changed, 1748 insertions(+), 89 deletions(-) create mode 100644 src/codec/ibc/applications/transfer/v1/query.ts create mode 100644 src/codec/ibc/applications/transfer/v1/transfer.ts create mode 100644 src/extensions/auth.ts create mode 100644 src/extensions/bank.ts create mode 100644 src/extensions/distribution.ts create mode 100644 src/extensions/gov.ts create mode 100644 src/extensions/ibc.ts create mode 100644 src/extensions/staking.ts create mode 100644 src/extensions/utils.ts create mode 100644 tests/utils.ts diff --git a/scripts/define-proto.sh b/scripts/define-proto.sh index 680105d..8e8097c 100644 --- a/scripts/define-proto.sh +++ b/scripts/define-proto.sh @@ -45,6 +45,7 @@ protoc \ "$COSMOS_PROTO_DIR/cosmos/tx/v1beta1/tx.proto" \ "$COSMOS_PROTO_DIR/cosmos/vesting/v1beta1/vesting.proto" \ "$COSMOS_PROTO_DIR/ibc/applications/transfer/v1/tx.proto" \ + "$COSMOS_PROTO_DIR/ibc/applications/transfer/v1/query.proto" \ "$COSMOS_PROTO_DIR/ibc/core/channel/v1/channel.proto" \ "$COSMOS_PROTO_DIR/ibc/core/channel/v1/query.proto" \ "$COSMOS_PROTO_DIR/ibc/core/channel/v1/tx.proto" \ diff --git a/src/client/LumClient.ts b/src/client/LumClient.ts index f225181..815b392 100644 --- a/src/client/LumClient.ts +++ b/src/client/LumClient.ts @@ -1,25 +1,29 @@ import { Tendermint34Client, StatusResponse } from '@cosmjs/tendermint-rpc'; +import { QueryClient as StargateQueryClient, accountFromAny } from '@cosmjs/stargate'; + +import { LumWallet, LumUtils, LumTypes } from '..'; import { - QueryClient as StargateQueryClient, - setupAuthExtension as StargateSetupAuthExtension, - setupBankExtension as StargateSetupBankExtension, - setupDistributionExtension as StargateDistributionExtension, - setupStakingExtension as StargateStakingExtension, - setupGovExtension as StargateGovExtension, AuthExtension, + setupAuthExtension, BankExtension, - StakingExtension, + setupBankExtension, + BeamExtension, + setupBeamExtension, DistributionExtension, + setupDistributionExtension, GovExtension, - accountFromAny, -} from '@cosmjs/stargate'; - -import { LumWallet, LumUtils, LumTypes } from '..'; -import { BeamExtension, setupBeamExtension as BeamSetupBeamExtension, MintExtension, setupMintExtension as MintSetupExtension } from '../extensions'; + setupGovExtension, + IbcExtension, + setupIbcExtension, + MintExtension, + setupMintExtension, + StakingExtension, + setupStakingExtension, +} from '../extensions'; export class LumClient { readonly tmClient: Tendermint34Client; - readonly queryClient: StargateQueryClient & AuthExtension & BankExtension & DistributionExtension & StakingExtension & GovExtension & MintExtension & BeamExtension; + readonly queryClient: StargateQueryClient & AuthExtension & BankExtension & BeamExtension & DistributionExtension & GovExtension & IbcExtension & MintExtension & StakingExtension; private chainId?: string; /** @@ -31,13 +35,14 @@ export class LumClient { this.tmClient = tmClient; this.queryClient = StargateQueryClient.withExtensions( tmClient, - StargateSetupAuthExtension, - StargateSetupBankExtension, - StargateDistributionExtension, - StargateStakingExtension, - StargateGovExtension, - MintSetupExtension, - BeamSetupBeamExtension, + setupAuthExtension, + setupBankExtension, + setupBeamExtension, + setupDistributionExtension, + setupGovExtension, + setupIbcExtension, + setupMintExtension, + setupStakingExtension, ); // Used for debugging while gasWanted, gasUsed and codespace are still waiting to be included in the code lib @@ -136,19 +141,6 @@ export class LumClient { * @param address wallet address */ getAccount = async (address: string): Promise => { - const anyAccount = await this.queryClient.auth.verified.account(address); - if (!anyAccount) { - return null; - } - return accountFromAny(anyAccount); - }; - - /** - * Get account information without verifying its existence - * - * @param address wallet address - */ - getAccountUnverified = async (address: string): Promise => { const anyAccount = await this.queryClient.auth.account(address); if (!anyAccount) { return null; @@ -163,27 +155,16 @@ export class LumClient { * @param searchDenom Coin denomination (ex: lum) */ getBalance = async (address: string, searchDenom: string): Promise => { - const balance = await this.queryClient.bank.verified.balance(address, searchDenom); - return balance ? balance : null; - }; - - /** - * Get an account balance without verifying their existence - * - * @param address wallet address - * @param searchDenom Coin denomination (ex: lum) - */ - getBalanceUnverified = async (address: string, searchDenom: string): Promise => { const balance = await this.queryClient.bank.balance(address, searchDenom); return balance ? balance : null; }; /** - * Get all account balances without verifying their existence + * Get all account balances * * @param address wallet address */ - getAllBalancesUnverified = async (address: string): Promise => { + getAllBalances = async (address: string): Promise => { const balances = await this.queryClient.bank.allBalances(address); return balances; }; diff --git a/src/codec/ibc/applications/transfer/v1/query.ts b/src/codec/ibc/applications/transfer/v1/query.ts new file mode 100644 index 0000000..cbf91e8 --- /dev/null +++ b/src/codec/ibc/applications/transfer/v1/query.ts @@ -0,0 +1,445 @@ +/* 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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; + /** DenomTraces queries all denomination traces. */ + DenomTraces(request: QueryDenomTracesRequest): Promise; + /** Params queries all parameters of the ibc-transfer module. */ + Params(request: QueryParamsRequest): Promise; +} + +export class QueryClientImpl implements Query { + private readonly rpc: Rpc; + constructor(rpc: Rpc) { + this.rpc = rpc; + } + DenomTrace(request: QueryDenomTraceRequest): Promise { + 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 { + 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 { + 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; +} + +type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined | Long; +export type DeepPartial = T extends Builtin + ? T + : T extends Array + ? Array> + : T extends ReadonlyArray + ? ReadonlyArray> + : T extends {} + ? { [K in keyof T]?: DeepPartial } + : Partial; + +if (_m0.util.Long !== Long) { + _m0.util.Long = Long as any; + _m0.configure(); +} diff --git a/src/codec/ibc/applications/transfer/v1/transfer.ts b/src/codec/ibc/applications/transfer/v1/transfer.ts new file mode 100644 index 0000000..996d81b --- /dev/null +++ b/src/codec/ibc/applications/transfer/v1/transfer.ts @@ -0,0 +1,320 @@ +/* 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 { + 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 { + 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 { + 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 | boolean | undefined | Long; +export type DeepPartial = T extends Builtin + ? T + : T extends Array + ? Array> + : T extends ReadonlyArray + ? ReadonlyArray> + : T extends {} + ? { [K in keyof T]?: DeepPartial } + : Partial; + +if (_m0.util.Long !== Long) { + _m0.util.Long = Long as any; + _m0.configure(); +} diff --git a/src/extensions/auth.ts b/src/extensions/auth.ts new file mode 100644 index 0000000..b6c1204 --- /dev/null +++ b/src/extensions/auth.ts @@ -0,0 +1,25 @@ +import { QueryClient } from '@cosmjs/stargate'; + +import { Any } from '../codec/google/protobuf/any'; +import { QueryClientImpl } from '../codec/cosmos/auth/v1beta1/query'; +import { createProtobufRpcClient } from './utils'; + +export interface AuthExtension { + readonly auth: { + readonly account: (address: string) => Promise; + }; +} + +export function setupAuthExtension(base: QueryClient): AuthExtension { + const rpc = createProtobufRpcClient(base); + const queryService = new QueryClientImpl(rpc); + + return { + auth: { + account: async (address: string) => { + const { account } = await queryService.Account({ address: address }); + return account ?? null; + }, + }, + }; +} diff --git a/src/extensions/bank.ts b/src/extensions/bank.ts new file mode 100644 index 0000000..030966d --- /dev/null +++ b/src/extensions/bank.ts @@ -0,0 +1,45 @@ +import { QueryClient } from '@cosmjs/stargate'; +import { assert } from '@cosmjs/utils'; + +import { QueryClientImpl } from '../codec/cosmos/bank/v1beta1/query'; +import { Coin } from '../codec/cosmos/base/v1beta1/coin'; +import { createProtobufRpcClient } from './utils'; + +export interface BankExtension { + readonly bank: { + readonly balance: (address: string, denom: string) => Promise; + readonly allBalances: (address: string) => Promise; + readonly totalSupply: () => Promise; + readonly supplyOf: (denom: string) => Promise; + }; +} + +export function setupBankExtension(base: QueryClient): BankExtension { + const rpc = createProtobufRpcClient(base); + // Use this service to get easy typed access to query methods + // This cannot be used for proof verification + const queryService = new QueryClientImpl(rpc); + + return { + bank: { + balance: async (address: string, denom: string) => { + const { balance } = await queryService.Balance({ address: address, denom: denom }); + assert(balance); + return balance; + }, + allBalances: async (address: string) => { + const { balances } = await queryService.AllBalances({ address: address }); + return balances; + }, + totalSupply: async () => { + const { supply } = await queryService.TotalSupply({}); + return supply; + }, + supplyOf: async (denom: string) => { + const { amount } = await queryService.SupplyOf({ denom: denom }); + assert(amount); + return amount; + }, + }, + }; +} diff --git a/src/extensions/beam.ts b/src/extensions/beam.ts index 654f723..b6e22e5 100644 --- a/src/extensions/beam.ts +++ b/src/extensions/beam.ts @@ -1,9 +1,9 @@ -import { createProtobufRpcClient, QueryClient } from '@cosmjs/stargate'; - +import { QueryClient } from '@cosmjs/stargate'; import { assert } from '@cosmjs/utils'; import { Beam } from '../codec/beam/beam'; import { QueryClientImpl } from '../codec/beam/query'; +import { createProtobufRpcClient } from './utils'; export interface BeamExtension { readonly beam: { diff --git a/src/extensions/distribution.ts b/src/extensions/distribution.ts new file mode 100644 index 0000000..e7e2a0f --- /dev/null +++ b/src/extensions/distribution.ts @@ -0,0 +1,94 @@ +import { QueryClient } from '@cosmjs/stargate'; +import { + QueryClientImpl, + QueryCommunityPoolResponse, + QueryDelegationRewardsResponse, + QueryDelegationTotalRewardsResponse, + QueryDelegatorValidatorsResponse, + QueryDelegatorWithdrawAddressResponse, + QueryParamsResponse, + QueryValidatorCommissionResponse, + QueryValidatorOutstandingRewardsResponse, + QueryValidatorSlashesResponse, +} from '../codec/cosmos/distribution/v1beta1/query'; +import Long from 'long'; + +import { createPagination, createProtobufRpcClient } from './utils'; + +export interface DistributionExtension { + readonly distribution: { + communityPool: () => Promise; + delegationRewards: (delegatorAddress: string, validatorAddress: string) => Promise; + delegationTotalRewards: (delegatorAddress: string) => Promise; + delegatorValidators: (delegatorAddress: string) => Promise; + delegatorWithdrawAddress: (delegatorAddress: string) => Promise; + params: () => Promise; + validatorCommission: (validatorAddress: string) => Promise; + validatorOutstandingRewards: (validatorAddress: string) => Promise; + validatorSlashes: (validatorAddress: string, startingHeight: number, endingHeight: number, paginationKey?: Uint8Array) => Promise; + }; +} + +export function setupDistributionExtension(base: QueryClient): DistributionExtension { + const rpc = createProtobufRpcClient(base); + const queryService = new QueryClientImpl(rpc); + + return { + distribution: { + communityPool: async () => { + const response = await queryService.CommunityPool({}); + return response; + }, + delegationRewards: async (delegatorAddress: string, validatorAddress: string) => { + const response = await queryService.DelegationRewards({ + delegatorAddress: delegatorAddress, + validatorAddress: validatorAddress, + }); + return response; + }, + delegationTotalRewards: async (delegatorAddress: string) => { + const response = await queryService.DelegationTotalRewards({ + delegatorAddress: delegatorAddress, + }); + return response; + }, + delegatorValidators: async (delegatorAddress: string) => { + const response = await queryService.DelegatorValidators({ + delegatorAddress: delegatorAddress, + }); + return response; + }, + delegatorWithdrawAddress: async (delegatorAddress: string) => { + const response = await queryService.DelegatorWithdrawAddress({ + delegatorAddress: delegatorAddress, + }); + return response; + }, + params: async () => { + const response = await queryService.Params({}); + return response; + }, + validatorCommission: async (validatorAddress: string) => { + const response = await queryService.ValidatorCommission({ + validatorAddress: validatorAddress, + }); + return response; + }, + validatorOutstandingRewards: async (validatorAddress: string) => { + const response = await queryService.ValidatorOutstandingRewards({ + validatorAddress: validatorAddress, + }); + return response; + }, + validatorSlashes: async (validatorAddress: string, startingHeight: number, endingHeight: number, paginationKey?: Uint8Array) => { + const response = await queryService.ValidatorSlashes({ + validatorAddress: validatorAddress, + startingHeight: Long.fromNumber(startingHeight, true), + endingHeight: Long.fromNumber(endingHeight, true), + pagination: createPagination(paginationKey), + }); + return response; + }, + }, + }; +} diff --git a/src/extensions/gov.ts b/src/extensions/gov.ts new file mode 100644 index 0000000..ef351fc --- /dev/null +++ b/src/extensions/gov.ts @@ -0,0 +1,95 @@ +import Long from 'long'; +import { QueryClient } from '@cosmjs/stargate'; +import { Uint64 } from '@cosmjs/math'; + +import { ProposalStatus } from '../codec/cosmos/gov/v1beta1/gov'; +import { + QueryClientImpl, + QueryDepositResponse, + QueryDepositsResponse, + QueryParamsResponse, + QueryProposalResponse, + QueryProposalsResponse, + QueryTallyResultResponse, + QueryVoteResponse, + QueryVotesResponse, +} from '../codec/cosmos/gov/v1beta1/query'; +import { createPagination, longify, createProtobufRpcClient } from './utils'; + +export type GovParamsType = 'deposit' | 'tallying' | 'voting'; + +export type GovProposalId = string | number | Long | Uint64; + +export interface GovExtension { + readonly gov: { + readonly params: (parametersType: GovParamsType) => Promise; + readonly proposals: (proposalStatus: ProposalStatus, depositor: string, voter: string) => Promise; + readonly proposal: (proposalId: GovProposalId) => Promise; + readonly deposits: (proposalId: GovProposalId) => Promise; + readonly deposit: (proposalId: GovProposalId, depositorAddress: string) => Promise; + readonly tally: (proposalId: GovProposalId) => Promise; + readonly votes: (proposalId: GovProposalId) => Promise; + readonly vote: (proposalId: GovProposalId, voterAddress: string) => Promise; + }; +} + +export function setupGovExtension(base: QueryClient): GovExtension { + const rpc = createProtobufRpcClient(base); + const queryService = new QueryClientImpl(rpc); + + return { + gov: { + params: async (parametersType: GovParamsType) => { + const response = await queryService.Params({ paramsType: parametersType }); + return response; + }, + proposals: async (proposalStatus: ProposalStatus, depositorAddress: string, voterAddress: string, paginationKey?: Uint8Array) => { + const response = await queryService.Proposals({ + proposalStatus, + depositor: depositorAddress, + voter: voterAddress, + pagination: createPagination(paginationKey), + }); + return response; + }, + proposal: async (proposalId: GovProposalId) => { + const response = await queryService.Proposal({ proposalId: longify(proposalId) }); + return response; + }, + deposits: async (proposalId: GovProposalId, paginationKey?: Uint8Array) => { + const response = await queryService.Deposits({ + proposalId: longify(proposalId), + pagination: createPagination(paginationKey), + }); + return response; + }, + deposit: async (proposalId: GovProposalId, depositorAddress: string) => { + const response = await queryService.Deposit({ + proposalId: longify(proposalId), + depositor: depositorAddress, + }); + return response; + }, + tally: async (proposalId: GovProposalId) => { + const response = await queryService.TallyResult({ + proposalId: longify(proposalId), + }); + return response; + }, + votes: async (proposalId: GovProposalId, paginationKey?: Uint8Array) => { + const response = await queryService.Votes({ + proposalId: longify(proposalId), + pagination: createPagination(paginationKey), + }); + return response; + }, + vote: async (proposalId: GovProposalId, voterAddress: string) => { + const response = await queryService.Vote({ + proposalId: longify(proposalId), + voter: voterAddress, + }); + return response; + }, + }, + }; +} diff --git a/src/extensions/ibc.ts b/src/extensions/ibc.ts new file mode 100644 index 0000000..9c0895a --- /dev/null +++ b/src/extensions/ibc.ts @@ -0,0 +1,461 @@ +import Long from 'long'; +import { QueryClient } from '@cosmjs/stargate'; +import { toAscii } from '@cosmjs/encoding'; +import { Uint64 } from '@cosmjs/math'; + +import { Any } from '../codec/google/protobuf/any'; +import { Channel } from '../codec/ibc/core/channel/v1/channel'; +import { QueryClientImpl as TransferQuery, QueryDenomTraceResponse, QueryDenomTracesResponse, QueryParamsResponse as QueryTransferParamsResponse } from '../codec/ibc/applications/transfer/v1/query'; +import { + QueryChannelClientStateResponse, + QueryChannelConsensusStateResponse, + QueryChannelResponse, + QueryChannelsResponse, + QueryClientImpl as ChannelQuery, + QueryConnectionChannelsResponse, + QueryNextSequenceReceiveResponse, + QueryPacketAcknowledgementResponse, + QueryPacketAcknowledgementsResponse, + QueryPacketCommitmentResponse, + QueryPacketCommitmentsResponse, + QueryPacketReceiptResponse, + QueryUnreceivedAcksResponse, + QueryUnreceivedPacketsResponse, +} from '../codec/ibc/core/channel/v1/query'; +import { Height } from '../codec/ibc/core/client/v1/client'; +import { + QueryClientImpl as ClientQuery, + QueryClientParamsResponse, + QueryClientStateResponse, + QueryClientStatesResponse, + QueryConsensusStateRequest, + QueryConsensusStateResponse, + QueryConsensusStatesResponse, +} from '../codec/ibc/core/client/v1/query'; +import { + QueryClientConnectionsResponse, + QueryClientImpl as ConnectionQuery, + QueryConnectionClientStateResponse, + QueryConnectionConsensusStateRequest, + QueryConnectionConsensusStateResponse, + QueryConnectionResponse, + QueryConnectionsResponse, +} from '../codec/ibc/core/connection/v1/query'; +import { ClientState as TendermintClientState, ConsensusState as TendermintConsensusState } from '../codec/ibc/lightclients/tendermint/v1/tendermint'; +import { createPagination, createProtobufRpcClient } from './utils'; + +function decodeTendermintClientStateAny(clientState: Any | undefined): TendermintClientState { + if (clientState?.typeUrl !== '/ibc.lightclients.tendermint.v1.ClientState') { + throw new Error(`Unexpected client state type: ${clientState?.typeUrl}`); + } + return TendermintClientState.decode(clientState.value); +} + +function decodeTendermintConsensusStateAny(clientState: Any | undefined): TendermintConsensusState { + if (clientState?.typeUrl !== '/ibc.lightclients.tendermint.v1.ConsensusState') { + throw new Error(`Unexpected client state type: ${clientState?.typeUrl}`); + } + return TendermintConsensusState.decode(clientState.value); +} + +export interface IbcExtension { + readonly ibc: { + readonly channel: { + readonly channel: (portId: string, channelId: string) => Promise; + readonly channels: (paginationKey?: Uint8Array) => Promise; + readonly allChannels: () => Promise; + readonly connectionChannels: (connection: string, paginationKey?: Uint8Array) => Promise; + readonly allConnectionChannels: (connection: string) => Promise; + readonly clientState: (portId: string, channelId: string) => Promise; + readonly consensusState: (portId: string, channelId: string, revisionNumber: number, revisionHeight: number) => Promise; + readonly packetCommitment: (portId: string, channelId: string, sequence: Long) => Promise; + readonly packetCommitments: (portId: string, channelId: string, paginationKey?: Uint8Array) => Promise; + readonly allPacketCommitments: (portId: string, channelId: string) => Promise; + readonly packetReceipt: (portId: string, channelId: string, sequence: number) => Promise; + readonly packetAcknowledgement: (portId: string, channelId: string, sequence: number) => Promise; + readonly packetAcknowledgements: (portId: string, channelId: string, paginationKey?: Uint8Array) => Promise; + readonly allPacketAcknowledgements: (portId: string, channelId: string) => Promise; + readonly unreceivedPackets: (portId: string, channelId: string, packetCommitmentSequences: readonly number[]) => Promise; + readonly unreceivedAcks: (portId: string, channelId: string, packetAckSequences: readonly number[]) => Promise; + readonly nextSequenceReceive: (portId: string, channelId: string) => Promise; + }; + readonly client: { + readonly state: (clientId: string) => Promise; + readonly states: (paginationKey?: Uint8Array) => Promise; + readonly allStates: () => Promise; + readonly consensusState: (clientId: string, height?: number) => Promise; + readonly consensusStates: (clientId: string, paginationKey?: Uint8Array) => Promise; + readonly allConsensusStates: (clientId: string) => Promise; + readonly params: () => Promise; + readonly stateTm: (clientId: string) => Promise; + readonly statesTm: (paginationKey?: Uint8Array) => Promise; + readonly allStatesTm: () => Promise; + readonly consensusStateTm: (clientId: string, height?: Height) => Promise; + }; + readonly connection: { + readonly connection: (connectionId: string) => Promise; + readonly connections: (paginationKey?: Uint8Array) => Promise; + readonly allConnections: () => Promise; + readonly clientConnections: (clientId: string) => Promise; + readonly clientState: (connectionId: string) => Promise; + readonly consensusState: (connectionId: string, revisionNumber: number, revisionHeight: number) => Promise; + }; + readonly transfer: { + readonly denomTrace: (hash: string) => Promise; + readonly denomTraces: (paginationKey?: Uint8Array) => Promise; + readonly allDenomTraces: () => Promise; + readonly params: () => Promise; + }; + readonly verified: { + readonly channel: { + readonly channel: (portId: string, channelId: string) => Promise; + readonly packetCommitment: (portId: string, channelId: string, sequence: number) => Promise; + readonly packetAcknowledgement: (portId: string, channelId: string, sequence: number) => Promise; + readonly nextSequenceReceive: (portId: string, channelId: string) => Promise; + }; + }; + }; +} + +export function setupIbcExtension(base: QueryClient): IbcExtension { + const rpc = createProtobufRpcClient(base); + // Use these services to get easy typed access to query methods + // These cannot be used for proof verification + const channelQueryService = new ChannelQuery(rpc); + const clientQueryService = new ClientQuery(rpc); + const connectionQueryService = new ConnectionQuery(rpc); + const transferQueryService = new TransferQuery(rpc); + + return { + ibc: { + channel: { + channel: async (portId: string, channelId: string) => + channelQueryService.Channel({ + portId: portId, + channelId: channelId, + }), + channels: async (paginationKey?: Uint8Array) => + channelQueryService.Channels({ + pagination: createPagination(paginationKey), + }), + allChannels: async () => { + const channels = []; + let response: QueryChannelsResponse; + let key: Uint8Array | undefined; + do { + response = await channelQueryService.Channels({ + pagination: createPagination(key), + }); + channels.push(...response.channels); + key = response.pagination?.nextKey; + } while (key && key.length); + return { + channels: channels, + height: response.height, + }; + }, + connectionChannels: async (connection: string, paginationKey?: Uint8Array) => + channelQueryService.ConnectionChannels({ + connection: connection, + pagination: createPagination(paginationKey), + }), + allConnectionChannels: async (connection: string) => { + const channels = []; + let response: QueryConnectionChannelsResponse; + let key: Uint8Array | undefined; + do { + response = await channelQueryService.ConnectionChannels({ + connection: connection, + pagination: createPagination(key), + }); + channels.push(...response.channels); + key = response.pagination?.nextKey; + } while (key && key.length); + return { + channels: channels, + height: response.height, + }; + }, + clientState: async (portId: string, channelId: string) => + channelQueryService.ChannelClientState({ + portId: portId, + channelId: channelId, + }), + consensusState: async (portId: string, channelId: string, revisionNumber: number, revisionHeight: number) => + channelQueryService.ChannelConsensusState({ + portId: portId, + channelId: channelId, + revisionNumber: Long.fromNumber(revisionNumber, true), + revisionHeight: Long.fromNumber(revisionHeight, true), + }), + packetCommitment: async (portId: string, channelId: string, sequence: Long) => + channelQueryService.PacketCommitment({ + portId: portId, + channelId: channelId, + sequence: sequence, + }), + packetCommitments: async (portId: string, channelId: string, paginationKey?: Uint8Array) => + channelQueryService.PacketCommitments({ + channelId: channelId, + portId: portId, + pagination: createPagination(paginationKey), + }), + allPacketCommitments: async (portId: string, channelId: string) => { + const commitments = []; + let response: QueryPacketCommitmentsResponse; + let key: Uint8Array | undefined; + do { + response = await channelQueryService.PacketCommitments({ + channelId: channelId, + portId: portId, + pagination: createPagination(key), + }); + commitments.push(...response.commitments); + key = response.pagination?.nextKey; + } while (key && key.length); + return { + commitments: commitments, + height: response.height, + }; + }, + packetReceipt: async (portId: string, channelId: string, sequence: number) => + channelQueryService.PacketReceipt({ + portId: portId, + channelId: channelId, + sequence: Long.fromNumber(sequence, true), + }), + packetAcknowledgement: async (portId: string, channelId: string, sequence: number) => + channelQueryService.PacketAcknowledgement({ + portId: portId, + channelId: channelId, + sequence: Long.fromNumber(sequence, true), + }), + packetAcknowledgements: async (portId: string, channelId: string, paginationKey?: Uint8Array) => + channelQueryService.PacketAcknowledgements({ + portId: portId, + channelId: channelId, + pagination: createPagination(paginationKey), + }), + allPacketAcknowledgements: async (portId: string, channelId: string) => { + const acknowledgements = []; + let response: QueryPacketAcknowledgementsResponse; + let key: Uint8Array | undefined; + do { + response = await channelQueryService.PacketAcknowledgements({ + channelId: channelId, + portId: portId, + pagination: createPagination(key), + }); + acknowledgements.push(...response.acknowledgements); + key = response.pagination?.nextKey; + } while (key && key.length); + return { + acknowledgements: acknowledgements, + height: response.height, + }; + }, + unreceivedPackets: async (portId: string, channelId: string, packetCommitmentSequences: readonly number[]) => + channelQueryService.UnreceivedPackets({ + portId: portId, + channelId: channelId, + packetCommitmentSequences: packetCommitmentSequences.map((s) => Long.fromNumber(s, true)), + }), + unreceivedAcks: async (portId: string, channelId: string, packetAckSequences: readonly number[]) => + channelQueryService.UnreceivedAcks({ + portId: portId, + channelId: channelId, + packetAckSequences: packetAckSequences.map((s) => Long.fromNumber(s, true)), + }), + nextSequenceReceive: async (portId: string, channelId: string) => + channelQueryService.NextSequenceReceive({ + portId: portId, + channelId: channelId, + }), + }, + client: { + state: async (clientId: string) => clientQueryService.ClientState({ clientId }), + states: async (paginationKey?: Uint8Array) => + clientQueryService.ClientStates({ + pagination: createPagination(paginationKey), + }), + allStates: async () => { + const clientStates = []; + let response: QueryClientStatesResponse; + let key: Uint8Array | undefined; + do { + response = await clientQueryService.ClientStates({ + pagination: createPagination(key), + }); + clientStates.push(...response.clientStates); + key = response.pagination?.nextKey; + } while (key && key.length); + return { + clientStates: clientStates, + }; + }, + consensusState: async (clientId: string, consensusHeight?: number) => + clientQueryService.ConsensusState( + QueryConsensusStateRequest.fromPartial({ + clientId: clientId, + revisionHeight: consensusHeight !== undefined ? Long.fromNumber(consensusHeight, true) : undefined, + latestHeight: consensusHeight === undefined, + }), + ), + consensusStates: async (clientId: string, paginationKey?: Uint8Array) => + clientQueryService.ConsensusStates({ + clientId: clientId, + pagination: createPagination(paginationKey), + }), + allConsensusStates: async (clientId: string) => { + const consensusStates = []; + let response: QueryConsensusStatesResponse; + let key: Uint8Array | undefined; + do { + response = await clientQueryService.ConsensusStates({ + clientId: clientId, + pagination: createPagination(key), + }); + consensusStates.push(...response.consensusStates); + key = response.pagination?.nextKey; + } while (key && key.length); + return { + consensusStates: consensusStates, + }; + }, + params: async () => clientQueryService.ClientParams({}), + stateTm: async (clientId: string) => { + const response = await clientQueryService.ClientState({ clientId }); + return decodeTendermintClientStateAny(response.clientState); + }, + statesTm: async (paginationKey?: Uint8Array) => { + const { clientStates } = await clientQueryService.ClientStates({ + pagination: createPagination(paginationKey), + }); + return clientStates.map(({ clientState }) => decodeTendermintClientStateAny(clientState)); + }, + allStatesTm: async () => { + const clientStates = []; + let response: QueryClientStatesResponse; + let key: Uint8Array | undefined; + do { + response = await clientQueryService.ClientStates({ + pagination: createPagination(key), + }); + clientStates.push(...response.clientStates); + key = response.pagination?.nextKey; + } while (key && key.length); + return clientStates.map(({ clientState }) => decodeTendermintClientStateAny(clientState)); + }, + consensusStateTm: async (clientId: string, consensusHeight?: Height) => { + const response = await clientQueryService.ConsensusState( + QueryConsensusStateRequest.fromPartial({ + clientId: clientId, + revisionHeight: consensusHeight?.revisionHeight, + revisionNumber: consensusHeight?.revisionNumber, + latestHeight: consensusHeight === undefined, + }), + ); + return decodeTendermintConsensusStateAny(response.consensusState); + }, + }, + connection: { + connection: async (connectionId: string) => + connectionQueryService.Connection({ + connectionId: connectionId, + }), + connections: async (paginationKey?: Uint8Array) => + connectionQueryService.Connections({ + pagination: createPagination(paginationKey), + }), + allConnections: async () => { + const connections = []; + let response: QueryConnectionsResponse; + let key: Uint8Array | undefined; + do { + response = await connectionQueryService.Connections({ + pagination: createPagination(key), + }); + connections.push(...response.connections); + key = response.pagination?.nextKey; + } while (key && key.length); + return { + connections: connections, + height: response.height, + }; + }, + clientConnections: async (clientId: string) => + connectionQueryService.ClientConnections({ + clientId: clientId, + }), + clientState: async (connectionId: string) => + connectionQueryService.ConnectionClientState({ + connectionId: connectionId, + }), + consensusState: async (connectionId: string, revisionHeight: number) => + connectionQueryService.ConnectionConsensusState( + QueryConnectionConsensusStateRequest.fromPartial({ + connectionId: connectionId, + revisionHeight: Long.fromNumber(revisionHeight, true), + }), + ), + }, + transfer: { + denomTrace: async (hash: string) => transferQueryService.DenomTrace({ hash: hash }), + denomTraces: async (paginationKey?: Uint8Array) => + transferQueryService.DenomTraces({ + pagination: createPagination(paginationKey), + }), + allDenomTraces: async () => { + const denomTraces = []; + let response: QueryDenomTracesResponse; + let key: Uint8Array | undefined; + do { + response = await transferQueryService.DenomTraces({ + pagination: createPagination(key), + }); + denomTraces.push(...response.denomTraces); + key = response.pagination?.nextKey; + } while (key && key.length); + return { + denomTraces: denomTraces, + }; + }, + params: async () => transferQueryService.Params({}), + }, + verified: { + channel: { + channel: async (portId: string, channelId: string) => { + // keeper: https://github.com/cosmos/cosmos-sdk/blob/3bafd8255a502e5a9cee07391cf8261538245dfd/x/ibc/04-channel/keeper/keeper.go#L55-L65 + // key: https://github.com/cosmos/cosmos-sdk/blob/ef0a7344af345882729598bc2958a21143930a6b/x/ibc/24-host/keys.go#L117-L120 + const key = toAscii(`channelEnds/ports/${portId}/channels/${channelId}`); + const responseData = await base.queryVerified('ibc', key); + return responseData.length ? Channel.decode(responseData) : null; + }, + packetCommitment: async (portId: string, channelId: string, sequence: number) => { + // keeper: https://github.com/cosmos/cosmos-sdk/blob/3bafd8255a502e5a9cee07391cf8261538245dfd/x/ibc/04-channel/keeper/keeper.go#L128-L133 + // key: https://github.com/cosmos/cosmos-sdk/blob/ef0a7344af345882729598bc2958a21143930a6b/x/ibc/24-host/keys.go#L183-L185 + const key = toAscii(`commitments/ports/${portId}/channels/${channelId}/packets/${sequence}`); + const responseData = await base.queryVerified('ibc', key); + // keeper code doesn't parse, but returns raw + return responseData; + }, + packetAcknowledgement: async (portId: string, channelId: string, sequence: number) => { + // keeper: https://github.com/cosmos/cosmos-sdk/blob/3bafd8255a502e5a9cee07391cf8261538245dfd/x/ibc/04-channel/keeper/keeper.go#L159-L166 + // key: https://github.com/cosmos/cosmos-sdk/blob/ef0a7344af345882729598bc2958a21143930a6b/x/ibc/24-host/keys.go#L153-L156 + const key = toAscii(`acks/ports/${portId}/channels/${channelId}/acknowledgements/${sequence}`); + const responseData = await base.queryVerified('ibc', key); + // keeper code doesn't parse, but returns raw + return responseData; + }, + nextSequenceReceive: async (portId: string, channelId: string) => { + // keeper: https://github.com/cosmos/cosmos-sdk/blob/3bafd8255a502e5a9cee07391cf8261538245dfd/x/ibc/04-channel/keeper/keeper.go#L92-L101 + // key: https://github.com/cosmos/cosmos-sdk/blob/ef0a7344af345882729598bc2958a21143930a6b/x/ibc/24-host/keys.go#L133-L136 + const key = toAscii(`seqAcks/ports/${portId}/channels/${channelId}/nextSequenceAck`); + const responseData = await base.queryVerified('ibc', key); + return responseData.length ? Uint64.fromBytes(responseData).toNumber() : null; + }, + }, + }, + }, + }; +} diff --git a/src/extensions/index.ts b/src/extensions/index.ts index c0f3448..b098e77 100644 --- a/src/extensions/index.ts +++ b/src/extensions/index.ts @@ -1,2 +1,8 @@ -export * from './mint'; +export * from './auth'; +export * from './bank'; export * from './beam'; +export * from './distribution'; +export * from './gov'; +export * from './ibc'; +export * from './mint'; +export * from './staking'; diff --git a/src/extensions/staking.ts b/src/extensions/staking.ts new file mode 100644 index 0000000..597f993 --- /dev/null +++ b/src/extensions/staking.ts @@ -0,0 +1,146 @@ +import Long from 'long'; +import { createProtobufRpcClient, QueryClient } from '@cosmjs/stargate'; + +import { + QueryClientImpl, + QueryDelegationResponse, + QueryDelegatorDelegationsResponse, + QueryDelegatorUnbondingDelegationsResponse, + QueryDelegatorValidatorResponse, + QueryDelegatorValidatorsResponse, + QueryHistoricalInfoResponse, + QueryParamsResponse, + QueryPoolResponse, + QueryRedelegationsResponse, + QueryUnbondingDelegationResponse, + QueryValidatorDelegationsResponse, + QueryValidatorResponse, + QueryValidatorsResponse, + QueryValidatorUnbondingDelegationsResponse, +} from '../codec/cosmos/staking/v1beta1/query'; +import { BondStatus } from '../codec/cosmos/staking/v1beta1/staking'; + +import { createPagination } from './utils'; + +export type BondStatusString = Exclude; + +export interface StakingExtension { + readonly staking: { + delegation: (delegatorAddress: string, validatorAddress: string) => Promise; + delegatorDelegations: (delegatorAddress: string, paginationKey?: Uint8Array) => Promise; + delegatorUnbondingDelegations: (delegatorAddress: string, paginationKey?: Uint8Array) => Promise; + delegatorValidator: (delegatorAddress: string, validatorAddress: string) => Promise; + delegatorValidators: (delegatorAddress: string, paginationKey?: Uint8Array) => Promise; + historicalInfo: (height: number) => Promise; + params: () => Promise; + pool: () => Promise; + redelegations: (delegatorAddress: string, sourceValidatorAddress: string, destinationValidatorAddress: string, paginationKey?: Uint8Array) => Promise; + unbondingDelegation: (delegatorAddress: string, validatorAddress: string) => Promise; + validator: (validatorAddress: string) => Promise; + validatorDelegations: (validatorAddress: string, paginationKey?: Uint8Array) => Promise; + validators: (status: BondStatusString, paginationKey?: Uint8Array) => Promise; + validatorUnbondingDelegations: (validatorAddress: string, paginationKey?: Uint8Array) => Promise; + }; +} + +export function setupStakingExtension(base: QueryClient): StakingExtension { + // Use this service to get easy typed access to query methods + // This cannot be used for proof verification + const rpc = createProtobufRpcClient(base); + const queryService = new QueryClientImpl(rpc); + + return { + staking: { + delegation: async (delegatorAddress: string, validatorAddress: string) => { + const response = await queryService.Delegation({ + delegatorAddr: delegatorAddress, + validatorAddr: validatorAddress, + }); + return response; + }, + delegatorDelegations: async (delegatorAddress: string, paginationKey?: Uint8Array) => { + const response = await queryService.DelegatorDelegations({ + delegatorAddr: delegatorAddress, + pagination: createPagination(paginationKey), + }); + return response; + }, + delegatorUnbondingDelegations: async (delegatorAddress: string, paginationKey?: Uint8Array) => { + const response = await queryService.DelegatorUnbondingDelegations({ + delegatorAddr: delegatorAddress, + pagination: createPagination(paginationKey), + }); + return response; + }, + delegatorValidator: async (delegatorAddress: string, validatorAddress: string) => { + const response = await queryService.DelegatorValidator({ + delegatorAddr: delegatorAddress, + validatorAddr: validatorAddress, + }); + return response; + }, + delegatorValidators: async (delegatorAddress: string, paginationKey?: Uint8Array) => { + const response = await queryService.DelegatorValidators({ + delegatorAddr: delegatorAddress, + pagination: createPagination(paginationKey), + }); + return response; + }, + historicalInfo: async (height: number) => { + const response = await queryService.HistoricalInfo({ + height: Long.fromNumber(height, true), + }); + return response; + }, + params: async () => { + const response = await queryService.Params({}); + return response; + }, + pool: async () => { + const response = await queryService.Pool({}); + return response; + }, + redelegations: async (delegatorAddress: string, sourceValidatorAddress: string, destinationValidatorAddress: string, paginationKey?: Uint8Array) => { + const response = await queryService.Redelegations({ + delegatorAddr: delegatorAddress, + srcValidatorAddr: sourceValidatorAddress, + dstValidatorAddr: destinationValidatorAddress, + pagination: createPagination(paginationKey), + }); + return response; + }, + unbondingDelegation: async (delegatorAddress: string, validatorAddress: string) => { + const response = await queryService.UnbondingDelegation({ + delegatorAddr: delegatorAddress, + validatorAddr: validatorAddress, + }); + return response; + }, + validator: async (validatorAddress: string) => { + const response = await queryService.Validator({ validatorAddr: validatorAddress }); + return response; + }, + validatorDelegations: async (validatorAddress: string, paginationKey?: Uint8Array) => { + const response = await queryService.ValidatorDelegations({ + validatorAddr: validatorAddress, + pagination: createPagination(paginationKey), + }); + return response; + }, + validators: async (status: BondStatusString, paginationKey?: Uint8Array) => { + const response = await queryService.Validators({ + status: status, + pagination: createPagination(paginationKey), + }); + return response; + }, + validatorUnbondingDelegations: async (validatorAddress: string, paginationKey?: Uint8Array) => { + const response = await queryService.ValidatorUnbondingDelegations({ + validatorAddr: validatorAddress, + pagination: createPagination(paginationKey), + }); + return response; + }, + }, + }; +} diff --git a/src/extensions/utils.ts b/src/extensions/utils.ts new file mode 100644 index 0000000..3f8dbde --- /dev/null +++ b/src/extensions/utils.ts @@ -0,0 +1,34 @@ +import Long from 'long'; +import { Uint64 } from '@cosmjs/math'; +import { QueryClient } from '@cosmjs/stargate'; + +import { PageRequest } from '../codec/cosmos/base/query/v1beta1/pagination'; + +export interface ProtobufRpcClient { + request(service: string, method: string, data: Uint8Array): Promise; +} + +export function createProtobufRpcClient(base: QueryClient): ProtobufRpcClient { + return { + request: (service: string, method: string, data: Uint8Array): Promise => { + const path = `/${service}/${method}`; + return base.queryUnverified(path, data); + }, + }; +} + +export function createPagination(paginationKey?: Uint8Array): PageRequest | undefined { + return paginationKey + ? { + key: paginationKey, + offset: Long.fromNumber(0, true), + limit: Long.fromNumber(0, true), + countTotal: false, + } + : undefined; +} + +export function longify(value: string | number | Long | Uint64): Long { + const checkedValue = Uint64.fromString(value.toString()); + return Long.fromBytesBE([...checkedValue.toBytesBigEndian()], true); +} diff --git a/tests/client.test.ts b/tests/client.test.ts index 0834094..2642a10 100644 --- a/tests/client.test.ts +++ b/tests/client.test.ts @@ -1,6 +1,6 @@ import { LumWallet, LumWalletFactory, LumClient, LumUtils, LumConstants, LumRegistry, LumTypes, LumMessages } from '../src'; -import axios from 'axios'; import { BeamData, BeamState } from '../src/codec/beam/beam'; +import { requestCoinsFromFaucet } from './utils'; const randomString = (): string => { return Math.random().toString(36).substring(7); @@ -12,7 +12,7 @@ describe('LumClient', () => { let w2: LumWallet; beforeAll(async () => { - clt = await LumClient.connect('https://node0.testnet.lum.network/rpc'); + clt = await LumClient.connect('http://0.0.0.0:26657'); // Prepare the wallets w1 = await LumWalletFactory.fromMnemonic(LumUtils.generateMnemonic()); @@ -21,26 +21,8 @@ describe('LumClient', () => { expect(w1.getAddress()).not.toEqual(w2.getAddress()); // Seed them with faucet coins each - let res = await axios.get(`https://bridge.testnet.lum.network/faucet/${w1.getAddress()}`); - expect(res.status).toEqual(200); - res = await axios.get(`https://bridge.testnet.lum.network/faucet/${w2.getAddress()}`); - expect(res.status).toEqual(200); - const faucetResult = new Promise((resolve, reject) => { - let it = 0; - const rec = setInterval(async () => { - const balance1 = await clt.getBalance(w1.getAddress(), LumConstants.MicroLumDenom); - const balance2 = await clt.getBalance(w2.getAddress(), LumConstants.MicroLumDenom); - if (balance1 && balance2 && parseInt(balance1.amount) > 0 && parseInt(balance2.amount) > 0) { - clearInterval(rec); - resolve(true); - } else if (it >= 60) { - clearInterval(rec); - reject(); - } - it++; - }, 1000); - }); - await expect(faucetResult).resolves.toBeTruthy(); + await requestCoinsFromFaucet(clt, w1.getAddress()); + await requestCoinsFromFaucet(clt, w2.getAddress()); }); afterAll(async () => { @@ -344,7 +326,7 @@ describe('LumClient', () => { expect(account).toBeTruthy(); // Get account balances - const balances = await clt.getAllBalancesUnverified(account.address); + const balances = await clt.getAllBalances(account.address); expect(balances).toBeTruthy(); expect(balances.length).toBeGreaterThan(0); const lumBalance = balances.filter((b) => b.denom === LumConstants.MicroLumDenom)[0]; diff --git a/tests/ledger.test.ts b/tests/ledger.test.ts index 981a8f1..d3f911f 100644 --- a/tests/ledger.test.ts +++ b/tests/ledger.test.ts @@ -3,29 +3,14 @@ import TransportNodeHid from '@ledgerhq/hw-transport-node-hid'; import { LumWalletFactory, LumMessages, LumUtils, LumConstants, LumWallet } from '../src'; import { LumClient } from '../src'; +import { requestCoinsFromFaucet } from './utils'; const requestCoinsIfNeeded = async (clt: LumClient, w: LumWallet, microLumMinAmount?: number) => { const balance = await clt.getBalance(w.getAddress(), LumConstants.MicroLumDenom); if (balance && parseInt(balance.amount) > microLumMinAmount) { return; } - const res = await axios.get(`https://bridge.testnet.lum.network/faucet/${w.getAddress()}`); - expect(res.status).toEqual(200); - const faucetResult = new Promise((resolve, reject) => { - let it = 0; - const rec = setInterval(async () => { - const balance = await clt.getBalance(w.getAddress(), LumConstants.MicroLumDenom); - if (balance && parseInt(balance.amount) > microLumMinAmount) { - clearInterval(rec); - resolve(true); - } else if (it >= 60) { - clearInterval(rec); - reject(); - } - it++; - }, 1000); - }); - await expect(faucetResult).resolves.toBeTruthy(); + await requestCoinsFromFaucet(clt, w.getAddress()); }; describe('Ledger', () => { diff --git a/tests/utils.ts b/tests/utils.ts new file mode 100644 index 0000000..7092712 --- /dev/null +++ b/tests/utils.ts @@ -0,0 +1,39 @@ +import axios from 'axios'; + +import { LumClient, LumConstants } from '../src'; + +export const requestCoinsFromFaucet = async (clt: LumClient, addr: string) => { + const ulumAmount = 100 * Math.pow(10, LumConstants.LumExponent); + + // Try to query the local faucet + let res = await axios.post( + `http://0.0.0.0:4500/`, + { 'address': addr, 'coins': [`${ulumAmount}ulum`] }, + { + headers: { + 'Content-Type': 'application/json', + }, + }, + ); + if (res.status !== 200) { + // Otherwise query the testnet official faucet + res = await axios.get(`https://bridge.testnet.lum.network/faucet/${addr}`); + } + expect(res.status).toEqual(200); + + const faucetResult = new Promise((resolve, reject) => { + let it = 0; + const rec = setInterval(async () => { + const balance = await clt.getBalance(addr, LumConstants.MicroLumDenom); + if (balance && parseInt(balance.amount) >= ulumAmount) { + clearInterval(rec); + resolve(true); + } else if (it >= 60) { + clearInterval(rec); + reject(); + } + it++; + }, 1000); + }); + await expect(faucetResult).resolves.toBeTruthy(); +}; From e6961da6b7008302aaab03d92b49a5a54263c422 Mon Sep 17 00:00:00 2001 From: Fabrice Bascoulergue Date: Wed, 15 Sep 2021 16:53:45 +0200 Subject: [PATCH 2/4] Improve faucet request implementation --- tests/client.test.ts | 2 +- tests/utils.ts | 22 +++++++++++++--------- 2 files changed, 14 insertions(+), 10 deletions(-) diff --git a/tests/client.test.ts b/tests/client.test.ts index 2642a10..f7ae43e 100644 --- a/tests/client.test.ts +++ b/tests/client.test.ts @@ -12,7 +12,7 @@ describe('LumClient', () => { let w2: LumWallet; beforeAll(async () => { - clt = await LumClient.connect('http://0.0.0.0:26657'); + clt = await LumClient.connect('http://node0.testnet.lum.network/rpc'); // Prepare the wallets w1 = await LumWalletFactory.fromMnemonic(LumUtils.generateMnemonic()); diff --git a/tests/utils.ts b/tests/utils.ts index 7092712..f82e401 100644 --- a/tests/utils.ts +++ b/tests/utils.ts @@ -6,19 +6,23 @@ export const requestCoinsFromFaucet = async (clt: LumClient, addr: string) => { const ulumAmount = 100 * Math.pow(10, LumConstants.LumExponent); // Try to query the local faucet - let res = await axios.post( - `http://0.0.0.0:4500/`, - { 'address': addr, 'coins': [`${ulumAmount}ulum`] }, - { - headers: { - 'Content-Type': 'application/json', + let res = null; + try { + res = await axios.post( + `http://0.0.0.0:4500/`, + { 'address': addr, 'coins': [`${ulumAmount}ulum`] }, + { + headers: { + 'Content-Type': 'application/json', + }, }, - }, - ); - if (res.status !== 200) { + ); + } catch (e) {} + if (!res || res.status !== 200) { // Otherwise query the testnet official faucet res = await axios.get(`https://bridge.testnet.lum.network/faucet/${addr}`); } + expect(res).toBeTruthy(); expect(res.status).toEqual(200); const faucetResult = new Promise((resolve, reject) => { From 233760ba9200b488c8aebaff3c17055bed15be40 Mon Sep 17 00:00:00 2001 From: Fabrice Bascoulergue Date: Wed, 15 Sep 2021 17:54:44 +0200 Subject: [PATCH 3/4] Upgrade to SDK v0.44.0 --- package.json | 2 +- scripts/define-proto.sh | 30 +- scripts/get-proto.sh | 78 ++- src/codec/cosmos/auth/v1beta1/query.ts | 157 ++++++ src/codec/cosmos/bank/v1beta1/bank.ts | 46 +- src/codec/cosmos/bank/v1beta1/query.ts | 49 +- .../cosmos/base/query/v1beta1/pagination.ts | 21 +- src/codec/cosmos/gov/v1beta1/gov.ts | 110 ++++ src/codec/cosmos/gov/v1beta1/tx.ts | 154 +++++- src/codec/cosmos/tx/v1beta1/tx.ts | 6 +- src/codec/cosmos/upgrade/v1beta1/upgrade.ts | 472 ++++++++++++++++++ src/codec/cosmos/vesting/v1beta1/vesting.ts | 64 +++ src/codec/ibc/core/channel/v1/query.ts | 50 +- src/codec/ibc/core/channel/v1/tx.ts | 19 +- src/codec/ibc/core/client/v1/client.ts | 200 ++++++-- src/codec/ibc/core/client/v1/query.ts | 377 +++++++++++++- src/codec/ibc/core/client/v1/tx.ts | 15 +- .../ibc/core/connection/v1/connection.ts | 70 ++- src/codec/ibc/core/connection/v1/tx.ts | 19 +- .../lightclients/tendermint/v1/tendermint.ts | 15 +- 20 files changed, 1847 insertions(+), 107 deletions(-) create mode 100644 src/codec/cosmos/upgrade/v1beta1/upgrade.ts diff --git a/package.json b/package.json index cc6f0fd..cc8a16d 100644 --- a/package.json +++ b/package.json @@ -35,7 +35,7 @@ "format": "prettier --write '**/*.{js,jsx,ts,tsx,css,json,md,html,yml}'", "bump": "npm version", "preget-proto": "rm -rf proto", - "get-proto": "CREF=v0.42.0 LREF=master sh ./scripts/get-proto.sh", + "get-proto": "COSMOS_REF=v0.44.0 IBC_REF=v1.2.0 LUM_REF=master sh ./scripts/get-proto.sh", "define-proto": "sh ./scripts/define-proto.sh", "postdefine-proto": "prettier --write \"src/codec/**/*.ts\"" }, diff --git a/scripts/define-proto.sh b/scripts/define-proto.sh index 8e8097c..31c5e88 100644 --- a/scripts/define-proto.sh +++ b/scripts/define-proto.sh @@ -6,6 +6,9 @@ ROOT_PROTO_DIR="./proto/cosmos/cosmos-sdk" COSMOS_PROTO_DIR="$ROOT_PROTO_DIR/proto" THIRD_PARTY_PROTO_DIR="$ROOT_PROTO_DIR/third_party/proto" +ROOT_IBC_PROTO_DIR="./proto/ibc/ibc-go" +IBC_PROTO_DIR="$ROOT_IBC_PROTO_DIR/proto" + ROOT_LUM_PROTO_DIR="./proto/lum-network/chain" LUM_PROTO_DIR="$ROOT_LUM_PROTO_DIR/proto" @@ -19,6 +22,7 @@ protoc \ --proto_path="$COSMOS_PROTO_DIR" \ --proto_path="$THIRD_PARTY_PROTO_DIR" \ --proto_path="$LUM_PROTO_DIR" \ + --proto_path="$IBC_PROTO_DIR" \ --ts_proto_opt="esModuleInterop=true,forceLong=long,useOptionals=true" \ "$COSMOS_PROTO_DIR/cosmos/auth/v1beta1/auth.proto" \ "$COSMOS_PROTO_DIR/cosmos/auth/v1beta1/query.proto" \ @@ -44,19 +48,19 @@ protoc \ "$COSMOS_PROTO_DIR/cosmos/tx/signing/v1beta1/signing.proto" \ "$COSMOS_PROTO_DIR/cosmos/tx/v1beta1/tx.proto" \ "$COSMOS_PROTO_DIR/cosmos/vesting/v1beta1/vesting.proto" \ - "$COSMOS_PROTO_DIR/ibc/applications/transfer/v1/tx.proto" \ - "$COSMOS_PROTO_DIR/ibc/applications/transfer/v1/query.proto" \ - "$COSMOS_PROTO_DIR/ibc/core/channel/v1/channel.proto" \ - "$COSMOS_PROTO_DIR/ibc/core/channel/v1/query.proto" \ - "$COSMOS_PROTO_DIR/ibc/core/channel/v1/tx.proto" \ - "$COSMOS_PROTO_DIR/ibc/core/client/v1/client.proto" \ - "$COSMOS_PROTO_DIR/ibc/core/client/v1/query.proto" \ - "$COSMOS_PROTO_DIR/ibc/core/client/v1/tx.proto" \ - "$COSMOS_PROTO_DIR/ibc/core/commitment/v1/commitment.proto" \ - "$COSMOS_PROTO_DIR/ibc/core/connection/v1/connection.proto" \ - "$COSMOS_PROTO_DIR/ibc/core/connection/v1/query.proto" \ - "$COSMOS_PROTO_DIR/ibc/core/connection/v1/tx.proto" \ - "$COSMOS_PROTO_DIR/ibc/lightclients/tendermint/v1/tendermint.proto" \ + "$IBC_PROTO_DIR/ibc/applications/transfer/v1/tx.proto" \ + "$IBC_PROTO_DIR/ibc/applications/transfer/v1/query.proto" \ + "$IBC_PROTO_DIR/ibc/core/channel/v1/channel.proto" \ + "$IBC_PROTO_DIR/ibc/core/channel/v1/query.proto" \ + "$IBC_PROTO_DIR/ibc/core/channel/v1/tx.proto" \ + "$IBC_PROTO_DIR/ibc/core/client/v1/client.proto" \ + "$IBC_PROTO_DIR/ibc/core/client/v1/query.proto" \ + "$IBC_PROTO_DIR/ibc/core/client/v1/tx.proto" \ + "$IBC_PROTO_DIR/ibc/core/commitment/v1/commitment.proto" \ + "$IBC_PROTO_DIR/ibc/core/connection/v1/connection.proto" \ + "$IBC_PROTO_DIR/ibc/core/connection/v1/query.proto" \ + "$IBC_PROTO_DIR/ibc/core/connection/v1/tx.proto" \ + "$IBC_PROTO_DIR/ibc/lightclients/tendermint/v1/tendermint.proto" \ "$THIRD_PARTY_PROTO_DIR/confio/proofs.proto" \ "$THIRD_PARTY_PROTO_DIR/tendermint/abci/types.proto" \ "$THIRD_PARTY_PROTO_DIR/tendermint/crypto/keys.proto" \ diff --git a/scripts/get-proto.sh b/scripts/get-proto.sh index 5d76070..10b0fda 100644 --- a/scripts/get-proto.sh +++ b/scripts/get-proto.sh @@ -3,36 +3,68 @@ set -o errexit -o nounset -o pipefail command -v shellcheck >/dev/null && shellcheck "$0" PROTO_DIR="./proto" + +## +## Cosmos SDK +## COSMOS_DIR="$PROTO_DIR/cosmos" COSMOS_SDK_DIR="$COSMOS_DIR/cosmos-sdk" -ZIP_FILE="$COSMOS_DIR/tmp.zip" +COSMOS_ZIP_FILE="$COSMOS_DIR/tmp.zip" -LUM_NETWORK_DIR="$PROTO_DIR/lum-network" -LUM_NETWORK_SDK_DIR="$LUM_NETWORK_DIR/chain" -ZIP_LUM_FILE="$LUM_NETWORK_DIR/tmp.zip" +# Init Cosmos REF +COSMOS_REF=${COSMOS_REF:-"master"} +COSMOS_SUFFIX=${COSMOS_REF} +[[ $COSMOS_SUFFIX =~ ^v[0-9]+\.[0-9]+\.[0-9]+(-.+)?$ ]] && COSMOS_SUFFIX=${COSMOS_SUFFIX#v} -CREF=${CREF:-"master"} -CSUFFIX=${CREF} -[[ $CSUFFIX =~ ^v[0-9]+\.[0-9]+\.[0-9]+(-.+)?$ ]] && CSUFFIX=${CSUFFIX#v} +# Create the Cosmos dir +mkdir -p "$COSMOS_DIR" -LREF=${LREF:-"master"} -LSUFFIX=${LREF} -[[ $LSUFFIX =~ ^v[0-9]+\.[0-9]+\.[0-9]+(-.+)?$ ]] && LSUFFIX=${LSUFFIX#v} +# Download the Cosmos archive +wget -qO "$COSMOS_ZIP_FILE" "https://github.com/cosmos/cosmos-sdk/archive/$COSMOS_REF.zip" +unzip "$COSMOS_ZIP_FILE" "*.proto" -d "$COSMOS_DIR" +mv "$COSMOS_SDK_DIR-$COSMOS_SUFFIX" "$COSMOS_SDK_DIR" +rm "$COSMOS_ZIP_FILE" -# Create the cosmos dir -mkdir -p "$COSMOS_DIR" +## +## IBC SDK +## + +IBC_DIR="$PROTO_DIR/ibc" +IBC_SDK_DIR="$IBC_DIR/ibc-go" +IBC_ZIP_FILE="$IBC_DIR/tmp.zip" + +# Init IBC REF +IBC_REF=${IBC_REF:-"master"} +IBC_SUFFIX=${IBC_REF} +[[ $IBC_SUFFIX =~ ^v[0-9]+\.[0-9]+\.[0-9]+(-.+)?$ ]] && IBC_SUFFIX=${IBC_SUFFIX#v} + +# Create the IBC dir +mkdir -p "$IBC_DIR" + +# Download the IBC archive +wget -qO "$IBC_ZIP_FILE" "https://github.com/cosmos/ibc-go/archive/$IBC_REF.zip" +unzip "$IBC_ZIP_FILE" "*.proto" -d "$IBC_DIR" +mv "$IBC_SDK_DIR-$IBC_SUFFIX" "$IBC_SDK_DIR" +rm "$IBC_ZIP_FILE" + +## +## LUM SDK +## + +LUM_DIR="$PROTO_DIR/lum-network" +LUM_SDK_DIR="$LUM_DIR/chain" +LUM_ZIP_FILE="$LUM_DIR/tmp.zip" -# Download the cosmos archive -wget -qO "$ZIP_FILE" "https://github.com/cosmos/cosmos-sdk/archive/$CREF.zip" -unzip "$ZIP_FILE" "*.proto" -d "$COSMOS_DIR" -mv "$COSMOS_SDK_DIR-$CSUFFIX" "$COSMOS_SDK_DIR" -rm "$ZIP_FILE" +# Init LUM REF +LUM_REF=${LUM_REF:-"master"} +LUM_SUFFIX=${LUM_REF} +[[ $LUM_SUFFIX =~ ^v[0-9]+\.[0-9]+\.[0-9]+(-.+)?$ ]] && LUM_SUFFIX=${LUM_SUFFIX#v} -# Create the lum network dir -mkdir -p "$LUM_NETWORK_DIR" +# Create the LUM dir +mkdir -p "$LUM_DIR" # Download the beam archive -wget -qO "$ZIP_LUM_FILE" "https://github.com/lum-network/chain/archive/$LREF.zip" -unzip "$ZIP_LUM_FILE" "*.proto" -d "$LUM_NETWORK_DIR" -mv "$LUM_NETWORK_SDK_DIR-$LSUFFIX" "$LUM_NETWORK_SDK_DIR" -rm "$ZIP_LUM_FILE" +wget -qO "$LUM_ZIP_FILE" "https://github.com/lum-network/chain/archive/$LUM_REF.zip" +unzip "$LUM_ZIP_FILE" "*.proto" -d "$LUM_DIR" +mv "$LUM_SDK_DIR-$LUM_SUFFIX" "$LUM_SDK_DIR" +rm "$LUM_ZIP_FILE" diff --git a/src/codec/cosmos/auth/v1beta1/query.ts b/src/codec/cosmos/auth/v1beta1/query.ts index dcbc792..d16da83 100644 --- a/src/codec/cosmos/auth/v1beta1/query.ts +++ b/src/codec/cosmos/auth/v1beta1/query.ts @@ -1,11 +1,26 @@ /* eslint-disable */ import Long from 'long'; import _m0 from 'protobufjs/minimal'; +import { PageRequest, PageResponse } from '../../../cosmos/base/query/v1beta1/pagination'; import { Any } from '../../../google/protobuf/any'; import { Params } from '../../../cosmos/auth/v1beta1/auth'; export const protobufPackage = 'cosmos.auth.v1beta1'; +/** QueryAccountsRequest is the request type for the Query/Accounts RPC method. */ +export interface QueryAccountsRequest { + /** pagination defines an optional pagination for the request. */ + pagination?: PageRequest; +} + +/** QueryAccountsResponse is the response type for the Query/Accounts RPC method. */ +export interface QueryAccountsResponse { + /** accounts are the existing accounts */ + accounts: Any[]; + /** pagination defines the pagination in the response. */ + pagination?: PageResponse; +} + /** QueryAccountRequest is the request type for the Query/Account RPC method. */ export interface QueryAccountRequest { /** address defines the address to query for. */ @@ -27,6 +42,140 @@ export interface QueryParamsResponse { params?: Params; } +const baseQueryAccountsRequest: object = {}; + +export const QueryAccountsRequest = { + encode(message: QueryAccountsRequest, 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): QueryAccountsRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseQueryAccountsRequest } as QueryAccountsRequest; + 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): QueryAccountsRequest { + const message = { ...baseQueryAccountsRequest } as QueryAccountsRequest; + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageRequest.fromJSON(object.pagination); + } else { + message.pagination = undefined; + } + return message; + }, + + toJSON(message: QueryAccountsRequest): unknown { + const obj: any = {}; + message.pagination !== undefined && (obj.pagination = message.pagination ? PageRequest.toJSON(message.pagination) : undefined); + return obj; + }, + + fromPartial(object: DeepPartial): QueryAccountsRequest { + const message = { ...baseQueryAccountsRequest } as QueryAccountsRequest; + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageRequest.fromPartial(object.pagination); + } else { + message.pagination = undefined; + } + return message; + }, +}; + +const baseQueryAccountsResponse: object = {}; + +export const QueryAccountsResponse = { + encode(message: QueryAccountsResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + for (const v of message.accounts) { + Any.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): QueryAccountsResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseQueryAccountsResponse } as QueryAccountsResponse; + message.accounts = []; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.accounts.push(Any.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): QueryAccountsResponse { + const message = { ...baseQueryAccountsResponse } as QueryAccountsResponse; + message.accounts = []; + if (object.accounts !== undefined && object.accounts !== null) { + for (const e of object.accounts) { + message.accounts.push(Any.fromJSON(e)); + } + } + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageResponse.fromJSON(object.pagination); + } else { + message.pagination = undefined; + } + return message; + }, + + toJSON(message: QueryAccountsResponse): unknown { + const obj: any = {}; + if (message.accounts) { + obj.accounts = message.accounts.map((e) => (e ? Any.toJSON(e) : undefined)); + } else { + obj.accounts = []; + } + message.pagination !== undefined && (obj.pagination = message.pagination ? PageResponse.toJSON(message.pagination) : undefined); + return obj; + }, + + fromPartial(object: DeepPartial): QueryAccountsResponse { + const message = { ...baseQueryAccountsResponse } as QueryAccountsResponse; + message.accounts = []; + if (object.accounts !== undefined && object.accounts !== null) { + for (const e of object.accounts) { + message.accounts.push(Any.fromPartial(e)); + } + } + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageResponse.fromPartial(object.pagination); + } else { + message.pagination = undefined; + } + return message; + }, +}; + const baseQueryAccountRequest: object = { address: '' }; export const QueryAccountRequest = { @@ -232,6 +381,8 @@ export const QueryParamsResponse = { /** Query defines the gRPC querier service. */ export interface Query { + /** Accounts returns all the existing accounts */ + Accounts(request: QueryAccountsRequest): Promise; /** Account returns account details based on address. */ Account(request: QueryAccountRequest): Promise; /** Params queries all parameters. */ @@ -243,6 +394,12 @@ export class QueryClientImpl implements Query { constructor(rpc: Rpc) { this.rpc = rpc; } + Accounts(request: QueryAccountsRequest): Promise { + const data = QueryAccountsRequest.encode(request).finish(); + const promise = this.rpc.request('cosmos.auth.v1beta1.Query', 'Accounts', data); + return promise.then((data) => QueryAccountsResponse.decode(new _m0.Reader(data))); + } + Account(request: QueryAccountRequest): Promise { const data = QueryAccountRequest.encode(request).finish(); const promise = this.rpc.request('cosmos.auth.v1beta1.Query', 'Account', data); diff --git a/src/codec/cosmos/bank/v1beta1/bank.ts b/src/codec/cosmos/bank/v1beta1/bank.ts index 7ff109c..b96ffb4 100644 --- a/src/codec/cosmos/bank/v1beta1/bank.ts +++ b/src/codec/cosmos/bank/v1beta1/bank.ts @@ -35,6 +35,9 @@ export interface Output { /** * Supply represents a struct that passively keeps track of the total supply * amounts in the network. + * This message is deprecated now that supply is indexed by denom. + * + * @deprecated */ export interface Supply { total: Coin[]; @@ -74,6 +77,13 @@ export interface Metadata { * displayed in clients. */ display: string; + /** name defines the name of the token (eg: Cosmos Atom) */ + name: string; + /** + * symbol is the token symbol usually shown on exchanges (eg: ATOM). This can + * be the same as the display. + */ + symbol: string; } const baseParams: object = { defaultSendEnabled: false }; @@ -543,7 +553,7 @@ export const DenomUnit = { }, }; -const baseMetadata: object = { description: '', base: '', display: '' }; +const baseMetadata: object = { description: '', base: '', display: '', name: '', symbol: '' }; export const Metadata = { encode(message: Metadata, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { @@ -559,6 +569,12 @@ export const Metadata = { if (message.display !== '') { writer.uint32(34).string(message.display); } + if (message.name !== '') { + writer.uint32(42).string(message.name); + } + if (message.symbol !== '') { + writer.uint32(50).string(message.symbol); + } return writer; }, @@ -582,6 +598,12 @@ export const Metadata = { case 4: message.display = reader.string(); break; + case 5: + message.name = reader.string(); + break; + case 6: + message.symbol = reader.string(); + break; default: reader.skipType(tag & 7); break; @@ -613,6 +635,16 @@ export const Metadata = { } else { message.display = ''; } + if (object.name !== undefined && object.name !== null) { + message.name = String(object.name); + } else { + message.name = ''; + } + if (object.symbol !== undefined && object.symbol !== null) { + message.symbol = String(object.symbol); + } else { + message.symbol = ''; + } return message; }, @@ -626,6 +658,8 @@ export const Metadata = { } message.base !== undefined && (obj.base = message.base); message.display !== undefined && (obj.display = message.display); + message.name !== undefined && (obj.name = message.name); + message.symbol !== undefined && (obj.symbol = message.symbol); return obj; }, @@ -652,6 +686,16 @@ export const Metadata = { } else { message.display = ''; } + if (object.name !== undefined && object.name !== null) { + message.name = object.name; + } else { + message.name = ''; + } + if (object.symbol !== undefined && object.symbol !== null) { + message.symbol = object.symbol; + } else { + message.symbol = ''; + } return message; }, }; diff --git a/src/codec/cosmos/bank/v1beta1/query.ts b/src/codec/cosmos/bank/v1beta1/query.ts index b81204d..c765f99 100644 --- a/src/codec/cosmos/bank/v1beta1/query.ts +++ b/src/codec/cosmos/bank/v1beta1/query.ts @@ -44,7 +44,10 @@ export interface QueryAllBalancesResponse { * QueryTotalSupplyRequest is the request type for the Query/TotalSupply RPC * method. */ -export interface QueryTotalSupplyRequest {} +export interface QueryTotalSupplyRequest { + /** pagination defines an optional pagination for the request. */ + pagination?: PageRequest; +} /** * QueryTotalSupplyResponse is the response type for the Query/TotalSupply RPC @@ -53,6 +56,8 @@ export interface QueryTotalSupplyRequest {} export interface QueryTotalSupplyResponse { /** supply is the supply of the coins */ supply: Coin[]; + /** pagination defines the pagination in the response. */ + pagination?: PageResponse; } /** QuerySupplyOfRequest is the request type for the Query/SupplyOf RPC method. */ @@ -388,7 +393,10 @@ export const QueryAllBalancesResponse = { const baseQueryTotalSupplyRequest: object = {}; export const QueryTotalSupplyRequest = { - encode(_: QueryTotalSupplyRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + encode(message: QueryTotalSupplyRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.pagination !== undefined) { + PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim(); + } return writer; }, @@ -399,6 +407,9 @@ export const QueryTotalSupplyRequest = { 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; @@ -407,18 +418,29 @@ export const QueryTotalSupplyRequest = { return message; }, - fromJSON(_: any): QueryTotalSupplyRequest { + fromJSON(object: any): QueryTotalSupplyRequest { const message = { ...baseQueryTotalSupplyRequest } as QueryTotalSupplyRequest; + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageRequest.fromJSON(object.pagination); + } else { + message.pagination = undefined; + } return message; }, - toJSON(_: QueryTotalSupplyRequest): unknown { + toJSON(message: QueryTotalSupplyRequest): unknown { const obj: any = {}; + message.pagination !== undefined && (obj.pagination = message.pagination ? PageRequest.toJSON(message.pagination) : undefined); return obj; }, - fromPartial(_: DeepPartial): QueryTotalSupplyRequest { + fromPartial(object: DeepPartial): QueryTotalSupplyRequest { const message = { ...baseQueryTotalSupplyRequest } as QueryTotalSupplyRequest; + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageRequest.fromPartial(object.pagination); + } else { + message.pagination = undefined; + } return message; }, }; @@ -430,6 +452,9 @@ export const QueryTotalSupplyResponse = { for (const v of message.supply) { Coin.encode(v!, writer.uint32(10).fork()).ldelim(); } + if (message.pagination !== undefined) { + PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim(); + } return writer; }, @@ -444,6 +469,9 @@ export const QueryTotalSupplyResponse = { case 1: message.supply.push(Coin.decode(reader, reader.uint32())); break; + case 2: + message.pagination = PageResponse.decode(reader, reader.uint32()); + break; default: reader.skipType(tag & 7); break; @@ -460,6 +488,11 @@ export const QueryTotalSupplyResponse = { message.supply.push(Coin.fromJSON(e)); } } + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageResponse.fromJSON(object.pagination); + } else { + message.pagination = undefined; + } return message; }, @@ -470,6 +503,7 @@ export const QueryTotalSupplyResponse = { } else { obj.supply = []; } + message.pagination !== undefined && (obj.pagination = message.pagination ? PageResponse.toJSON(message.pagination) : undefined); return obj; }, @@ -481,6 +515,11 @@ export const QueryTotalSupplyResponse = { message.supply.push(Coin.fromPartial(e)); } } + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageResponse.fromPartial(object.pagination); + } else { + message.pagination = undefined; + } return message; }, }; diff --git a/src/codec/cosmos/base/query/v1beta1/pagination.ts b/src/codec/cosmos/base/query/v1beta1/pagination.ts index ceac974..36654ed 100644 --- a/src/codec/cosmos/base/query/v1beta1/pagination.ts +++ b/src/codec/cosmos/base/query/v1beta1/pagination.ts @@ -38,6 +38,8 @@ export interface PageRequest { * is set. */ countTotal: boolean; + /** reverse is set to true if results are to be returned in the descending order. */ + reverse: boolean; } /** @@ -62,7 +64,7 @@ export interface PageResponse { total: Long; } -const basePageRequest: object = { offset: Long.UZERO, limit: Long.UZERO, countTotal: false }; +const basePageRequest: object = { offset: Long.UZERO, limit: Long.UZERO, countTotal: false, reverse: false }; export const PageRequest = { encode(message: PageRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { @@ -78,6 +80,9 @@ export const PageRequest = { if (message.countTotal === true) { writer.uint32(32).bool(message.countTotal); } + if (message.reverse === true) { + writer.uint32(40).bool(message.reverse); + } return writer; }, @@ -101,6 +106,9 @@ export const PageRequest = { case 4: message.countTotal = reader.bool(); break; + case 5: + message.reverse = reader.bool(); + break; default: reader.skipType(tag & 7); break; @@ -130,6 +138,11 @@ export const PageRequest = { } else { message.countTotal = false; } + if (object.reverse !== undefined && object.reverse !== null) { + message.reverse = Boolean(object.reverse); + } else { + message.reverse = false; + } return message; }, @@ -139,6 +152,7 @@ export const PageRequest = { 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); + message.reverse !== undefined && (obj.reverse = message.reverse); return obj; }, @@ -164,6 +178,11 @@ export const PageRequest = { } else { message.countTotal = false; } + if (object.reverse !== undefined && object.reverse !== null) { + message.reverse = object.reverse; + } else { + message.reverse = false; + } return message; }, }; diff --git a/src/codec/cosmos/gov/v1beta1/gov.ts b/src/codec/cosmos/gov/v1beta1/gov.ts index 85b5670..a1f1310 100644 --- a/src/codec/cosmos/gov/v1beta1/gov.ts +++ b/src/codec/cosmos/gov/v1beta1/gov.ts @@ -142,6 +142,12 @@ export function proposalStatusToJSON(object: ProposalStatus): string { } } +/** WeightedVoteOption defines a unit of vote for vote split. */ +export interface WeightedVoteOption { + option: VoteOption; + weight: string; +} + /** * TextProposal defines a standard text proposal whose changes need to be * manually updated in case of approval. @@ -189,7 +195,15 @@ export interface TallyResult { export interface Vote { proposalId: Long; voter: string; + /** + * Deprecated: Prefer to use `options` instead. This field is set in queries + * if and only if `len(options) == 1` and that option has weight 1. In all + * other cases, this field will default to VOTE_OPTION_UNSPECIFIED. + * + * @deprecated + */ option: VoteOption; + options: WeightedVoteOption[]; } /** DepositParams defines the params for deposits on governance proposals. */ @@ -225,6 +239,78 @@ export interface TallyParams { vetoThreshold: Uint8Array; } +const baseWeightedVoteOption: object = { option: 0, weight: '' }; + +export const WeightedVoteOption = { + encode(message: WeightedVoteOption, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.option !== 0) { + writer.uint32(8).int32(message.option); + } + if (message.weight !== '') { + writer.uint32(18).string(message.weight); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): WeightedVoteOption { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseWeightedVoteOption } as WeightedVoteOption; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.option = reader.int32() as any; + break; + case 2: + message.weight = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): WeightedVoteOption { + const message = { ...baseWeightedVoteOption } as WeightedVoteOption; + if (object.option !== undefined && object.option !== null) { + message.option = voteOptionFromJSON(object.option); + } else { + message.option = 0; + } + if (object.weight !== undefined && object.weight !== null) { + message.weight = String(object.weight); + } else { + message.weight = ''; + } + return message; + }, + + toJSON(message: WeightedVoteOption): unknown { + const obj: any = {}; + message.option !== undefined && (obj.option = voteOptionToJSON(message.option)); + message.weight !== undefined && (obj.weight = message.weight); + return obj; + }, + + fromPartial(object: DeepPartial): WeightedVoteOption { + const message = { ...baseWeightedVoteOption } as WeightedVoteOption; + if (object.option !== undefined && object.option !== null) { + message.option = object.option; + } else { + message.option = 0; + } + if (object.weight !== undefined && object.weight !== null) { + message.weight = object.weight; + } else { + message.weight = ''; + } + return message; + }, +}; + const baseTextProposal: object = { title: '', description: '' }; export const TextProposal = { @@ -710,6 +796,9 @@ export const Vote = { if (message.option !== 0) { writer.uint32(24).int32(message.option); } + for (const v of message.options) { + WeightedVoteOption.encode(v!, writer.uint32(34).fork()).ldelim(); + } return writer; }, @@ -717,6 +806,7 @@ export const Vote = { const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); let end = length === undefined ? reader.len : reader.pos + length; const message = { ...baseVote } as Vote; + message.options = []; while (reader.pos < end) { const tag = reader.uint32(); switch (tag >>> 3) { @@ -729,6 +819,9 @@ export const Vote = { case 3: message.option = reader.int32() as any; break; + case 4: + message.options.push(WeightedVoteOption.decode(reader, reader.uint32())); + break; default: reader.skipType(tag & 7); break; @@ -739,6 +832,7 @@ export const Vote = { fromJSON(object: any): Vote { const message = { ...baseVote } as Vote; + message.options = []; if (object.proposalId !== undefined && object.proposalId !== null) { message.proposalId = Long.fromString(object.proposalId); } else { @@ -754,6 +848,11 @@ export const Vote = { } else { message.option = 0; } + if (object.options !== undefined && object.options !== null) { + for (const e of object.options) { + message.options.push(WeightedVoteOption.fromJSON(e)); + } + } return message; }, @@ -762,11 +861,17 @@ export const Vote = { message.proposalId !== undefined && (obj.proposalId = (message.proposalId || Long.UZERO).toString()); message.voter !== undefined && (obj.voter = message.voter); message.option !== undefined && (obj.option = voteOptionToJSON(message.option)); + if (message.options) { + obj.options = message.options.map((e) => (e ? WeightedVoteOption.toJSON(e) : undefined)); + } else { + obj.options = []; + } return obj; }, fromPartial(object: DeepPartial): Vote { const message = { ...baseVote } as Vote; + message.options = []; if (object.proposalId !== undefined && object.proposalId !== null) { message.proposalId = object.proposalId as Long; } else { @@ -782,6 +887,11 @@ export const Vote = { } else { message.option = 0; } + if (object.options !== undefined && object.options !== null) { + for (const e of object.options) { + message.options.push(WeightedVoteOption.fromPartial(e)); + } + } return message; }, }; diff --git a/src/codec/cosmos/gov/v1beta1/tx.ts b/src/codec/cosmos/gov/v1beta1/tx.ts index 5d46fde..aea2df4 100644 --- a/src/codec/cosmos/gov/v1beta1/tx.ts +++ b/src/codec/cosmos/gov/v1beta1/tx.ts @@ -2,7 +2,7 @@ import Long from 'long'; import _m0 from 'protobufjs/minimal'; import { Any } from '../../../google/protobuf/any'; -import { VoteOption, voteOptionFromJSON, voteOptionToJSON } from '../../../cosmos/gov/v1beta1/gov'; +import { VoteOption, WeightedVoteOption, voteOptionFromJSON, voteOptionToJSON } from '../../../cosmos/gov/v1beta1/gov'; import { Coin } from '../../../cosmos/base/v1beta1/coin'; export const protobufPackage = 'cosmos.gov.v1beta1'; @@ -32,6 +32,16 @@ export interface MsgVote { /** MsgVoteResponse defines the Msg/Vote response type. */ export interface MsgVoteResponse {} +/** MsgVoteWeighted defines a message to cast a vote. */ +export interface MsgVoteWeighted { + proposalId: Long; + voter: string; + options: WeightedVoteOption[]; +} + +/** MsgVoteWeightedResponse defines the Msg/VoteWeighted response type. */ +export interface MsgVoteWeightedResponse {} + /** MsgDeposit defines a message to submit a deposit to an existing proposal. */ export interface MsgDeposit { proposalId: Long; @@ -320,6 +330,140 @@ export const MsgVoteResponse = { }, }; +const baseMsgVoteWeighted: object = { proposalId: Long.UZERO, voter: '' }; + +export const MsgVoteWeighted = { + encode(message: MsgVoteWeighted, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (!message.proposalId.isZero()) { + writer.uint32(8).uint64(message.proposalId); + } + if (message.voter !== '') { + writer.uint32(18).string(message.voter); + } + for (const v of message.options) { + WeightedVoteOption.encode(v!, writer.uint32(26).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): MsgVoteWeighted { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseMsgVoteWeighted } as MsgVoteWeighted; + message.options = []; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.proposalId = reader.uint64() as Long; + break; + case 2: + message.voter = reader.string(); + break; + case 3: + message.options.push(WeightedVoteOption.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): MsgVoteWeighted { + const message = { ...baseMsgVoteWeighted } as MsgVoteWeighted; + message.options = []; + if (object.proposalId !== undefined && object.proposalId !== null) { + message.proposalId = Long.fromString(object.proposalId); + } else { + message.proposalId = Long.UZERO; + } + if (object.voter !== undefined && object.voter !== null) { + message.voter = String(object.voter); + } else { + message.voter = ''; + } + if (object.options !== undefined && object.options !== null) { + for (const e of object.options) { + message.options.push(WeightedVoteOption.fromJSON(e)); + } + } + return message; + }, + + toJSON(message: MsgVoteWeighted): unknown { + const obj: any = {}; + message.proposalId !== undefined && (obj.proposalId = (message.proposalId || Long.UZERO).toString()); + message.voter !== undefined && (obj.voter = message.voter); + if (message.options) { + obj.options = message.options.map((e) => (e ? WeightedVoteOption.toJSON(e) : undefined)); + } else { + obj.options = []; + } + return obj; + }, + + fromPartial(object: DeepPartial): MsgVoteWeighted { + const message = { ...baseMsgVoteWeighted } as MsgVoteWeighted; + message.options = []; + if (object.proposalId !== undefined && object.proposalId !== null) { + message.proposalId = object.proposalId as Long; + } else { + message.proposalId = Long.UZERO; + } + if (object.voter !== undefined && object.voter !== null) { + message.voter = object.voter; + } else { + message.voter = ''; + } + if (object.options !== undefined && object.options !== null) { + for (const e of object.options) { + message.options.push(WeightedVoteOption.fromPartial(e)); + } + } + return message; + }, +}; + +const baseMsgVoteWeightedResponse: object = {}; + +export const MsgVoteWeightedResponse = { + encode(_: MsgVoteWeightedResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): MsgVoteWeightedResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseMsgVoteWeightedResponse } as MsgVoteWeightedResponse; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(_: any): MsgVoteWeightedResponse { + const message = { ...baseMsgVoteWeightedResponse } as MsgVoteWeightedResponse; + return message; + }, + + toJSON(_: MsgVoteWeightedResponse): unknown { + const obj: any = {}; + return obj; + }, + + fromPartial(_: DeepPartial): MsgVoteWeightedResponse { + const message = { ...baseMsgVoteWeightedResponse } as MsgVoteWeightedResponse; + return message; + }, +}; + const baseMsgDeposit: object = { proposalId: Long.UZERO, depositor: '' }; export const MsgDeposit = { @@ -460,6 +604,8 @@ export interface Msg { SubmitProposal(request: MsgSubmitProposal): Promise; /** Vote defines a method to add a vote on a specific proposal. */ Vote(request: MsgVote): Promise; + /** VoteWeighted defines a method to add a weighted vote on a specific proposal. */ + VoteWeighted(request: MsgVoteWeighted): Promise; /** Deposit defines a method to add deposit on a specific proposal. */ Deposit(request: MsgDeposit): Promise; } @@ -481,6 +627,12 @@ export class MsgClientImpl implements Msg { return promise.then((data) => MsgVoteResponse.decode(new _m0.Reader(data))); } + VoteWeighted(request: MsgVoteWeighted): Promise { + const data = MsgVoteWeighted.encode(request).finish(); + const promise = this.rpc.request('cosmos.gov.v1beta1.Msg', 'VoteWeighted', data); + return promise.then((data) => MsgVoteWeightedResponse.decode(new _m0.Reader(data))); + } + Deposit(request: MsgDeposit): Promise { const data = MsgDeposit.encode(request).finish(); const promise = this.rpc.request('cosmos.gov.v1beta1.Msg', 'Deposit', data); diff --git a/src/codec/cosmos/tx/v1beta1/tx.ts b/src/codec/cosmos/tx/v1beta1/tx.ts index 1b1e493..e0c6675 100644 --- a/src/codec/cosmos/tx/v1beta1/tx.ts +++ b/src/codec/cosmos/tx/v1beta1/tx.ts @@ -85,7 +85,11 @@ export interface TxBody { * transaction. */ messages: Any[]; - /** memo is any arbitrary memo to be added to the transaction */ + /** + * memo is any arbitrary note/comment to be added to the transaction. + * WARNING: in clients, any publicly exposed text should not be called memo, + * but should be called `note` instead (see https://github.com/cosmos/cosmos-sdk/issues/9122). + */ memo: string; /** * timeout is the block height after which this transaction will not diff --git a/src/codec/cosmos/upgrade/v1beta1/upgrade.ts b/src/codec/cosmos/upgrade/v1beta1/upgrade.ts new file mode 100644 index 0000000..052e864 --- /dev/null +++ b/src/codec/cosmos/upgrade/v1beta1/upgrade.ts @@ -0,0 +1,472 @@ +/* eslint-disable */ +import Long from 'long'; +import _m0 from 'protobufjs/minimal'; +import { Any } from '../../../google/protobuf/any'; +import { Timestamp } from '../../../google/protobuf/timestamp'; + +export const protobufPackage = 'cosmos.upgrade.v1beta1'; + +/** Plan specifies information about a planned upgrade and when it should occur. */ +export interface Plan { + /** + * Sets the name for the upgrade. This name will be used by the upgraded + * version of the software to apply any special "on-upgrade" commands during + * the first BeginBlock method after the upgrade is applied. It is also used + * to detect whether a software version can handle a given upgrade. If no + * upgrade handler with this name has been set in the software, it will be + * assumed that the software is out-of-date when the upgrade Time or Height is + * reached and the software will exit. + */ + name: string; + /** + * Deprecated: Time based upgrades have been deprecated. Time based upgrade logic + * has been removed from the SDK. + * If this field is not empty, an error will be thrown. + * + * @deprecated + */ + time?: Date; + /** + * The height at which the upgrade must be performed. + * Only used if Time is not set. + */ + height: Long; + /** + * Any application specific upgrade info to be included on-chain + * such as a git commit that validators could automatically upgrade to + */ + info: string; + /** + * Deprecated: UpgradedClientState field has been deprecated. IBC upgrade logic has been + * moved to the IBC module in the sub module 02-client. + * If this field is not empty, an error will be thrown. + * + * @deprecated + */ + upgradedClientState?: Any; +} + +/** + * SoftwareUpgradeProposal is a gov Content type for initiating a software + * upgrade. + */ +export interface SoftwareUpgradeProposal { + title: string; + description: string; + plan?: Plan; +} + +/** + * CancelSoftwareUpgradeProposal is a gov Content type for cancelling a software + * upgrade. + */ +export interface CancelSoftwareUpgradeProposal { + title: string; + description: string; +} + +/** ModuleVersion specifies a module and its consensus version. */ +export interface ModuleVersion { + /** name of the app module */ + name: string; + /** consensus version of the app module */ + version: Long; +} + +const basePlan: object = { name: '', height: Long.ZERO, info: '' }; + +export const Plan = { + encode(message: Plan, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.name !== '') { + writer.uint32(10).string(message.name); + } + if (message.time !== undefined) { + Timestamp.encode(toTimestamp(message.time), writer.uint32(18).fork()).ldelim(); + } + if (!message.height.isZero()) { + writer.uint32(24).int64(message.height); + } + if (message.info !== '') { + writer.uint32(34).string(message.info); + } + if (message.upgradedClientState !== undefined) { + Any.encode(message.upgradedClientState, writer.uint32(42).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): Plan { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...basePlan } as Plan; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.name = reader.string(); + break; + case 2: + message.time = fromTimestamp(Timestamp.decode(reader, reader.uint32())); + break; + case 3: + message.height = reader.int64() as Long; + break; + case 4: + message.info = reader.string(); + break; + case 5: + message.upgradedClientState = Any.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Plan { + const message = { ...basePlan } as Plan; + if (object.name !== undefined && object.name !== null) { + message.name = String(object.name); + } else { + message.name = ''; + } + if (object.time !== undefined && object.time !== null) { + message.time = fromJsonTimestamp(object.time); + } else { + message.time = undefined; + } + if (object.height !== undefined && object.height !== null) { + message.height = Long.fromString(object.height); + } else { + message.height = Long.ZERO; + } + if (object.info !== undefined && object.info !== null) { + message.info = String(object.info); + } else { + message.info = ''; + } + if (object.upgradedClientState !== undefined && object.upgradedClientState !== null) { + message.upgradedClientState = Any.fromJSON(object.upgradedClientState); + } else { + message.upgradedClientState = undefined; + } + return message; + }, + + toJSON(message: Plan): unknown { + const obj: any = {}; + message.name !== undefined && (obj.name = message.name); + message.time !== undefined && (obj.time = message.time.toISOString()); + message.height !== undefined && (obj.height = (message.height || Long.ZERO).toString()); + message.info !== undefined && (obj.info = message.info); + message.upgradedClientState !== undefined && (obj.upgradedClientState = message.upgradedClientState ? Any.toJSON(message.upgradedClientState) : undefined); + return obj; + }, + + fromPartial(object: DeepPartial): Plan { + const message = { ...basePlan } as Plan; + if (object.name !== undefined && object.name !== null) { + message.name = object.name; + } else { + message.name = ''; + } + if (object.time !== undefined && object.time !== null) { + message.time = object.time; + } else { + message.time = undefined; + } + if (object.height !== undefined && object.height !== null) { + message.height = object.height as Long; + } else { + message.height = Long.ZERO; + } + if (object.info !== undefined && object.info !== null) { + message.info = object.info; + } else { + message.info = ''; + } + if (object.upgradedClientState !== undefined && object.upgradedClientState !== null) { + message.upgradedClientState = Any.fromPartial(object.upgradedClientState); + } else { + message.upgradedClientState = undefined; + } + return message; + }, +}; + +const baseSoftwareUpgradeProposal: object = { title: '', description: '' }; + +export const SoftwareUpgradeProposal = { + encode(message: SoftwareUpgradeProposal, 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.plan !== undefined) { + Plan.encode(message.plan, writer.uint32(26).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): SoftwareUpgradeProposal { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseSoftwareUpgradeProposal } as SoftwareUpgradeProposal; + 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.plan = Plan.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SoftwareUpgradeProposal { + const message = { ...baseSoftwareUpgradeProposal } as SoftwareUpgradeProposal; + 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.plan !== undefined && object.plan !== null) { + message.plan = Plan.fromJSON(object.plan); + } else { + message.plan = undefined; + } + return message; + }, + + toJSON(message: SoftwareUpgradeProposal): unknown { + const obj: any = {}; + message.title !== undefined && (obj.title = message.title); + message.description !== undefined && (obj.description = message.description); + message.plan !== undefined && (obj.plan = message.plan ? Plan.toJSON(message.plan) : undefined); + return obj; + }, + + fromPartial(object: DeepPartial): SoftwareUpgradeProposal { + const message = { ...baseSoftwareUpgradeProposal } as SoftwareUpgradeProposal; + 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.plan !== undefined && object.plan !== null) { + message.plan = Plan.fromPartial(object.plan); + } else { + message.plan = undefined; + } + return message; + }, +}; + +const baseCancelSoftwareUpgradeProposal: object = { title: '', description: '' }; + +export const CancelSoftwareUpgradeProposal = { + encode(message: CancelSoftwareUpgradeProposal, 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); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): CancelSoftwareUpgradeProposal { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseCancelSoftwareUpgradeProposal } as CancelSoftwareUpgradeProposal; + 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; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): CancelSoftwareUpgradeProposal { + const message = { ...baseCancelSoftwareUpgradeProposal } as CancelSoftwareUpgradeProposal; + 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 = ''; + } + return message; + }, + + toJSON(message: CancelSoftwareUpgradeProposal): unknown { + const obj: any = {}; + message.title !== undefined && (obj.title = message.title); + message.description !== undefined && (obj.description = message.description); + return obj; + }, + + fromPartial(object: DeepPartial): CancelSoftwareUpgradeProposal { + const message = { ...baseCancelSoftwareUpgradeProposal } as CancelSoftwareUpgradeProposal; + 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 = ''; + } + return message; + }, +}; + +const baseModuleVersion: object = { name: '', version: Long.UZERO }; + +export const ModuleVersion = { + encode(message: ModuleVersion, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.name !== '') { + writer.uint32(10).string(message.name); + } + if (!message.version.isZero()) { + writer.uint32(16).uint64(message.version); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): ModuleVersion { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseModuleVersion } as ModuleVersion; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.name = reader.string(); + break; + case 2: + message.version = reader.uint64() as Long; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): ModuleVersion { + const message = { ...baseModuleVersion } as ModuleVersion; + if (object.name !== undefined && object.name !== null) { + message.name = String(object.name); + } else { + message.name = ''; + } + if (object.version !== undefined && object.version !== null) { + message.version = Long.fromString(object.version); + } else { + message.version = Long.UZERO; + } + return message; + }, + + toJSON(message: ModuleVersion): unknown { + const obj: any = {}; + message.name !== undefined && (obj.name = message.name); + message.version !== undefined && (obj.version = (message.version || Long.UZERO).toString()); + return obj; + }, + + fromPartial(object: DeepPartial): ModuleVersion { + const message = { ...baseModuleVersion } as ModuleVersion; + if (object.name !== undefined && object.name !== null) { + message.name = object.name; + } else { + message.name = ''; + } + if (object.version !== undefined && object.version !== null) { + message.version = object.version as Long; + } else { + message.version = Long.UZERO; + } + return message; + }, +}; + +type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined | Long; +export type DeepPartial = T extends Builtin + ? T + : T extends Array + ? Array> + : T extends ReadonlyArray + ? ReadonlyArray> + : T extends {} + ? { [K in keyof T]?: DeepPartial } + : Partial; + +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(); +} diff --git a/src/codec/cosmos/vesting/v1beta1/vesting.ts b/src/codec/cosmos/vesting/v1beta1/vesting.ts index 0516403..a3d168d 100644 --- a/src/codec/cosmos/vesting/v1beta1/vesting.ts +++ b/src/codec/cosmos/vesting/v1beta1/vesting.ts @@ -52,6 +52,15 @@ export interface PeriodicVestingAccount { vestingPeriods: Period[]; } +/** + * PermanentLockedAccount implements the VestingAccount interface. It does + * not ever release coins, locking them indefinitely. Coins in this account can + * still be used for delegating and for governance votes even while locked. + */ +export interface PermanentLockedAccount { + baseVestingAccount?: BaseVestingAccount; +} + const baseBaseVestingAccount: object = { endTime: Long.ZERO }; export const BaseVestingAccount = { @@ -498,6 +507,61 @@ export const PeriodicVestingAccount = { }, }; +const basePermanentLockedAccount: object = {}; + +export const PermanentLockedAccount = { + encode(message: PermanentLockedAccount, 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): PermanentLockedAccount { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...basePermanentLockedAccount } as PermanentLockedAccount; + 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): PermanentLockedAccount { + const message = { ...basePermanentLockedAccount } as PermanentLockedAccount; + if (object.baseVestingAccount !== undefined && object.baseVestingAccount !== null) { + message.baseVestingAccount = BaseVestingAccount.fromJSON(object.baseVestingAccount); + } else { + message.baseVestingAccount = undefined; + } + return message; + }, + + toJSON(message: PermanentLockedAccount): unknown { + const obj: any = {}; + message.baseVestingAccount !== undefined && (obj.baseVestingAccount = message.baseVestingAccount ? BaseVestingAccount.toJSON(message.baseVestingAccount) : undefined); + return obj; + }, + + fromPartial(object: DeepPartial): PermanentLockedAccount { + const message = { ...basePermanentLockedAccount } as PermanentLockedAccount; + if (object.baseVestingAccount !== undefined && object.baseVestingAccount !== null) { + message.baseVestingAccount = BaseVestingAccount.fromPartial(object.baseVestingAccount); + } else { + message.baseVestingAccount = undefined; + } + return message; + }, +}; + type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined | Long; export type DeepPartial = T extends Builtin ? T diff --git a/src/codec/ibc/core/channel/v1/query.ts b/src/codec/ibc/core/channel/v1/query.ts index e8b5bd3..3cf8a7e 100644 --- a/src/codec/ibc/core/channel/v1/query.ts +++ b/src/codec/ibc/core/channel/v1/query.ts @@ -190,8 +190,8 @@ export interface QueryPacketReceiptRequest { } /** - * QueryPacketReceiptResponse defines the client query response for a packet receipt - * which also includes a proof, and the height from which the proof was + * QueryPacketReceiptResponse defines the client query response for a packet + * receipt which also includes a proof, and the height from which the proof was * retrieved */ export interface QueryPacketReceiptResponse { @@ -241,6 +241,8 @@ export interface QueryPacketAcknowledgementsRequest { channelId: string; /** pagination request */ pagination?: PageRequest; + /** list of packet sequences */ + packetCommitmentSequences: Long[]; } /** @@ -1899,7 +1901,7 @@ export const QueryPacketAcknowledgementResponse = { }, }; -const baseQueryPacketAcknowledgementsRequest: object = { portId: '', channelId: '' }; +const baseQueryPacketAcknowledgementsRequest: object = { portId: '', channelId: '', packetCommitmentSequences: Long.UZERO }; export const QueryPacketAcknowledgementsRequest = { encode(message: QueryPacketAcknowledgementsRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { @@ -1912,6 +1914,11 @@ export const QueryPacketAcknowledgementsRequest = { if (message.pagination !== undefined) { PageRequest.encode(message.pagination, writer.uint32(26).fork()).ldelim(); } + writer.uint32(34).fork(); + for (const v of message.packetCommitmentSequences) { + writer.uint64(v); + } + writer.ldelim(); return writer; }, @@ -1919,6 +1926,7 @@ export const QueryPacketAcknowledgementsRequest = { const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); let end = length === undefined ? reader.len : reader.pos + length; const message = { ...baseQueryPacketAcknowledgementsRequest } as QueryPacketAcknowledgementsRequest; + message.packetCommitmentSequences = []; while (reader.pos < end) { const tag = reader.uint32(); switch (tag >>> 3) { @@ -1931,6 +1939,16 @@ export const QueryPacketAcknowledgementsRequest = { case 3: message.pagination = PageRequest.decode(reader, reader.uint32()); break; + case 4: + if ((tag & 7) === 2) { + const end2 = reader.uint32() + reader.pos; + while (reader.pos < end2) { + message.packetCommitmentSequences.push(reader.uint64() as Long); + } + } else { + message.packetCommitmentSequences.push(reader.uint64() as Long); + } + break; default: reader.skipType(tag & 7); break; @@ -1941,6 +1959,7 @@ export const QueryPacketAcknowledgementsRequest = { fromJSON(object: any): QueryPacketAcknowledgementsRequest { const message = { ...baseQueryPacketAcknowledgementsRequest } as QueryPacketAcknowledgementsRequest; + message.packetCommitmentSequences = []; if (object.portId !== undefined && object.portId !== null) { message.portId = String(object.portId); } else { @@ -1956,6 +1975,11 @@ export const QueryPacketAcknowledgementsRequest = { } else { message.pagination = undefined; } + if (object.packetCommitmentSequences !== undefined && object.packetCommitmentSequences !== null) { + for (const e of object.packetCommitmentSequences) { + message.packetCommitmentSequences.push(Long.fromString(e)); + } + } return message; }, @@ -1964,11 +1988,17 @@ export const QueryPacketAcknowledgementsRequest = { message.portId !== undefined && (obj.portId = message.portId); message.channelId !== undefined && (obj.channelId = message.channelId); message.pagination !== undefined && (obj.pagination = message.pagination ? PageRequest.toJSON(message.pagination) : undefined); + if (message.packetCommitmentSequences) { + obj.packetCommitmentSequences = message.packetCommitmentSequences.map((e) => (e || Long.UZERO).toString()); + } else { + obj.packetCommitmentSequences = []; + } return obj; }, fromPartial(object: DeepPartial): QueryPacketAcknowledgementsRequest { const message = { ...baseQueryPacketAcknowledgementsRequest } as QueryPacketAcknowledgementsRequest; + message.packetCommitmentSequences = []; if (object.portId !== undefined && object.portId !== null) { message.portId = object.portId; } else { @@ -1984,6 +2014,11 @@ export const QueryPacketAcknowledgementsRequest = { } else { message.pagination = undefined; } + if (object.packetCommitmentSequences !== undefined && object.packetCommitmentSequences !== null) { + for (const e of object.packetCommitmentSequences) { + message.packetCommitmentSequences.push(e); + } + } return message; }, }; @@ -2659,7 +2694,10 @@ export interface Query { * with a channel. */ PacketCommitments(request: QueryPacketCommitmentsRequest): Promise; - /** PacketReceipt queries if a given packet sequence has been received on the queried chain */ + /** + * PacketReceipt queries if a given packet sequence has been received on the + * queried chain + */ PacketReceipt(request: QueryPacketReceiptRequest): Promise; /** PacketAcknowledgement queries a stored packet acknowledgement hash. */ PacketAcknowledgement(request: QueryPacketAcknowledgementRequest): Promise; @@ -2674,8 +2712,8 @@ export interface Query { */ UnreceivedPackets(request: QueryUnreceivedPacketsRequest): Promise; /** - * UnreceivedAcks returns all the unreceived IBC acknowledgements associated with a - * channel and sequences. + * UnreceivedAcks returns all the unreceived IBC acknowledgements associated + * with a channel and sequences. */ UnreceivedAcks(request: QueryUnreceivedAcksRequest): Promise; /** NextSequenceReceive returns the next receive sequence for a given channel. */ diff --git a/src/codec/ibc/core/channel/v1/tx.ts b/src/codec/ibc/core/channel/v1/tx.ts index 5d3837b..9a96f4b 100644 --- a/src/codec/ibc/core/channel/v1/tx.ts +++ b/src/codec/ibc/core/channel/v1/tx.ts @@ -26,8 +26,8 @@ export interface MsgChannelOpenInitResponse {} export interface MsgChannelOpenTry { portId: string; /** - * in the case of crossing hello's, when both chains call OpenInit, we need the channel identifier - * of the previous channel in state INIT + * in the case of crossing hello's, when both chains call OpenInit, we need + * the channel identifier of the previous channel in state INIT */ previousChannelId: string; channel?: Channel; @@ -69,7 +69,10 @@ export interface MsgChannelOpenConfirm { signer: string; } -/** MsgChannelOpenConfirmResponse defines the Msg/ChannelOpenConfirm response type. */ +/** + * MsgChannelOpenConfirmResponse defines the Msg/ChannelOpenConfirm response + * type. + */ export interface MsgChannelOpenConfirmResponse {} /** @@ -97,7 +100,10 @@ export interface MsgChannelCloseConfirm { signer: string; } -/** MsgChannelCloseConfirmResponse defines the Msg/ChannelCloseConfirm response type. */ +/** + * MsgChannelCloseConfirmResponse defines the Msg/ChannelCloseConfirm response + * type. + */ export interface MsgChannelCloseConfirmResponse {} /** MsgRecvPacket receives incoming IBC packet */ @@ -1770,7 +1776,10 @@ export interface Msg { ChannelOpenConfirm(request: MsgChannelOpenConfirm): Promise; /** ChannelCloseInit defines a rpc handler method for MsgChannelCloseInit. */ ChannelCloseInit(request: MsgChannelCloseInit): Promise; - /** ChannelCloseConfirm defines a rpc handler method for MsgChannelCloseConfirm. */ + /** + * ChannelCloseConfirm defines a rpc handler method for + * MsgChannelCloseConfirm. + */ ChannelCloseConfirm(request: MsgChannelCloseConfirm): Promise; /** RecvPacket defines a rpc handler method for MsgRecvPacket. */ RecvPacket(request: MsgRecvPacket): Promise; diff --git a/src/codec/ibc/core/client/v1/client.ts b/src/codec/ibc/core/client/v1/client.ts index 8fbc7e1..80b29cc 100644 --- a/src/codec/ibc/core/client/v1/client.ts +++ b/src/codec/ibc/core/client/v1/client.ts @@ -2,6 +2,7 @@ import Long from 'long'; import _m0 from 'protobufjs/minimal'; import { Any } from '../../../../google/protobuf/any'; +import { Plan } from '../../../../cosmos/upgrade/v1beta1/upgrade'; export const protobufPackage = 'ibc.core.client.v1'; @@ -16,7 +17,10 @@ export interface IdentifiedClientState { clientState?: Any; } -/** ConsensusStateWithHeight defines a consensus state with an additional height field. */ +/** + * ConsensusStateWithHeight defines a consensus state with an additional height + * field. + */ export interface ConsensusStateWithHeight { /** consensus state height */ height?: Height; @@ -36,9 +40,10 @@ export interface ClientConsensusStates { } /** - * 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. + * ClientUpdateProposal is a governance proposal. If it passes, the substitute + * client's latest consensus state is copied over to the subject client. The proposal + * handler may fail if the subject and the substitute do not match in client and + * chain parameters (with exception to latest height, frozen height, and chain-id). */ export interface ClientUpdateProposal { /** the title of the update proposal */ @@ -46,9 +51,31 @@ export interface ClientUpdateProposal { /** 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; + subjectClientId: string; + /** + * the substitute client identifier for the client standing in for the subject + * client + */ + substituteClientId: string; +} + +/** + * UpgradeProposal is a gov Content type for initiating an IBC breaking + * upgrade. + */ +export interface UpgradeProposal { + title: string; + description: string; + plan?: Plan; + /** + * An UpgradedClientState must be provided to perform an IBC breaking upgrade. + * This will make the chain commit to the correct upgraded (self) client state + * before the upgrade occurs, so that connecting chains can verify that the + * new upgraded client is valid by verifying a proof on the previous version + * of the chain. This will allow IBC connections to persist smoothly across + * planned chain upgrades + */ + upgradedClientState?: Any; } /** @@ -56,11 +83,12 @@ export interface ClientUpdateProposal { * 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 + * 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 */ @@ -298,7 +326,7 @@ export const ClientConsensusStates = { }, }; -const baseClientUpdateProposal: object = { title: '', description: '', clientId: '' }; +const baseClientUpdateProposal: object = { title: '', description: '', subjectClientId: '', substituteClientId: '' }; export const ClientUpdateProposal = { encode(message: ClientUpdateProposal, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { @@ -308,11 +336,11 @@ export const ClientUpdateProposal = { if (message.description !== '') { writer.uint32(18).string(message.description); } - if (message.clientId !== '') { - writer.uint32(26).string(message.clientId); + if (message.subjectClientId !== '') { + writer.uint32(26).string(message.subjectClientId); } - if (message.header !== undefined) { - Any.encode(message.header, writer.uint32(34).fork()).ldelim(); + if (message.substituteClientId !== '') { + writer.uint32(34).string(message.substituteClientId); } return writer; }, @@ -331,10 +359,10 @@ export const ClientUpdateProposal = { message.description = reader.string(); break; case 3: - message.clientId = reader.string(); + message.subjectClientId = reader.string(); break; case 4: - message.header = Any.decode(reader, reader.uint32()); + message.substituteClientId = reader.string(); break; default: reader.skipType(tag & 7); @@ -356,15 +384,15 @@ export const ClientUpdateProposal = { } else { message.description = ''; } - if (object.clientId !== undefined && object.clientId !== null) { - message.clientId = String(object.clientId); + if (object.subjectClientId !== undefined && object.subjectClientId !== null) { + message.subjectClientId = String(object.subjectClientId); } else { - message.clientId = ''; + message.subjectClientId = ''; } - if (object.header !== undefined && object.header !== null) { - message.header = Any.fromJSON(object.header); + if (object.substituteClientId !== undefined && object.substituteClientId !== null) { + message.substituteClientId = String(object.substituteClientId); } else { - message.header = undefined; + message.substituteClientId = ''; } return message; }, @@ -373,8 +401,8 @@ export const ClientUpdateProposal = { 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); + message.subjectClientId !== undefined && (obj.subjectClientId = message.subjectClientId); + message.substituteClientId !== undefined && (obj.substituteClientId = message.substituteClientId); return obj; }, @@ -390,15 +418,121 @@ export const ClientUpdateProposal = { } else { message.description = ''; } - if (object.clientId !== undefined && object.clientId !== null) { - message.clientId = object.clientId; + if (object.subjectClientId !== undefined && object.subjectClientId !== null) { + message.subjectClientId = object.subjectClientId; } else { - message.clientId = ''; + message.subjectClientId = ''; + } + if (object.substituteClientId !== undefined && object.substituteClientId !== null) { + message.substituteClientId = object.substituteClientId; + } else { + message.substituteClientId = ''; + } + return message; + }, +}; + +const baseUpgradeProposal: object = { title: '', description: '' }; + +export const UpgradeProposal = { + encode(message: UpgradeProposal, 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.plan !== undefined) { + Plan.encode(message.plan, writer.uint32(26).fork()).ldelim(); + } + if (message.upgradedClientState !== undefined) { + Any.encode(message.upgradedClientState, writer.uint32(34).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): UpgradeProposal { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseUpgradeProposal } as UpgradeProposal; + 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.plan = Plan.decode(reader, reader.uint32()); + break; + case 4: + message.upgradedClientState = Any.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): UpgradeProposal { + const message = { ...baseUpgradeProposal } as UpgradeProposal; + 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.plan !== undefined && object.plan !== null) { + message.plan = Plan.fromJSON(object.plan); + } else { + message.plan = undefined; + } + if (object.upgradedClientState !== undefined && object.upgradedClientState !== null) { + message.upgradedClientState = Any.fromJSON(object.upgradedClientState); + } else { + message.upgradedClientState = undefined; + } + return message; + }, + + toJSON(message: UpgradeProposal): unknown { + const obj: any = {}; + message.title !== undefined && (obj.title = message.title); + message.description !== undefined && (obj.description = message.description); + message.plan !== undefined && (obj.plan = message.plan ? Plan.toJSON(message.plan) : undefined); + message.upgradedClientState !== undefined && (obj.upgradedClientState = message.upgradedClientState ? Any.toJSON(message.upgradedClientState) : undefined); + return obj; + }, + + fromPartial(object: DeepPartial): UpgradeProposal { + const message = { ...baseUpgradeProposal } as UpgradeProposal; + 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.plan !== undefined && object.plan !== null) { + message.plan = Plan.fromPartial(object.plan); + } else { + message.plan = undefined; } - if (object.header !== undefined && object.header !== null) { - message.header = Any.fromPartial(object.header); + if (object.upgradedClientState !== undefined && object.upgradedClientState !== null) { + message.upgradedClientState = Any.fromPartial(object.upgradedClientState); } else { - message.header = undefined; + message.upgradedClientState = undefined; } return message; }, diff --git a/src/codec/ibc/core/client/v1/query.ts b/src/codec/ibc/core/client/v1/query.ts index 3dbe9a6..4ac6686 100644 --- a/src/codec/ibc/core/client/v1/query.ts +++ b/src/codec/ibc/core/client/v1/query.ts @@ -104,15 +104,68 @@ export interface QueryConsensusStatesResponse { pagination?: PageResponse; } -/** QueryClientParamsRequest is the request type for the Query/ClientParams RPC method. */ +/** + * QueryClientStatusRequest is the request type for the Query/ClientStatus RPC + * method + */ +export interface QueryClientStatusRequest { + /** client unique identifier */ + clientId: string; +} + +/** + * QueryClientStatusResponse is the response type for the Query/ClientStatus RPC + * method. It returns the current status of the IBC client. + */ +export interface QueryClientStatusResponse { + status: string; +} + +/** + * 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. */ +/** + * QueryClientParamsResponse is the response type for the Query/ClientParams RPC + * method. + */ export interface QueryClientParamsResponse { /** params defines the parameters of the module. */ params?: Params; } +/** + * QueryUpgradedClientStateRequest is the request type for the + * Query/UpgradedClientState RPC method + */ +export interface QueryUpgradedClientStateRequest {} + +/** + * QueryUpgradedClientStateResponse is the response type for the + * Query/UpgradedClientState RPC method. + */ +export interface QueryUpgradedClientStateResponse { + /** client state associated with the request identifier */ + upgradedClientState?: Any; +} + +/** + * QueryUpgradedConsensusStateRequest is the request type for the + * Query/UpgradedConsensusState RPC method + */ +export interface QueryUpgradedConsensusStateRequest {} + +/** + * QueryUpgradedConsensusStateResponse is the response type for the + * Query/UpgradedConsensusState RPC method. + */ +export interface QueryUpgradedConsensusStateResponse { + /** Consensus state associated with the request identifier */ + upgradedConsensusState?: Any; +} + const baseQueryClientStateRequest: object = { clientId: '' }; export const QueryClientStateRequest = { @@ -737,6 +790,116 @@ export const QueryConsensusStatesResponse = { }, }; +const baseQueryClientStatusRequest: object = { clientId: '' }; + +export const QueryClientStatusRequest = { + encode(message: QueryClientStatusRequest, 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): QueryClientStatusRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseQueryClientStatusRequest } as QueryClientStatusRequest; + 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): QueryClientStatusRequest { + const message = { ...baseQueryClientStatusRequest } as QueryClientStatusRequest; + if (object.clientId !== undefined && object.clientId !== null) { + message.clientId = String(object.clientId); + } else { + message.clientId = ''; + } + return message; + }, + + toJSON(message: QueryClientStatusRequest): unknown { + const obj: any = {}; + message.clientId !== undefined && (obj.clientId = message.clientId); + return obj; + }, + + fromPartial(object: DeepPartial): QueryClientStatusRequest { + const message = { ...baseQueryClientStatusRequest } as QueryClientStatusRequest; + if (object.clientId !== undefined && object.clientId !== null) { + message.clientId = object.clientId; + } else { + message.clientId = ''; + } + return message; + }, +}; + +const baseQueryClientStatusResponse: object = { status: '' }; + +export const QueryClientStatusResponse = { + encode(message: QueryClientStatusResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.status !== '') { + writer.uint32(10).string(message.status); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): QueryClientStatusResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseQueryClientStatusResponse } as QueryClientStatusResponse; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.status = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): QueryClientStatusResponse { + const message = { ...baseQueryClientStatusResponse } as QueryClientStatusResponse; + if (object.status !== undefined && object.status !== null) { + message.status = String(object.status); + } else { + message.status = ''; + } + return message; + }, + + toJSON(message: QueryClientStatusResponse): unknown { + const obj: any = {}; + message.status !== undefined && (obj.status = message.status); + return obj; + }, + + fromPartial(object: DeepPartial): QueryClientStatusResponse { + const message = { ...baseQueryClientStatusResponse } as QueryClientStatusResponse; + if (object.status !== undefined && object.status !== null) { + message.status = object.status; + } else { + message.status = ''; + } + return message; + }, +}; + const baseQueryClientParamsRequest: object = {}; export const QueryClientParamsRequest = { @@ -830,6 +993,192 @@ export const QueryClientParamsResponse = { }, }; +const baseQueryUpgradedClientStateRequest: object = {}; + +export const QueryUpgradedClientStateRequest = { + encode(_: QueryUpgradedClientStateRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): QueryUpgradedClientStateRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseQueryUpgradedClientStateRequest } as QueryUpgradedClientStateRequest; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(_: any): QueryUpgradedClientStateRequest { + const message = { ...baseQueryUpgradedClientStateRequest } as QueryUpgradedClientStateRequest; + return message; + }, + + toJSON(_: QueryUpgradedClientStateRequest): unknown { + const obj: any = {}; + return obj; + }, + + fromPartial(_: DeepPartial): QueryUpgradedClientStateRequest { + const message = { ...baseQueryUpgradedClientStateRequest } as QueryUpgradedClientStateRequest; + return message; + }, +}; + +const baseQueryUpgradedClientStateResponse: object = {}; + +export const QueryUpgradedClientStateResponse = { + encode(message: QueryUpgradedClientStateResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.upgradedClientState !== undefined) { + Any.encode(message.upgradedClientState, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): QueryUpgradedClientStateResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseQueryUpgradedClientStateResponse } as QueryUpgradedClientStateResponse; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.upgradedClientState = Any.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): QueryUpgradedClientStateResponse { + const message = { ...baseQueryUpgradedClientStateResponse } as QueryUpgradedClientStateResponse; + if (object.upgradedClientState !== undefined && object.upgradedClientState !== null) { + message.upgradedClientState = Any.fromJSON(object.upgradedClientState); + } else { + message.upgradedClientState = undefined; + } + return message; + }, + + toJSON(message: QueryUpgradedClientStateResponse): unknown { + const obj: any = {}; + message.upgradedClientState !== undefined && (obj.upgradedClientState = message.upgradedClientState ? Any.toJSON(message.upgradedClientState) : undefined); + return obj; + }, + + fromPartial(object: DeepPartial): QueryUpgradedClientStateResponse { + const message = { ...baseQueryUpgradedClientStateResponse } as QueryUpgradedClientStateResponse; + if (object.upgradedClientState !== undefined && object.upgradedClientState !== null) { + message.upgradedClientState = Any.fromPartial(object.upgradedClientState); + } else { + message.upgradedClientState = undefined; + } + return message; + }, +}; + +const baseQueryUpgradedConsensusStateRequest: object = {}; + +export const QueryUpgradedConsensusStateRequest = { + encode(_: QueryUpgradedConsensusStateRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): QueryUpgradedConsensusStateRequest { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseQueryUpgradedConsensusStateRequest } as QueryUpgradedConsensusStateRequest; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(_: any): QueryUpgradedConsensusStateRequest { + const message = { ...baseQueryUpgradedConsensusStateRequest } as QueryUpgradedConsensusStateRequest; + return message; + }, + + toJSON(_: QueryUpgradedConsensusStateRequest): unknown { + const obj: any = {}; + return obj; + }, + + fromPartial(_: DeepPartial): QueryUpgradedConsensusStateRequest { + const message = { ...baseQueryUpgradedConsensusStateRequest } as QueryUpgradedConsensusStateRequest; + return message; + }, +}; + +const baseQueryUpgradedConsensusStateResponse: object = {}; + +export const QueryUpgradedConsensusStateResponse = { + encode(message: QueryUpgradedConsensusStateResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (message.upgradedConsensusState !== undefined) { + Any.encode(message.upgradedConsensusState, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + + decode(input: _m0.Reader | Uint8Array, length?: number): QueryUpgradedConsensusStateResponse { + const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseQueryUpgradedConsensusStateResponse } as QueryUpgradedConsensusStateResponse; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.upgradedConsensusState = Any.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): QueryUpgradedConsensusStateResponse { + const message = { ...baseQueryUpgradedConsensusStateResponse } as QueryUpgradedConsensusStateResponse; + if (object.upgradedConsensusState !== undefined && object.upgradedConsensusState !== null) { + message.upgradedConsensusState = Any.fromJSON(object.upgradedConsensusState); + } else { + message.upgradedConsensusState = undefined; + } + return message; + }, + + toJSON(message: QueryUpgradedConsensusStateResponse): unknown { + const obj: any = {}; + message.upgradedConsensusState !== undefined && (obj.upgradedConsensusState = message.upgradedConsensusState ? Any.toJSON(message.upgradedConsensusState) : undefined); + return obj; + }, + + fromPartial(object: DeepPartial): QueryUpgradedConsensusStateResponse { + const message = { ...baseQueryUpgradedConsensusStateResponse } as QueryUpgradedConsensusStateResponse; + if (object.upgradedConsensusState !== undefined && object.upgradedConsensusState !== null) { + message.upgradedConsensusState = Any.fromPartial(object.upgradedConsensusState); + } else { + message.upgradedConsensusState = undefined; + } + return message; + }, +}; + /** Query provides defines the gRPC querier service */ export interface Query { /** ClientState queries an IBC light client. */ @@ -846,8 +1195,14 @@ export interface Query { * client. */ ConsensusStates(request: QueryConsensusStatesRequest): Promise; + /** Status queries the status of an IBC client. */ + ClientStatus(request: QueryClientStatusRequest): Promise; /** ClientParams queries all parameters of the ibc client. */ ClientParams(request: QueryClientParamsRequest): Promise; + /** UpgradedClientState queries an Upgraded IBC light client. */ + UpgradedClientState(request: QueryUpgradedClientStateRequest): Promise; + /** UpgradedConsensusState queries an Upgraded IBC consensus state. */ + UpgradedConsensusState(request: QueryUpgradedConsensusStateRequest): Promise; } export class QueryClientImpl implements Query { @@ -879,11 +1234,29 @@ export class QueryClientImpl implements Query { return promise.then((data) => QueryConsensusStatesResponse.decode(new _m0.Reader(data))); } + ClientStatus(request: QueryClientStatusRequest): Promise { + const data = QueryClientStatusRequest.encode(request).finish(); + const promise = this.rpc.request('ibc.core.client.v1.Query', 'ClientStatus', data); + return promise.then((data) => QueryClientStatusResponse.decode(new _m0.Reader(data))); + } + ClientParams(request: QueryClientParamsRequest): Promise { 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))); } + + UpgradedClientState(request: QueryUpgradedClientStateRequest): Promise { + const data = QueryUpgradedClientStateRequest.encode(request).finish(); + const promise = this.rpc.request('ibc.core.client.v1.Query', 'UpgradedClientState', data); + return promise.then((data) => QueryUpgradedClientStateResponse.decode(new _m0.Reader(data))); + } + + UpgradedConsensusState(request: QueryUpgradedConsensusStateRequest): Promise { + const data = QueryUpgradedConsensusStateRequest.encode(request).finish(); + const promise = this.rpc.request('ibc.core.client.v1.Query', 'UpgradedConsensusState', data); + return promise.then((data) => QueryUpgradedConsensusStateResponse.decode(new _m0.Reader(data))); + } } interface Rpc { diff --git a/src/codec/ibc/core/client/v1/tx.ts b/src/codec/ibc/core/client/v1/tx.ts index ac02b0d..2d0502a 100644 --- a/src/codec/ibc/core/client/v1/tx.ts +++ b/src/codec/ibc/core/client/v1/tx.ts @@ -37,13 +37,19 @@ export interface MsgUpdateClient { /** 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 */ +/** + * 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 */ + /** + * 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; @@ -69,7 +75,10 @@ export interface MsgSubmitMisbehaviour { signer: string; } -/** MsgSubmitMisbehaviourResponse defines the Msg/SubmitMisbehaviour response type. */ +/** + * MsgSubmitMisbehaviourResponse defines the Msg/SubmitMisbehaviour response + * type. + */ export interface MsgSubmitMisbehaviourResponse {} const baseMsgCreateClient: object = { signer: '' }; diff --git a/src/codec/ibc/core/connection/v1/connection.ts b/src/codec/ibc/core/connection/v1/connection.ts index 87eab49..af373b7 100644 --- a/src/codec/ibc/core/connection/v1/connection.ts +++ b/src/codec/ibc/core/connection/v1/connection.ts @@ -79,8 +79,9 @@ export interface ConnectionEnd { /** 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. + * 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; } @@ -148,6 +149,16 @@ export interface Version { features: string[]; } +/** Params defines the set of Connection parameters. */ +export interface Params { + /** + * maximum expected time per block (in nanoseconds), used to enforce block delay. This parameter should reflect the + * largest amount of time that the chain might reasonably take to produce the next block under normal operating + * conditions. A safe choice is 3-5x the expected time per block. + */ + maxExpectedTimePerBlock: Long; +} + const baseConnectionEnd: object = { clientId: '', state: 0, delayPeriod: Long.UZERO }; export const ConnectionEnd = { @@ -734,6 +745,61 @@ export const Version = { }, }; +const baseParams: object = { maxExpectedTimePerBlock: Long.UZERO }; + +export const Params = { + encode(message: Params, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer { + if (!message.maxExpectedTimePerBlock.isZero()) { + writer.uint32(8).uint64(message.maxExpectedTimePerBlock); + } + 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.maxExpectedTimePerBlock = reader.uint64() as Long; + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Params { + const message = { ...baseParams } as Params; + if (object.maxExpectedTimePerBlock !== undefined && object.maxExpectedTimePerBlock !== null) { + message.maxExpectedTimePerBlock = Long.fromString(object.maxExpectedTimePerBlock); + } else { + message.maxExpectedTimePerBlock = Long.UZERO; + } + return message; + }, + + toJSON(message: Params): unknown { + const obj: any = {}; + message.maxExpectedTimePerBlock !== undefined && (obj.maxExpectedTimePerBlock = (message.maxExpectedTimePerBlock || Long.UZERO).toString()); + return obj; + }, + + fromPartial(object: DeepPartial): Params { + const message = { ...baseParams } as Params; + if (object.maxExpectedTimePerBlock !== undefined && object.maxExpectedTimePerBlock !== null) { + message.maxExpectedTimePerBlock = object.maxExpectedTimePerBlock as Long; + } else { + message.maxExpectedTimePerBlock = Long.UZERO; + } + return message; + }, +}; + type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined | Long; export type DeepPartial = T extends Builtin ? T diff --git a/src/codec/ibc/core/connection/v1/tx.ts b/src/codec/ibc/core/connection/v1/tx.ts index 9b4403a..e822134 100644 --- a/src/codec/ibc/core/connection/v1/tx.ts +++ b/src/codec/ibc/core/connection/v1/tx.ts @@ -19,7 +19,10 @@ export interface MsgConnectionOpenInit { signer: string; } -/** MsgConnectionOpenInitResponse defines the Msg/ConnectionOpenInit response type. */ +/** + * MsgConnectionOpenInitResponse defines the Msg/ConnectionOpenInit response + * type. + */ export interface MsgConnectionOpenInitResponse {} /** @@ -29,8 +32,8 @@ export interface MsgConnectionOpenInitResponse {} export interface MsgConnectionOpenTry { clientId: string; /** - * in the case of crossing hello's, when both chains call OpenInit, we need the connection identifier - * of the previous connection in state INIT + * in the case of crossing hello's, when both chains call OpenInit, we need + * the connection identifier of the previous connection in state INIT */ previousConnectionId: string; clientState?: Any; @@ -92,7 +95,10 @@ export interface MsgConnectionOpenConfirm { signer: string; } -/** MsgConnectionOpenConfirmResponse defines the Msg/ConnectionOpenConfirm response type. */ +/** + * MsgConnectionOpenConfirmResponse defines the Msg/ConnectionOpenConfirm + * response type. + */ export interface MsgConnectionOpenConfirmResponse {} const baseMsgConnectionOpenInit: object = { clientId: '', delayPeriod: Long.UZERO, signer: '' }; @@ -941,7 +947,10 @@ export interface Msg { ConnectionOpenTry(request: MsgConnectionOpenTry): Promise; /** ConnectionOpenAck defines a rpc handler method for MsgConnectionOpenAck. */ ConnectionOpenAck(request: MsgConnectionOpenAck): Promise; - /** ConnectionOpenConfirm defines a rpc handler method for MsgConnectionOpenConfirm. */ + /** + * ConnectionOpenConfirm defines a rpc handler method for + * MsgConnectionOpenConfirm. + */ ConnectionOpenConfirm(request: MsgConnectionOpenConfirm): Promise; } diff --git a/src/codec/ibc/lightclients/tendermint/v1/tendermint.ts b/src/codec/ibc/lightclients/tendermint/v1/tendermint.ts index 54493e8..defc3e0 100644 --- a/src/codec/ibc/lightclients/tendermint/v1/tendermint.ts +++ b/src/codec/ibc/lightclients/tendermint/v1/tendermint.ts @@ -35,10 +35,12 @@ export interface ClientState { 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"}` + * 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[]; /** @@ -96,7 +98,10 @@ export interface Header { trustedValidators?: ValidatorSet; } -/** Fraction defines the protobuf message type for tmmath.Fraction that only supports positive values. */ +/** + * Fraction defines the protobuf message type for tmmath.Fraction that only + * supports positive values. + */ export interface Fraction { numerator: Long; denominator: Long; From 8790293ebdc5601afa60feacd885400f410c2f8a Mon Sep 17 00:00:00 2001 From: Fabrice Bascoulergue Date: Wed, 15 Sep 2021 17:55:46 +0200 Subject: [PATCH 4/4] Bump version to 0.5.0 --- package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/package.json b/package.json index cc8a16d..79d0049 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "@lum-network/sdk-javascript", - "version": "0.4.9", + "version": "0.5.0", "license": "Apache-2.0", "description": "Javascript SDK library for NodeJS and Web browsers to interact with the Lum Network.", "homepage": "https://github.com/lum-network/sdk-javascript#readme",