From 9bf2ca7ff240281e9279dcf53d8e0ad516d9503e Mon Sep 17 00:00:00 2001 From: willclarktech Date: Tue, 20 Apr 2021 17:43:29 +0200 Subject: [PATCH 1/3] stargate: Add IBC transfer query codec --- packages/stargate/scripts/define-proto.sh | 1 + .../ibc/applications/transfer/v1/query.ts | 448 ++++++++++++++++++ .../ibc/applications/transfer/v1/transfer.ts | 320 +++++++++++++ 3 files changed, 769 insertions(+) create mode 100644 packages/stargate/src/codec/ibc/applications/transfer/v1/query.ts create mode 100644 packages/stargate/src/codec/ibc/applications/transfer/v1/transfer.ts diff --git a/packages/stargate/scripts/define-proto.sh b/packages/stargate/scripts/define-proto.sh index 13b7107c..3f3f978f 100755 --- a/packages/stargate/scripts/define-proto.sh +++ b/packages/stargate/scripts/define-proto.sh @@ -34,6 +34,7 @@ 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/query.proto" \ "$COSMOS_PROTO_DIR/ibc/applications/transfer/v1/tx.proto" \ "$COSMOS_PROTO_DIR/ibc/core/channel/v1/channel.proto" \ "$COSMOS_PROTO_DIR/ibc/core/channel/v1/query.proto" \ diff --git a/packages/stargate/src/codec/ibc/applications/transfer/v1/query.ts b/packages/stargate/src/codec/ibc/applications/transfer/v1/query.ts new file mode 100644 index 00000000..33c1a4d1 --- /dev/null +++ b/packages/stargate/src/codec/ibc/applications/transfer/v1/query.ts @@ -0,0 +1,448 @@ +/* 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 | 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/packages/stargate/src/codec/ibc/applications/transfer/v1/transfer.ts b/packages/stargate/src/codec/ibc/applications/transfer/v1/transfer.ts new file mode 100644 index 00000000..e032e90e --- /dev/null +++ b/packages/stargate/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 | 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(); +} From 0f9e54e1519e9ec4c04f3324973a79856960324b Mon Sep 17 00:00:00 2001 From: willclarktech Date: Tue, 20 Apr 2021 18:19:53 +0200 Subject: [PATCH 2/3] stargate: Add transfer queries to IBC extension --- packages/stargate/src/queries/ibc.ts | 46 +++++++++++++++++++++++++--- 1 file changed, 41 insertions(+), 5 deletions(-) diff --git a/packages/stargate/src/queries/ibc.ts b/packages/stargate/src/queries/ibc.ts index 7f14bec4..ee0c8deb 100644 --- a/packages/stargate/src/queries/ibc.ts +++ b/packages/stargate/src/queries/ibc.ts @@ -4,6 +4,12 @@ import { Uint64 } from "@cosmjs/math"; import Long from "long"; import { Any } from "../codec/google/protobuf/any"; +import { + QueryClientImpl as TransferQuery, + QueryDenomTraceResponse, + QueryDenomTracesResponse, + QueryParamsResponse as QueryTransferParamsResponse, +} from "../codec/ibc/applications/transfer/v1/query"; import { Channel } from "../codec/ibc/core/channel/v1/channel"; import { QueryChannelClientStateResponse, @@ -155,6 +161,12 @@ export interface IbcExtension { 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; @@ -181,6 +193,7 @@ export function setupIbcExtension(base: QueryClient): IbcExtension { const channelQueryService = new ChannelQuery(rpc); const clientQueryService = new ClientQuery(rpc); const connectionQueryService = new ConnectionQuery(rpc); + const transferQueryService = new TransferQuery(rpc); return { ibc: { @@ -338,8 +351,8 @@ export function setupIbcExtension(base: QueryClient): IbcExtension { }), }, client: { - state: (clientId: string) => clientQueryService.ClientState({ clientId }), - states: (paginationKey?: Uint8Array) => + state: async (clientId: string) => clientQueryService.ClientState({ clientId }), + states: async (paginationKey?: Uint8Array) => clientQueryService.ClientStates({ pagination: createPagination(paginationKey), }), @@ -358,7 +371,7 @@ export function setupIbcExtension(base: QueryClient): IbcExtension { clientStates: clientStates, }; }, - consensusState: (clientId: string, consensusHeight?: number) => + consensusState: async (clientId: string, consensusHeight?: number) => clientQueryService.ConsensusState( QueryConsensusStateRequest.fromPartial({ clientId: clientId, @@ -367,7 +380,7 @@ export function setupIbcExtension(base: QueryClient): IbcExtension { latestHeight: consensusHeight === undefined, }), ), - consensusStates: (clientId: string, paginationKey?: Uint8Array) => + consensusStates: async (clientId: string, paginationKey?: Uint8Array) => clientQueryService.ConsensusStates({ clientId: clientId, pagination: createPagination(paginationKey), @@ -388,7 +401,7 @@ export function setupIbcExtension(base: QueryClient): IbcExtension { consensusStates: consensusStates, }; }, - params: () => clientQueryService.ClientParams({}), + params: async () => clientQueryService.ClientParams({}), stateTm: async (clientId: string) => { const response = await clientQueryService.ClientState({ clientId }); return decodeTendermintClientStateAny(response.clientState); @@ -465,6 +478,29 @@ export function setupIbcExtension(base: QueryClient): IbcExtension { }), ), }, + 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) => { From 0eb200154fd11bfcb70d5f62760dce11477350de Mon Sep 17 00:00:00 2001 From: willclarktech Date: Tue, 20 Apr 2021 18:33:51 +0200 Subject: [PATCH 3/3] Update CHANGELOG for IBC transfer queries --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 040c20e3..ae235846 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -84,6 +84,8 @@ and this project adheres to `MsgMigrateContractEncodeObject`, `MsgStoreCodeEncodeObject` and `MsgUpdateAdminEncodeObject` interfaces as well as `isMsgClearAdminEncodeObject` etc helpers. +- @cosmjs/stargate: Add transfer queries codec, as well as transfer query + methods to IBC query extension. ### Changed