@gitopia/gitopiajs 0.0.4 → 0.0.5

package/dist/ibc/bundle.d.ts

@@ -0,0 +1,450 @@
+import * as _47 from "./applications/transfer/v1/query";
+import * as _48 from "./applications/transfer/v1/transfer";
+import * as _49 from "./applications/transfer/v1/tx";
+import * as _50 from "./core/client/v1/client";
+import * as _74 from "./applications/transfer/v1/query.lcd";
+import * as _75 from "./applications/transfer/v1/query.rpc.Query";
+import * as _76 from "./applications/transfer/v1/tx.rpc.msg";
+export declare namespace ibc {
+    namespace applications {
+        namespace transfer {
+            const v1: {
+                MsgClientImpl: typeof _76.MsgClientImpl;
+                QueryClientImpl: typeof _75.QueryClientImpl;
+                createRpcQueryExtension: (base: import("@cosmjs/stargate").QueryClient) => {
+                    denomTraces(request?: _47.QueryDenomTracesRequest): Promise<_47.QueryDenomTracesResponse>;
+                    denomTrace(request: _47.QueryDenomTraceRequest): Promise<_47.QueryDenomTraceResponse>;
+                    params(request?: _47.QueryParamsRequest): Promise<_47.QueryParamsResponse>;
+                    denomHash(request: _47.QueryDenomHashRequest): Promise<_47.QueryDenomHashResponse>;
+                    escrowAddress(request: _47.QueryEscrowAddressRequest): Promise<_47.QueryEscrowAddressResponse>;
+                    totalEscrowForDenom(request: _47.QueryTotalEscrowForDenomRequest): Promise<_47.QueryTotalEscrowForDenomResponse>;
+                };
+                LCDQueryClient: typeof _74.LCDQueryClient;
+                registry: ReadonlyArray<[string, import("@cosmjs/proto-signing").GeneratedType]>;
+                load: (protoRegistry: import("@cosmjs/proto-signing").Registry) => void;
+                MessageComposer: {
+                    encoded: {
+                        transfer(value: _49.MsgTransfer): {
+                            typeUrl: string;
+                            value: Uint8Array<ArrayBufferLike>;
+                        };
+                    };
+                    withTypeUrl: {
+                        transfer(value: _49.MsgTransfer): {
+                            typeUrl: string;
+                            value: _49.MsgTransfer;
+                        };
+                    };
+                    fromPartial: {
+                        transfer(value: _49.MsgTransfer): {
+                            typeUrl: string;
+                            value: _49.MsgTransfer;
+                        };
+                    };
+                };
+                AminoConverter: {
+                    "/ibc.applications.transfer.v1.MsgTransfer": {
+                        aminoType: string;
+                        toAmino: (message: _49.MsgTransfer) => _49.MsgTransferAmino;
+                        fromAmino: (object: _49.MsgTransferAmino) => _49.MsgTransfer;
+                    };
+                };
+                MsgTransfer: {
+                    typeUrl: string;
+                    encode(message: _49.MsgTransfer, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _49.MsgTransfer;
+                    fromPartial(object: Partial<_49.MsgTransfer>): _49.MsgTransfer;
+                    fromAmino(object: _49.MsgTransferAmino): _49.MsgTransfer;
+                    toAmino(message: _49.MsgTransfer): _49.MsgTransferAmino;
+                    fromAminoMsg(object: _49.MsgTransferAminoMsg): _49.MsgTransfer;
+                    toAminoMsg(message: _49.MsgTransfer): _49.MsgTransferAminoMsg;
+                    fromProtoMsg(message: _49.MsgTransferProtoMsg): _49.MsgTransfer;
+                    toProto(message: _49.MsgTransfer): Uint8Array;
+                    toProtoMsg(message: _49.MsgTransfer): _49.MsgTransferProtoMsg;
+                };
+                MsgTransferResponse: {
+                    typeUrl: string;
+                    encode(message: _49.MsgTransferResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _49.MsgTransferResponse;
+                    fromPartial(object: Partial<_49.MsgTransferResponse>): _49.MsgTransferResponse;
+                    fromAmino(object: _49.MsgTransferResponseAmino): _49.MsgTransferResponse;
+                    toAmino(message: _49.MsgTransferResponse): _49.MsgTransferResponseAmino;
+                    fromAminoMsg(object: _49.MsgTransferResponseAminoMsg): _49.MsgTransferResponse;
+                    toAminoMsg(message: _49.MsgTransferResponse): _49.MsgTransferResponseAminoMsg;
+                    fromProtoMsg(message: _49.MsgTransferResponseProtoMsg): _49.MsgTransferResponse;
+                    toProto(message: _49.MsgTransferResponse): Uint8Array;
+                    toProtoMsg(message: _49.MsgTransferResponse): _49.MsgTransferResponseProtoMsg;
+                };
+                DenomTrace: {
+                    typeUrl: string;
+                    encode(message: _48.DenomTrace, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _48.DenomTrace;
+                    fromPartial(object: Partial<_48.DenomTrace>): _48.DenomTrace;
+                    fromAmino(object: _48.DenomTraceAmino): _48.DenomTrace;
+                    toAmino(message: _48.DenomTrace): _48.DenomTraceAmino;
+                    fromAminoMsg(object: _48.DenomTraceAminoMsg): _48.DenomTrace;
+                    toAminoMsg(message: _48.DenomTrace): _48.DenomTraceAminoMsg;
+                    fromProtoMsg(message: _48.DenomTraceProtoMsg): _48.DenomTrace;
+                    toProto(message: _48.DenomTrace): Uint8Array;
+                    toProtoMsg(message: _48.DenomTrace): _48.DenomTraceProtoMsg;
+                };
+                Params: {
+                    typeUrl: string;
+                    encode(message: _48.Params, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _48.Params;
+                    fromPartial(object: Partial<_48.Params>): _48.Params;
+                    fromAmino(object: _48.ParamsAmino): _48.Params;
+                    toAmino(message: _48.Params): _48.ParamsAmino;
+                    fromAminoMsg(object: _48.ParamsAminoMsg): _48.Params;
+                    toAminoMsg(message: _48.Params): _48.ParamsAminoMsg;
+                    fromProtoMsg(message: _48.ParamsProtoMsg): _48.Params;
+                    toProto(message: _48.Params): Uint8Array;
+                    toProtoMsg(message: _48.Params): _48.ParamsProtoMsg;
+                };
+                QueryDenomTraceRequest: {
+                    typeUrl: string;
+                    encode(message: _47.QueryDenomTraceRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _47.QueryDenomTraceRequest;
+                    fromPartial(object: Partial<_47.QueryDenomTraceRequest>): _47.QueryDenomTraceRequest;
+                    fromAmino(object: _47.QueryDenomTraceRequestAmino): _47.QueryDenomTraceRequest;
+                    toAmino(message: _47.QueryDenomTraceRequest): _47.QueryDenomTraceRequestAmino;
+                    fromAminoMsg(object: _47.QueryDenomTraceRequestAminoMsg): _47.QueryDenomTraceRequest;
+                    toAminoMsg(message: _47.QueryDenomTraceRequest): _47.QueryDenomTraceRequestAminoMsg;
+                    fromProtoMsg(message: _47.QueryDenomTraceRequestProtoMsg): _47.QueryDenomTraceRequest;
+                    toProto(message: _47.QueryDenomTraceRequest): Uint8Array;
+                    toProtoMsg(message: _47.QueryDenomTraceRequest): _47.QueryDenomTraceRequestProtoMsg;
+                };
+                QueryDenomTraceResponse: {
+                    typeUrl: string;
+                    encode(message: _47.QueryDenomTraceResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _47.QueryDenomTraceResponse;
+                    fromPartial(object: Partial<_47.QueryDenomTraceResponse>): _47.QueryDenomTraceResponse;
+                    fromAmino(object: _47.QueryDenomTraceResponseAmino): _47.QueryDenomTraceResponse;
+                    toAmino(message: _47.QueryDenomTraceResponse): _47.QueryDenomTraceResponseAmino;
+                    fromAminoMsg(object: _47.QueryDenomTraceResponseAminoMsg): _47.QueryDenomTraceResponse;
+                    toAminoMsg(message: _47.QueryDenomTraceResponse): _47.QueryDenomTraceResponseAminoMsg;
+                    fromProtoMsg(message: _47.QueryDenomTraceResponseProtoMsg): _47.QueryDenomTraceResponse;
+                    toProto(message: _47.QueryDenomTraceResponse): Uint8Array;
+                    toProtoMsg(message: _47.QueryDenomTraceResponse): _47.QueryDenomTraceResponseProtoMsg;
+                };
+                QueryDenomTracesRequest: {
+                    typeUrl: string;
+                    encode(message: _47.QueryDenomTracesRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _47.QueryDenomTracesRequest;
+                    fromPartial(object: Partial<_47.QueryDenomTracesRequest>): _47.QueryDenomTracesRequest;
+                    fromAmino(object: _47.QueryDenomTracesRequestAmino): _47.QueryDenomTracesRequest;
+                    toAmino(message: _47.QueryDenomTracesRequest): _47.QueryDenomTracesRequestAmino;
+                    fromAminoMsg(object: _47.QueryDenomTracesRequestAminoMsg): _47.QueryDenomTracesRequest;
+                    toAminoMsg(message: _47.QueryDenomTracesRequest): _47.QueryDenomTracesRequestAminoMsg;
+                    fromProtoMsg(message: _47.QueryDenomTracesRequestProtoMsg): _47.QueryDenomTracesRequest;
+                    toProto(message: _47.QueryDenomTracesRequest): Uint8Array;
+                    toProtoMsg(message: _47.QueryDenomTracesRequest): _47.QueryDenomTracesRequestProtoMsg;
+                };
+                QueryDenomTracesResponse: {
+                    typeUrl: string;
+                    encode(message: _47.QueryDenomTracesResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _47.QueryDenomTracesResponse;
+                    fromPartial(object: Partial<_47.QueryDenomTracesResponse>): _47.QueryDenomTracesResponse;
+                    fromAmino(object: _47.QueryDenomTracesResponseAmino): _47.QueryDenomTracesResponse;
+                    toAmino(message: _47.QueryDenomTracesResponse): _47.QueryDenomTracesResponseAmino;
+                    fromAminoMsg(object: _47.QueryDenomTracesResponseAminoMsg): _47.QueryDenomTracesResponse;
+                    toAminoMsg(message: _47.QueryDenomTracesResponse): _47.QueryDenomTracesResponseAminoMsg;
+                    fromProtoMsg(message: _47.QueryDenomTracesResponseProtoMsg): _47.QueryDenomTracesResponse;
+                    toProto(message: _47.QueryDenomTracesResponse): Uint8Array;
+                    toProtoMsg(message: _47.QueryDenomTracesResponse): _47.QueryDenomTracesResponseProtoMsg;
+                };
+                QueryParamsRequest: {
+                    typeUrl: string;
+                    encode(_: _47.QueryParamsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _47.QueryParamsRequest;
+                    fromPartial(_: Partial<_47.QueryParamsRequest>): _47.QueryParamsRequest;
+                    fromAmino(_: _47.QueryParamsRequestAmino): _47.QueryParamsRequest;
+                    toAmino(_: _47.QueryParamsRequest): _47.QueryParamsRequestAmino;
+                    fromAminoMsg(object: _47.QueryParamsRequestAminoMsg): _47.QueryParamsRequest;
+                    toAminoMsg(message: _47.QueryParamsRequest): _47.QueryParamsRequestAminoMsg;
+                    fromProtoMsg(message: _47.QueryParamsRequestProtoMsg): _47.QueryParamsRequest;
+                    toProto(message: _47.QueryParamsRequest): Uint8Array;
+                    toProtoMsg(message: _47.QueryParamsRequest): _47.QueryParamsRequestProtoMsg;
+                };
+                QueryParamsResponse: {
+                    typeUrl: string;
+                    encode(message: _47.QueryParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _47.QueryParamsResponse;
+                    fromPartial(object: Partial<_47.QueryParamsResponse>): _47.QueryParamsResponse;
+                    fromAmino(object: _47.QueryParamsResponseAmino): _47.QueryParamsResponse;
+                    toAmino(message: _47.QueryParamsResponse): _47.QueryParamsResponseAmino;
+                    fromAminoMsg(object: _47.QueryParamsResponseAminoMsg): _47.QueryParamsResponse;
+                    toAminoMsg(message: _47.QueryParamsResponse): _47.QueryParamsResponseAminoMsg;
+                    fromProtoMsg(message: _47.QueryParamsResponseProtoMsg): _47.QueryParamsResponse;
+                    toProto(message: _47.QueryParamsResponse): Uint8Array;
+                    toProtoMsg(message: _47.QueryParamsResponse): _47.QueryParamsResponseProtoMsg;
+                };
+                QueryDenomHashRequest: {
+                    typeUrl: string;
+                    encode(message: _47.QueryDenomHashRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _47.QueryDenomHashRequest;
+                    fromPartial(object: Partial<_47.QueryDenomHashRequest>): _47.QueryDenomHashRequest;
+                    fromAmino(object: _47.QueryDenomHashRequestAmino): _47.QueryDenomHashRequest;
+                    toAmino(message: _47.QueryDenomHashRequest): _47.QueryDenomHashRequestAmino;
+                    fromAminoMsg(object: _47.QueryDenomHashRequestAminoMsg): _47.QueryDenomHashRequest;
+                    toAminoMsg(message: _47.QueryDenomHashRequest): _47.QueryDenomHashRequestAminoMsg;
+                    fromProtoMsg(message: _47.QueryDenomHashRequestProtoMsg): _47.QueryDenomHashRequest;
+                    toProto(message: _47.QueryDenomHashRequest): Uint8Array;
+                    toProtoMsg(message: _47.QueryDenomHashRequest): _47.QueryDenomHashRequestProtoMsg;
+                };
+                QueryDenomHashResponse: {
+                    typeUrl: string;
+                    encode(message: _47.QueryDenomHashResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _47.QueryDenomHashResponse;
+                    fromPartial(object: Partial<_47.QueryDenomHashResponse>): _47.QueryDenomHashResponse;
+                    fromAmino(object: _47.QueryDenomHashResponseAmino): _47.QueryDenomHashResponse;
+                    toAmino(message: _47.QueryDenomHashResponse): _47.QueryDenomHashResponseAmino;
+                    fromAminoMsg(object: _47.QueryDenomHashResponseAminoMsg): _47.QueryDenomHashResponse;
+                    toAminoMsg(message: _47.QueryDenomHashResponse): _47.QueryDenomHashResponseAminoMsg;
+                    fromProtoMsg(message: _47.QueryDenomHashResponseProtoMsg): _47.QueryDenomHashResponse;
+                    toProto(message: _47.QueryDenomHashResponse): Uint8Array;
+                    toProtoMsg(message: _47.QueryDenomHashResponse): _47.QueryDenomHashResponseProtoMsg;
+                };
+                QueryEscrowAddressRequest: {
+                    typeUrl: string;
+                    encode(message: _47.QueryEscrowAddressRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _47.QueryEscrowAddressRequest;
+                    fromPartial(object: Partial<_47.QueryEscrowAddressRequest>): _47.QueryEscrowAddressRequest;
+                    fromAmino(object: _47.QueryEscrowAddressRequestAmino): _47.QueryEscrowAddressRequest;
+                    toAmino(message: _47.QueryEscrowAddressRequest): _47.QueryEscrowAddressRequestAmino;
+                    fromAminoMsg(object: _47.QueryEscrowAddressRequestAminoMsg): _47.QueryEscrowAddressRequest;
+                    toAminoMsg(message: _47.QueryEscrowAddressRequest): _47.QueryEscrowAddressRequestAminoMsg;
+                    fromProtoMsg(message: _47.QueryEscrowAddressRequestProtoMsg): _47.QueryEscrowAddressRequest;
+                    toProto(message: _47.QueryEscrowAddressRequest): Uint8Array;
+                    toProtoMsg(message: _47.QueryEscrowAddressRequest): _47.QueryEscrowAddressRequestProtoMsg;
+                };
+                QueryEscrowAddressResponse: {
+                    typeUrl: string;
+                    encode(message: _47.QueryEscrowAddressResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _47.QueryEscrowAddressResponse;
+                    fromPartial(object: Partial<_47.QueryEscrowAddressResponse>): _47.QueryEscrowAddressResponse;
+                    fromAmino(object: _47.QueryEscrowAddressResponseAmino): _47.QueryEscrowAddressResponse;
+                    toAmino(message: _47.QueryEscrowAddressResponse): _47.QueryEscrowAddressResponseAmino;
+                    fromAminoMsg(object: _47.QueryEscrowAddressResponseAminoMsg): _47.QueryEscrowAddressResponse;
+                    toAminoMsg(message: _47.QueryEscrowAddressResponse): _47.QueryEscrowAddressResponseAminoMsg;
+                    fromProtoMsg(message: _47.QueryEscrowAddressResponseProtoMsg): _47.QueryEscrowAddressResponse;
+                    toProto(message: _47.QueryEscrowAddressResponse): Uint8Array;
+                    toProtoMsg(message: _47.QueryEscrowAddressResponse): _47.QueryEscrowAddressResponseProtoMsg;
+                };
+                QueryTotalEscrowForDenomRequest: {
+                    typeUrl: string;
+                    encode(message: _47.QueryTotalEscrowForDenomRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _47.QueryTotalEscrowForDenomRequest;
+                    fromPartial(object: Partial<_47.QueryTotalEscrowForDenomRequest>): _47.QueryTotalEscrowForDenomRequest;
+                    fromAmino(object: _47.QueryTotalEscrowForDenomRequestAmino): _47.QueryTotalEscrowForDenomRequest;
+                    toAmino(message: _47.QueryTotalEscrowForDenomRequest): _47.QueryTotalEscrowForDenomRequestAmino;
+                    fromAminoMsg(object: _47.QueryTotalEscrowForDenomRequestAminoMsg): _47.QueryTotalEscrowForDenomRequest;
+                    toAminoMsg(message: _47.QueryTotalEscrowForDenomRequest): _47.QueryTotalEscrowForDenomRequestAminoMsg;
+                    fromProtoMsg(message: _47.QueryTotalEscrowForDenomRequestProtoMsg): _47.QueryTotalEscrowForDenomRequest;
+                    toProto(message: _47.QueryTotalEscrowForDenomRequest): Uint8Array;
+                    toProtoMsg(message: _47.QueryTotalEscrowForDenomRequest): _47.QueryTotalEscrowForDenomRequestProtoMsg;
+                };
+                QueryTotalEscrowForDenomResponse: {
+                    typeUrl: string;
+                    encode(message: _47.QueryTotalEscrowForDenomResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _47.QueryTotalEscrowForDenomResponse;
+                    fromPartial(object: Partial<_47.QueryTotalEscrowForDenomResponse>): _47.QueryTotalEscrowForDenomResponse;
+                    fromAmino(object: _47.QueryTotalEscrowForDenomResponseAmino): _47.QueryTotalEscrowForDenomResponse;
+                    toAmino(message: _47.QueryTotalEscrowForDenomResponse): _47.QueryTotalEscrowForDenomResponseAmino;
+                    fromAminoMsg(object: _47.QueryTotalEscrowForDenomResponseAminoMsg): _47.QueryTotalEscrowForDenomResponse;
+                    toAminoMsg(message: _47.QueryTotalEscrowForDenomResponse): _47.QueryTotalEscrowForDenomResponseAminoMsg;
+                    fromProtoMsg(message: _47.QueryTotalEscrowForDenomResponseProtoMsg): _47.QueryTotalEscrowForDenomResponse;
+                    toProto(message: _47.QueryTotalEscrowForDenomResponse): Uint8Array;
+                    toProtoMsg(message: _47.QueryTotalEscrowForDenomResponse): _47.QueryTotalEscrowForDenomResponseProtoMsg;
+                };
+            };
+        }
+    }
+    namespace core {
+        namespace client {
+            const v1: {
+                IdentifiedClientState: {
+                    typeUrl: string;
+                    encode(message: _50.IdentifiedClientState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _50.IdentifiedClientState;
+                    fromPartial(object: Partial<_50.IdentifiedClientState>): _50.IdentifiedClientState;
+                    fromAmino(object: _50.IdentifiedClientStateAmino): _50.IdentifiedClientState;
+                    toAmino(message: _50.IdentifiedClientState): _50.IdentifiedClientStateAmino;
+                    fromAminoMsg(object: _50.IdentifiedClientStateAminoMsg): _50.IdentifiedClientState;
+                    toAminoMsg(message: _50.IdentifiedClientState): _50.IdentifiedClientStateAminoMsg;
+                    fromProtoMsg(message: _50.IdentifiedClientStateProtoMsg): _50.IdentifiedClientState;
+                    toProto(message: _50.IdentifiedClientState): Uint8Array;
+                    toProtoMsg(message: _50.IdentifiedClientState): _50.IdentifiedClientStateProtoMsg;
+                };
+                ConsensusStateWithHeight: {
+                    typeUrl: string;
+                    encode(message: _50.ConsensusStateWithHeight, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _50.ConsensusStateWithHeight;
+                    fromPartial(object: Partial<_50.ConsensusStateWithHeight>): _50.ConsensusStateWithHeight;
+                    fromAmino(object: _50.ConsensusStateWithHeightAmino): _50.ConsensusStateWithHeight;
+                    toAmino(message: _50.ConsensusStateWithHeight): _50.ConsensusStateWithHeightAmino;
+                    fromAminoMsg(object: _50.ConsensusStateWithHeightAminoMsg): _50.ConsensusStateWithHeight;
+                    toAminoMsg(message: _50.ConsensusStateWithHeight): _50.ConsensusStateWithHeightAminoMsg;
+                    fromProtoMsg(message: _50.ConsensusStateWithHeightProtoMsg): _50.ConsensusStateWithHeight;
+                    toProto(message: _50.ConsensusStateWithHeight): Uint8Array;
+                    toProtoMsg(message: _50.ConsensusStateWithHeight): _50.ConsensusStateWithHeightProtoMsg;
+                };
+                ClientConsensusStates: {
+                    typeUrl: string;
+                    encode(message: _50.ClientConsensusStates, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _50.ClientConsensusStates;
+                    fromPartial(object: Partial<_50.ClientConsensusStates>): _50.ClientConsensusStates;
+                    fromAmino(object: _50.ClientConsensusStatesAmino): _50.ClientConsensusStates;
+                    toAmino(message: _50.ClientConsensusStates): _50.ClientConsensusStatesAmino;
+                    fromAminoMsg(object: _50.ClientConsensusStatesAminoMsg): _50.ClientConsensusStates;
+                    toAminoMsg(message: _50.ClientConsensusStates): _50.ClientConsensusStatesAminoMsg;
+                    fromProtoMsg(message: _50.ClientConsensusStatesProtoMsg): _50.ClientConsensusStates;
+                    toProto(message: _50.ClientConsensusStates): Uint8Array;
+                    toProtoMsg(message: _50.ClientConsensusStates): _50.ClientConsensusStatesProtoMsg;
+                };
+                ClientUpdateProposal: {
+                    typeUrl: string;
+                    encode(message: _50.ClientUpdateProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _50.ClientUpdateProposal;
+                    fromPartial(object: Partial<_50.ClientUpdateProposal>): _50.ClientUpdateProposal;
+                    fromAmino(object: _50.ClientUpdateProposalAmino): _50.ClientUpdateProposal;
+                    toAmino(message: _50.ClientUpdateProposal): _50.ClientUpdateProposalAmino;
+                    fromAminoMsg(object: _50.ClientUpdateProposalAminoMsg): _50.ClientUpdateProposal;
+                    toAminoMsg(message: _50.ClientUpdateProposal): _50.ClientUpdateProposalAminoMsg;
+                    fromProtoMsg(message: _50.ClientUpdateProposalProtoMsg): _50.ClientUpdateProposal;
+                    toProto(message: _50.ClientUpdateProposal): Uint8Array;
+                    toProtoMsg(message: _50.ClientUpdateProposal): _50.ClientUpdateProposalProtoMsg;
+                };
+                UpgradeProposal: {
+                    typeUrl: string;
+                    encode(message: _50.UpgradeProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _50.UpgradeProposal;
+                    fromPartial(object: Partial<_50.UpgradeProposal>): _50.UpgradeProposal;
+                    fromAmino(object: _50.UpgradeProposalAmino): _50.UpgradeProposal;
+                    toAmino(message: _50.UpgradeProposal): _50.UpgradeProposalAmino;
+                    fromAminoMsg(object: _50.UpgradeProposalAminoMsg): _50.UpgradeProposal;
+                    toAminoMsg(message: _50.UpgradeProposal): _50.UpgradeProposalAminoMsg;
+                    fromProtoMsg(message: _50.UpgradeProposalProtoMsg): _50.UpgradeProposal;
+                    toProto(message: _50.UpgradeProposal): Uint8Array;
+                    toProtoMsg(message: _50.UpgradeProposal): _50.UpgradeProposalProtoMsg;
+                };
+                Height: {
+                    typeUrl: string;
+                    encode(message: _50.Height, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _50.Height;
+                    fromPartial(object: Partial<_50.Height>): _50.Height;
+                    fromAmino(object: _50.HeightAmino): _50.Height;
+                    toAmino(message: _50.Height): _50.HeightAmino;
+                    fromAminoMsg(object: _50.HeightAminoMsg): _50.Height;
+                    toAminoMsg(message: _50.Height): _50.HeightAminoMsg;
+                    fromProtoMsg(message: _50.HeightProtoMsg): _50.Height;
+                    toProto(message: _50.Height): Uint8Array;
+                    toProtoMsg(message: _50.Height): _50.HeightProtoMsg;
+                };
+                Params: {
+                    typeUrl: string;
+                    encode(message: _50.Params, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _50.Params;
+                    fromPartial(object: Partial<_50.Params>): _50.Params;
+                    fromAmino(object: _50.ParamsAmino): _50.Params;
+                    toAmino(message: _50.Params): _50.ParamsAmino;
+                    fromAminoMsg(object: _50.ParamsAminoMsg): _50.Params;
+                    toAminoMsg(message: _50.Params): _50.ParamsAminoMsg;
+                    fromProtoMsg(message: _50.ParamsProtoMsg): _50.Params;
+                    toProto(message: _50.Params): Uint8Array;
+                    toProtoMsg(message: _50.Params): _50.ParamsProtoMsg;
+                };
+            };
+        }
+    }
+    const ClientFactory: {
+        createRPCMsgClient: ({ rpc }: {
+            rpc: import("../helpers").Rpc;
+        }) => Promise<{
+            cosmos: {
+                group: {
+                    v1: import("../cosmos/group/v1/tx.rpc.msg").MsgClientImpl;
+                };
+            };
+            ibc: {
+                applications: {
+                    transfer: {
+                        v1: _76.MsgClientImpl;
+                    };
+                };
+            };
+        }>;
+        createRPCQueryClient: ({ rpcEndpoint }: {
+            rpcEndpoint: string | import("@cosmjs/tendermint-rpc").HttpEndpoint;
+        }) => Promise<{
+            cosmos: {
+                bank: {
+                    v1beta1: {
+                        balance(request: import("../cosmos/bank/v1beta1/query").QueryBalanceRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryBalanceResponse>;
+                        allBalances(request: import("../cosmos/bank/v1beta1/query").QueryAllBalancesRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryAllBalancesResponse>;
+                        spendableBalances(request: import("../cosmos/bank/v1beta1/query").QuerySpendableBalancesRequest): Promise<import("../cosmos/bank/v1beta1/query").QuerySpendableBalancesResponse>;
+                        spendableBalanceByDenom(request: import("../cosmos/bank/v1beta1/query").QuerySpendableBalanceByDenomRequest): Promise<import("../cosmos/bank/v1beta1/query").QuerySpendableBalanceByDenomResponse>;
+                        totalSupply(request?: import("../cosmos/bank/v1beta1/query").QueryTotalSupplyRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryTotalSupplyResponse>;
+                        supplyOf(request: import("../cosmos/bank/v1beta1/query").QuerySupplyOfRequest): Promise<import("../cosmos/bank/v1beta1/query").QuerySupplyOfResponse>;
+                        params(request?: import("../cosmos/bank/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryParamsResponse>;
+                        denomMetadata(request: import("../cosmos/bank/v1beta1/query").QueryDenomMetadataRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryDenomMetadataResponse>;
+                        denomsMetadata(request?: import("../cosmos/bank/v1beta1/query").QueryDenomsMetadataRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryDenomsMetadataResponse>;
+                        denomOwners(request: import("../cosmos/bank/v1beta1/query").QueryDenomOwnersRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryDenomOwnersResponse>;
+                        sendEnabled(request: import("../cosmos/bank/v1beta1/query").QuerySendEnabledRequest): Promise<import("../cosmos/bank/v1beta1/query").QuerySendEnabledResponse>;
+                    };
+                };
+                feegrant: {
+                    v1beta1: {
+                        allowance(request: import("../cosmos/feegrant/v1beta1/query").QueryAllowanceRequest): Promise<import("../cosmos/feegrant/v1beta1/query").QueryAllowanceResponse>;
+                        allowances(request: import("../cosmos/feegrant/v1beta1/query").QueryAllowancesRequest): Promise<import("../cosmos/feegrant/v1beta1/query").QueryAllowancesResponse>;
+                        allowancesByGranter(request: import("../cosmos/feegrant/v1beta1/query").QueryAllowancesByGranterRequest): Promise<import("../cosmos/feegrant/v1beta1/query").QueryAllowancesByGranterResponse>;
+                    };
+                };
+                gov: {
+                    v1beta1: {
+                        proposal(request: import("../cosmos/gov/v1beta1/query").QueryProposalRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryProposalResponse>;
+                        proposals(request: import("../cosmos/gov/v1beta1/query").QueryProposalsRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryProposalsResponse>;
+                        vote(request: import("../cosmos/gov/v1beta1/query").QueryVoteRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryVoteResponse>;
+                        votes(request: import("../cosmos/gov/v1beta1/query").QueryVotesRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryVotesResponse>;
+                        params(request: import("../cosmos/gov/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryParamsResponse>;
+                        deposit(request: import("../cosmos/gov/v1beta1/query").QueryDepositRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryDepositResponse>;
+                        deposits(request: import("../cosmos/gov/v1beta1/query").QueryDepositsRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryDepositsResponse>;
+                        tallyResult(request: import("../cosmos/gov/v1beta1/query").QueryTallyResultRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryTallyResultResponse>;
+                    };
+                };
+                group: {
+                    v1: {
+                        groupInfo(request: import("../cosmos/group/v1/query").QueryGroupInfoRequest): Promise<import("../cosmos/group/v1/query").QueryGroupInfoResponse>;
+                        groupPolicyInfo(request: import("../cosmos/group/v1/query").QueryGroupPolicyInfoRequest): Promise<import("../cosmos/group/v1/query").QueryGroupPolicyInfoResponse>;
+                        groupMembers(request: import("../cosmos/group/v1/query").QueryGroupMembersRequest): Promise<import("../cosmos/group/v1/query").QueryGroupMembersResponse>;
+                        groupsByAdmin(request: import("../cosmos/group/v1/query").QueryGroupsByAdminRequest): Promise<import("../cosmos/group/v1/query").QueryGroupsByAdminResponse>;
+                        groupPoliciesByGroup(request: import("../cosmos/group/v1/query").QueryGroupPoliciesByGroupRequest): Promise<import("../cosmos/group/v1/query").QueryGroupPoliciesByGroupResponse>;
+                        groupPoliciesByAdmin(request: import("../cosmos/group/v1/query").QueryGroupPoliciesByAdminRequest): Promise<import("../cosmos/group/v1/query").QueryGroupPoliciesByAdminResponse>;
+                        proposal(request: import("../cosmos/group/v1/query").QueryProposalRequest): Promise<import("../cosmos/group/v1/query").QueryProposalResponse>;
+                        proposalsByGroupPolicy(request: import("../cosmos/group/v1/query").QueryProposalsByGroupPolicyRequest): Promise<import("../cosmos/group/v1/query").QueryProposalsByGroupPolicyResponse>;
+                        voteByProposalVoter(request: import("../cosmos/group/v1/query").QueryVoteByProposalVoterRequest): Promise<import("../cosmos/group/v1/query").QueryVoteByProposalVoterResponse>;
+                        votesByProposal(request: import("../cosmos/group/v1/query").QueryVotesByProposalRequest): Promise<import("../cosmos/group/v1/query").QueryVotesByProposalResponse>;
+                        votesByVoter(request: import("../cosmos/group/v1/query").QueryVotesByVoterRequest): Promise<import("../cosmos/group/v1/query").QueryVotesByVoterResponse>;
+                        groupsByMember(request: import("../cosmos/group/v1/query").QueryGroupsByMemberRequest): Promise<import("../cosmos/group/v1/query").QueryGroupsByMemberResponse>;
+                        tallyResult(request: import("../cosmos/group/v1/query").QueryTallyResultRequest): Promise<import("../cosmos/group/v1/query").QueryTallyResultResponse>;
+                        groups(request?: import("../cosmos/group/v1/query").QueryGroupsRequest): Promise<import("../cosmos/group/v1/query").QueryGroupsResponse>;
+                    };
+                };
+            };
+            ibc: {
+                applications: {
+                    transfer: {
+                        v1: {
+                            denomTraces(request?: _47.QueryDenomTracesRequest): Promise<_47.QueryDenomTracesResponse>;
+                            denomTrace(request: _47.QueryDenomTraceRequest): Promise<_47.QueryDenomTraceResponse>;
+                            params(request?: _47.QueryParamsRequest): Promise<_47.QueryParamsResponse>;
+                            denomHash(request: _47.QueryDenomHashRequest): Promise<_47.QueryDenomHashResponse>;
+                            escrowAddress(request: _47.QueryEscrowAddressRequest): Promise<_47.QueryEscrowAddressResponse>;
+                            totalEscrowForDenom(request: _47.QueryTotalEscrowForDenomRequest): Promise<_47.QueryTotalEscrowForDenomResponse>;
+                        };
+                    };
+                };
+            };
+        }>;
+    };
+}

package/dist/ibc/bundle.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ibc = void 0;
+//@ts-nocheck
+const _47 = __importStar(require("./applications/transfer/v1/query"));
+const _48 = __importStar(require("./applications/transfer/v1/transfer"));
+const _49 = __importStar(require("./applications/transfer/v1/tx"));
+const _50 = __importStar(require("./core/client/v1/client"));
+const _72 = __importStar(require("./applications/transfer/v1/tx.amino"));
+const _73 = __importStar(require("./applications/transfer/v1/tx.registry"));
+const _74 = __importStar(require("./applications/transfer/v1/query.lcd"));
+const _75 = __importStar(require("./applications/transfer/v1/query.rpc.Query"));
+const _76 = __importStar(require("./applications/transfer/v1/tx.rpc.msg"));
+const _82 = __importStar(require("./rpc.query"));
+const _83 = __importStar(require("./rpc.tx"));
+var ibc;
+(function (ibc) {
+    let applications;
+    (function (applications) {
+        let transfer;
+        (function (transfer) {
+            transfer.v1 = {
+                ..._47,
+                ..._48,
+                ..._49,
+                ..._72,
+                ..._73,
+                ..._74,
+                ..._75,
+                ..._76
+            };
+        })(transfer = applications.transfer || (applications.transfer = {}));
+    })(applications = ibc.applications || (ibc.applications = {}));
+    let core;
+    (function (core) {
+        let client;
+        (function (client) {
+            client.v1 = {
+                ..._50
+            };
+        })(client = core.client || (core.client = {}));
+    })(core = ibc.core || (ibc.core = {}));
+    ibc.ClientFactory = {
+        ..._82,
+        ..._83
+    };
+})(ibc || (exports.ibc = ibc = {}));

package/dist/ibc/client.d.ts

@@ -0,0 +1,22 @@
+import { GeneratedType, Registry, OfflineSigner } from "@cosmjs/proto-signing";
+import { AminoTypes, SigningStargateClient } from "@cosmjs/stargate";
+import { HttpEndpoint } from "@cosmjs/tendermint-rpc";
+export declare const ibcAminoConverters: {
+    "/ibc.applications.transfer.v1.MsgTransfer": {
+        aminoType: string;
+        toAmino: (message: import("./applications/transfer/v1/tx").MsgTransfer) => import("./applications/transfer/v1/tx").MsgTransferAmino;
+        fromAmino: (object: import("./applications/transfer/v1/tx").MsgTransferAmino) => import("./applications/transfer/v1/tx").MsgTransfer;
+    };
+};
+export declare const ibcProtoRegistry: ReadonlyArray<[string, GeneratedType]>;
+export declare const getSigningIbcClientOptions: ({ defaultTypes }?: {
+    defaultTypes?: ReadonlyArray<[string, GeneratedType]>;
+}) => {
+    registry: Registry;
+    aminoTypes: AminoTypes;
+};
+export declare const getSigningIbcClient: ({ rpcEndpoint, signer, defaultTypes }: {
+    rpcEndpoint: string | HttpEndpoint;
+    signer: OfflineSigner;
+    defaultTypes?: ReadonlyArray<[string, GeneratedType]>;
+}) => Promise<SigningStargateClient>;

package/dist/ibc/client.js

@@ -0,0 +1,67 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSigningIbcClient = exports.getSigningIbcClientOptions = exports.ibcProtoRegistry = exports.ibcAminoConverters = void 0;
+//@ts-nocheck
+const proto_signing_1 = require("@cosmjs/proto-signing");
+const stargate_1 = require("@cosmjs/stargate");
+const ibcApplicationsTransferV1TxRegistry = __importStar(require("./applications/transfer/v1/tx.registry"));
+const ibcApplicationsTransferV1TxAmino = __importStar(require("./applications/transfer/v1/tx.amino"));
+exports.ibcAminoConverters = {
+    ...ibcApplicationsTransferV1TxAmino.AminoConverter
+};
+exports.ibcProtoRegistry = [...ibcApplicationsTransferV1TxRegistry.registry];
+const getSigningIbcClientOptions = ({ defaultTypes = stargate_1.defaultRegistryTypes } = {}) => {
+    const registry = new proto_signing_1.Registry([...defaultTypes, ...exports.ibcProtoRegistry]);
+    const aminoTypes = new stargate_1.AminoTypes({
+        ...exports.ibcAminoConverters
+    });
+    return {
+        registry,
+        aminoTypes
+    };
+};
+exports.getSigningIbcClientOptions = getSigningIbcClientOptions;
+const getSigningIbcClient = async ({ rpcEndpoint, signer, defaultTypes = stargate_1.defaultRegistryTypes }) => {
+    const { registry, aminoTypes } = (0, exports.getSigningIbcClientOptions)({
+        defaultTypes
+    });
+    const client = await stargate_1.SigningStargateClient.connectWithSigner(rpcEndpoint, signer, {
+        registry: registry,
+        aminoTypes
+    });
+    return client;
+};
+exports.getSigningIbcClient = getSigningIbcClient;