@xpla/xplajs 1.7.0 → 1.8.0-rc.0

package/ibc/lightclients/wasm/v1/wasm.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Checksums = exports.ClientMessage = exports.ConsensusState = exports.ClientState = void 0;
 const client_1 = require("../../../core/client/v1/client");
 const binary_1 = require("../../../../binary");
+const registry_1 = require("../../../../registry");
 const helpers_1 = require("../../../../helpers");
 function createBaseClientState() {
     return {
@@ -11,6 +12,12 @@ function createBaseClientState() {
         latestHeight: client_1.Height.fromPartial({})
     };
 }
+/**
+ * Wasm light client's Client state
+ * @name ClientState
+ * @package ibc.lightclients.wasm.v1
+ * @see proto type: ibc.lightclients.wasm.v1.ClientState
+ */
 exports.ClientState = {
     typeUrl: "/ibc.lightclients.wasm.v1.ClientState",
     aminoType: "cosmos-sdk/ClientState",
@@ -104,6 +111,9 @@ exports.ClientState = {
         };
     },
     registerTypeUrl() {
+        if (!registry_1.GlobalDecoderRegistry.registerExistingTypeUrl(exports.ClientState.typeUrl)) {
+            return;
+        }
         client_1.Height.registerTypeUrl();
     }
 };
@@ -112,6 +122,12 @@ function createBaseConsensusState() {
         data: new Uint8Array()
     };
 }
+/**
+ * Wasm light client's ConsensusState
+ * @name ConsensusState
+ * @package ibc.lightclients.wasm.v1
+ * @see proto type: ibc.lightclients.wasm.v1.ConsensusState
+ */
 exports.ConsensusState = {
     typeUrl: "/ibc.lightclients.wasm.v1.ConsensusState",
     aminoType: "cosmos-sdk/ConsensusState",
@@ -189,6 +205,12 @@ function createBaseClientMessage() {
         data: new Uint8Array()
     };
 }
+/**
+ * Wasm light client message (either header(s) or misbehaviour)
+ * @name ClientMessage
+ * @package ibc.lightclients.wasm.v1
+ * @see proto type: ibc.lightclients.wasm.v1.ClientMessage
+ */
 exports.ClientMessage = {
     typeUrl: "/ibc.lightclients.wasm.v1.ClientMessage",
     aminoType: "cosmos-sdk/ClientMessage",
@@ -266,6 +288,16 @@ function createBaseChecksums() {
         checksums: []
     };
 }
+/**
+ * Checksums defines a list of all checksums that are stored
+ *
+ * Deprecated: This message is deprecated in favor of storing the checksums
+ * using a Collections.KeySet.
+ * @name Checksums
+ * @package ibc.lightclients.wasm.v1
+ * @see proto type: ibc.lightclients.wasm.v1.Checksums
+ * @deprecated
+ */
 exports.Checksums = {
     typeUrl: "/ibc.lightclients.wasm.v1.Checksums",
     aminoType: "cosmos-sdk/Checksums",

package/ibc/rpc.query.d.ts

@@ -0,0 +1,310 @@
+import { HttpEndpoint } from "@cosmjs/tendermint-rpc";
+export declare const createRPCQueryClient: ({ rpcEndpoint }: {
+    rpcEndpoint: string | HttpEndpoint;
+}) => Promise<{
+    cosmos: {
+        app: {
+            v1alpha1: {
+                config(request?: import("..").QueryConfigRequest): Promise<import("..").QueryConfigResponse>;
+            };
+        };
+        auth: {
+            v1beta1: {
+                accounts(request?: import("..").QueryAccountsRequest): Promise<import("..").QueryAccountsResponse>;
+                account(request: import("..").QueryAccountRequest): Promise<import("..").QueryAccountResponse>;
+                accountAddressByID(request: import("..").QueryAccountAddressByIDRequest): Promise<import("..").QueryAccountAddressByIDResponse>;
+                params(request?: import("..").QueryParamsRequest): Promise<import("..").QueryParamsResponse>;
+                moduleAccounts(request?: import("..").QueryModuleAccountsRequest): Promise<import("..").QueryModuleAccountsResponse>;
+                moduleAccountByName(request: import("..").QueryModuleAccountByNameRequest): Promise<import("..").QueryModuleAccountByNameResponse>;
+                bech32Prefix(request?: import("..").Bech32PrefixRequest): Promise<import("..").Bech32PrefixResponse>;
+                addressBytesToString(request: import("..").AddressBytesToStringRequest): Promise<import("..").AddressBytesToStringResponse>;
+                addressStringToBytes(request: import("..").AddressStringToBytesRequest): Promise<import("..").AddressStringToBytesResponse>;
+                accountInfo(request: import("..").QueryAccountInfoRequest): Promise<import("..").QueryAccountInfoResponse>;
+            };
+        };
+        authz: {
+            v1beta1: {
+                grants(request: import("..").QueryGrantsRequest): Promise<import("..").QueryGrantsResponse>;
+                granterGrants(request: import("..").QueryGranterGrantsRequest): Promise<import("..").QueryGranterGrantsResponse>;
+                granteeGrants(request: import("..").QueryGranteeGrantsRequest): Promise<import("..").QueryGranteeGrantsResponse>;
+            };
+        };
+        autocli: {
+            v1: {
+                appOptions(request?: import("..").AppOptionsRequest): Promise<import("..").AppOptionsResponse>;
+            };
+        };
+        bank: {
+            v1beta1: {
+                balance(request: import("..").QueryBalanceRequest): Promise<import("..").QueryBalanceResponse>;
+                allBalances(request: import("..").QueryAllBalancesRequest): Promise<import("..").QueryAllBalancesResponse>;
+                spendableBalances(request: import("..").QuerySpendableBalancesRequest): Promise<import("..").QuerySpendableBalancesResponse>;
+                spendableBalanceByDenom(request: import("..").QuerySpendableBalanceByDenomRequest): Promise<import("..").QuerySpendableBalanceByDenomResponse>;
+                totalSupply(request?: import("..").QueryTotalSupplyRequest): Promise<import("..").QueryTotalSupplyResponse>;
+                supplyOf(request: import("..").QuerySupplyOfRequest): Promise<import("..").QuerySupplyOfResponse>;
+                params(request?: import("..").CosmosBankV1beta1QueryParamsRequest): Promise<import("..").CosmosBankV1beta1QueryParamsResponse>;
+                denomMetadata(request: import("..").QueryDenomMetadataRequest): Promise<import("..").QueryDenomMetadataResponse>;
+                denomMetadataByQueryString(request: import("..").QueryDenomMetadataByQueryStringRequest): Promise<import("..").QueryDenomMetadataByQueryStringResponse>;
+                denomsMetadata(request?: import("..").QueryDenomsMetadataRequest): Promise<import("..").QueryDenomsMetadataResponse>;
+                denomOwners(request: import("..").QueryDenomOwnersRequest): Promise<import("..").QueryDenomOwnersResponse>;
+                denomOwnersByQuery(request: import("..").QueryDenomOwnersByQueryRequest): Promise<import("..").QueryDenomOwnersByQueryResponse>;
+                sendEnabled(request: import("..").QuerySendEnabledRequest): Promise<import("..").QuerySendEnabledResponse>;
+            };
+        };
+        base: {
+            node: {
+                v1beta1: {
+                    config(request?: import("..").ConfigRequest): Promise<import("..").ConfigResponse>;
+                    status(request?: import("..").StatusRequest): Promise<import("..").StatusResponse>;
+                };
+            };
+            tendermint: {
+                v1beta1: {
+                    getNodeInfo(request?: import("..").GetNodeInfoRequest): Promise<import("..").GetNodeInfoResponse>;
+                    getSyncing(request?: import("..").GetSyncingRequest): Promise<import("..").GetSyncingResponse>;
+                    getLatestBlock(request?: import("..").GetLatestBlockRequest): Promise<import("..").GetLatestBlockResponse>;
+                    getBlockByHeight(request: import("..").GetBlockByHeightRequest): Promise<import("..").GetBlockByHeightResponse>;
+                    getLatestValidatorSet(request?: import("..").GetLatestValidatorSetRequest): Promise<import("..").GetLatestValidatorSetResponse>;
+                    getValidatorSetByHeight(request: import("..").GetValidatorSetByHeightRequest): Promise<import("..").GetValidatorSetByHeightResponse>;
+                    aBCIQuery(request: import("..").ABCIQueryRequest): Promise<import("..").ABCIQueryResponse>;
+                };
+            };
+        };
+        consensus: {
+            v1: {
+                params(request?: import("..").CosmosConsensusV1QueryParamsRequest): Promise<import("..").CosmosConsensusV1QueryParamsResponse>;
+            };
+        };
+        distribution: {
+            v1beta1: {
+                params(request?: import("..").CosmosDistributionV1beta1QueryParamsRequest): Promise<import("..").CosmosDistributionV1beta1QueryParamsResponse>;
+                validatorDistributionInfo(request: import("..").QueryValidatorDistributionInfoRequest): Promise<import("..").QueryValidatorDistributionInfoResponse>;
+                validatorOutstandingRewards(request: import("..").QueryValidatorOutstandingRewardsRequest): Promise<import("..").QueryValidatorOutstandingRewardsResponse>;
+                validatorCommission(request: import("..").QueryValidatorCommissionRequest): Promise<import("..").QueryValidatorCommissionResponse>;
+                validatorSlashes(request: import("..").QueryValidatorSlashesRequest): Promise<import("..").QueryValidatorSlashesResponse>;
+                delegationRewards(request: import("..").QueryDelegationRewardsRequest): Promise<import("..").QueryDelegationRewardsResponse>;
+                delegationTotalRewards(request: import("..").QueryDelegationTotalRewardsRequest): Promise<import("..").QueryDelegationTotalRewardsResponse>;
+                delegatorValidators(request: import("..").QueryDelegatorValidatorsRequest): Promise<import("..").QueryDelegatorValidatorsResponse>;
+                delegatorWithdrawAddress(request: import("..").QueryDelegatorWithdrawAddressRequest): Promise<import("..").QueryDelegatorWithdrawAddressResponse>;
+                communityPool(request?: import("..").QueryCommunityPoolRequest): Promise<import("..").QueryCommunityPoolResponse>;
+            };
+        };
+        evidence: {
+            v1beta1: {
+                evidence(request: import("..").QueryEvidenceRequest): Promise<import("..").QueryEvidenceResponse>;
+                allEvidence(request?: import("..").QueryAllEvidenceRequest): Promise<import("..").QueryAllEvidenceResponse>;
+            };
+        };
+        evm: {
+            feemarket: {
+                v1: {
+                    params(request?: import("..").CosmosEvmFeemarketV1QueryParamsRequest): Promise<import("..").CosmosEvmFeemarketV1QueryParamsResponse>;
+                    baseFee(request?: import("..").QueryBaseFeeRequest): Promise<import("..").QueryBaseFeeResponse>;
+                    blockGas(request?: import("..").QueryBlockGasRequest): Promise<import("..").QueryBlockGasResponse>;
+                };
+            };
+            vm: {
+                v1: {
+                    account(request: import("..").CosmosEvmVmV1QueryAccountRequest): Promise<import("..").CosmosEvmVmV1QueryAccountResponse>;
+                    cosmosAccount(request: import("..").QueryCosmosAccountRequest): Promise<import("..").QueryCosmosAccountResponse>;
+                    validatorAccount(request: import("..").QueryValidatorAccountRequest): Promise<import("..").QueryValidatorAccountResponse>;
+                    balance(request: import("..").CosmosEvmVmV1QueryBalanceRequest): Promise<import("..").CosmosEvmVmV1QueryBalanceResponse>;
+                    storage(request: import("..").QueryStorageRequest): Promise<import("..").QueryStorageResponse>;
+                    code(request: import("..").QueryCodeRequest): Promise<import("..").QueryCodeResponse>;
+                    params(request?: import("..").CosmosEvmVmV1QueryParamsRequest): Promise<import("..").CosmosEvmVmV1QueryParamsResponse>;
+                    ethCall(request: import("..").EthCallRequest): Promise<import("..").MsgEthereumTxResponse>;
+                    estimateGas(request: import("..").EthCallRequest): Promise<import("..").EstimateGasResponse>;
+                    traceTx(request: import("..").QueryTraceTxRequest): Promise<import("..").QueryTraceTxResponse>;
+                    traceBlock(request: import("..").QueryTraceBlockRequest): Promise<import("..").QueryTraceBlockResponse>;
+                    baseFee(request?: import("..").CosmosEvmVmV1QueryBaseFeeRequest): Promise<import("..").CosmosEvmVmV1QueryBaseFeeResponse>;
+                    config(request?: import("..").CosmosEvmVmV1QueryConfigRequest): Promise<import("..").CosmosEvmVmV1QueryConfigResponse>;
+                    globalMinGasPrice(request?: import("..").QueryGlobalMinGasPriceRequest): Promise<import("..").QueryGlobalMinGasPriceResponse>;
+                };
+            };
+        };
+        feegrant: {
+            v1beta1: {
+                allowance(request: import("..").QueryAllowanceRequest): Promise<import("..").QueryAllowanceResponse>;
+                allowances(request: import("..").QueryAllowancesRequest): Promise<import("..").QueryAllowancesResponse>;
+                allowancesByGranter(request: import("..").QueryAllowancesByGranterRequest): Promise<import("..").QueryAllowancesByGranterResponse>;
+            };
+        };
+        gov: {
+            v1: {
+                constitution(request?: import("..").QueryConstitutionRequest): Promise<import("..").QueryConstitutionResponse>;
+                proposal(request: import("..").QueryProposalRequest): Promise<import("..").QueryProposalResponse>;
+                proposals(request: import("..").QueryProposalsRequest): Promise<import("..").QueryProposalsResponse>;
+                vote(request: import("..").QueryVoteRequest): Promise<import("..").QueryVoteResponse>;
+                votes(request: import("..").QueryVotesRequest): Promise<import("..").QueryVotesResponse>;
+                params(request: import("..").CosmosGovV1QueryParamsRequest): Promise<import("..").CosmosGovV1QueryParamsResponse>;
+                deposit(request: import("..").QueryDepositRequest): Promise<import("..").QueryDepositResponse>;
+                deposits(request: import("..").QueryDepositsRequest): Promise<import("..").QueryDepositsResponse>;
+                tallyResult(request: import("..").QueryTallyResultRequest): Promise<import("..").QueryTallyResultResponse>;
+            };
+            v1beta1: {
+                proposal(request: import("..").CosmosGovV1beta1QueryProposalRequest): Promise<import("..").CosmosGovV1beta1QueryProposalResponse>;
+                proposals(request: import("..").CosmosGovV1beta1QueryProposalsRequest): Promise<import("..").CosmosGovV1beta1QueryProposalsResponse>;
+                vote(request: import("..").CosmosGovV1beta1QueryVoteRequest): Promise<import("..").CosmosGovV1beta1QueryVoteResponse>;
+                votes(request: import("..").CosmosGovV1beta1QueryVotesRequest): Promise<import("..").CosmosGovV1beta1QueryVotesResponse>;
+                params(request: import("..").CosmosGovV1beta1QueryParamsRequest): Promise<import("..").CosmosGovV1beta1QueryParamsResponse>;
+                deposit(request: import("..").CosmosGovV1beta1QueryDepositRequest): Promise<import("..").CosmosGovV1beta1QueryDepositResponse>;
+                deposits(request: import("..").CosmosGovV1beta1QueryDepositsRequest): Promise<import("..").CosmosGovV1beta1QueryDepositsResponse>;
+                tallyResult(request: import("..").CosmosGovV1beta1QueryTallyResultRequest): Promise<import("..").CosmosGovV1beta1QueryTallyResultResponse>;
+            };
+        };
+        mint: {
+            v1beta1: {
+                params(request?: import("..").CosmosMintV1beta1QueryParamsRequest): Promise<import("..").CosmosMintV1beta1QueryParamsResponse>;
+                inflation(request?: import("..").QueryInflationRequest): Promise<import("..").QueryInflationResponse>;
+                annualProvisions(request?: import("..").QueryAnnualProvisionsRequest): Promise<import("..").QueryAnnualProvisionsResponse>;
+            };
+        };
+        params: {
+            v1beta1: {
+                params(request: import("..").CosmosParamsV1beta1QueryParamsRequest): Promise<import("..").CosmosParamsV1beta1QueryParamsResponse>;
+                subspaces(request?: import("..").QuerySubspacesRequest): Promise<import("..").QuerySubspacesResponse>;
+            };
+        };
+        slashing: {
+            v1beta1: {
+                params(request?: import("..").CosmosSlashingV1beta1QueryParamsRequest): Promise<import("..").CosmosSlashingV1beta1QueryParamsResponse>;
+                signingInfo(request: import("..").QuerySigningInfoRequest): Promise<import("..").QuerySigningInfoResponse>;
+                signingInfos(request?: import("..").QuerySigningInfosRequest): Promise<import("..").QuerySigningInfosResponse>;
+            };
+        };
+        staking: {
+            v1beta1: {
+                validators(request: import("..").QueryValidatorsRequest): Promise<import("..").QueryValidatorsResponse>;
+                validator(request: import("..").QueryValidatorRequest): Promise<import("..").QueryValidatorResponse>;
+                validatorDelegations(request: import("..").QueryValidatorDelegationsRequest): Promise<import("..").QueryValidatorDelegationsResponse>;
+                validatorUnbondingDelegations(request: import("..").QueryValidatorUnbondingDelegationsRequest): Promise<import("..").QueryValidatorUnbondingDelegationsResponse>;
+                delegation(request: import("..").QueryDelegationRequest): Promise<import("..").QueryDelegationResponse>;
+                unbondingDelegation(request: import("..").QueryUnbondingDelegationRequest): Promise<import("..").QueryUnbondingDelegationResponse>;
+                delegatorDelegations(request: import("..").QueryDelegatorDelegationsRequest): Promise<import("..").QueryDelegatorDelegationsResponse>;
+                delegatorUnbondingDelegations(request: import("..").QueryDelegatorUnbondingDelegationsRequest): Promise<import("..").QueryDelegatorUnbondingDelegationsResponse>;
+                redelegations(request: import("..").QueryRedelegationsRequest): Promise<import("..").QueryRedelegationsResponse>;
+                delegatorValidators(request: import("..").CosmosStakingV1beta1QueryDelegatorValidatorsRequest): Promise<import("..").CosmosStakingV1beta1QueryDelegatorValidatorsResponse>;
+                delegatorValidator(request: import("..").QueryDelegatorValidatorRequest): Promise<import("..").QueryDelegatorValidatorResponse>;
+                historicalInfo(request: import("..").QueryHistoricalInfoRequest): Promise<import("..").QueryHistoricalInfoResponse>;
+                pool(request?: import("..").QueryPoolRequest): Promise<import("..").QueryPoolResponse>;
+                params(request?: import("..").CosmosStakingV1beta1QueryParamsRequest): Promise<import("..").CosmosStakingV1beta1QueryParamsResponse>;
+            };
+        };
+        tx: {
+            v1beta1: {
+                simulate(request: import("..").SimulateRequest): Promise<import("..").SimulateResponse>;
+                getTx(request: import("..").GetTxRequest): Promise<import("..").GetTxResponse>;
+                broadcastTx(request: import("..").BroadcastTxRequest): Promise<import("..").BroadcastTxResponse>;
+                getTxsEvent(request: import("..").GetTxsEventRequest): Promise<import("..").GetTxsEventResponse>;
+                getBlockWithTxs(request: import("..").GetBlockWithTxsRequest): Promise<import("..").GetBlockWithTxsResponse>;
+                txDecode(request: import("..").TxDecodeRequest): Promise<import("..").TxDecodeResponse>;
+                txEncode(request: import("..").TxEncodeRequest): Promise<import("..").TxEncodeResponse>;
+                txEncodeAmino(request: import("..").TxEncodeAminoRequest): Promise<import("..").TxEncodeAminoResponse>;
+                txDecodeAmino(request: import("..").TxDecodeAminoRequest): Promise<import("..").TxDecodeAminoResponse>;
+            };
+        };
+        upgrade: {
+            v1beta1: {
+                currentPlan(request?: import("..").QueryCurrentPlanRequest): Promise<import("..").QueryCurrentPlanResponse>;
+                appliedPlan(request: import("..").QueryAppliedPlanRequest): Promise<import("..").QueryAppliedPlanResponse>;
+                upgradedConsensusState(request: import("..").QueryUpgradedConsensusStateRequest): Promise<import("..").QueryUpgradedConsensusStateResponse>;
+                moduleVersions(request: import("..").QueryModuleVersionsRequest): Promise<import("..").QueryModuleVersionsResponse>;
+                authority(request?: import("..").QueryAuthorityRequest): Promise<import("..").QueryAuthorityResponse>;
+            };
+        };
+    };
+    ibc: {
+        applications: {
+            interchain_accounts: {
+                controller: {
+                    v1: {
+                        interchainAccount(request: import("./bundle").QueryInterchainAccountRequest): Promise<import("./bundle").QueryInterchainAccountResponse>;
+                        params(request?: import("./bundle").IbcApplicationsInterchainAccountsControllerV1QueryParamsRequest): Promise<import("./bundle").IbcApplicationsInterchainAccountsControllerV1QueryParamsResponse>;
+                    };
+                };
+                host: {
+                    v1: {
+                        params(request?: import("./bundle").IbcApplicationsInterchainAccountsHostV1QueryParamsRequest): Promise<import("./bundle").IbcApplicationsInterchainAccountsHostV1QueryParamsResponse>;
+                    };
+                };
+            };
+            transfer: {
+                v1: {
+                    params(request?: import("./bundle").IbcApplicationsTransferV1QueryParamsRequest): Promise<import("./bundle").IbcApplicationsTransferV1QueryParamsResponse>;
+                    denoms(request?: import("./bundle").QueryDenomsRequest): Promise<import("./bundle").QueryDenomsResponse>;
+                    denom(request: import("./bundle").QueryDenomRequest): Promise<import("./bundle").QueryDenomResponse>;
+                    denomHash(request: import("./bundle").QueryDenomHashRequest): Promise<import("./bundle").QueryDenomHashResponse>;
+                    escrowAddress(request: import("./bundle").QueryEscrowAddressRequest): Promise<import("./bundle").QueryEscrowAddressResponse>;
+                    totalEscrowForDenom(request: import("./bundle").QueryTotalEscrowForDenomRequest): Promise<import("./bundle").QueryTotalEscrowForDenomResponse>;
+                };
+            };
+        };
+        core: {
+            channel: {
+                v1: {
+                    channel(request: import("./bundle").QueryChannelRequest): Promise<import("./bundle").QueryChannelResponse>;
+                    channels(request?: import("./bundle").QueryChannelsRequest): Promise<import("./bundle").QueryChannelsResponse>;
+                    connectionChannels(request: import("./bundle").QueryConnectionChannelsRequest): Promise<import("./bundle").QueryConnectionChannelsResponse>;
+                    channelClientState(request: import("./bundle").QueryChannelClientStateRequest): Promise<import("./bundle").QueryChannelClientStateResponse>;
+                    channelConsensusState(request: import("./bundle").QueryChannelConsensusStateRequest): Promise<import("./bundle").QueryChannelConsensusStateResponse>;
+                    packetCommitment(request: import("./bundle").QueryPacketCommitmentRequest): Promise<import("./bundle").QueryPacketCommitmentResponse>;
+                    packetCommitments(request: import("./bundle").QueryPacketCommitmentsRequest): Promise<import("./bundle").QueryPacketCommitmentsResponse>;
+                    packetReceipt(request: import("./bundle").QueryPacketReceiptRequest): Promise<import("./bundle").QueryPacketReceiptResponse>;
+                    packetAcknowledgement(request: import("./bundle").QueryPacketAcknowledgementRequest): Promise<import("./bundle").QueryPacketAcknowledgementResponse>;
+                    packetAcknowledgements(request: import("./bundle").QueryPacketAcknowledgementsRequest): Promise<import("./bundle").QueryPacketAcknowledgementsResponse>;
+                    unreceivedPackets(request: import("./bundle").QueryUnreceivedPacketsRequest): Promise<import("./bundle").QueryUnreceivedPacketsResponse>;
+                    unreceivedAcks(request: import("./bundle").QueryUnreceivedAcksRequest): Promise<import("./bundle").QueryUnreceivedAcksResponse>;
+                    nextSequenceReceive(request: import("./bundle").QueryNextSequenceReceiveRequest): Promise<import("./bundle").QueryNextSequenceReceiveResponse>;
+                    nextSequenceSend(request: import("./bundle").QueryNextSequenceSendRequest): Promise<import("./bundle").QueryNextSequenceSendResponse>;
+                };
+                v2: {
+                    nextSequenceSend(request: import("./bundle").IbcCoreChannelV2QueryNextSequenceSendRequest): Promise<import("./bundle").IbcCoreChannelV2QueryNextSequenceSendResponse>;
+                    packetCommitment(request: import("./bundle").IbcCoreChannelV2QueryPacketCommitmentRequest): Promise<import("./bundle").IbcCoreChannelV2QueryPacketCommitmentResponse>;
+                    packetCommitments(request: import("./bundle").IbcCoreChannelV2QueryPacketCommitmentsRequest): Promise<import("./bundle").IbcCoreChannelV2QueryPacketCommitmentsResponse>;
+                    packetAcknowledgement(request: import("./bundle").IbcCoreChannelV2QueryPacketAcknowledgementRequest): Promise<import("./bundle").IbcCoreChannelV2QueryPacketAcknowledgementResponse>;
+                    packetAcknowledgements(request: import("./bundle").IbcCoreChannelV2QueryPacketAcknowledgementsRequest): Promise<import("./bundle").IbcCoreChannelV2QueryPacketAcknowledgementsResponse>;
+                    packetReceipt(request: import("./bundle").IbcCoreChannelV2QueryPacketReceiptRequest): Promise<import("./bundle").IbcCoreChannelV2QueryPacketReceiptResponse>;
+                    unreceivedPackets(request: import("./bundle").IbcCoreChannelV2QueryUnreceivedPacketsRequest): Promise<import("./bundle").IbcCoreChannelV2QueryUnreceivedPacketsResponse>;
+                    unreceivedAcks(request: import("./bundle").IbcCoreChannelV2QueryUnreceivedAcksRequest): Promise<import("./bundle").IbcCoreChannelV2QueryUnreceivedAcksResponse>;
+                };
+            };
+            client: {
+                v1: {
+                    clientState(request: import("./bundle").QueryClientStateRequest): Promise<import("./bundle").QueryClientStateResponse>;
+                    clientStates(request?: import("./bundle").QueryClientStatesRequest): Promise<import("./bundle").QueryClientStatesResponse>;
+                    consensusState(request: import("./bundle").QueryConsensusStateRequest): Promise<import("./bundle").QueryConsensusStateResponse>;
+                    consensusStates(request: import("./bundle").QueryConsensusStatesRequest): Promise<import("./bundle").QueryConsensusStatesResponse>;
+                    consensusStateHeights(request: import("./bundle").QueryConsensusStateHeightsRequest): Promise<import("./bundle").QueryConsensusStateHeightsResponse>;
+                    clientStatus(request: import("./bundle").QueryClientStatusRequest): Promise<import("./bundle").QueryClientStatusResponse>;
+                    clientParams(request?: import("./bundle").QueryClientParamsRequest): Promise<import("./bundle").QueryClientParamsResponse>;
+                    clientCreator(request: import("./bundle").QueryClientCreatorRequest): Promise<import("./bundle").QueryClientCreatorResponse>;
+                    upgradedClientState(request?: import("./bundle").QueryUpgradedClientStateRequest): Promise<import("./bundle").QueryUpgradedClientStateResponse>;
+                    upgradedConsensusState(request?: import("./bundle").IbcCoreClientV1QueryUpgradedConsensusStateRequest): Promise<import("./bundle").IbcCoreClientV1QueryUpgradedConsensusStateResponse>;
+                    verifyMembership(request: import("./bundle").QueryVerifyMembershipRequest): Promise<import("./bundle").QueryVerifyMembershipResponse>;
+                };
+                v2: {
+                    counterpartyInfo(request: import("./bundle").QueryCounterpartyInfoRequest): Promise<import("./bundle").QueryCounterpartyInfoResponse>;
+                    config(request: import("./bundle").IbcCoreClientV2QueryConfigRequest): Promise<import("./bundle").IbcCoreClientV2QueryConfigResponse>;
+                };
+            };
+            connection: {
+                v1: {
+                    connection(request: import("./bundle").QueryConnectionRequest): Promise<import("./bundle").QueryConnectionResponse>;
+                    connections(request?: import("./bundle").QueryConnectionsRequest): Promise<import("./bundle").QueryConnectionsResponse>;
+                    clientConnections(request: import("./bundle").QueryClientConnectionsRequest): Promise<import("./bundle").QueryClientConnectionsResponse>;
+                    connectionClientState(request: import("./bundle").QueryConnectionClientStateRequest): Promise<import("./bundle").QueryConnectionClientStateResponse>;
+                    connectionConsensusState(request: import("./bundle").QueryConnectionConsensusStateRequest): Promise<import("./bundle").QueryConnectionConsensusStateResponse>;
+                    connectionParams(request?: import("./bundle").QueryConnectionParamsRequest): Promise<import("./bundle").QueryConnectionParamsResponse>;
+                };
+            };
+        };
+        lightclients: {
+            wasm: {
+                v1: {
+                    checksums(request?: import("./bundle").QueryChecksumsRequest): Promise<import("./bundle").QueryChecksumsResponse>;
+                    code(request: import("./bundle").IbcLightclientsWasmV1QueryCodeRequest): Promise<import("./bundle").IbcLightclientsWasmV1QueryCodeResponse>;
+                };
+            };
+        };
+    };
+}>;

package/ibc/rpc.query.js

@@ -0,0 +1,135 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRPCQueryClient = void 0;
+const tendermint_rpc_1 = require("@cosmjs/tendermint-rpc");
+const stargate_1 = require("@cosmjs/stargate");
+const createRPCQueryClient = async ({ rpcEndpoint }) => {
+    const tmClient = await tendermint_rpc_1.Tendermint34Client.connect(rpcEndpoint);
+    const client = new stargate_1.QueryClient(tmClient);
+    return {
+        cosmos: {
+            app: {
+                v1alpha1: (await Promise.resolve().then(() => __importStar(require("../cosmos/app/v1alpha1/query.rpc.Query")))).createRpcQueryExtension(client)
+            },
+            auth: {
+                v1beta1: (await Promise.resolve().then(() => __importStar(require("../cosmos/auth/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
+            },
+            authz: {
+                v1beta1: (await Promise.resolve().then(() => __importStar(require("../cosmos/authz/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
+            },
+            autocli: {
+                v1: (await Promise.resolve().then(() => __importStar(require("../cosmos/autocli/v1/query.rpc.Query")))).createRpcQueryExtension(client)
+            },
+            bank: {
+                v1beta1: (await Promise.resolve().then(() => __importStar(require("../cosmos/bank/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
+            },
+            base: {
+                node: {
+                    v1beta1: (await Promise.resolve().then(() => __importStar(require("../cosmos/base/node/v1beta1/query.rpc.Service")))).createRpcQueryExtension(client)
+                },
+                tendermint: {
+                    v1beta1: (await Promise.resolve().then(() => __importStar(require("../cosmos/base/tendermint/v1beta1/query.rpc.Service")))).createRpcQueryExtension(client)
+                }
+            },
+            consensus: {
+                v1: (await Promise.resolve().then(() => __importStar(require("../cosmos/consensus/v1/query.rpc.Query")))).createRpcQueryExtension(client)
+            },
+            distribution: {
+                v1beta1: (await Promise.resolve().then(() => __importStar(require("../cosmos/distribution/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
+            },
+            evidence: {
+                v1beta1: (await Promise.resolve().then(() => __importStar(require("../cosmos/evidence/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
+            },
+            evm: {
+                feemarket: {
+                    v1: (await Promise.resolve().then(() => __importStar(require("../cosmos/evm/feemarket/v1/query.rpc.Query")))).createRpcQueryExtension(client)
+                },
+                vm: {
+                    v1: (await Promise.resolve().then(() => __importStar(require("../cosmos/evm/vm/v1/query.rpc.Query")))).createRpcQueryExtension(client)
+                }
+            },
+            feegrant: {
+                v1beta1: (await Promise.resolve().then(() => __importStar(require("../cosmos/feegrant/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
+            },
+            gov: {
+                v1: (await Promise.resolve().then(() => __importStar(require("../cosmos/gov/v1/query.rpc.Query")))).createRpcQueryExtension(client),
+                v1beta1: (await Promise.resolve().then(() => __importStar(require("../cosmos/gov/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
+            },
+            mint: {
+                v1beta1: (await Promise.resolve().then(() => __importStar(require("../cosmos/mint/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
+            },
+            params: {
+                v1beta1: (await Promise.resolve().then(() => __importStar(require("../cosmos/params/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
+            },
+            slashing: {
+                v1beta1: (await Promise.resolve().then(() => __importStar(require("../cosmos/slashing/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
+            },
+            staking: {
+                v1beta1: (await Promise.resolve().then(() => __importStar(require("../cosmos/staking/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
+            },
+            tx: {
+                v1beta1: (await Promise.resolve().then(() => __importStar(require("../cosmos/tx/v1beta1/service.rpc.Service")))).createRpcQueryExtension(client)
+            },
+            upgrade: {
+                v1beta1: (await Promise.resolve().then(() => __importStar(require("../cosmos/upgrade/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
+            }
+        },
+        ibc: {
+            applications: {
+                interchain_accounts: {
+                    controller: {
+                        v1: (await Promise.resolve().then(() => __importStar(require("./applications/interchain_accounts/controller/v1/query.rpc.Query")))).createRpcQueryExtension(client)
+                    },
+                    host: {
+                        v1: (await Promise.resolve().then(() => __importStar(require("./applications/interchain_accounts/host/v1/query.rpc.Query")))).createRpcQueryExtension(client)
+                    }
+                },
+                transfer: {
+                    v1: (await Promise.resolve().then(() => __importStar(require("./applications/transfer/v1/query.rpc.Query")))).createRpcQueryExtension(client)
+                }
+            },
+            core: {
+                channel: {
+                    v1: (await Promise.resolve().then(() => __importStar(require("./core/channel/v1/query.rpc.Query")))).createRpcQueryExtension(client),
+                    v2: (await Promise.resolve().then(() => __importStar(require("./core/channel/v2/query.rpc.Query")))).createRpcQueryExtension(client)
+                },
+                client: {
+                    v1: (await Promise.resolve().then(() => __importStar(require("./core/client/v1/query.rpc.Query")))).createRpcQueryExtension(client),
+                    v2: (await Promise.resolve().then(() => __importStar(require("./core/client/v2/query.rpc.Query")))).createRpcQueryExtension(client)
+                },
+                connection: {
+                    v1: (await Promise.resolve().then(() => __importStar(require("./core/connection/v1/query.rpc.Query")))).createRpcQueryExtension(client)
+                }
+            },
+            lightclients: {
+                wasm: {
+                    v1: (await Promise.resolve().then(() => __importStar(require("./lightclients/wasm/v1/query.rpc.Query")))).createRpcQueryExtension(client)
+                }
+            }
+        }
+    };
+};
+exports.createRPCQueryClient = createRPCQueryClient;

package/ibc/rpc.tx.d.ts

@@ -0,0 +1,85 @@
+import { Rpc } from "../helpers";
+export declare const createRPCMsgClient: ({ rpc }: {
+    rpc: Rpc;
+}) => Promise<{
+    cosmos: {
+        auth: {
+            v1beta1: import("../cosmos/auth/v1beta1/tx.rpc.msg").MsgClientImpl;
+        };
+        authz: {
+            v1beta1: import("../cosmos/authz/v1beta1/tx.rpc.msg").MsgClientImpl;
+        };
+        bank: {
+            v1beta1: import("../cosmos/bank/v1beta1/tx.rpc.msg").MsgClientImpl;
+        };
+        consensus: {
+            v1: import("../cosmos/consensus/v1/tx.rpc.msg").MsgClientImpl;
+        };
+        distribution: {
+            v1beta1: import("../cosmos/distribution/v1beta1/tx.rpc.msg").MsgClientImpl;
+        };
+        evidence: {
+            v1beta1: import("../cosmos/evidence/v1beta1/tx.rpc.msg").MsgClientImpl;
+        };
+        evm: {
+            feemarket: {
+                v1: import("../cosmos/evm/feemarket/v1/tx.rpc.msg").MsgClientImpl;
+            };
+            vm: {
+                v1: import("../cosmos/evm/vm/v1/tx.rpc.msg").MsgClientImpl;
+            };
+        };
+        feegrant: {
+            v1beta1: import("../cosmos/feegrant/v1beta1/tx.rpc.msg").MsgClientImpl;
+        };
+        gov: {
+            v1: import("../cosmos/gov/v1/tx.rpc.msg").MsgClientImpl;
+            v1beta1: import("../cosmos/gov/v1beta1/tx.rpc.msg").MsgClientImpl;
+        };
+        mint: {
+            v1beta1: import("../cosmos/mint/v1beta1/tx.rpc.msg").MsgClientImpl;
+        };
+        slashing: {
+            v1beta1: import("../cosmos/slashing/v1beta1/tx.rpc.msg").MsgClientImpl;
+        };
+        staking: {
+            v1beta1: import("../cosmos/staking/v1beta1/tx.rpc.msg").MsgClientImpl;
+        };
+        upgrade: {
+            v1beta1: import("../cosmos/upgrade/v1beta1/tx.rpc.msg").MsgClientImpl;
+        };
+    };
+    ibc: {
+        applications: {
+            interchain_accounts: {
+                controller: {
+                    v1: import("./applications/interchain_accounts/controller/v1/tx.rpc.msg").MsgClientImpl;
+                };
+                host: {
+                    v1: import("./applications/interchain_accounts/host/v1/tx.rpc.msg").MsgClientImpl;
+                };
+            };
+            transfer: {
+                v1: import("./applications/transfer/v1/tx.rpc.msg").MsgClientImpl;
+            };
+        };
+        core: {
+            channel: {
+                v1: import("./core/channel/v1/tx.rpc.msg").MsgClientImpl;
+                v2: import("./core/channel/v2/tx.rpc.msg").MsgClientImpl;
+            };
+            client: {
+                v1: import("./core/client/v1/tx.rpc.msg").MsgClientImpl;
+                v2: import("./core/client/v2/tx.rpc.msg").MsgClientImpl;
+            };
+            connection: {
+                v1: import("./core/connection/v1/tx.rpc.msg").MsgClientImpl;
+            };
+        };
+        lightclients: {
+            wasm: {
+                v1: import("./lightclients/wasm/v1/tx.rpc.msg").MsgClientImpl;
+            };
+        };
+    };
+}>;