Options
All
  • Public
  • Public/Protected
  • All
Menu

Namespace <internal>

Index

Namespaces

Enumerations

Classes

Interfaces

Type aliases

Variables

Type aliases

ABCIMessageLog: { events?: StringEvent[]; log?: string; msg_index?: number }

Type declaration

  • Optional events?: StringEvent[]
  • Optional log?: string
  • Optional msg_index?: number
Absent<T, K>: { [ k in Exclude<keyof T, K>]?: undefined }

Type parameters

  • T

  • K: keyof T

Absent<T, K>: { [ k in Exclude<keyof T, K>]?: undefined }

Type parameters

  • T

  • K: keyof T

Absent<T, K>: { [ k in Exclude<keyof T, K>]?: undefined }

Type parameters

  • T

  • K: keyof T

Absent<T, K>: { [ k in Exclude<keyof T, K>]?: undefined }

Type parameters

  • T

  • K: keyof T

AbsoluteTxPosition: { block_height?: string; tx_index?: string }

Type declaration

  • Optional block_height?: string
  • Optional tx_index?: string
AccountData: { address: string; algo: Algo; pubkey: Uint8Array }

Type declaration

  • Readonly address: string

    A printable address (typically bech32 encoded)

  • Readonly algo: Algo
  • Readonly pubkey: Uint8Array
Algo: "secp256k1" | "ed25519" | "sr25519"
AminoSignResponse: { signature: <internal>.StdSignature; signed: StdSignDoc }

Type declaration

  • Readonly signature: <internal>.StdSignature
  • Readonly signed: StdSignDoc

    The sign doc that was signed. This may be different from the input signDoc when the signer modifies it as part of the signing process.

Any: { type_url?: string; value?: Uint8Array }

Type declaration

  • Optional type_url?: string
  • Optional value?: Uint8Array
ArrayBufferLike: ArrayBufferTypes[keyof ArrayBufferTypes]
ArrayBufferView: TypedArray | DataView
Attribute: { key?: string; value?: string }

Type declaration

  • Optional key?: string
  • Optional value?: string
AuthInfo: { fee?: <internal>.Fee; signer_infos?: <internal>.SignerInfo[] }

Type declaration

BaseAccount: { account_number?: string; address?: string; pub_key?: <internal>.Any; sequence?: string }

Type declaration

  • Optional account_number?: string
  • Optional address?: string
  • Optional pub_key?: <internal>.Any
  • Optional sequence?: string
BaseEvidence: {}

Type declaration

    BaseModeInfo: {}

    Type declaration

      BasePublicKey: {}

      Type declaration

        BaseRequest: {}

        Type declaration

          BaseResponse: {}

          Type declaration

            BaseVestingAccount: { base_account?: BaseAccount; delegated_free?: <internal>.Coin[]; delegated_vesting?: <internal>.Coin[]; end_time?: string; original_vesting?: <internal>.Coin[] }

            Type declaration

            Block: { data?: Data; evidence?: EvidenceList; header?: Header; last_commit?: Commit }

            Type declaration

            BlockID: { hash?: Uint8Array; part_set_header?: PartSetHeader }

            Type declaration

            • Optional hash?: Uint8Array
            • Optional part_set_header?: PartSetHeader
            BufferEncoding: "ascii" | "utf8" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex"
            BufferSource: <internal>.ArrayBufferView | ArrayBuffer
            Builtin: Date | Function | Uint8Array | string | number | boolean | undefined
            Builtin: Date | Function | Uint8Array | string | number | boolean | undefined
            Builtin: Date | Function | Uint8Array | string | number | boolean | undefined
            Builtin: Date | Function | Uint8Array | string | number | boolean | undefined
            Builtin: Date | Function | Uint8Array | string | number | boolean | undefined
            Builtin: Date | Function | Uint8Array | string | number | boolean | undefined
            BurnType: { burn: { burner: string; owner: string } }

            Type declaration

            • burn: { burner: string; owner: string }
              • burner: string
              • owner: string
            Channel: { connection_hops?: string[]; counterparty?: <internal>.Counterparty; ordering?: <internal>.Order; state?: <internal>.State; version?: string }

            Type declaration

            CodeInfoResponse: { builder?: string; code_hash?: string; code_id?: string; creator?: string; source?: string }

            Type declaration

            • Optional builder?: string
            • Optional code_hash?: string
            • Optional code_id?: string
            • Optional creator?: string
            • Optional source?: string
            Coin: { amount?: string; denom?: string }

            Type declaration

            • Optional amount?: string
            • Optional denom?: string
            Commission: { commission_rates?: <internal>.CommissionRates; update_time?: <internal>.Timestamp }

            Type declaration

            CommissionRates: { max_change_rate?: string; max_rate?: string; rate?: string }

            Type declaration

            • Optional max_change_rate?: string
            • Optional max_rate?: string
            • Optional rate?: string
            Commit: { block_id?: BlockID; height?: string; round?: number; signatures?: CommitSig[] }

            Type declaration

            • Optional block_id?: BlockID
            • Optional height?: string
            • Optional round?: number
            • Optional signatures?: CommitSig[]
            CommitSig: { block_id_flag?: BlockIDFlag; signature?: Uint8Array; timestamp?: <internal>.Timestamp; validator_address?: Uint8Array }

            Type declaration

            CompactBitArray: { elems?: Uint8Array; extra_bits_stored?: number }

            Type declaration

            • Optional elems?: Uint8Array
            • Optional extra_bits_stored?: number
            ConfigRequest: {}

            Type declaration

              ConfigResponse: { minimum_gas_price?: string }

              Type declaration

              • Optional minimum_gas_price?: string
              ConnectionEnd: { client_id?: string; counterparty?: <internal>.Counterparty; delay_period?: string; state?: <internal>.State; versions?: <internal>.Version[] }

              Type declaration

              Consensus: { app?: string; block?: string }

              Type declaration

              • Optional app?: string
              • Optional block?: string
              ConsensusStateWithHeight: { consensus_state?: <internal>.Any; height?: <internal>.Height }

              Type declaration

              ContractInfo: { code_id?: string; created?: AbsoluteTxPosition; creator?: Uint8Array; ibc_port_id?: string; label?: string }

              Type declaration

              • Optional code_id?: string
              • Optional created?: AbsoluteTxPosition
              • Optional creator?: Uint8Array
              • Optional ibc_port_id?: string
              • Optional label?: string
              ContractInfoWithAddress: { ContractInfo?: ContractInfo; contract_address?: string }

              Type declaration

              • Optional ContractInfo?: ContractInfo
              • Optional contract_address?: string
              Counterparty: { channel_id?: string; port_id?: string }

              Type declaration

              • Optional channel_id?: string
              • Optional port_id?: string
              Counterparty: { client_id?: string; connection_id?: string; prefix?: <internal>.MerklePrefix }

              Type declaration

              CreateViewingKeyContractParams: MsgExecuteContractParams<CreateViewingKeyOptions>
              Data: { txs?: Uint8Array[] }

              Type declaration

              • Optional txs?: Uint8Array[]
              DecCoin: { amount?: string; denom?: string }

              Type declaration

              • Optional amount?: string
              • Optional denom?: string
              DefaultNodeInfo: { channels?: Uint8Array; default_node_id?: string; listen_addr?: string; moniker?: string; network?: string; other?: DefaultNodeInfoOther; protocol_version?: ProtocolVersion; version?: string }

              Type declaration

              • Optional channels?: Uint8Array
              • Optional default_node_id?: string
              • Optional listen_addr?: string
              • Optional moniker?: string
              • Optional network?: string
              • Optional other?: DefaultNodeInfoOther
              • Optional protocol_version?: ProtocolVersion
              • Optional version?: string
              DefaultNodeInfoOther: { rpc_address?: string; tx_index?: string }

              Type declaration

              • Optional rpc_address?: string
              • Optional tx_index?: string
              Delegation: { delegator_address?: string; shares?: string; validator_address?: string }

              Type declaration

              • Optional delegator_address?: string
              • Optional shares?: string
              • Optional validator_address?: string
              DelegationDelegatorReward: { reward?: <internal>.DecCoin[]; validator_address?: string }

              Type declaration

              DelegationResponse: { balance?: <internal>.Coin; delegation?: Delegation }

              Type declaration

              DenomTrace: { base_denom?: string; path?: string }

              Type declaration

              • Optional base_denom?: string
              • Optional path?: string
              DenomUnit: { aliases?: string[]; denom?: string; exponent?: number }

              Type declaration

              • Optional aliases?: string[]
              • Optional denom?: string
              • Optional exponent?: number
              Deposit: { amount?: <internal>.Coin[]; depositor?: string; proposal_id?: string }

              Type declaration

              • Optional amount?: <internal>.Coin[]
              • Optional depositor?: string
              • Optional proposal_id?: string
              DepositParams: { max_deposit_period?: <internal>.Duration; min_deposit?: <internal>.Coin[] }

              Type declaration

              DepositType: { deposit: {} }

              Type declaration

              • deposit: {}
                Description: { details?: string; identity?: string; moniker?: string; security_contact?: string; website?: string }

                Type declaration

                • Optional details?: string
                • Optional identity?: string
                • Optional moniker?: string
                • Optional security_contact?: string
                • Optional website?: string

                Type declaration

                Type declaration

                DirectSigner: { getAccounts: any; signDirect: any }

                Type declaration

                DuplicateVoteEvidence: { timestamp?: <internal>.Timestamp; total_voting_power?: string; validator_power?: string; vote_a?: <internal>.Vote; vote_b?: <internal>.Vote }

                Type declaration

                Duration: { nanos?: number; seconds?: string }

                Type declaration

                • Optional nanos?: number
                • Optional seconds?: string
                Empty: {}

                Type declaration

                  Evidence: BaseEvidence & <internal>.OneOf<{ duplicate_vote_evidence: DuplicateVoteEvidence; light_client_attack_evidence: LightClientAttackEvidence }>
                  EvidenceList: { evidence?: <internal>.Evidence[] }

                  Type declaration

                  EvidenceParams: { max_age_duration?: <internal>.Duration; max_age_num_blocks?: string; max_bytes?: string }

                  Type declaration

                  • Optional max_age_duration?: <internal>.Duration
                  • Optional max_age_num_blocks?: string
                  • Optional max_bytes?: string
                  Exclude<T, U>: T extends U ? never : T

                  Exclude from T those types that are assignable to U

                  Type parameters

                  • T

                  • U

                  Fee: { amount?: <internal>.Coin[]; gas_limit?: string; granter?: string; payer?: string }

                  Type declaration

                  • Optional amount?: <internal>.Coin[]
                  • Optional gas_limit?: string
                  • Optional granter?: string
                  • Optional payer?: string
                  FormDataEntryValue: <internal>.File | string
                  GasInfo: { gas_used?: string; gas_wanted?: string }

                  Type declaration

                  • Optional gas_used?: string
                  • Optional gas_wanted?: string
                  GetBlockByHeightRequest: { height?: string }

                  Type declaration

                  • Optional height?: string
                  GetBlockByHeightResponse: { block?: Block; block_id?: BlockID }

                  Type declaration

                  GetLatestBlockRequest: {}

                  Type declaration

                    GetLatestBlockResponse: { block?: Block; block_id?: BlockID }

                    Type declaration

                    GetLatestValidatorSetRequest: { pagination?: PageRequest }

                    Type declaration

                    GetLatestValidatorSetResponse: { block_height?: string; pagination?: PageResponse; validators?: <internal>.Validator[] }

                    Type declaration

                    GetNodeInfoRequest: {}

                    Type declaration

                      GetNodeInfoResponse: { application_version?: VersionInfo; default_node_info?: DefaultNodeInfo }

                      Type declaration

                      GetSyncingRequest: {}

                      Type declaration

                        GetSyncingResponse: { syncing?: boolean }

                        Type declaration

                        • Optional syncing?: boolean
                        GetValidatorSetByHeightRequest: { height?: string; pagination?: PageRequest }

                        Type declaration

                        • Optional height?: string
                        • Optional pagination?: PageRequest
                        GetValidatorSetByHeightResponse: { block_height?: string; pagination?: PageResponse; validators?: <internal>.Validator[] }

                        Type declaration

                        Grant: { authorization?: <internal>.Any; expiration?: <internal>.Timestamp }

                        Type declaration

                        Grant: { allowance?: <internal>.Any; grantee?: string; granter?: string }

                        Type declaration

                        • Optional allowance?: <internal>.Any
                        • Optional grantee?: string
                        • Optional granter?: string
                        GrantAuthorization: { authorization?: <internal>.Any; expiration?: <internal>.Timestamp; grantee?: string; granter?: string }

                        Type declaration

                        Header: { app_hash?: Uint8Array; chain_id?: string; consensus_hash?: Uint8Array; data_hash?: Uint8Array; evidence_hash?: Uint8Array; height?: string; last_block_id?: BlockID; last_commit_hash?: Uint8Array; last_results_hash?: Uint8Array; next_validators_hash?: Uint8Array; proposer_address?: Uint8Array; time?: <internal>.Timestamp; validators_hash?: Uint8Array; version?: Consensus }

                        Type declaration

                        • Optional app_hash?: Uint8Array
                        • Optional chain_id?: string
                        • Optional consensus_hash?: Uint8Array
                        • Optional data_hash?: Uint8Array
                        • Optional evidence_hash?: Uint8Array
                        • Optional height?: string
                        • Optional last_block_id?: BlockID
                        • Optional last_commit_hash?: Uint8Array
                        • Optional last_results_hash?: Uint8Array
                        • Optional next_validators_hash?: Uint8Array
                        • Optional proposer_address?: Uint8Array
                        • Optional time?: <internal>.Timestamp
                        • Optional validators_hash?: Uint8Array
                        • Optional version?: Consensus
                        HeadersInit: string[][] | Record<string, string> | <internal>.Headers
                        Height: { revision_height?: string; revision_number?: string }

                        Type declaration

                        • Optional revision_height?: string
                        • Optional revision_number?: string
                        HistoricalInfo: { header?: Header; valset?: <internal>.Validator[] }

                        Type declaration

                        IdentifiedChannel: { channel_id?: string; connection_hops?: string[]; counterparty?: <internal>.Counterparty; ordering?: <internal>.Order; port_id?: string; state?: <internal>.State; version?: string }

                        Type declaration

                        IdentifiedClientState: { client_id?: string; client_state?: <internal>.Any }

                        Type declaration

                        • Optional client_id?: string
                        • Optional client_state?: <internal>.Any
                        IdentifiedConnection: { client_id?: string; counterparty?: <internal>.Counterparty; delay_period?: string; id?: string; state?: <internal>.State; versions?: <internal>.Version[] }

                        Type declaration

                        IteratorResult<T, TReturn>: IteratorYieldResult<T> | IteratorReturnResult<TReturn>

                        Type parameters

                        • T

                        • TReturn = any

                        Key: { key?: Uint8Array }

                        Type declaration

                        • Optional key?: Uint8Array
                        KeysOfUnion<T>: T extends T ? keyof T : never

                        Type parameters

                        • T

                        KeysOfUnion<T>: T extends T ? keyof T : never

                        Type parameters

                        • T

                        KeysOfUnion<T>: T extends T ? keyof T : never

                        Type parameters

                        • T

                        KeysOfUnion<T>: T extends T ? keyof T : never

                        Type parameters

                        • T

                        KeysOfUnion<T>: T extends T ? keyof T : never

                        Type parameters

                        • T

                        KeysOfUnion<T>: T extends T ? keyof T : never

                        Type parameters

                        • T

                        LightBlock: { signed_header?: SignedHeader; validator_set?: ValidatorSet }

                        Type declaration

                        LightClientAttackEvidence: { byzantine_validators?: <internal>.Validator[]; common_height?: string; conflicting_block?: LightBlock; timestamp?: <internal>.Timestamp; total_voting_power?: string }

                        Type declaration

                        MerklePrefix: { key_prefix?: Uint8Array }

                        Type declaration

                        • Optional key_prefix?: Uint8Array
                        Metadata: { base?: string; denom_units?: DenomUnit[]; description?: string; display?: string; name?: string; symbol?: string }

                        Type declaration

                        • Optional base?: string
                        • Optional denom_units?: DenomUnit[]
                        • Optional description?: string
                        • Optional display?: string
                        • Optional name?: string
                        • Optional symbol?: string
                        MintType: { mint: { minter: string; recipient: string } }

                        Type declaration

                        • mint: { minter: string; recipient: string }
                          • minter: string
                          • recipient: string
                        ModeInfo: BaseModeInfo & <internal>.OneOf<{ multi: ModeInfoMulti; single: ModeInfoSingle }>
                        ModeInfoMulti: { bitarray?: <internal>.CompactBitArray; mode_infos?: <internal>.ModeInfo[] }

                        Type declaration

                        ModeInfoSingle: { mode?: <internal>.SignMode }

                        Type declaration

                        Module: { path?: string; sum?: string; version?: string }

                        Type declaration

                        • Optional path?: string
                        • Optional sum?: string
                        • Optional version?: string
                        ModuleAccount: { base_account?: BaseAccount; name?: string; permissions?: string[] }

                        Type declaration

                        • Optional base_account?: BaseAccount
                        • Optional name?: string
                        • Optional permissions?: string[]
                        ModuleVersion: { name?: string; version?: string }

                        Type declaration

                        • Optional name?: string
                        • Optional version?: string
                        OneOf<T>: { [ k in keyof T]?: undefined } | (keyof T extends infer K ? K extends string & keyof T ? { [ k in K]: T[K] } & <internal>.Absent<T, K> : never : never)

                        Type parameters

                        • T

                        OneOf<T>: { [ k in keyof T]?: undefined } | (keyof T extends infer K ? K extends string & keyof T ? { [ k in K]: T[K] } & <internal>.Absent<T, K> : never : never)

                        Type parameters

                        • T

                        OneOf<T>: { [ k in keyof T]?: undefined } | (keyof T extends infer K ? K extends string & keyof T ? { [ k in K]: T[K] } & <internal>.Absent<T, K> : never : never)

                        Type parameters

                        • T

                        OneOf<T>: { [ k in keyof T]?: undefined } | (keyof T extends infer K ? K extends string & keyof T ? { [ k in K]: T[K] } & <internal>.Absent<T, K> : never : never)

                        Type parameters

                        • T

                        PacketState: { channel_id?: string; data?: Uint8Array; port_id?: string; sequence?: string }

                        Type declaration

                        • Optional channel_id?: string
                        • Optional data?: Uint8Array
                        • Optional port_id?: string
                        • Optional sequence?: string
                        PageRequest: { count_total?: boolean; key?: Uint8Array; limit?: string; offset?: string; reverse?: boolean }

                        Type declaration

                        • Optional count_total?: boolean
                        • Optional key?: Uint8Array
                        • Optional limit?: string
                        • Optional offset?: string
                        • Optional reverse?: boolean
                        PageResponse: { next_key?: Uint8Array; total?: string }

                        Type declaration

                        • Optional next_key?: Uint8Array
                        • Optional total?: string
                        ParamChange: { key?: string; subspace?: string; value?: string }

                        Type declaration

                        • Optional key?: string
                        • Optional subspace?: string
                        • Optional value?: string
                        Params: { max_memo_characters?: string; sig_verify_cost_ed25519?: string; sig_verify_cost_secp256k1?: string; tx_sig_limit?: string; tx_size_cost_per_byte?: string }

                        Type declaration

                        • Optional max_memo_characters?: string
                        • Optional sig_verify_cost_ed25519?: string
                        • Optional sig_verify_cost_secp256k1?: string
                        • Optional tx_sig_limit?: string
                        • Optional tx_size_cost_per_byte?: string
                        Params: { default_send_enabled?: boolean; send_enabled?: SendEnabled[] }

                        Type declaration

                        • Optional default_send_enabled?: boolean
                        • Optional send_enabled?: SendEnabled[]
                        Params: { base_proposer_reward?: string; bonus_proposer_reward?: string; community_tax?: string; secret_foundation_address?: string; secret_foundation_tax?: string; withdraw_addr_enabled?: boolean }

                        Type declaration

                        • Optional base_proposer_reward?: string
                        • Optional bonus_proposer_reward?: string
                        • Optional community_tax?: string
                        • Optional secret_foundation_address?: string
                        • Optional secret_foundation_tax?: string
                        • Optional withdraw_addr_enabled?: boolean
                        Params: { allowed_clients?: string[] }

                        Type declaration

                        • Optional allowed_clients?: string[]
                        Params: { receive_enabled?: boolean; send_enabled?: boolean }

                        Type declaration

                        • Optional receive_enabled?: boolean
                        • Optional send_enabled?: boolean
                        Params: { blocks_per_year?: string; goal_bonded?: string; inflation_max?: string; inflation_min?: string; inflation_rate_change?: string; mint_denom?: string }

                        Type declaration

                        • Optional blocks_per_year?: string
                        • Optional goal_bonded?: string
                        • Optional inflation_max?: string
                        • Optional inflation_min?: string
                        • Optional inflation_rate_change?: string
                        • Optional mint_denom?: string
                        Params: { downtime_jail_duration?: <internal>.Duration; min_signed_per_window?: Uint8Array; signed_blocks_window?: string; slash_fraction_double_sign?: Uint8Array; slash_fraction_downtime?: Uint8Array }

                        Type declaration

                        • Optional downtime_jail_duration?: <internal>.Duration
                        • Optional min_signed_per_window?: Uint8Array
                        • Optional signed_blocks_window?: string
                        • Optional slash_fraction_double_sign?: Uint8Array
                        • Optional slash_fraction_downtime?: Uint8Array
                        Params: { bond_denom?: string; historical_entries?: number; max_entries?: number; max_validators?: number; unbonding_time?: <internal>.Duration }

                        Type declaration

                        • Optional bond_denom?: string
                        • Optional historical_entries?: number
                        • Optional max_entries?: number
                        • Optional max_validators?: number
                        • Optional unbonding_time?: <internal>.Duration
                        PartSetHeader: { hash?: Uint8Array; total?: number }

                        Type declaration

                        • Optional hash?: Uint8Array
                        • Optional total?: number
                        Partial<T>: { [ P in keyof T]?: T[P] }

                        Make all properties in T optional

                        Type parameters

                        • T

                        Plan: { height?: string; info?: string; name?: string; time?: <internal>.Timestamp; upgraded_client_state?: <internal>.Any }

                        Type declaration

                        Pool: { bonded_tokens?: string; not_bonded_tokens?: string }

                        Type declaration

                        • Optional bonded_tokens?: string
                        • Optional not_bonded_tokens?: string
                        ProofOp: { data?: Uint8Array; key?: Uint8Array; type?: string }

                        Type declaration

                        • Optional data?: Uint8Array
                        • Optional key?: Uint8Array
                        • Optional type?: string
                        ProofOps: { ops?: ProofOp[] }

                        Type declaration

                        Proposal: { content?: <internal>.Any; deposit_end_time?: <internal>.Timestamp; final_tally_result?: <internal>.TallyResult; proposal_id?: string; status?: <internal>.ProposalStatus; submit_time?: <internal>.Timestamp; total_deposit?: <internal>.Coin[]; voting_end_time?: <internal>.Timestamp; voting_start_time?: <internal>.Timestamp }

                        Type declaration

                        ProtocolVersion: { app?: string; block?: string; p2p?: string }

                        Type declaration

                        • Optional app?: string
                        • Optional block?: string
                        • Optional p2p?: string
                        Pubkey: { type: string; value: any }

                        Type declaration

                        • Readonly type: string
                        • Readonly value: any
                        PublicKey: BasePublicKey & <internal>.OneOf<{ ed25519: Uint8Array; secp256k1: Uint8Array }>
                        QueryAccountRequest: { address?: string }

                        Type declaration

                        • Optional address?: string
                        QueryAccountsRequest: { pagination?: PageRequest }

                        Type declaration

                        QueryAllBalancesRequest: { address?: string; pagination?: PageRequest }

                        Type declaration

                        • Optional address?: string
                        • Optional pagination?: PageRequest
                        QueryAllBalancesResponse: { balances?: <internal>.Coin[]; pagination?: PageResponse }

                        Type declaration

                        QueryAllEvidenceRequest: { pagination?: PageRequest }

                        Type declaration

                        QueryAllEvidenceResponse: { evidence?: <internal>.Any[]; pagination?: PageResponse }

                        Type declaration

                        QueryAllowanceRequest: { grantee?: string; granter?: string }

                        Type declaration

                        • Optional grantee?: string
                        • Optional granter?: string
                        QueryAllowanceResponse: { allowance?: <internal>.Grant }

                        Type declaration

                        QueryAllowancesByGranterRequest: { granter?: string; pagination?: PageRequest }

                        Type declaration

                        • Optional granter?: string
                        • Optional pagination?: PageRequest
                        QueryAllowancesByGranterResponse: { allowances?: <internal>.Grant[]; pagination?: PageResponse }

                        Type declaration

                        QueryAllowancesRequest: { grantee?: string; pagination?: PageRequest }

                        Type declaration

                        • Optional grantee?: string
                        • Optional pagination?: PageRequest
                        QueryAllowancesResponse: { allowances?: <internal>.Grant[]; pagination?: PageResponse }

                        Type declaration

                        QueryAnnualProvisionsRequest: {}

                        Type declaration

                          QueryAnnualProvisionsResponse: { annual_provisions?: Uint8Array }

                          Type declaration

                          • Optional annual_provisions?: Uint8Array
                          QueryAppliedPlanRequest: { name?: string }

                          Type declaration

                          • Optional name?: string
                          QueryAppliedPlanResponse: { height?: string }

                          Type declaration

                          • Optional height?: string
                          QueryBalanceRequest: { address?: string; denom?: string }

                          Type declaration

                          • Optional address?: string
                          • Optional denom?: string
                          QueryBalanceResponse: { balance?: <internal>.Coin }

                          Type declaration

                          QueryByCodeIdRequest: { code_id?: string }

                          Type declaration

                          • Optional code_id?: string
                          QueryByContractAddressRequest: { contract_address?: string }

                          Type declaration

                          • Optional contract_address?: string
                          QueryByLabelRequest: { label?: string }

                          Type declaration

                          • Optional label?: string
                          QueryChannelClientStateRequest: { channel_id?: string; port_id?: string }

                          Type declaration

                          • Optional channel_id?: string
                          • Optional port_id?: string
                          QueryChannelClientStateResponse: { identified_client_state?: <internal>.IdentifiedClientState; proof?: Uint8Array; proof_height?: <internal>.Height }

                          Type declaration

                          QueryChannelConsensusStateRequest: { channel_id?: string; port_id?: string; revision_height?: string; revision_number?: string }

                          Type declaration

                          • Optional channel_id?: string
                          • Optional port_id?: string
                          • Optional revision_height?: string
                          • Optional revision_number?: string
                          QueryChannelConsensusStateResponse: { client_id?: string; consensus_state?: <internal>.Any; proof?: Uint8Array; proof_height?: <internal>.Height }

                          Type declaration

                          QueryChannelRequest: { channel_id?: string; port_id?: string }

                          Type declaration

                          • Optional channel_id?: string
                          • Optional port_id?: string
                          QueryChannelResponse: { channel?: <internal>.Channel; proof?: Uint8Array; proof_height?: <internal>.Height }

                          Type declaration

                          QueryChannelsRequest: { pagination?: PageRequest }

                          Type declaration

                          QueryChannelsResponse: { channels?: IdentifiedChannel[]; height?: <internal>.Height; pagination?: PageResponse }

                          Type declaration

                          QueryClientConnectionsRequest: { client_id?: string }

                          Type declaration

                          • Optional client_id?: string
                          QueryClientConnectionsResponse: { connection_paths?: string[]; proof?: Uint8Array; proof_height?: <internal>.Height }

                          Type declaration

                          • Optional connection_paths?: string[]
                          • Optional proof?: Uint8Array
                          • Optional proof_height?: <internal>.Height
                          QueryClientParamsRequest: {}

                          Type declaration

                            QueryClientParamsResponse: { params?: <internal>.Params }

                            Type declaration

                            QueryClientStateRequest: { client_id?: string }

                            Type declaration

                            • Optional client_id?: string
                            QueryClientStateResponse: { client_state?: <internal>.Any; proof?: Uint8Array; proof_height?: <internal>.Height }

                            Type declaration

                            QueryClientStatesRequest: { pagination?: PageRequest }

                            Type declaration

                            QueryClientStatesResponse: { client_states?: <internal>.IdentifiedClientState[]; pagination?: PageResponse }

                            Type declaration

                            QueryClientStatusRequest: { client_id?: string }

                            Type declaration

                            • Optional client_id?: string
                            QueryClientStatusResponse: { status?: string }

                            Type declaration

                            • Optional status?: string
                            QueryCodeHashResponse: { code_hash?: string }

                            Type declaration

                            • Optional code_hash?: string
                            QueryCodeResponse: { code_info?: CodeInfoResponse; wasm?: Uint8Array }

                            Type declaration

                            QueryCodesResponse: { code_infos?: CodeInfoResponse[] }

                            Type declaration

                            QueryCommunityPoolRequest: {}

                            Type declaration

                              QueryCommunityPoolResponse: { pool?: <internal>.DecCoin[] }

                              Type declaration

                              QueryConnectionChannelsRequest: { connection?: string; pagination?: PageRequest }

                              Type declaration

                              • Optional connection?: string
                              • Optional pagination?: PageRequest
                              QueryConnectionChannelsResponse: { channels?: IdentifiedChannel[]; height?: <internal>.Height; pagination?: PageResponse }

                              Type declaration

                              QueryConnectionClientStateRequest: { connection_id?: string }

                              Type declaration

                              • Optional connection_id?: string
                              QueryConnectionClientStateResponse: { identified_client_state?: <internal>.IdentifiedClientState; proof?: Uint8Array; proof_height?: <internal>.Height }

                              Type declaration

                              QueryConnectionConsensusStateRequest: { connection_id?: string; revision_height?: string; revision_number?: string }

                              Type declaration

                              • Optional connection_id?: string
                              • Optional revision_height?: string
                              • Optional revision_number?: string
                              QueryConnectionConsensusStateResponse: { client_id?: string; consensus_state?: <internal>.Any; proof?: Uint8Array; proof_height?: <internal>.Height }

                              Type declaration

                              QueryConnectionRequest: { connection_id?: string }

                              Type declaration

                              • Optional connection_id?: string
                              QueryConnectionResponse: { connection?: ConnectionEnd; proof?: Uint8Array; proof_height?: <internal>.Height }

                              Type declaration

                              QueryConnectionsRequest: { pagination?: PageRequest }

                              Type declaration

                              QueryConnectionsResponse: { connections?: IdentifiedConnection[]; height?: <internal>.Height; pagination?: PageResponse }

                              Type declaration

                              QueryConsensusStateRequest: { client_id?: string; latest_height?: boolean; revision_height?: string; revision_number?: string }

                              Type declaration

                              • Optional client_id?: string
                              • Optional latest_height?: boolean
                              • Optional revision_height?: string
                              • Optional revision_number?: string
                              QueryConsensusStateResponse: { consensus_state?: <internal>.Any; proof?: Uint8Array; proof_height?: <internal>.Height }

                              Type declaration

                              QueryConsensusStatesRequest: { client_id?: string; pagination?: PageRequest }

                              Type declaration

                              • Optional client_id?: string
                              • Optional pagination?: PageRequest
                              QueryConsensusStatesResponse: { consensus_states?: <internal>.ConsensusStateWithHeight[]; pagination?: PageResponse }

                              Type declaration

                              QueryContractAddressResponse: { contract_address?: string }

                              Type declaration

                              • Optional contract_address?: string
                              QueryContractInfoResponse: { ContractInfo?: ContractInfo; contract_address?: string }

                              Type declaration

                              • Optional ContractInfo?: ContractInfo
                              • Optional contract_address?: string
                              QueryContractLabelResponse: { label?: string }

                              Type declaration

                              • Optional label?: string
                              QueryContractsByCodeIdResponse: { contract_infos?: ContractInfoWithAddress[] }

                              Type declaration

                              QueryCurrentPlanRequest: {}

                              Type declaration

                                QueryCurrentPlanResponse: { plan?: <internal>.Plan }

                                Type declaration

                                QueryDelegationRequest: { delegator_addr?: string; validator_addr?: string }

                                Type declaration

                                • Optional delegator_addr?: string
                                • Optional validator_addr?: string
                                QueryDelegationResponse: { delegation_response?: DelegationResponse }

                                Type declaration

                                QueryDelegationRewardsRequest: { delegator_address?: string; validator_address?: string }

                                Type declaration

                                • Optional delegator_address?: string
                                • Optional validator_address?: string
                                QueryDelegationRewardsResponse: { rewards?: <internal>.DecCoin[] }

                                Type declaration

                                QueryDelegationTotalRewardsRequest: { delegator_address?: string }

                                Type declaration

                                • Optional delegator_address?: string
                                QueryDelegationTotalRewardsResponse: { rewards?: <internal>.DelegationDelegatorReward[]; total?: <internal>.DecCoin[] }

                                Type declaration

                                QueryDelegatorDelegationsRequest: { delegator_addr?: string; pagination?: PageRequest }

                                Type declaration

                                • Optional delegator_addr?: string
                                • Optional pagination?: PageRequest
                                QueryDelegatorDelegationsResponse: { delegation_responses?: DelegationResponse[]; pagination?: PageResponse }

                                Type declaration

                                QueryDelegatorUnbondingDelegationsRequest: { delegator_addr?: string; pagination?: PageRequest }

                                Type declaration

                                • Optional delegator_addr?: string
                                • Optional pagination?: PageRequest
                                QueryDelegatorUnbondingDelegationsResponse: { pagination?: PageResponse; unbonding_responses?: UnbondingDelegation[] }

                                Type declaration

                                QueryDelegatorValidatorRequest: { delegator_addr?: string; validator_addr?: string }

                                Type declaration

                                • Optional delegator_addr?: string
                                • Optional validator_addr?: string
                                QueryDelegatorValidatorResponse: { validator?: <internal>.Validator }

                                Type declaration

                                QueryDelegatorValidatorsRequest: { delegator_address?: string }

                                Type declaration

                                • Optional delegator_address?: string
                                QueryDelegatorValidatorsRequest: { delegator_addr?: string; pagination?: PageRequest }

                                Type declaration

                                • Optional delegator_addr?: string
                                • Optional pagination?: PageRequest
                                QueryDelegatorValidatorsResponse: { validators?: string[] }

                                Type declaration

                                • Optional validators?: string[]
                                QueryDelegatorValidatorsResponse: { pagination?: PageResponse; validators?: <internal>.Validator[] }

                                Type declaration

                                QueryDelegatorWithdrawAddressRequest: { delegator_address?: string }

                                Type declaration

                                • Optional delegator_address?: string
                                QueryDelegatorWithdrawAddressResponse: { withdraw_address?: string }

                                Type declaration

                                • Optional withdraw_address?: string
                                QueryDenomHashRequest: { trace?: string }

                                Type declaration

                                • Optional trace?: string
                                QueryDenomHashResponse: { hash?: string }

                                Type declaration

                                • Optional hash?: string
                                QueryDenomMetadataRequest: { denom?: string }

                                Type declaration

                                • Optional denom?: string
                                QueryDenomMetadataResponse: { metadata?: <internal>.Metadata }

                                Type declaration

                                QueryDenomTraceRequest: { hash?: string }

                                Type declaration

                                • Optional hash?: string
                                QueryDenomTraceResponse: { denom_trace?: DenomTrace }

                                Type declaration

                                QueryDenomTracesRequest: { pagination?: PageRequest }

                                Type declaration

                                QueryDenomTracesResponse: { denom_traces?: DenomTrace[]; pagination?: PageResponse }

                                Type declaration

                                QueryDenomsMetadataRequest: { pagination?: PageRequest }

                                Type declaration

                                QueryDenomsMetadataResponse: { metadatas?: <internal>.Metadata[]; pagination?: PageResponse }

                                Type declaration

                                QueryDepositRequest: { depositor?: string; proposal_id?: string }

                                Type declaration

                                • Optional depositor?: string
                                • Optional proposal_id?: string
                                QueryDepositResponse: { deposit?: <internal>.Deposit }

                                Type declaration

                                QueryDepositsRequest: { pagination?: PageRequest; proposal_id?: string }

                                Type declaration

                                • Optional pagination?: PageRequest
                                • Optional proposal_id?: string
                                QueryDepositsResponse: { deposits?: <internal>.Deposit[]; pagination?: PageResponse }

                                Type declaration

                                QueryEncryptedSeedRequest: { pub_key?: Uint8Array }

                                Type declaration

                                • Optional pub_key?: Uint8Array
                                QueryEncryptedSeedResponse: { encrypted_seed?: Uint8Array }

                                Type declaration

                                • Optional encrypted_seed?: Uint8Array
                                QueryEvidenceRequest: { evidence_hash?: Uint8Array }

                                Type declaration

                                • Optional evidence_hash?: Uint8Array
                                QueryEvidenceResponse: { evidence?: <internal>.Any }

                                Type declaration

                                QueryFoundationTaxRequest: {}

                                Type declaration

                                  QueryFoundationTaxResponse: { foundation_address?: string; tax?: string }

                                  Type declaration

                                  • Optional foundation_address?: string
                                  • Optional tax?: string
                                  QueryGranteeGrantsRequest: { grantee?: string; pagination?: PageRequest }

                                  Type declaration

                                  • Optional grantee?: string
                                  • Optional pagination?: PageRequest
                                  QueryGranteeGrantsResponse: { grants?: GrantAuthorization[]; pagination?: PageResponse }

                                  Type declaration

                                  QueryGranterGrantsRequest: { granter?: string; pagination?: PageRequest }

                                  Type declaration

                                  • Optional granter?: string
                                  • Optional pagination?: PageRequest
                                  QueryGranterGrantsResponse: { grants?: GrantAuthorization[]; pagination?: PageResponse }

                                  Type declaration

                                  QueryGrantsRequest: { grantee?: string; granter?: string; msg_type_url?: string; pagination?: PageRequest }

                                  Type declaration

                                  • Optional grantee?: string
                                  • Optional granter?: string
                                  • Optional msg_type_url?: string
                                  • Optional pagination?: PageRequest
                                  QueryGrantsResponse: { grants?: <internal>.Grant[]; pagination?: PageResponse }

                                  Type declaration

                                  QueryHistoricalInfoRequest: { height?: string }

                                  Type declaration

                                  • Optional height?: string
                                  QueryHistoricalInfoResponse: { hist?: HistoricalInfo }

                                  Type declaration

                                  QueryInflationRequest: {}

                                  Type declaration

                                    QueryInflationResponse: { inflation?: Uint8Array }

                                    Type declaration

                                    • Optional inflation?: Uint8Array
                                    QueryInterchainAccountFromAddressRequest: { connection_id?: string; owner?: string }

                                    Type declaration

                                    • Optional connection_id?: string
                                    • Optional owner?: string
                                    QueryInterchainAccountFromAddressResponse: { interchain_account_address?: string }

                                    Type declaration

                                    • Optional interchain_account_address?: string
                                    QueryModuleVersionsRequest: { module_name?: string }

                                    Type declaration

                                    • Optional module_name?: string
                                    QueryModuleVersionsResponse: { module_versions?: <internal>.ModuleVersion[] }

                                    Type declaration

                                    QueryNextSequenceReceiveRequest: { channel_id?: string; port_id?: string }

                                    Type declaration

                                    • Optional channel_id?: string
                                    • Optional port_id?: string
                                    QueryNextSequenceReceiveResponse: { next_sequence_receive?: string; proof?: Uint8Array; proof_height?: <internal>.Height }

                                    Type declaration

                                    • Optional next_sequence_receive?: string
                                    • Optional proof?: Uint8Array
                                    • Optional proof_height?: <internal>.Height
                                    QueryPacketAcknowledgementRequest: { channel_id?: string; port_id?: string; sequence?: string }

                                    Type declaration

                                    • Optional channel_id?: string
                                    • Optional port_id?: string
                                    • Optional sequence?: string
                                    QueryPacketAcknowledgementResponse: { acknowledgement?: Uint8Array; proof?: Uint8Array; proof_height?: <internal>.Height }

                                    Type declaration

                                    • Optional acknowledgement?: Uint8Array
                                    • Optional proof?: Uint8Array
                                    • Optional proof_height?: <internal>.Height
                                    QueryPacketAcknowledgementsRequest: { channel_id?: string; packet_commitment_sequences?: string[]; pagination?: PageRequest; port_id?: string }

                                    Type declaration

                                    • Optional channel_id?: string
                                    • Optional packet_commitment_sequences?: string[]
                                    • Optional pagination?: PageRequest
                                    • Optional port_id?: string
                                    QueryPacketAcknowledgementsResponse: { acknowledgements?: PacketState[]; height?: <internal>.Height; pagination?: PageResponse }

                                    Type declaration

                                    QueryPacketCommitmentRequest: { channel_id?: string; port_id?: string; sequence?: string }

                                    Type declaration

                                    • Optional channel_id?: string
                                    • Optional port_id?: string
                                    • Optional sequence?: string
                                    QueryPacketCommitmentResponse: { commitment?: Uint8Array; proof?: Uint8Array; proof_height?: <internal>.Height }

                                    Type declaration

                                    • Optional commitment?: Uint8Array
                                    • Optional proof?: Uint8Array
                                    • Optional proof_height?: <internal>.Height
                                    QueryPacketCommitmentsRequest: { channel_id?: string; pagination?: PageRequest; port_id?: string }

                                    Type declaration

                                    • Optional channel_id?: string
                                    • Optional pagination?: PageRequest
                                    • Optional port_id?: string
                                    QueryPacketCommitmentsResponse: { commitments?: PacketState[]; height?: <internal>.Height; pagination?: PageResponse }

                                    Type declaration

                                    QueryPacketReceiptRequest: { channel_id?: string; port_id?: string; sequence?: string }

                                    Type declaration

                                    • Optional channel_id?: string
                                    • Optional port_id?: string
                                    • Optional sequence?: string
                                    QueryPacketReceiptResponse: { proof?: Uint8Array; proof_height?: <internal>.Height; received?: boolean }

                                    Type declaration

                                    • Optional proof?: Uint8Array
                                    • Optional proof_height?: <internal>.Height
                                    • Optional received?: boolean
                                    QueryParamsRequest: {}

                                    Type declaration

                                      QueryParamsRequest: {}

                                      Type declaration

                                        QueryParamsRequest: {}

                                        Type declaration

                                          QueryParamsRequest: { params_type?: string }

                                          Type declaration

                                          • Optional params_type?: string
                                          QueryParamsRequest: {}

                                          Type declaration

                                            QueryParamsRequest: {}

                                            Type declaration

                                              QueryParamsRequest: { key?: string; subspace?: string }

                                              Type declaration

                                              • Optional key?: string
                                              • Optional subspace?: string
                                              QueryParamsRequest: {}

                                              Type declaration

                                                QueryParamsRequest: {}

                                                Type declaration

                                                  QueryParamsResponse: { params?: <internal>.Params }

                                                  Type declaration

                                                  QueryParamsResponse: { params?: <internal>.Params }

                                                  Type declaration

                                                  QueryParamsResponse: { params?: <internal>.Params }

                                                  Type declaration

                                                  QueryParamsResponse: { deposit_params?: <internal>.DepositParams; tally_params?: <internal>.TallyParams; voting_params?: <internal>.VotingParams }

                                                  Type declaration

                                                  QueryParamsResponse: { params?: <internal>.Params }

                                                  Type declaration

                                                  QueryParamsResponse: { params?: <internal>.Params }

                                                  Type declaration

                                                  QueryParamsResponse: { param?: <internal>.ParamChange }

                                                  Type declaration

                                                  QueryParamsResponse: { params?: <internal>.Params }

                                                  Type declaration

                                                  QueryParamsResponse: { params?: <internal>.Params }

                                                  Type declaration

                                                  QueryPoolRequest: {}

                                                  Type declaration

                                                    QueryPoolResponse: { pool?: Pool }

                                                    Type declaration

                                                    • Optional pool?: Pool
                                                    QueryProposalRequest: { proposal_id?: string }

                                                    Type declaration

                                                    • Optional proposal_id?: string
                                                    QueryProposalResponse: { proposal?: <internal>.Proposal }

                                                    Type declaration

                                                    QueryProposalsRequest: { depositor?: string; pagination?: PageRequest; proposal_status?: <internal>.ProposalStatus; voter?: string }

                                                    Type declaration

                                                    QueryProposalsResponse: { pagination?: PageResponse; proposals?: <internal>.Proposal[] }

                                                    Type declaration

                                                    QueryRedelegationsRequest: { delegator_addr?: string; dst_validator_addr?: string; pagination?: PageRequest; src_validator_addr?: string }

                                                    Type declaration

                                                    • Optional delegator_addr?: string
                                                    • Optional dst_validator_addr?: string
                                                    • Optional pagination?: PageRequest
                                                    • Optional src_validator_addr?: string
                                                    QueryRedelegationsResponse: { pagination?: PageResponse; redelegation_responses?: RedelegationResponse[] }

                                                    Type declaration

                                                    QuerySigningInfoRequest: { cons_address?: string }

                                                    Type declaration

                                                    • Optional cons_address?: string
                                                    QuerySigningInfoResponse: { val_signing_info?: ValidatorSigningInfo }

                                                    Type declaration

                                                    QuerySigningInfosRequest: { pagination?: PageRequest }

                                                    Type declaration

                                                    QuerySigningInfosResponse: { info?: ValidatorSigningInfo[]; pagination?: PageResponse }

                                                    Type declaration

                                                    QuerySpendableBalancesRequest: { address?: string; pagination?: PageRequest }

                                                    Type declaration

                                                    • Optional address?: string
                                                    • Optional pagination?: PageRequest
                                                    QuerySpendableBalancesResponse: { balances?: <internal>.Coin[]; pagination?: PageResponse }

                                                    Type declaration

                                                    QuerySupplyOfRequest: { denom?: string }

                                                    Type declaration

                                                    • Optional denom?: string
                                                    QuerySupplyOfResponse: { amount?: <internal>.Coin }

                                                    Type declaration

                                                    QueryTallyResultRequest: { proposal_id?: string }

                                                    Type declaration

                                                    • Optional proposal_id?: string
                                                    QueryTallyResultResponse: { tally?: <internal>.TallyResult }

                                                    Type declaration

                                                    QueryTotalSupplyRequest: { pagination?: PageRequest }

                                                    Type declaration

                                                    QueryTotalSupplyResponse: { pagination?: PageResponse; supply?: <internal>.Coin[] }

                                                    Type declaration

                                                    QueryUnbondingDelegationRequest: { delegator_addr?: string; validator_addr?: string }

                                                    Type declaration

                                                    • Optional delegator_addr?: string
                                                    • Optional validator_addr?: string
                                                    QueryUnbondingDelegationResponse: { unbond?: UnbondingDelegation }

                                                    Type declaration

                                                    QueryUnreceivedAcksRequest: { channel_id?: string; packet_ack_sequences?: string[]; port_id?: string }

                                                    Type declaration

                                                    • Optional channel_id?: string
                                                    • Optional packet_ack_sequences?: string[]
                                                    • Optional port_id?: string
                                                    QueryUnreceivedAcksResponse: { height?: <internal>.Height; sequences?: string[] }

                                                    Type declaration

                                                    QueryUnreceivedPacketsRequest: { channel_id?: string; packet_commitment_sequences?: string[]; port_id?: string }

                                                    Type declaration

                                                    • Optional channel_id?: string
                                                    • Optional packet_commitment_sequences?: string[]
                                                    • Optional port_id?: string
                                                    QueryUnreceivedPacketsResponse: { height?: <internal>.Height; sequences?: string[] }

                                                    Type declaration

                                                    QueryUpgradedClientStateRequest: {}

                                                    Type declaration

                                                      QueryUpgradedClientStateResponse: { upgraded_client_state?: <internal>.Any }

                                                      Type declaration

                                                      QueryUpgradedConsensusStateRequest: {}

                                                      Type declaration

                                                        QueryUpgradedConsensusStateRequest: { last_height?: string }

                                                        Type declaration

                                                        • Optional last_height?: string
                                                        QueryUpgradedConsensusStateResponse: { upgraded_consensus_state?: <internal>.Any }

                                                        Type declaration

                                                        QueryUpgradedConsensusStateResponse: { upgraded_consensus_state?: Uint8Array }

                                                        Type declaration

                                                        • Optional upgraded_consensus_state?: Uint8Array
                                                        QueryValidatorCommissionRequest: { validator_address?: string }

                                                        Type declaration

                                                        • Optional validator_address?: string
                                                        QueryValidatorCommissionResponse: { commission?: <internal>.ValidatorAccumulatedCommission }

                                                        Type declaration

                                                        QueryValidatorDelegationsRequest: { pagination?: PageRequest; validator_addr?: string }

                                                        Type declaration

                                                        • Optional pagination?: PageRequest
                                                        • Optional validator_addr?: string
                                                        QueryValidatorDelegationsResponse: { delegation_responses?: DelegationResponse[]; pagination?: PageResponse }

                                                        Type declaration

                                                        QueryValidatorOutstandingRewardsRequest: { validator_address?: string }

                                                        Type declaration

                                                        • Optional validator_address?: string
                                                        QueryValidatorOutstandingRewardsResponse: { rewards?: <internal>.ValidatorOutstandingRewards }

                                                        Type declaration

                                                        QueryValidatorRequest: { validator_addr?: string }

                                                        Type declaration

                                                        • Optional validator_addr?: string
                                                        QueryValidatorResponse: { validator?: <internal>.Validator }

                                                        Type declaration

                                                        QueryValidatorSlashesRequest: { ending_height?: string; pagination?: PageRequest; starting_height?: string; validator_address?: string }

                                                        Type declaration

                                                        • Optional ending_height?: string
                                                        • Optional pagination?: PageRequest
                                                        • Optional starting_height?: string
                                                        • Optional validator_address?: string
                                                        QueryValidatorSlashesResponse: { pagination?: PageResponse; slashes?: <internal>.ValidatorSlashEvent[] }

                                                        Type declaration

                                                        QueryValidatorUnbondingDelegationsRequest: { pagination?: PageRequest; validator_addr?: string }

                                                        Type declaration

                                                        • Optional pagination?: PageRequest
                                                        • Optional validator_addr?: string
                                                        QueryValidatorUnbondingDelegationsResponse: { pagination?: PageResponse; unbonding_responses?: UnbondingDelegation[] }

                                                        Type declaration

                                                        QueryValidatorsRequest: { pagination?: PageRequest; status?: string }

                                                        Type declaration

                                                        • Optional pagination?: PageRequest
                                                        • Optional status?: string
                                                        QueryValidatorsResponse: { pagination?: PageResponse; validators?: <internal>.Validator[] }

                                                        Type declaration

                                                        QueryVoteRequest: { proposal_id?: string; voter?: string }

                                                        Type declaration

                                                        • Optional proposal_id?: string
                                                        • Optional voter?: string
                                                        QueryVoteResponse: { vote?: <internal>.Vote }

                                                        Type declaration

                                                        QueryVotesRequest: { pagination?: PageRequest; proposal_id?: string }

                                                        Type declaration

                                                        • Optional pagination?: PageRequest
                                                        • Optional proposal_id?: string
                                                        QueryVotesResponse: { pagination?: PageResponse; votes?: <internal>.Vote[] }

                                                        Type declaration

                                                        Type parameters

                                                        • T

                                                        Record<K, T>: { [ P in K]: T }

                                                        Construct a type with a set of properties K of type T

                                                        Type parameters

                                                        • K: keyof any

                                                        • T

                                                        RedeemType: { redeem: {} }

                                                        Type declaration

                                                        • redeem: {}
                                                          Redelegation: { delegator_address?: string; entries?: RedelegationEntry[]; validator_dst_address?: string; validator_src_address?: string }

                                                          Type declaration

                                                          • Optional delegator_address?: string
                                                          • Optional entries?: RedelegationEntry[]
                                                          • Optional validator_dst_address?: string
                                                          • Optional validator_src_address?: string
                                                          RedelegationEntry: { completion_time?: <internal>.Timestamp; creation_height?: string; initial_balance?: string; shares_dst?: string }

                                                          Type declaration

                                                          • Optional completion_time?: <internal>.Timestamp
                                                          • Optional creation_height?: string
                                                          • Optional initial_balance?: string
                                                          • Optional shares_dst?: string
                                                          RedelegationEntryResponse: { balance?: string; redelegation_entry?: RedelegationEntry }

                                                          Type declaration

                                                          RedelegationResponse: { entries?: RedelegationEntryResponse[]; redelegation?: Redelegation }

                                                          Type declaration

                                                          ReferrerPolicy: "" | "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url"
                                                          RequestCache: "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload"
                                                          RequestCredentials: "include" | "omit" | "same-origin"
                                                          RequestMode: "cors" | "navigate" | "no-cors" | "same-origin"
                                                          RequestRedirect: "error" | "follow" | "manual"
                                                          Result: { data?: Uint8Array; events?: Event[]; log?: string }

                                                          Type declaration

                                                          • Optional data?: Uint8Array
                                                          • Optional events?: Event[]
                                                          • Optional log?: string
                                                          SendEnabled: { denom?: string; enabled?: boolean }

                                                          Type declaration

                                                          • Optional denom?: string
                                                          • Optional enabled?: boolean
                                                          SetViewingKeyContractParams: MsgExecuteContractParams<SetViewingKeyOptions>
                                                          SignedHeader: { commit?: Commit; header?: Header }

                                                          Type declaration

                                                          SignerInfo: { mode_info?: <internal>.ModeInfo; public_key?: <internal>.Any; sequence?: string }

                                                          Type declaration

                                                          SimulateResponse: { gas_info?: GasInfo; result?: Result }

                                                          Type declaration

                                                          StdFee: { amount: readonly Coin[]; gas: string; granter?: string }

                                                          Type declaration

                                                          • Readonly amount: readonly Coin[]
                                                          • Readonly gas: string
                                                          • Optional Readonly granter?: string
                                                          StdSignDoc: { account_number: string; chain_id: string; fee: StdFee; memo: string; msgs: readonly AminoMsg[]; sequence: string }

                                                          Type declaration

                                                          • Readonly account_number: string
                                                          • Readonly chain_id: string
                                                          • Readonly fee: StdFee
                                                          • Readonly memo: string
                                                          • Readonly msgs: readonly AminoMsg[]
                                                          • Readonly sequence: string
                                                          StdSignature: { pub_key: Pubkey; signature: string }

                                                          Type declaration

                                                          • Readonly pub_key: Pubkey
                                                          • Readonly signature: string
                                                          StringEvent: { attributes?: Attribute[]; type?: string }

                                                          Type declaration

                                                          • Optional attributes?: Attribute[]
                                                          • Optional type?: string
                                                          TallyParams: { quorum?: Uint8Array; threshold?: Uint8Array; veto_threshold?: Uint8Array }

                                                          Type declaration

                                                          • Optional quorum?: Uint8Array
                                                          • Optional threshold?: Uint8Array
                                                          • Optional veto_threshold?: Uint8Array
                                                          TallyResult: { abstain?: string; no?: string; no_with_veto?: string; yes?: string }

                                                          Type declaration

                                                          • Optional abstain?: string
                                                          • Optional no?: string
                                                          • Optional no_with_veto?: string
                                                          • Optional yes?: string
                                                          Timestamp: { nanos?: number; seconds?: string }

                                                          Type declaration

                                                          • Optional nanos?: number
                                                          • Optional seconds?: string
                                                          TransferType: { transfer: { from: string; recipient: string; sender: string } }

                                                          Type declaration

                                                          • transfer: { from: string; recipient: string; sender: string }
                                                            • from: string
                                                            • recipient: string
                                                            • sender: string
                                                          Tx: { auth_info?: <internal>.AuthInfo; body?: <internal>.TxBody; signatures?: Uint8Array[] }

                                                          Type declaration

                                                          TxBody: { extension_options?: <internal>.Any[]; memo?: string; messages?: <internal>.Any[]; non_critical_extension_options?: <internal>.Any[]; timeout_height?: string }

                                                          Type declaration

                                                          TxResponse: { code?: number; codespace?: string; data?: string; events?: Event[]; gas_used?: string; gas_wanted?: string; height?: string; info?: string; logs?: ABCIMessageLog[]; raw_log?: string; timestamp?: string; tx?: <internal>.Any; txhash?: string }

                                                          Type declaration

                                                          • Optional code?: number
                                                          • Optional codespace?: string
                                                          • Optional data?: string
                                                          • Optional events?: Event[]
                                                          • Optional gas_used?: string
                                                          • Optional gas_wanted?: string
                                                          • Optional height?: string
                                                          • Optional info?: string
                                                          • Optional logs?: ABCIMessageLog[]
                                                          • Optional raw_log?: string
                                                          • Optional timestamp?: string
                                                          • Optional tx?: <internal>.Any
                                                          • Optional txhash?: string
                                                          TypedArray: Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | BigUint64Array | BigInt64Array | Float32Array | Float64Array
                                                          UnbondingDelegation: { delegator_address?: string; entries?: UnbondingDelegationEntry[]; validator_address?: string }

                                                          Type declaration

                                                          UnbondingDelegationEntry: { balance?: string; completion_time?: <internal>.Timestamp; creation_height?: string; initial_balance?: string }

                                                          Type declaration

                                                          • Optional balance?: string
                                                          • Optional completion_time?: <internal>.Timestamp
                                                          • Optional creation_height?: string
                                                          • Optional initial_balance?: string
                                                          Validator: { commission?: Commission; consensus_pubkey?: <internal>.Any; delegator_shares?: string; description?: Description; jailed?: boolean; min_self_delegation?: string; operator_address?: string; status?: BondStatus; tokens?: string; unbonding_height?: string; unbonding_time?: <internal>.Timestamp }

                                                          Type declaration

                                                          • Optional commission?: Commission
                                                          • Optional consensus_pubkey?: <internal>.Any
                                                          • Optional delegator_shares?: string
                                                          • Optional description?: Description
                                                          • Optional jailed?: boolean
                                                          • Optional min_self_delegation?: string
                                                          • Optional operator_address?: string
                                                          • Optional status?: BondStatus
                                                          • Optional tokens?: string
                                                          • Optional unbonding_height?: string
                                                          • Optional unbonding_time?: <internal>.Timestamp
                                                          Validator: { address?: string; proposer_priority?: string; pub_key?: <internal>.Any; voting_power?: string }

                                                          Type declaration

                                                          • Optional address?: string
                                                          • Optional proposer_priority?: string
                                                          • Optional pub_key?: <internal>.Any
                                                          • Optional voting_power?: string
                                                          Validator: { address?: Uint8Array; proposer_priority?: string; pub_key?: PublicKey; voting_power?: string }

                                                          Type declaration

                                                          • Optional address?: Uint8Array
                                                          • Optional proposer_priority?: string
                                                          • Optional pub_key?: PublicKey
                                                          • Optional voting_power?: string
                                                          ValidatorAccumulatedCommission: { commission?: <internal>.DecCoin[] }

                                                          Type declaration

                                                          ValidatorOutstandingRewards: { rewards?: <internal>.DecCoin[] }

                                                          Type declaration

                                                          ValidatorParams: { pub_key_types?: string[] }

                                                          Type declaration

                                                          • Optional pub_key_types?: string[]
                                                          ValidatorSet: { proposer?: <internal>.Validator; total_voting_power?: string; validators?: <internal>.Validator[] }

                                                          Type declaration

                                                          ValidatorSigningInfo: { address?: string; index_offset?: string; jailed_until?: <internal>.Timestamp; missed_blocks_counter?: string; start_height?: string; tombstoned?: boolean }

                                                          Type declaration

                                                          • Optional address?: string
                                                          • Optional index_offset?: string
                                                          • Optional jailed_until?: <internal>.Timestamp
                                                          • Optional missed_blocks_counter?: string
                                                          • Optional start_height?: string
                                                          • Optional tombstoned?: boolean
                                                          ValidatorSlashEvent: { fraction?: string; validator_period?: string }

                                                          Type declaration

                                                          • Optional fraction?: string
                                                          • Optional validator_period?: string
                                                          Version: { features?: string[]; identifier?: string }

                                                          Type declaration

                                                          • Optional features?: string[]
                                                          • Optional identifier?: string
                                                          VersionInfo: { app_name?: string; build_deps?: Module[]; build_tags?: string; cosmos_sdk_version?: string; git_commit?: string; go_version?: string; name?: string; version?: string }

                                                          Type declaration

                                                          • Optional app_name?: string
                                                          • Optional build_deps?: Module[]
                                                          • Optional build_tags?: string
                                                          • Optional cosmos_sdk_version?: string
                                                          • Optional git_commit?: string
                                                          • Optional go_version?: string
                                                          • Optional name?: string
                                                          • Optional version?: string
                                                          VersionParams: { app_version?: string }

                                                          Type declaration

                                                          • Optional app_version?: string
                                                          Vote: { option?: <internal>.VoteOption; options?: <internal>.WeightedVoteOption[]; proposal_id?: string; voter?: string }

                                                          Type declaration

                                                          Vote: { block_id?: BlockID; height?: string; round?: number; signature?: Uint8Array; timestamp?: <internal>.Timestamp; type?: SignedMsgType; validator_address?: Uint8Array; validator_index?: number }

                                                          Type declaration

                                                          • Optional block_id?: BlockID
                                                          • Optional height?: string
                                                          • Optional round?: number
                                                          • Optional signature?: Uint8Array
                                                          • Optional timestamp?: <internal>.Timestamp
                                                          • Optional type?: SignedMsgType
                                                          • Optional validator_address?: Uint8Array
                                                          • Optional validator_index?: number
                                                          VotingParams: { voting_period?: <internal>.Duration }

                                                          Type declaration

                                                          WeightedVoteOption: { option?: <internal>.VoteOption; weight?: string }

                                                          Type declaration

                                                          WithImplicitCoercion<T>: T | { valueOf: any }

                                                          Type parameters

                                                          • T

                                                          XMLHttpRequestBodyInit: Blob | BufferSource | <internal>.FormData | URLSearchParams | string

                                                          Variables

                                                          Any: { decode: any; encode: any; fromJSON: any; fromPartial: any; toJSON: any }

                                                          Type declaration

                                                          BasicAllowance: { decode: any; encode: any; fromJSON: any; fromPartial: any; toJSON: any }

                                                          Type declaration

                                                          Channel: { decode: any; encode: any; fromJSON: any; fromPartial: any; toJSON: any }

                                                          Type declaration

                                                          Coin: { decode: any; encode: any; fromJSON: any; fromPartial: any; toJSON: any }

                                                          Type declaration

                                                          CompactBitArray: { decode: any; encode: any; fromJSON: any; fromPartial: any; toJSON: any }

                                                          Type declaration

                                                          Counterparty: { decode: any; encode: any; fromJSON: any; fromPartial: any; toJSON: any }

                                                          Type declaration

                                                          Counterparty: { decode: any; encode: any; fromJSON: any; fromPartial: any; toJSON: any }

                                                          Type declaration

                                                          • decode:function
                                                            • decode(input: Uint8Array | Reader, length?: number):