@xpla/xplajs 1.7.0 → 1.8.0-rc.0

package/cosmos/rpc.query.d.ts

@@ -3,78 +3,213 @@ export declare const createRPCQueryClient: ({ rpcEndpoint }: {
     rpcEndpoint: string | HttpEndpoint;
 }) => Promise<{
     cosmos: {
-        tx: {
+        app: {
+            v1alpha1: {
+                config(request?: import("./bundle").QueryConfigRequest): Promise<import("./bundle").QueryConfigResponse>;
+            };
+        };
+        auth: {
             v1beta1: {
-                simulate(request: import("./tx/v1beta1/service").SimulateRequest): Promise<import("./tx/v1beta1/service").SimulateResponse>;
-                getTx(request: import("./tx/v1beta1/service").GetTxRequest): Promise<import("./tx/v1beta1/service").GetTxResponse>;
-                broadcastTx(request: import("./tx/v1beta1/service").BroadcastTxRequest): Promise<import("./tx/v1beta1/service").BroadcastTxResponse>;
-                getTxsEvent(request: import("./tx/v1beta1/service").GetTxsEventRequest): Promise<import("./tx/v1beta1/service").GetTxsEventResponse>;
-                getBlockWithTxs(request: import("./tx/v1beta1/service").GetBlockWithTxsRequest): Promise<import("./tx/v1beta1/service").GetBlockWithTxsResponse>;
-                txDecode(request: import("./tx/v1beta1/service").TxDecodeRequest): Promise<import("./tx/v1beta1/service").TxDecodeResponse>;
-                txEncode(request: import("./tx/v1beta1/service").TxEncodeRequest): Promise<import("./tx/v1beta1/service").TxEncodeResponse>;
-                txEncodeAmino(request: import("./tx/v1beta1/service").TxEncodeAminoRequest): Promise<import("./tx/v1beta1/service").TxEncodeAminoResponse>;
-                txDecodeAmino(request: import("./tx/v1beta1/service").TxDecodeAminoRequest): Promise<import("./tx/v1beta1/service").TxDecodeAminoResponse>;
+                accounts(request?: import("./bundle").QueryAccountsRequest): Promise<import("./bundle").QueryAccountsResponse>;
+                account(request: import("./bundle").QueryAccountRequest): Promise<import("./bundle").QueryAccountResponse>;
+                accountAddressByID(request: import("./bundle").QueryAccountAddressByIDRequest): Promise<import("./bundle").QueryAccountAddressByIDResponse>;
+                params(request?: import("./bundle").QueryParamsRequest): Promise<import("./bundle").QueryParamsResponse>;
+                moduleAccounts(request?: import("./bundle").QueryModuleAccountsRequest): Promise<import("./bundle").QueryModuleAccountsResponse>;
+                moduleAccountByName(request: import("./bundle").QueryModuleAccountByNameRequest): Promise<import("./bundle").QueryModuleAccountByNameResponse>;
+                bech32Prefix(request?: import("./bundle").Bech32PrefixRequest): Promise<import("./bundle").Bech32PrefixResponse>;
+                addressBytesToString(request: import("./bundle").AddressBytesToStringRequest): Promise<import("./bundle").AddressBytesToStringResponse>;
+                addressStringToBytes(request: import("./bundle").AddressStringToBytesRequest): Promise<import("./bundle").AddressStringToBytesResponse>;
+                accountInfo(request: import("./bundle").QueryAccountInfoRequest): Promise<import("./bundle").QueryAccountInfoResponse>;
             };
         };
-        staking: {
+        authz: {
+            v1beta1: {
+                grants(request: import("./bundle").QueryGrantsRequest): Promise<import("./bundle").QueryGrantsResponse>;
+                granterGrants(request: import("./bundle").QueryGranterGrantsRequest): Promise<import("./bundle").QueryGranterGrantsResponse>;
+                granteeGrants(request: import("./bundle").QueryGranteeGrantsRequest): Promise<import("./bundle").QueryGranteeGrantsResponse>;
+            };
+        };
+        autocli: {
+            v1: {
+                appOptions(request?: import("./bundle").AppOptionsRequest): Promise<import("./bundle").AppOptionsResponse>;
+            };
+        };
+        bank: {
             v1beta1: {
-                validators(request: import("./staking/v1beta1/query").QueryValidatorsRequest): Promise<import("./staking/v1beta1/query").QueryValidatorsResponse>;
-                validator(request: import("./staking/v1beta1/query").QueryValidatorRequest): Promise<import("./staking/v1beta1/query").QueryValidatorResponse>;
-                validatorDelegations(request: import("./staking/v1beta1/query").QueryValidatorDelegationsRequest): Promise<import("./staking/v1beta1/query").QueryValidatorDelegationsResponse>;
-                validatorUnbondingDelegations(request: import("./staking/v1beta1/query").QueryValidatorUnbondingDelegationsRequest): Promise<import("./staking/v1beta1/query").QueryValidatorUnbondingDelegationsResponse>;
-                delegation(request: import("./staking/v1beta1/query").QueryDelegationRequest): Promise<import("./staking/v1beta1/query").QueryDelegationResponse>;
-                unbondingDelegation(request: import("./staking/v1beta1/query").QueryUnbondingDelegationRequest): Promise<import("./staking/v1beta1/query").QueryUnbondingDelegationResponse>;
-                delegatorDelegations(request: import("./staking/v1beta1/query").QueryDelegatorDelegationsRequest): Promise<import("./staking/v1beta1/query").QueryDelegatorDelegationsResponse>;
-                delegatorUnbondingDelegations(request: import("./staking/v1beta1/query").QueryDelegatorUnbondingDelegationsRequest): Promise<import("./staking/v1beta1/query").QueryDelegatorUnbondingDelegationsResponse>;
-                redelegations(request: import("./staking/v1beta1/query").QueryRedelegationsRequest): Promise<import("./staking/v1beta1/query").QueryRedelegationsResponse>;
-                delegatorValidators(request: import("./staking/v1beta1/query").QueryDelegatorValidatorsRequest): Promise<import("./staking/v1beta1/query").QueryDelegatorValidatorsResponse>;
-                delegatorValidator(request: import("./staking/v1beta1/query").QueryDelegatorValidatorRequest): Promise<import("./staking/v1beta1/query").QueryDelegatorValidatorResponse>;
-                historicalInfo(request: import("./staking/v1beta1/query").QueryHistoricalInfoRequest): Promise<import("./staking/v1beta1/query").QueryHistoricalInfoResponse>;
-                pool(request?: import("./staking/v1beta1/query").QueryPoolRequest): Promise<import("./staking/v1beta1/query").QueryPoolResponse>;
-                params(request?: import("./staking/v1beta1/query").QueryParamsRequest): Promise<import("./staking/v1beta1/query").QueryParamsResponse>;
+                balance(request: import("./bundle").QueryBalanceRequest): Promise<import("./bundle").QueryBalanceResponse>;
+                allBalances(request: import("./bundle").QueryAllBalancesRequest): Promise<import("./bundle").QueryAllBalancesResponse>;
+                spendableBalances(request: import("./bundle").QuerySpendableBalancesRequest): Promise<import("./bundle").QuerySpendableBalancesResponse>;
+                spendableBalanceByDenom(request: import("./bundle").QuerySpendableBalanceByDenomRequest): Promise<import("./bundle").QuerySpendableBalanceByDenomResponse>;
+                totalSupply(request?: import("./bundle").QueryTotalSupplyRequest): Promise<import("./bundle").QueryTotalSupplyResponse>;
+                supplyOf(request: import("./bundle").QuerySupplyOfRequest): Promise<import("./bundle").QuerySupplyOfResponse>;
+                params(request?: import("./bundle").CosmosBankV1beta1QueryParamsRequest): Promise<import("./bundle").CosmosBankV1beta1QueryParamsResponse>;
+                denomMetadata(request: import("./bundle").QueryDenomMetadataRequest): Promise<import("./bundle").QueryDenomMetadataResponse>;
+                denomMetadataByQueryString(request: import("./bundle").QueryDenomMetadataByQueryStringRequest): Promise<import("./bundle").QueryDenomMetadataByQueryStringResponse>;
+                denomsMetadata(request?: import("./bundle").QueryDenomsMetadataRequest): Promise<import("./bundle").QueryDenomsMetadataResponse>;
+                denomOwners(request: import("./bundle").QueryDenomOwnersRequest): Promise<import("./bundle").QueryDenomOwnersResponse>;
+                denomOwnersByQuery(request: import("./bundle").QueryDenomOwnersByQueryRequest): Promise<import("./bundle").QueryDenomOwnersByQueryResponse>;
+                sendEnabled(request: import("./bundle").QuerySendEnabledRequest): Promise<import("./bundle").QuerySendEnabledResponse>;
+            };
+        };
+        base: {
+            node: {
+                v1beta1: {
+                    config(request?: import("./bundle").ConfigRequest): Promise<import("./bundle").ConfigResponse>;
+                    status(request?: import("./bundle").StatusRequest): Promise<import("./bundle").StatusResponse>;
+                };
+            };
+            tendermint: {
+                v1beta1: {
+                    getNodeInfo(request?: import("./bundle").GetNodeInfoRequest): Promise<import("./bundle").GetNodeInfoResponse>;
+                    getSyncing(request?: import("./bundle").GetSyncingRequest): Promise<import("./bundle").GetSyncingResponse>;
+                    getLatestBlock(request?: import("./bundle").GetLatestBlockRequest): Promise<import("./bundle").GetLatestBlockResponse>;
+                    getBlockByHeight(request: import("./bundle").GetBlockByHeightRequest): Promise<import("./bundle").GetBlockByHeightResponse>;
+                    getLatestValidatorSet(request?: import("./bundle").GetLatestValidatorSetRequest): Promise<import("./bundle").GetLatestValidatorSetResponse>;
+                    getValidatorSetByHeight(request: import("./bundle").GetValidatorSetByHeightRequest): Promise<import("./bundle").GetValidatorSetByHeightResponse>;
+                    aBCIQuery(request: import("./bundle").ABCIQueryRequest): Promise<import("./bundle").ABCIQueryResponse>;
+                };
+            };
+        };
+        consensus: {
+            v1: {
+                params(request?: import("./bundle").CosmosConsensusV1QueryParamsRequest): Promise<import("./bundle").CosmosConsensusV1QueryParamsResponse>;
+            };
+        };
+        distribution: {
+            v1beta1: {
+                params(request?: import("./bundle").CosmosDistributionV1beta1QueryParamsRequest): Promise<import("./bundle").CosmosDistributionV1beta1QueryParamsResponse>;
+                validatorDistributionInfo(request: import("./bundle").QueryValidatorDistributionInfoRequest): Promise<import("./bundle").QueryValidatorDistributionInfoResponse>;
+                validatorOutstandingRewards(request: import("./bundle").QueryValidatorOutstandingRewardsRequest): Promise<import("./bundle").QueryValidatorOutstandingRewardsResponse>;
+                validatorCommission(request: import("./bundle").QueryValidatorCommissionRequest): Promise<import("./bundle").QueryValidatorCommissionResponse>;
+                validatorSlashes(request: import("./bundle").QueryValidatorSlashesRequest): Promise<import("./bundle").QueryValidatorSlashesResponse>;
+                delegationRewards(request: import("./bundle").QueryDelegationRewardsRequest): Promise<import("./bundle").QueryDelegationRewardsResponse>;
+                delegationTotalRewards(request: import("./bundle").QueryDelegationTotalRewardsRequest): Promise<import("./bundle").QueryDelegationTotalRewardsResponse>;
+                delegatorValidators(request: import("./bundle").QueryDelegatorValidatorsRequest): Promise<import("./bundle").QueryDelegatorValidatorsResponse>;
+                delegatorWithdrawAddress(request: import("./bundle").QueryDelegatorWithdrawAddressRequest): Promise<import("./bundle").QueryDelegatorWithdrawAddressResponse>;
+                communityPool(request?: import("./bundle").QueryCommunityPoolRequest): Promise<import("./bundle").QueryCommunityPoolResponse>;
+            };
+        };
+        evidence: {
+            v1beta1: {
+                evidence(request: import("./bundle").QueryEvidenceRequest): Promise<import("./bundle").QueryEvidenceResponse>;
+                allEvidence(request?: import("./bundle").QueryAllEvidenceRequest): Promise<import("./bundle").QueryAllEvidenceResponse>;
+            };
+        };
+        evm: {
+            feemarket: {
+                v1: {
+                    params(request?: import("./bundle").CosmosEvmFeemarketV1QueryParamsRequest): Promise<import("./bundle").CosmosEvmFeemarketV1QueryParamsResponse>;
+                    baseFee(request?: import("./bundle").QueryBaseFeeRequest): Promise<import("./bundle").QueryBaseFeeResponse>;
+                    blockGas(request?: import("./bundle").QueryBlockGasRequest): Promise<import("./bundle").QueryBlockGasResponse>;
+                };
+            };
+            vm: {
+                v1: {
+                    account(request: import("./bundle").CosmosEvmVmV1QueryAccountRequest): Promise<import("./bundle").CosmosEvmVmV1QueryAccountResponse>;
+                    cosmosAccount(request: import("./bundle").QueryCosmosAccountRequest): Promise<import("./bundle").QueryCosmosAccountResponse>;
+                    validatorAccount(request: import("./bundle").QueryValidatorAccountRequest): Promise<import("./bundle").QueryValidatorAccountResponse>;
+                    balance(request: import("./bundle").CosmosEvmVmV1QueryBalanceRequest): Promise<import("./bundle").CosmosEvmVmV1QueryBalanceResponse>;
+                    storage(request: import("./bundle").QueryStorageRequest): Promise<import("./bundle").QueryStorageResponse>;
+                    code(request: import("./bundle").QueryCodeRequest): Promise<import("./bundle").QueryCodeResponse>;
+                    params(request?: import("./bundle").CosmosEvmVmV1QueryParamsRequest): Promise<import("./bundle").CosmosEvmVmV1QueryParamsResponse>;
+                    ethCall(request: import("./bundle").EthCallRequest): Promise<import("./bundle").MsgEthereumTxResponse>;
+                    estimateGas(request: import("./bundle").EthCallRequest): Promise<import("./bundle").EstimateGasResponse>;
+                    traceTx(request: import("./bundle").QueryTraceTxRequest): Promise<import("./bundle").QueryTraceTxResponse>;
+                    traceBlock(request: import("./bundle").QueryTraceBlockRequest): Promise<import("./bundle").QueryTraceBlockResponse>;
+                    baseFee(request?: import("./bundle").CosmosEvmVmV1QueryBaseFeeRequest): Promise<import("./bundle").CosmosEvmVmV1QueryBaseFeeResponse>;
+                    config(request?: import("./bundle").CosmosEvmVmV1QueryConfigRequest): Promise<import("./bundle").CosmosEvmVmV1QueryConfigResponse>;
+                    globalMinGasPrice(request?: import("./bundle").QueryGlobalMinGasPriceRequest): Promise<import("./bundle").QueryGlobalMinGasPriceResponse>;
+                };
+            };
+        };
+        feegrant: {
+            v1beta1: {
+                allowance(request: import("./bundle").QueryAllowanceRequest): Promise<import("./bundle").QueryAllowanceResponse>;
+                allowances(request: import("./bundle").QueryAllowancesRequest): Promise<import("./bundle").QueryAllowancesResponse>;
+                allowancesByGranter(request: import("./bundle").QueryAllowancesByGranterRequest): Promise<import("./bundle").QueryAllowancesByGranterResponse>;
             };
         };
         gov: {
+            v1: {
+                constitution(request?: import("./bundle").QueryConstitutionRequest): Promise<import("./bundle").QueryConstitutionResponse>;
+                proposal(request: import("./bundle").QueryProposalRequest): Promise<import("./bundle").QueryProposalResponse>;
+                proposals(request: import("./bundle").QueryProposalsRequest): Promise<import("./bundle").QueryProposalsResponse>;
+                vote(request: import("./bundle").QueryVoteRequest): Promise<import("./bundle").QueryVoteResponse>;
+                votes(request: import("./bundle").QueryVotesRequest): Promise<import("./bundle").QueryVotesResponse>;
+                params(request: import("./bundle").CosmosGovV1QueryParamsRequest): Promise<import("./bundle").CosmosGovV1QueryParamsResponse>;
+                deposit(request: import("./bundle").QueryDepositRequest): Promise<import("./bundle").QueryDepositResponse>;
+                deposits(request: import("./bundle").QueryDepositsRequest): Promise<import("./bundle").QueryDepositsResponse>;
+                tallyResult(request: import("./bundle").QueryTallyResultRequest): Promise<import("./bundle").QueryTallyResultResponse>;
+            };
             v1beta1: {
-                proposal(request: import("./gov/v1beta1/query").QueryProposalRequest): Promise<import("./gov/v1beta1/query").QueryProposalResponse>;
-                proposals(request: import("./gov/v1beta1/query").QueryProposalsRequest): Promise<import("./gov/v1beta1/query").QueryProposalsResponse>;
-                vote(request: import("./gov/v1beta1/query").QueryVoteRequest): Promise<import("./gov/v1beta1/query").QueryVoteResponse>;
-                votes(request: import("./gov/v1beta1/query").QueryVotesRequest): Promise<import("./gov/v1beta1/query").QueryVotesResponse>;
-                params(request: import("./gov/v1beta1/query").QueryParamsRequest): Promise<import("./gov/v1beta1/query").QueryParamsResponse>;
-                deposit(request: import("./gov/v1beta1/query").QueryDepositRequest): Promise<import("./gov/v1beta1/query").QueryDepositResponse>;
-                deposits(request: import("./gov/v1beta1/query").QueryDepositsRequest): Promise<import("./gov/v1beta1/query").QueryDepositsResponse>;
-                tallyResult(request: import("./gov/v1beta1/query").QueryTallyResultRequest): Promise<import("./gov/v1beta1/query").QueryTallyResultResponse>;
+                proposal(request: import("./bundle").CosmosGovV1beta1QueryProposalRequest): Promise<import("./bundle").CosmosGovV1beta1QueryProposalResponse>;
+                proposals(request: import("./bundle").CosmosGovV1beta1QueryProposalsRequest): Promise<import("./bundle").CosmosGovV1beta1QueryProposalsResponse>;
+                vote(request: import("./bundle").CosmosGovV1beta1QueryVoteRequest): Promise<import("./bundle").CosmosGovV1beta1QueryVoteResponse>;
+                votes(request: import("./bundle").CosmosGovV1beta1QueryVotesRequest): Promise<import("./bundle").CosmosGovV1beta1QueryVotesResponse>;
+                params(request: import("./bundle").CosmosGovV1beta1QueryParamsRequest): Promise<import("./bundle").CosmosGovV1beta1QueryParamsResponse>;
+                deposit(request: import("./bundle").CosmosGovV1beta1QueryDepositRequest): Promise<import("./bundle").CosmosGovV1beta1QueryDepositResponse>;
+                deposits(request: import("./bundle").CosmosGovV1beta1QueryDepositsRequest): Promise<import("./bundle").CosmosGovV1beta1QueryDepositsResponse>;
+                tallyResult(request: import("./bundle").CosmosGovV1beta1QueryTallyResultRequest): Promise<import("./bundle").CosmosGovV1beta1QueryTallyResultResponse>;
             };
         };
-        bank: {
+        mint: {
             v1beta1: {
-                balance(request: import("./bank/v1beta1/query").QueryBalanceRequest): Promise<import("./bank/v1beta1/query").QueryBalanceResponse>;
-                allBalances(request: import("./bank/v1beta1/query").QueryAllBalancesRequest): Promise<import("./bank/v1beta1/query").QueryAllBalancesResponse>;
-                spendableBalances(request: import("./bank/v1beta1/query").QuerySpendableBalancesRequest): Promise<import("./bank/v1beta1/query").QuerySpendableBalancesResponse>;
-                spendableBalanceByDenom(request: import("./bank/v1beta1/query").QuerySpendableBalanceByDenomRequest): Promise<import("./bank/v1beta1/query").QuerySpendableBalanceByDenomResponse>;
-                totalSupply(request?: import("./bank/v1beta1/query").QueryTotalSupplyRequest): Promise<import("./bank/v1beta1/query").QueryTotalSupplyResponse>;
-                supplyOf(request: import("./bank/v1beta1/query").QuerySupplyOfRequest): Promise<import("./bank/v1beta1/query").QuerySupplyOfResponse>;
-                params(request?: import("./bank/v1beta1/query").QueryParamsRequest): Promise<import("./bank/v1beta1/query").QueryParamsResponse>;
-                denomMetadata(request: import("./bank/v1beta1/query").QueryDenomMetadataRequest): Promise<import("./bank/v1beta1/query").QueryDenomMetadataResponse>;
-                denomMetadataByQueryString(request: import("./bank/v1beta1/query").QueryDenomMetadataByQueryStringRequest): Promise<import("./bank/v1beta1/query").QueryDenomMetadataByQueryStringResponse>;
-                denomsMetadata(request?: import("./bank/v1beta1/query").QueryDenomsMetadataRequest): Promise<import("./bank/v1beta1/query").QueryDenomsMetadataResponse>;
-                denomOwners(request: import("./bank/v1beta1/query").QueryDenomOwnersRequest): Promise<import("./bank/v1beta1/query").QueryDenomOwnersResponse>;
-                denomOwnersByQuery(request: import("./bank/v1beta1/query").QueryDenomOwnersByQueryRequest): Promise<import("./bank/v1beta1/query").QueryDenomOwnersByQueryResponse>;
-                sendEnabled(request: import("./bank/v1beta1/query").QuerySendEnabledRequest): Promise<import("./bank/v1beta1/query").QuerySendEnabledResponse>;
+                params(request?: import("./bundle").CosmosMintV1beta1QueryParamsRequest): Promise<import("./bundle").CosmosMintV1beta1QueryParamsResponse>;
+                inflation(request?: import("./bundle").QueryInflationRequest): Promise<import("./bundle").QueryInflationResponse>;
+                annualProvisions(request?: import("./bundle").QueryAnnualProvisionsRequest): Promise<import("./bundle").QueryAnnualProvisionsResponse>;
             };
         };
-        auth: {
+        params: {
+            v1beta1: {
+                params(request: import("./bundle").CosmosParamsV1beta1QueryParamsRequest): Promise<import("./bundle").CosmosParamsV1beta1QueryParamsResponse>;
+                subspaces(request?: import("./bundle").QuerySubspacesRequest): Promise<import("./bundle").QuerySubspacesResponse>;
+            };
+        };
+        slashing: {
+            v1beta1: {
+                params(request?: import("./bundle").CosmosSlashingV1beta1QueryParamsRequest): Promise<import("./bundle").CosmosSlashingV1beta1QueryParamsResponse>;
+                signingInfo(request: import("./bundle").QuerySigningInfoRequest): Promise<import("./bundle").QuerySigningInfoResponse>;
+                signingInfos(request?: import("./bundle").QuerySigningInfosRequest): Promise<import("./bundle").QuerySigningInfosResponse>;
+            };
+        };
+        staking: {
+            v1beta1: {
+                validators(request: import("./bundle").QueryValidatorsRequest): Promise<import("./bundle").QueryValidatorsResponse>;
+                validator(request: import("./bundle").QueryValidatorRequest): Promise<import("./bundle").QueryValidatorResponse>;
+                validatorDelegations(request: import("./bundle").QueryValidatorDelegationsRequest): Promise<import("./bundle").QueryValidatorDelegationsResponse>;
+                validatorUnbondingDelegations(request: import("./bundle").QueryValidatorUnbondingDelegationsRequest): Promise<import("./bundle").QueryValidatorUnbondingDelegationsResponse>;
+                delegation(request: import("./bundle").QueryDelegationRequest): Promise<import("./bundle").QueryDelegationResponse>;
+                unbondingDelegation(request: import("./bundle").QueryUnbondingDelegationRequest): Promise<import("./bundle").QueryUnbondingDelegationResponse>;
+                delegatorDelegations(request: import("./bundle").QueryDelegatorDelegationsRequest): Promise<import("./bundle").QueryDelegatorDelegationsResponse>;
+                delegatorUnbondingDelegations(request: import("./bundle").QueryDelegatorUnbondingDelegationsRequest): Promise<import("./bundle").QueryDelegatorUnbondingDelegationsResponse>;
+                redelegations(request: import("./bundle").QueryRedelegationsRequest): Promise<import("./bundle").QueryRedelegationsResponse>;
+                delegatorValidators(request: import("./bundle").CosmosStakingV1beta1QueryDelegatorValidatorsRequest): Promise<import("./bundle").CosmosStakingV1beta1QueryDelegatorValidatorsResponse>;
+                delegatorValidator(request: import("./bundle").QueryDelegatorValidatorRequest): Promise<import("./bundle").QueryDelegatorValidatorResponse>;
+                historicalInfo(request: import("./bundle").QueryHistoricalInfoRequest): Promise<import("./bundle").QueryHistoricalInfoResponse>;
+                pool(request?: import("./bundle").QueryPoolRequest): Promise<import("./bundle").QueryPoolResponse>;
+                params(request?: import("./bundle").CosmosStakingV1beta1QueryParamsRequest): Promise<import("./bundle").CosmosStakingV1beta1QueryParamsResponse>;
+            };
+        };
+        tx: {
+            v1beta1: {
+                simulate(request: import("./bundle").SimulateRequest): Promise<import("./bundle").SimulateResponse>;
+                getTx(request: import("./bundle").GetTxRequest): Promise<import("./bundle").GetTxResponse>;
+                broadcastTx(request: import("./bundle").BroadcastTxRequest): Promise<import("./bundle").BroadcastTxResponse>;
+                getTxsEvent(request: import("./bundle").GetTxsEventRequest): Promise<import("./bundle").GetTxsEventResponse>;
+                getBlockWithTxs(request: import("./bundle").GetBlockWithTxsRequest): Promise<import("./bundle").GetBlockWithTxsResponse>;
+                txDecode(request: import("./bundle").TxDecodeRequest): Promise<import("./bundle").TxDecodeResponse>;
+                txEncode(request: import("./bundle").TxEncodeRequest): Promise<import("./bundle").TxEncodeResponse>;
+                txEncodeAmino(request: import("./bundle").TxEncodeAminoRequest): Promise<import("./bundle").TxEncodeAminoResponse>;
+                txDecodeAmino(request: import("./bundle").TxDecodeAminoRequest): Promise<import("./bundle").TxDecodeAminoResponse>;
+            };
+        };
+        upgrade: {
             v1beta1: {
-                accounts(request?: import("./auth/v1beta1/query").QueryAccountsRequest): Promise<import("./auth/v1beta1/query").QueryAccountsResponse>;
-                account(request: import("./auth/v1beta1/query").QueryAccountRequest): Promise<import("./auth/v1beta1/query").QueryAccountResponse>;
-                accountAddressByID(request: import("./auth/v1beta1/query").QueryAccountAddressByIDRequest): Promise<import("./auth/v1beta1/query").QueryAccountAddressByIDResponse>;
-                params(request?: import("./auth/v1beta1/query").QueryParamsRequest): Promise<import("./auth/v1beta1/query").QueryParamsResponse>;
-                moduleAccounts(request?: import("./auth/v1beta1/query").QueryModuleAccountsRequest): Promise<import("./auth/v1beta1/query").QueryModuleAccountsResponse>;
-                moduleAccountByName(request: import("./auth/v1beta1/query").QueryModuleAccountByNameRequest): Promise<import("./auth/v1beta1/query").QueryModuleAccountByNameResponse>;
-                bech32Prefix(request?: import("./auth/v1beta1/query").Bech32PrefixRequest): Promise<import("./auth/v1beta1/query").Bech32PrefixResponse>;
-                addressBytesToString(request: import("./auth/v1beta1/query").AddressBytesToStringRequest): Promise<import("./auth/v1beta1/query").AddressBytesToStringResponse>;
-                addressStringToBytes(request: import("./auth/v1beta1/query").AddressStringToBytesRequest): Promise<import("./auth/v1beta1/query").AddressStringToBytesResponse>;
-                accountInfo(request: import("./auth/v1beta1/query").QueryAccountInfoRequest): Promise<import("./auth/v1beta1/query").QueryAccountInfoResponse>;
+                currentPlan(request?: import("./bundle").QueryCurrentPlanRequest): Promise<import("./bundle").QueryCurrentPlanResponse>;
+                appliedPlan(request: import("./bundle").QueryAppliedPlanRequest): Promise<import("./bundle").QueryAppliedPlanResponse>;
+                upgradedConsensusState(request: import("./bundle").QueryUpgradedConsensusStateRequest): Promise<import("./bundle").QueryUpgradedConsensusStateResponse>;
+                moduleVersions(request: import("./bundle").QueryModuleVersionsRequest): Promise<import("./bundle").QueryModuleVersionsResponse>;
+                authority(request?: import("./bundle").QueryAuthorityRequest): Promise<import("./bundle").QueryAuthorityResponse>;
             };
         };
     };

package/cosmos/rpc.query.js

@@ -31,20 +31,70 @@ const createRPCQueryClient = async ({ rpcEndpoint }) => {
     const client = new stargate_1.QueryClient(tmClient);
     return {
         cosmos: {
-            tx: {
-                v1beta1: (await Promise.resolve().then(() => __importStar(require("./tx/v1beta1/service.rpc.Service")))).createRpcQueryExtension(client)
+            app: {
+                v1alpha1: (await Promise.resolve().then(() => __importStar(require("./app/v1alpha1/query.rpc.Query")))).createRpcQueryExtension(client)
             },
-            staking: {
-                v1beta1: (await Promise.resolve().then(() => __importStar(require("./staking/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
+            auth: {
+                v1beta1: (await Promise.resolve().then(() => __importStar(require("./auth/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
             },
-            gov: {
-                v1beta1: (await Promise.resolve().then(() => __importStar(require("./gov/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
+            authz: {
+                v1beta1: (await Promise.resolve().then(() => __importStar(require("./authz/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
+            },
+            autocli: {
+                v1: (await Promise.resolve().then(() => __importStar(require("./autocli/v1/query.rpc.Query")))).createRpcQueryExtension(client)
             },
             bank: {
                 v1beta1: (await Promise.resolve().then(() => __importStar(require("./bank/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
             },
-            auth: {
-                v1beta1: (await Promise.resolve().then(() => __importStar(require("./auth/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
+            base: {
+                node: {
+                    v1beta1: (await Promise.resolve().then(() => __importStar(require("./base/node/v1beta1/query.rpc.Service")))).createRpcQueryExtension(client)
+                },
+                tendermint: {
+                    v1beta1: (await Promise.resolve().then(() => __importStar(require("./base/tendermint/v1beta1/query.rpc.Service")))).createRpcQueryExtension(client)
+                }
+            },
+            consensus: {
+                v1: (await Promise.resolve().then(() => __importStar(require("./consensus/v1/query.rpc.Query")))).createRpcQueryExtension(client)
+            },
+            distribution: {
+                v1beta1: (await Promise.resolve().then(() => __importStar(require("./distribution/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
+            },
+            evidence: {
+                v1beta1: (await Promise.resolve().then(() => __importStar(require("./evidence/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
+            },
+            evm: {
+                feemarket: {
+                    v1: (await Promise.resolve().then(() => __importStar(require("./evm/feemarket/v1/query.rpc.Query")))).createRpcQueryExtension(client)
+                },
+                vm: {
+                    v1: (await Promise.resolve().then(() => __importStar(require("./evm/vm/v1/query.rpc.Query")))).createRpcQueryExtension(client)
+                }
+            },
+            feegrant: {
+                v1beta1: (await Promise.resolve().then(() => __importStar(require("./feegrant/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
+            },
+            gov: {
+                v1: (await Promise.resolve().then(() => __importStar(require("./gov/v1/query.rpc.Query")))).createRpcQueryExtension(client),
+                v1beta1: (await Promise.resolve().then(() => __importStar(require("./gov/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
+            },
+            mint: {
+                v1beta1: (await Promise.resolve().then(() => __importStar(require("./mint/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
+            },
+            params: {
+                v1beta1: (await Promise.resolve().then(() => __importStar(require("./params/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
+            },
+            slashing: {
+                v1beta1: (await Promise.resolve().then(() => __importStar(require("./slashing/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
+            },
+            staking: {
+                v1beta1: (await Promise.resolve().then(() => __importStar(require("./staking/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
+            },
+            tx: {
+                v1beta1: (await Promise.resolve().then(() => __importStar(require("./tx/v1beta1/service.rpc.Service")))).createRpcQueryExtension(client)
+            },
+            upgrade: {
+                v1beta1: (await Promise.resolve().then(() => __importStar(require("./upgrade/v1beta1/query.rpc.Query")))).createRpcQueryExtension(client)
             }
         }
     };

package/cosmos/rpc.tx.d.ts

@@ -3,30 +3,50 @@ export declare const createRPCMsgClient: ({ rpc }: {
     rpc: Rpc;
 }) => Promise<{
     cosmos: {
-        vesting: {
-            v1beta1: import("./vesting/v1beta1/tx.rpc.msg").MsgClientImpl;
+        auth: {
+            v1beta1: import("./auth/v1beta1/tx.rpc.msg").MsgClientImpl;
         };
-        staking: {
-            v1beta1: import("./staking/v1beta1/tx.rpc.msg").MsgClientImpl;
+        authz: {
+            v1beta1: import("./authz/v1beta1/tx.rpc.msg").MsgClientImpl;
         };
-        group: {
-            v1: import("./group/v1/tx.rpc.msg").MsgClientImpl;
+        bank: {
+            v1beta1: import("./bank/v1beta1/tx.rpc.msg").MsgClientImpl;
         };
-        gov: {
-            v1beta1: import("./gov/v1beta1/tx.rpc.msg").MsgClientImpl;
-            v1: import("./gov/v1/tx.rpc.msg").MsgClientImpl;
+        consensus: {
+            v1: import("./consensus/v1/tx.rpc.msg").MsgClientImpl;
+        };
+        distribution: {
+            v1beta1: import("./distribution/v1beta1/tx.rpc.msg").MsgClientImpl;
+        };
+        evidence: {
+            v1beta1: import("./evidence/v1beta1/tx.rpc.msg").MsgClientImpl;
+        };
+        evm: {
+            feemarket: {
+                v1: import("./evm/feemarket/v1/tx.rpc.msg").MsgClientImpl;
+            };
+            vm: {
+                v1: import("./evm/vm/v1/tx.rpc.msg").MsgClientImpl;
+            };
         };
         feegrant: {
             v1beta1: import("./feegrant/v1beta1/tx.rpc.msg").MsgClientImpl;
         };
-        distribution: {
-            v1beta1: import("./distribution/v1beta1/tx.rpc.msg").MsgClientImpl;
+        gov: {
+            v1: import("./gov/v1/tx.rpc.msg").MsgClientImpl;
+            v1beta1: import("./gov/v1beta1/tx.rpc.msg").MsgClientImpl;
         };
-        bank: {
-            v1beta1: import("./bank/v1beta1/tx.rpc.msg").MsgClientImpl;
+        mint: {
+            v1beta1: import("./mint/v1beta1/tx.rpc.msg").MsgClientImpl;
         };
-        authz: {
-            v1beta1: import("./authz/v1beta1/tx.rpc.msg").MsgClientImpl;
+        slashing: {
+            v1beta1: import("./slashing/v1beta1/tx.rpc.msg").MsgClientImpl;
+        };
+        staking: {
+            v1beta1: import("./staking/v1beta1/tx.rpc.msg").MsgClientImpl;
+        };
+        upgrade: {
+            v1beta1: import("./upgrade/v1beta1/tx.rpc.msg").MsgClientImpl;
         };
     };
 }>;

package/cosmos/rpc.tx.js

@@ -26,30 +26,50 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRPCMsgClient = void 0;
 const createRPCMsgClient = async ({ rpc }) => ({
     cosmos: {
-        vesting: {
-            v1beta1: new (await Promise.resolve().then(() => __importStar(require("./vesting/v1beta1/tx.rpc.msg")))).MsgClientImpl(rpc)
+        auth: {
+            v1beta1: new (await Promise.resolve().then(() => __importStar(require("./auth/v1beta1/tx.rpc.msg")))).MsgClientImpl(rpc)
         },
-        staking: {
-            v1beta1: new (await Promise.resolve().then(() => __importStar(require("./staking/v1beta1/tx.rpc.msg")))).MsgClientImpl(rpc)
+        authz: {
+            v1beta1: new (await Promise.resolve().then(() => __importStar(require("./authz/v1beta1/tx.rpc.msg")))).MsgClientImpl(rpc)
+        },
+        bank: {
+            v1beta1: new (await Promise.resolve().then(() => __importStar(require("./bank/v1beta1/tx.rpc.msg")))).MsgClientImpl(rpc)
         },
-        group: {
-            v1: new (await Promise.resolve().then(() => __importStar(require("./group/v1/tx.rpc.msg")))).MsgClientImpl(rpc)
+        consensus: {
+            v1: new (await Promise.resolve().then(() => __importStar(require("./consensus/v1/tx.rpc.msg")))).MsgClientImpl(rpc)
         },
-        gov: {
-            v1beta1: new (await Promise.resolve().then(() => __importStar(require("./gov/v1beta1/tx.rpc.msg")))).MsgClientImpl(rpc),
-            v1: new (await Promise.resolve().then(() => __importStar(require("./gov/v1/tx.rpc.msg")))).MsgClientImpl(rpc)
+        distribution: {
+            v1beta1: new (await Promise.resolve().then(() => __importStar(require("./distribution/v1beta1/tx.rpc.msg")))).MsgClientImpl(rpc)
+        },
+        evidence: {
+            v1beta1: new (await Promise.resolve().then(() => __importStar(require("./evidence/v1beta1/tx.rpc.msg")))).MsgClientImpl(rpc)
+        },
+        evm: {
+            feemarket: {
+                v1: new (await Promise.resolve().then(() => __importStar(require("./evm/feemarket/v1/tx.rpc.msg")))).MsgClientImpl(rpc)
+            },
+            vm: {
+                v1: new (await Promise.resolve().then(() => __importStar(require("./evm/vm/v1/tx.rpc.msg")))).MsgClientImpl(rpc)
+            }
         },
         feegrant: {
             v1beta1: new (await Promise.resolve().then(() => __importStar(require("./feegrant/v1beta1/tx.rpc.msg")))).MsgClientImpl(rpc)
         },
-        distribution: {
-            v1beta1: new (await Promise.resolve().then(() => __importStar(require("./distribution/v1beta1/tx.rpc.msg")))).MsgClientImpl(rpc)
+        gov: {
+            v1: new (await Promise.resolve().then(() => __importStar(require("./gov/v1/tx.rpc.msg")))).MsgClientImpl(rpc),
+            v1beta1: new (await Promise.resolve().then(() => __importStar(require("./gov/v1beta1/tx.rpc.msg")))).MsgClientImpl(rpc)
         },
-        bank: {
-            v1beta1: new (await Promise.resolve().then(() => __importStar(require("./bank/v1beta1/tx.rpc.msg")))).MsgClientImpl(rpc)
+        mint: {
+            v1beta1: new (await Promise.resolve().then(() => __importStar(require("./mint/v1beta1/tx.rpc.msg")))).MsgClientImpl(rpc)
         },
-        authz: {
-            v1beta1: new (await Promise.resolve().then(() => __importStar(require("./authz/v1beta1/tx.rpc.msg")))).MsgClientImpl(rpc)
+        slashing: {
+            v1beta1: new (await Promise.resolve().then(() => __importStar(require("./slashing/v1beta1/tx.rpc.msg")))).MsgClientImpl(rpc)
+        },
+        staking: {
+            v1beta1: new (await Promise.resolve().then(() => __importStar(require("./staking/v1beta1/tx.rpc.msg")))).MsgClientImpl(rpc)
+        },
+        upgrade: {
+            v1beta1: new (await Promise.resolve().then(() => __importStar(require("./upgrade/v1beta1/tx.rpc.msg")))).MsgClientImpl(rpc)
         }
     }
 });

package/cosmos/slashing/module/v1/module.d.ts

@@ -1,23 +1,43 @@
 import { BinaryReader, BinaryWriter } from "../../../../binary";
 import { DeepPartial } from "../../../../helpers";
-/** Module is the config object of the slashing module. */
+/**
+ * Module is the config object of the slashing module.
+ * @name Module
+ * @package cosmos.slashing.module.v1
+ * @see proto type: cosmos.slashing.module.v1.Module
+ */
 export interface Module {
-    /** authority defines the custom module authority. If not set, defaults to the governance module. */
+    /**
+     * authority defines the custom module authority. If not set, defaults to the governance module.
+     */
     authority: string;
 }
 export interface ModuleProtoMsg {
     typeUrl: "/cosmos.slashing.module.v1.Module";
     value: Uint8Array;
 }
-/** Module is the config object of the slashing module. */
+/**
+ * Module is the config object of the slashing module.
+ * @name ModuleAmino
+ * @package cosmos.slashing.module.v1
+ * @see proto type: cosmos.slashing.module.v1.Module
+ */
 export interface ModuleAmino {
-    /** authority defines the custom module authority. If not set, defaults to the governance module. */
+    /**
+     * authority defines the custom module authority. If not set, defaults to the governance module.
+     */
     authority: string;
 }
 export interface ModuleAminoMsg {
     type: "cosmos-sdk/Module";
     value: ModuleAmino;
 }
+/**
+ * Module is the config object of the slashing module.
+ * @name Module
+ * @package cosmos.slashing.module.v1
+ * @see proto type: cosmos.slashing.module.v1.Module
+ */
 export declare const Module: {
     typeUrl: string;
     aminoType: string;

package/cosmos/slashing/module/v1/module.js

@@ -7,6 +7,12 @@ function createBaseModule() {
         authority: ""
     };
 }
+/**
+ * Module is the config object of the slashing module.
+ * @name Module
+ * @package cosmos.slashing.module.v1
+ * @see proto type: cosmos.slashing.module.v1.Module
+ */
 exports.Module = {
     typeUrl: "/cosmos.slashing.module.v1.Module",
     aminoType: "cosmos-sdk/Module",