@xpla/xplajs 1.7.0 → 1.8.0-rc.0

package/cosmos/evm/vm/v1/query.d.ts

@@ -0,0 +1,1773 @@
+import { MsgEthereumTx, MsgEthereumTxAmino } from "./tx";
+import { TraceConfig, TraceConfigAmino, ChainConfig, ChainConfigAmino, Log, LogAmino, Params, ParamsAmino } from "./evm";
+import { PageRequest, PageRequestAmino, PageResponse, PageResponseAmino } from "../../../base/query/v1beta1/pagination";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+/**
+ * QueryConfigRequest defines the request type for querying the config
+ * @name QueryConfigRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryConfigRequest
+ */
+export interface QueryConfigRequest {
+}
+export interface QueryConfigRequestProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryConfigRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryConfigRequest defines the request type for querying the config
+ * @name QueryConfigRequestAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryConfigRequest
+ */
+export interface QueryConfigRequestAmino {
+}
+export interface QueryConfigRequestAminoMsg {
+    type: "cosmos-sdk/QueryConfigRequest";
+    value: QueryConfigRequestAmino;
+}
+/**
+ * QueryConfigResponse returns the EVM config.
+ * @name QueryConfigResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryConfigResponse
+ */
+export interface QueryConfigResponse {
+    /**
+     * config is the evm configuration
+     */
+    config?: ChainConfig;
+}
+export interface QueryConfigResponseProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryConfigResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryConfigResponse returns the EVM config.
+ * @name QueryConfigResponseAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryConfigResponse
+ */
+export interface QueryConfigResponseAmino {
+    /**
+     * config is the evm configuration
+     */
+    config?: ChainConfigAmino;
+}
+export interface QueryConfigResponseAminoMsg {
+    type: "cosmos-sdk/QueryConfigResponse";
+    value: QueryConfigResponseAmino;
+}
+/**
+ * QueryAccountRequest is the request type for the Query/Account RPC method.
+ * @name QueryAccountRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryAccountRequest
+ */
+export interface QueryAccountRequest {
+    /**
+     * address is the ethereum hex address to query the account for.
+     */
+    address: string;
+}
+export interface QueryAccountRequestProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryAccountRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryAccountRequest is the request type for the Query/Account RPC method.
+ * @name QueryAccountRequestAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryAccountRequest
+ */
+export interface QueryAccountRequestAmino {
+    /**
+     * address is the ethereum hex address to query the account for.
+     */
+    address: string;
+}
+export interface QueryAccountRequestAminoMsg {
+    type: "cosmos-sdk/QueryAccountRequest";
+    value: QueryAccountRequestAmino;
+}
+/**
+ * QueryAccountResponse is the response type for the Query/Account RPC method.
+ * @name QueryAccountResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryAccountResponse
+ */
+export interface QueryAccountResponse {
+    /**
+     * balance is the balance of the EVM denomination.
+     */
+    balance: string;
+    /**
+     * code_hash is the hex-formatted code bytes from the EOA.
+     */
+    codeHash: string;
+    /**
+     * nonce is the account's sequence number.
+     */
+    nonce: bigint;
+}
+export interface QueryAccountResponseProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryAccountResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryAccountResponse is the response type for the Query/Account RPC method.
+ * @name QueryAccountResponseAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryAccountResponse
+ */
+export interface QueryAccountResponseAmino {
+    /**
+     * balance is the balance of the EVM denomination.
+     */
+    balance: string;
+    /**
+     * code_hash is the hex-formatted code bytes from the EOA.
+     */
+    code_hash: string;
+    /**
+     * nonce is the account's sequence number.
+     */
+    nonce: string;
+}
+export interface QueryAccountResponseAminoMsg {
+    type: "cosmos-sdk/QueryAccountResponse";
+    value: QueryAccountResponseAmino;
+}
+/**
+ * QueryCosmosAccountRequest is the request type for the Query/CosmosAccount RPC
+ * method.
+ * @name QueryCosmosAccountRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryCosmosAccountRequest
+ */
+export interface QueryCosmosAccountRequest {
+    /**
+     * address is the ethereum hex address to query the account for.
+     */
+    address: string;
+}
+export interface QueryCosmosAccountRequestProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryCosmosAccountRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryCosmosAccountRequest is the request type for the Query/CosmosAccount RPC
+ * method.
+ * @name QueryCosmosAccountRequestAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryCosmosAccountRequest
+ */
+export interface QueryCosmosAccountRequestAmino {
+    /**
+     * address is the ethereum hex address to query the account for.
+     */
+    address: string;
+}
+export interface QueryCosmosAccountRequestAminoMsg {
+    type: "cosmos-sdk/QueryCosmosAccountRequest";
+    value: QueryCosmosAccountRequestAmino;
+}
+/**
+ * QueryCosmosAccountResponse is the response type for the Query/CosmosAccount
+ * RPC method.
+ * @name QueryCosmosAccountResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryCosmosAccountResponse
+ */
+export interface QueryCosmosAccountResponse {
+    /**
+     * cosmos_address is the cosmos address of the account.
+     */
+    cosmosAddress: string;
+    /**
+     * sequence is the account's sequence number.
+     */
+    sequence: bigint;
+    /**
+     * account_number is the account number
+     */
+    accountNumber: bigint;
+}
+export interface QueryCosmosAccountResponseProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryCosmosAccountResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryCosmosAccountResponse is the response type for the Query/CosmosAccount
+ * RPC method.
+ * @name QueryCosmosAccountResponseAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryCosmosAccountResponse
+ */
+export interface QueryCosmosAccountResponseAmino {
+    /**
+     * cosmos_address is the cosmos address of the account.
+     */
+    cosmos_address: string;
+    /**
+     * sequence is the account's sequence number.
+     */
+    sequence: string;
+    /**
+     * account_number is the account number
+     */
+    account_number: string;
+}
+export interface QueryCosmosAccountResponseAminoMsg {
+    type: "cosmos-sdk/QueryCosmosAccountResponse";
+    value: QueryCosmosAccountResponseAmino;
+}
+/**
+ * QueryValidatorAccountRequest is the request type for the
+ * Query/ValidatorAccount RPC method.
+ * @name QueryValidatorAccountRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryValidatorAccountRequest
+ */
+export interface QueryValidatorAccountRequest {
+    /**
+     * cons_address is the validator cons address to query the account for.
+     */
+    consAddress: string;
+}
+export interface QueryValidatorAccountRequestProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryValidatorAccountRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryValidatorAccountRequest is the request type for the
+ * Query/ValidatorAccount RPC method.
+ * @name QueryValidatorAccountRequestAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryValidatorAccountRequest
+ */
+export interface QueryValidatorAccountRequestAmino {
+    /**
+     * cons_address is the validator cons address to query the account for.
+     */
+    cons_address: string;
+}
+export interface QueryValidatorAccountRequestAminoMsg {
+    type: "cosmos-sdk/QueryValidatorAccountRequest";
+    value: QueryValidatorAccountRequestAmino;
+}
+/**
+ * QueryValidatorAccountResponse is the response type for the
+ * Query/ValidatorAccount RPC method.
+ * @name QueryValidatorAccountResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryValidatorAccountResponse
+ */
+export interface QueryValidatorAccountResponse {
+    /**
+     * account_address is the cosmos address of the account in bech32 format.
+     */
+    accountAddress: string;
+    /**
+     * sequence is the account's sequence number.
+     */
+    sequence: bigint;
+    /**
+     * account_number is the account number
+     */
+    accountNumber: bigint;
+}
+export interface QueryValidatorAccountResponseProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryValidatorAccountResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryValidatorAccountResponse is the response type for the
+ * Query/ValidatorAccount RPC method.
+ * @name QueryValidatorAccountResponseAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryValidatorAccountResponse
+ */
+export interface QueryValidatorAccountResponseAmino {
+    /**
+     * account_address is the cosmos address of the account in bech32 format.
+     */
+    account_address: string;
+    /**
+     * sequence is the account's sequence number.
+     */
+    sequence: string;
+    /**
+     * account_number is the account number
+     */
+    account_number: string;
+}
+export interface QueryValidatorAccountResponseAminoMsg {
+    type: "cosmos-sdk/QueryValidatorAccountResponse";
+    value: QueryValidatorAccountResponseAmino;
+}
+/**
+ * QueryBalanceRequest is the request type for the Query/Balance RPC method.
+ * @name QueryBalanceRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryBalanceRequest
+ */
+export interface QueryBalanceRequest {
+    /**
+     * address is the ethereum hex address to query the balance for.
+     */
+    address: string;
+}
+export interface QueryBalanceRequestProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryBalanceRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryBalanceRequest is the request type for the Query/Balance RPC method.
+ * @name QueryBalanceRequestAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryBalanceRequest
+ */
+export interface QueryBalanceRequestAmino {
+    /**
+     * address is the ethereum hex address to query the balance for.
+     */
+    address: string;
+}
+export interface QueryBalanceRequestAminoMsg {
+    type: "cosmos-sdk/QueryBalanceRequest";
+    value: QueryBalanceRequestAmino;
+}
+/**
+ * QueryBalanceResponse is the response type for the Query/Balance RPC method.
+ * @name QueryBalanceResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryBalanceResponse
+ */
+export interface QueryBalanceResponse {
+    /**
+     * balance is the balance of the EVM denomination.
+     */
+    balance: string;
+}
+export interface QueryBalanceResponseProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryBalanceResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryBalanceResponse is the response type for the Query/Balance RPC method.
+ * @name QueryBalanceResponseAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryBalanceResponse
+ */
+export interface QueryBalanceResponseAmino {
+    /**
+     * balance is the balance of the EVM denomination.
+     */
+    balance: string;
+}
+export interface QueryBalanceResponseAminoMsg {
+    type: "cosmos-sdk/QueryBalanceResponse";
+    value: QueryBalanceResponseAmino;
+}
+/**
+ * QueryStorageRequest is the request type for the Query/Storage RPC method.
+ * @name QueryStorageRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryStorageRequest
+ */
+export interface QueryStorageRequest {
+    /**
+     * address is the ethereum hex address to query the storage state for.
+     */
+    address: string;
+    /**
+     * key defines the key of the storage state
+     */
+    key: string;
+}
+export interface QueryStorageRequestProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryStorageRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryStorageRequest is the request type for the Query/Storage RPC method.
+ * @name QueryStorageRequestAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryStorageRequest
+ */
+export interface QueryStorageRequestAmino {
+    /**
+     * address is the ethereum hex address to query the storage state for.
+     */
+    address: string;
+    /**
+     * key defines the key of the storage state
+     */
+    key: string;
+}
+export interface QueryStorageRequestAminoMsg {
+    type: "cosmos-sdk/QueryStorageRequest";
+    value: QueryStorageRequestAmino;
+}
+/**
+ * QueryStorageResponse is the response type for the Query/Storage RPC
+ * method.
+ * @name QueryStorageResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryStorageResponse
+ */
+export interface QueryStorageResponse {
+    /**
+     * value defines the storage state value hash associated with the given key.
+     */
+    value: string;
+}
+export interface QueryStorageResponseProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryStorageResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryStorageResponse is the response type for the Query/Storage RPC
+ * method.
+ * @name QueryStorageResponseAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryStorageResponse
+ */
+export interface QueryStorageResponseAmino {
+    /**
+     * value defines the storage state value hash associated with the given key.
+     */
+    value: string;
+}
+export interface QueryStorageResponseAminoMsg {
+    type: "cosmos-sdk/QueryStorageResponse";
+    value: QueryStorageResponseAmino;
+}
+/**
+ * QueryCodeRequest is the request type for the Query/Code RPC method.
+ * @name QueryCodeRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryCodeRequest
+ */
+export interface QueryCodeRequest {
+    /**
+     * address is the ethereum hex address to query the code for.
+     */
+    address: string;
+}
+export interface QueryCodeRequestProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryCodeRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryCodeRequest is the request type for the Query/Code RPC method.
+ * @name QueryCodeRequestAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryCodeRequest
+ */
+export interface QueryCodeRequestAmino {
+    /**
+     * address is the ethereum hex address to query the code for.
+     */
+    address: string;
+}
+export interface QueryCodeRequestAminoMsg {
+    type: "cosmos-sdk/QueryCodeRequest";
+    value: QueryCodeRequestAmino;
+}
+/**
+ * QueryCodeResponse is the response type for the Query/Code RPC
+ * method.
+ * @name QueryCodeResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryCodeResponse
+ */
+export interface QueryCodeResponse {
+    /**
+     * code represents the code bytes from an ethereum address.
+     */
+    code: Uint8Array;
+}
+export interface QueryCodeResponseProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryCodeResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryCodeResponse is the response type for the Query/Code RPC
+ * method.
+ * @name QueryCodeResponseAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryCodeResponse
+ */
+export interface QueryCodeResponseAmino {
+    /**
+     * code represents the code bytes from an ethereum address.
+     */
+    code: string;
+}
+export interface QueryCodeResponseAminoMsg {
+    type: "cosmos-sdk/QueryCodeResponse";
+    value: QueryCodeResponseAmino;
+}
+/**
+ * QueryTxLogsRequest is the request type for the Query/TxLogs RPC method.
+ * @name QueryTxLogsRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryTxLogsRequest
+ */
+export interface QueryTxLogsRequest {
+    /**
+     * hash is the ethereum transaction hex hash to query the logs for.
+     */
+    hash: string;
+    /**
+     * pagination defines an optional pagination for the request.
+     */
+    pagination?: PageRequest;
+}
+export interface QueryTxLogsRequestProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryTxLogsRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryTxLogsRequest is the request type for the Query/TxLogs RPC method.
+ * @name QueryTxLogsRequestAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryTxLogsRequest
+ */
+export interface QueryTxLogsRequestAmino {
+    /**
+     * hash is the ethereum transaction hex hash to query the logs for.
+     */
+    hash: string;
+    /**
+     * pagination defines an optional pagination for the request.
+     */
+    pagination?: PageRequestAmino;
+}
+export interface QueryTxLogsRequestAminoMsg {
+    type: "cosmos-sdk/QueryTxLogsRequest";
+    value: QueryTxLogsRequestAmino;
+}
+/**
+ * QueryTxLogsResponse is the response type for the Query/TxLogs RPC method.
+ * @name QueryTxLogsResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryTxLogsResponse
+ */
+export interface QueryTxLogsResponse {
+    /**
+     * logs represents the ethereum logs generated from the given transaction.
+     */
+    logs: Log[];
+    /**
+     * pagination defines the pagination in the response.
+     */
+    pagination?: PageResponse;
+}
+export interface QueryTxLogsResponseProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryTxLogsResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryTxLogsResponse is the response type for the Query/TxLogs RPC method.
+ * @name QueryTxLogsResponseAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryTxLogsResponse
+ */
+export interface QueryTxLogsResponseAmino {
+    /**
+     * logs represents the ethereum logs generated from the given transaction.
+     */
+    logs: LogAmino[];
+    /**
+     * pagination defines the pagination in the response.
+     */
+    pagination?: PageResponseAmino;
+}
+export interface QueryTxLogsResponseAminoMsg {
+    type: "cosmos-sdk/QueryTxLogsResponse";
+    value: QueryTxLogsResponseAmino;
+}
+/**
+ * QueryParamsRequest defines the request type for querying x/vm parameters.
+ * @name QueryParamsRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryParamsRequest
+ */
+export interface QueryParamsRequest {
+}
+export interface QueryParamsRequestProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryParamsRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryParamsRequest defines the request type for querying x/vm parameters.
+ * @name QueryParamsRequestAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryParamsRequest
+ */
+export interface QueryParamsRequestAmino {
+}
+export interface QueryParamsRequestAminoMsg {
+    type: "cosmos-sdk/QueryParamsRequest";
+    value: QueryParamsRequestAmino;
+}
+/**
+ * QueryParamsResponse defines the response type for querying x/vm parameters.
+ * @name QueryParamsResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryParamsResponse
+ */
+export interface QueryParamsResponse {
+    /**
+     * params define the evm module parameters.
+     */
+    params: Params;
+}
+export interface QueryParamsResponseProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryParamsResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryParamsResponse defines the response type for querying x/vm parameters.
+ * @name QueryParamsResponseAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryParamsResponse
+ */
+export interface QueryParamsResponseAmino {
+    /**
+     * params define the evm module parameters.
+     */
+    params: ParamsAmino;
+}
+export interface QueryParamsResponseAminoMsg {
+    type: "cosmos-sdk/QueryParamsResponse";
+    value: QueryParamsResponseAmino;
+}
+/**
+ * EthCallRequest defines EthCall request
+ * @name EthCallRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.EthCallRequest
+ */
+export interface EthCallRequest {
+    /**
+     * args uses the same json format as the json rpc api.
+     */
+    args: Uint8Array;
+    /**
+     * gas_cap defines the default gas cap to be used
+     */
+    gasCap: bigint;
+    /**
+     * proposer_address of the requested block in hex format
+     */
+    proposerAddress: Uint8Array;
+    /**
+     * chain_id is the eip155 chain id parsed from the requested block header
+     */
+    chainId: bigint;
+}
+export interface EthCallRequestProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.EthCallRequest";
+    value: Uint8Array;
+}
+/**
+ * EthCallRequest defines EthCall request
+ * @name EthCallRequestAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.EthCallRequest
+ */
+export interface EthCallRequestAmino {
+    /**
+     * args uses the same json format as the json rpc api.
+     */
+    args: string;
+    /**
+     * gas_cap defines the default gas cap to be used
+     */
+    gas_cap: string;
+    /**
+     * proposer_address of the requested block in hex format
+     */
+    proposer_address: string;
+    /**
+     * chain_id is the eip155 chain id parsed from the requested block header
+     */
+    chain_id: string;
+}
+export interface EthCallRequestAminoMsg {
+    type: "cosmos-sdk/EthCallRequest";
+    value: EthCallRequestAmino;
+}
+/**
+ * EstimateGasResponse defines EstimateGas response
+ * @name EstimateGasResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.EstimateGasResponse
+ */
+export interface EstimateGasResponse {
+    /**
+     * gas returns the estimated gas
+     */
+    gas: bigint;
+    /**
+     * ret is the returned data from evm function (result or data supplied with
+     * revert opcode)
+     */
+    ret: Uint8Array;
+    /**
+     * vm_error is the error returned by vm execution
+     */
+    vmError: string;
+}
+export interface EstimateGasResponseProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.EstimateGasResponse";
+    value: Uint8Array;
+}
+/**
+ * EstimateGasResponse defines EstimateGas response
+ * @name EstimateGasResponseAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.EstimateGasResponse
+ */
+export interface EstimateGasResponseAmino {
+    /**
+     * gas returns the estimated gas
+     */
+    gas: string;
+    /**
+     * ret is the returned data from evm function (result or data supplied with
+     * revert opcode)
+     */
+    ret: string;
+    /**
+     * vm_error is the error returned by vm execution
+     */
+    vm_error: string;
+}
+export interface EstimateGasResponseAminoMsg {
+    type: "cosmos-sdk/EstimateGasResponse";
+    value: EstimateGasResponseAmino;
+}
+/**
+ * QueryTraceTxRequest defines TraceTx request
+ * @name QueryTraceTxRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryTraceTxRequest
+ */
+export interface QueryTraceTxRequest {
+    /**
+     * msg is the MsgEthereumTx for the requested transaction
+     */
+    msg?: MsgEthereumTx;
+    /**
+     * trace_config holds extra parameters to trace functions.
+     */
+    traceConfig?: TraceConfig;
+    /**
+     * predecessors is an array of transactions included in the same block
+     * need to be replayed first to get correct context for tracing.
+     */
+    predecessors: MsgEthereumTx[];
+    /**
+     * block_number of requested transaction
+     */
+    blockNumber: bigint;
+    /**
+     * block_hash of requested transaction
+     */
+    blockHash: string;
+    /**
+     * block_time of requested transaction
+     */
+    blockTime: Date;
+    /**
+     * proposer_address is the proposer of the requested block
+     */
+    proposerAddress: Uint8Array;
+    /**
+     * chain_id is the eip155 chain id parsed from the requested block header
+     */
+    chainId: bigint;
+    /**
+     * block_max_gas of the block of the requested transaction
+     */
+    blockMaxGas: bigint;
+}
+export interface QueryTraceTxRequestProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryTraceTxRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryTraceTxRequest defines TraceTx request
+ * @name QueryTraceTxRequestAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryTraceTxRequest
+ */
+export interface QueryTraceTxRequestAmino {
+    /**
+     * msg is the MsgEthereumTx for the requested transaction
+     */
+    msg?: MsgEthereumTxAmino;
+    /**
+     * trace_config holds extra parameters to trace functions.
+     */
+    trace_config?: TraceConfigAmino;
+    /**
+     * predecessors is an array of transactions included in the same block
+     * need to be replayed first to get correct context for tracing.
+     */
+    predecessors: MsgEthereumTxAmino[];
+    /**
+     * block_number of requested transaction
+     */
+    block_number: string;
+    /**
+     * block_hash of requested transaction
+     */
+    block_hash: string;
+    /**
+     * block_time of requested transaction
+     */
+    block_time: string;
+    /**
+     * proposer_address is the proposer of the requested block
+     */
+    proposer_address: string;
+    /**
+     * chain_id is the eip155 chain id parsed from the requested block header
+     */
+    chain_id: string;
+    /**
+     * block_max_gas of the block of the requested transaction
+     */
+    block_max_gas: string;
+}
+export interface QueryTraceTxRequestAminoMsg {
+    type: "cosmos-sdk/QueryTraceTxRequest";
+    value: QueryTraceTxRequestAmino;
+}
+/**
+ * QueryTraceTxResponse defines TraceTx response
+ * @name QueryTraceTxResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryTraceTxResponse
+ */
+export interface QueryTraceTxResponse {
+    /**
+     * data is the response serialized in bytes
+     */
+    data: Uint8Array;
+}
+export interface QueryTraceTxResponseProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryTraceTxResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryTraceTxResponse defines TraceTx response
+ * @name QueryTraceTxResponseAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryTraceTxResponse
+ */
+export interface QueryTraceTxResponseAmino {
+    /**
+     * data is the response serialized in bytes
+     */
+    data: string;
+}
+export interface QueryTraceTxResponseAminoMsg {
+    type: "cosmos-sdk/QueryTraceTxResponse";
+    value: QueryTraceTxResponseAmino;
+}
+/**
+ * QueryTraceBlockRequest defines TraceTx request
+ * @name QueryTraceBlockRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryTraceBlockRequest
+ */
+export interface QueryTraceBlockRequest {
+    /**
+     * txs is an array of messages in the block
+     */
+    txs: MsgEthereumTx[];
+    /**
+     * trace_config holds extra parameters to trace functions.
+     */
+    traceConfig?: TraceConfig;
+    /**
+     * block_number of the traced block
+     */
+    blockNumber: bigint;
+    /**
+     * block_hash (hex) of the traced block
+     */
+    blockHash: string;
+    /**
+     * block_time of the traced block
+     */
+    blockTime: Date;
+    /**
+     * proposer_address is the address of the requested block
+     */
+    proposerAddress: Uint8Array;
+    /**
+     * chain_id is the eip155 chain id parsed from the requested block header
+     */
+    chainId: bigint;
+    /**
+     * block_max_gas of the traced block
+     */
+    blockMaxGas: bigint;
+}
+export interface QueryTraceBlockRequestProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryTraceBlockRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryTraceBlockRequest defines TraceTx request
+ * @name QueryTraceBlockRequestAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryTraceBlockRequest
+ */
+export interface QueryTraceBlockRequestAmino {
+    /**
+     * txs is an array of messages in the block
+     */
+    txs: MsgEthereumTxAmino[];
+    /**
+     * trace_config holds extra parameters to trace functions.
+     */
+    trace_config?: TraceConfigAmino;
+    /**
+     * block_number of the traced block
+     */
+    block_number: string;
+    /**
+     * block_hash (hex) of the traced block
+     */
+    block_hash: string;
+    /**
+     * block_time of the traced block
+     */
+    block_time: string;
+    /**
+     * proposer_address is the address of the requested block
+     */
+    proposer_address: string;
+    /**
+     * chain_id is the eip155 chain id parsed from the requested block header
+     */
+    chain_id: string;
+    /**
+     * block_max_gas of the traced block
+     */
+    block_max_gas: string;
+}
+export interface QueryTraceBlockRequestAminoMsg {
+    type: "cosmos-sdk/QueryTraceBlockRequest";
+    value: QueryTraceBlockRequestAmino;
+}
+/**
+ * QueryTraceBlockResponse defines TraceBlock response
+ * @name QueryTraceBlockResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryTraceBlockResponse
+ */
+export interface QueryTraceBlockResponse {
+    /**
+     * data is the response serialized in bytes
+     */
+    data: Uint8Array;
+}
+export interface QueryTraceBlockResponseProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryTraceBlockResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryTraceBlockResponse defines TraceBlock response
+ * @name QueryTraceBlockResponseAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryTraceBlockResponse
+ */
+export interface QueryTraceBlockResponseAmino {
+    /**
+     * data is the response serialized in bytes
+     */
+    data: string;
+}
+export interface QueryTraceBlockResponseAminoMsg {
+    type: "cosmos-sdk/QueryTraceBlockResponse";
+    value: QueryTraceBlockResponseAmino;
+}
+/**
+ * QueryBaseFeeRequest defines the request type for querying the EIP1559 base
+ * fee.
+ * @name QueryBaseFeeRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryBaseFeeRequest
+ */
+export interface QueryBaseFeeRequest {
+}
+export interface QueryBaseFeeRequestProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryBaseFeeRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryBaseFeeRequest defines the request type for querying the EIP1559 base
+ * fee.
+ * @name QueryBaseFeeRequestAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryBaseFeeRequest
+ */
+export interface QueryBaseFeeRequestAmino {
+}
+export interface QueryBaseFeeRequestAminoMsg {
+    type: "cosmos-sdk/QueryBaseFeeRequest";
+    value: QueryBaseFeeRequestAmino;
+}
+/**
+ * QueryBaseFeeResponse returns the EIP1559 base fee.
+ * @name QueryBaseFeeResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryBaseFeeResponse
+ */
+export interface QueryBaseFeeResponse {
+    /**
+     * base_fee is the EIP1559 base fee
+     */
+    baseFee: string;
+}
+export interface QueryBaseFeeResponseProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryBaseFeeResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryBaseFeeResponse returns the EIP1559 base fee.
+ * @name QueryBaseFeeResponseAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryBaseFeeResponse
+ */
+export interface QueryBaseFeeResponseAmino {
+    /**
+     * base_fee is the EIP1559 base fee
+     */
+    base_fee: string;
+}
+export interface QueryBaseFeeResponseAminoMsg {
+    type: "cosmos-sdk/QueryBaseFeeResponse";
+    value: QueryBaseFeeResponseAmino;
+}
+/**
+ * QueryGlobalMinGasPriceRequest defines the request type for querying the
+ * GlobalMinGasPrice
+ * @name QueryGlobalMinGasPriceRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryGlobalMinGasPriceRequest
+ */
+export interface QueryGlobalMinGasPriceRequest {
+}
+export interface QueryGlobalMinGasPriceRequestProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryGlobalMinGasPriceRequest";
+    value: Uint8Array;
+}
+/**
+ * QueryGlobalMinGasPriceRequest defines the request type for querying the
+ * GlobalMinGasPrice
+ * @name QueryGlobalMinGasPriceRequestAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryGlobalMinGasPriceRequest
+ */
+export interface QueryGlobalMinGasPriceRequestAmino {
+}
+export interface QueryGlobalMinGasPriceRequestAminoMsg {
+    type: "cosmos-sdk/QueryGlobalMinGasPriceRequest";
+    value: QueryGlobalMinGasPriceRequestAmino;
+}
+/**
+ * QueryGlobalMinGasPriceResponse returns the GlobalMinGasPrice
+ * @name QueryGlobalMinGasPriceResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryGlobalMinGasPriceResponse
+ */
+export interface QueryGlobalMinGasPriceResponse {
+    /**
+     * min_gas_price is the feemarket's min_gas_price
+     */
+    minGasPrice: string;
+}
+export interface QueryGlobalMinGasPriceResponseProtoMsg {
+    typeUrl: "/cosmos.evm.vm.v1.QueryGlobalMinGasPriceResponse";
+    value: Uint8Array;
+}
+/**
+ * QueryGlobalMinGasPriceResponse returns the GlobalMinGasPrice
+ * @name QueryGlobalMinGasPriceResponseAmino
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryGlobalMinGasPriceResponse
+ */
+export interface QueryGlobalMinGasPriceResponseAmino {
+    /**
+     * min_gas_price is the feemarket's min_gas_price
+     */
+    min_gas_price: string;
+}
+export interface QueryGlobalMinGasPriceResponseAminoMsg {
+    type: "cosmos-sdk/QueryGlobalMinGasPriceResponse";
+    value: QueryGlobalMinGasPriceResponseAmino;
+}
+/**
+ * QueryConfigRequest defines the request type for querying the config
+ * @name QueryConfigRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryConfigRequest
+ */
+export declare const QueryConfigRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryConfigRequest;
+    isAmino(o: any): o is QueryConfigRequestAmino;
+    encode(_: QueryConfigRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryConfigRequest;
+    fromPartial(_: DeepPartial<QueryConfigRequest>): QueryConfigRequest;
+    fromAmino(_: QueryConfigRequestAmino): QueryConfigRequest;
+    toAmino(_: QueryConfigRequest): QueryConfigRequestAmino;
+    fromAminoMsg(object: QueryConfigRequestAminoMsg): QueryConfigRequest;
+    toAminoMsg(message: QueryConfigRequest): QueryConfigRequestAminoMsg;
+    fromProtoMsg(message: QueryConfigRequestProtoMsg): QueryConfigRequest;
+    toProto(message: QueryConfigRequest): Uint8Array;
+    toProtoMsg(message: QueryConfigRequest): QueryConfigRequestProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryConfigResponse returns the EVM config.
+ * @name QueryConfigResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryConfigResponse
+ */
+export declare const QueryConfigResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryConfigResponse;
+    isAmino(o: any): o is QueryConfigResponseAmino;
+    encode(message: QueryConfigResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryConfigResponse;
+    fromPartial(object: DeepPartial<QueryConfigResponse>): QueryConfigResponse;
+    fromAmino(object: QueryConfigResponseAmino): QueryConfigResponse;
+    toAmino(message: QueryConfigResponse): QueryConfigResponseAmino;
+    fromAminoMsg(object: QueryConfigResponseAminoMsg): QueryConfigResponse;
+    toAminoMsg(message: QueryConfigResponse): QueryConfigResponseAminoMsg;
+    fromProtoMsg(message: QueryConfigResponseProtoMsg): QueryConfigResponse;
+    toProto(message: QueryConfigResponse): Uint8Array;
+    toProtoMsg(message: QueryConfigResponse): QueryConfigResponseProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryAccountRequest is the request type for the Query/Account RPC method.
+ * @name QueryAccountRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryAccountRequest
+ */
+export declare const QueryAccountRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryAccountRequest;
+    isAmino(o: any): o is QueryAccountRequestAmino;
+    encode(message: QueryAccountRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryAccountRequest;
+    fromPartial(object: DeepPartial<QueryAccountRequest>): QueryAccountRequest;
+    fromAmino(object: QueryAccountRequestAmino): QueryAccountRequest;
+    toAmino(message: QueryAccountRequest): QueryAccountRequestAmino;
+    fromAminoMsg(object: QueryAccountRequestAminoMsg): QueryAccountRequest;
+    toAminoMsg(message: QueryAccountRequest): QueryAccountRequestAminoMsg;
+    fromProtoMsg(message: QueryAccountRequestProtoMsg): QueryAccountRequest;
+    toProto(message: QueryAccountRequest): Uint8Array;
+    toProtoMsg(message: QueryAccountRequest): QueryAccountRequestProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryAccountResponse is the response type for the Query/Account RPC method.
+ * @name QueryAccountResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryAccountResponse
+ */
+export declare const QueryAccountResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryAccountResponse;
+    isAmino(o: any): o is QueryAccountResponseAmino;
+    encode(message: QueryAccountResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryAccountResponse;
+    fromPartial(object: DeepPartial<QueryAccountResponse>): QueryAccountResponse;
+    fromAmino(object: QueryAccountResponseAmino): QueryAccountResponse;
+    toAmino(message: QueryAccountResponse): QueryAccountResponseAmino;
+    fromAminoMsg(object: QueryAccountResponseAminoMsg): QueryAccountResponse;
+    toAminoMsg(message: QueryAccountResponse): QueryAccountResponseAminoMsg;
+    fromProtoMsg(message: QueryAccountResponseProtoMsg): QueryAccountResponse;
+    toProto(message: QueryAccountResponse): Uint8Array;
+    toProtoMsg(message: QueryAccountResponse): QueryAccountResponseProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryCosmosAccountRequest is the request type for the Query/CosmosAccount RPC
+ * method.
+ * @name QueryCosmosAccountRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryCosmosAccountRequest
+ */
+export declare const QueryCosmosAccountRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryCosmosAccountRequest;
+    isAmino(o: any): o is QueryCosmosAccountRequestAmino;
+    encode(message: QueryCosmosAccountRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryCosmosAccountRequest;
+    fromPartial(object: DeepPartial<QueryCosmosAccountRequest>): QueryCosmosAccountRequest;
+    fromAmino(object: QueryCosmosAccountRequestAmino): QueryCosmosAccountRequest;
+    toAmino(message: QueryCosmosAccountRequest): QueryCosmosAccountRequestAmino;
+    fromAminoMsg(object: QueryCosmosAccountRequestAminoMsg): QueryCosmosAccountRequest;
+    toAminoMsg(message: QueryCosmosAccountRequest): QueryCosmosAccountRequestAminoMsg;
+    fromProtoMsg(message: QueryCosmosAccountRequestProtoMsg): QueryCosmosAccountRequest;
+    toProto(message: QueryCosmosAccountRequest): Uint8Array;
+    toProtoMsg(message: QueryCosmosAccountRequest): QueryCosmosAccountRequestProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryCosmosAccountResponse is the response type for the Query/CosmosAccount
+ * RPC method.
+ * @name QueryCosmosAccountResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryCosmosAccountResponse
+ */
+export declare const QueryCosmosAccountResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryCosmosAccountResponse;
+    isAmino(o: any): o is QueryCosmosAccountResponseAmino;
+    encode(message: QueryCosmosAccountResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryCosmosAccountResponse;
+    fromPartial(object: DeepPartial<QueryCosmosAccountResponse>): QueryCosmosAccountResponse;
+    fromAmino(object: QueryCosmosAccountResponseAmino): QueryCosmosAccountResponse;
+    toAmino(message: QueryCosmosAccountResponse): QueryCosmosAccountResponseAmino;
+    fromAminoMsg(object: QueryCosmosAccountResponseAminoMsg): QueryCosmosAccountResponse;
+    toAminoMsg(message: QueryCosmosAccountResponse): QueryCosmosAccountResponseAminoMsg;
+    fromProtoMsg(message: QueryCosmosAccountResponseProtoMsg): QueryCosmosAccountResponse;
+    toProto(message: QueryCosmosAccountResponse): Uint8Array;
+    toProtoMsg(message: QueryCosmosAccountResponse): QueryCosmosAccountResponseProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryValidatorAccountRequest is the request type for the
+ * Query/ValidatorAccount RPC method.
+ * @name QueryValidatorAccountRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryValidatorAccountRequest
+ */
+export declare const QueryValidatorAccountRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryValidatorAccountRequest;
+    isAmino(o: any): o is QueryValidatorAccountRequestAmino;
+    encode(message: QueryValidatorAccountRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryValidatorAccountRequest;
+    fromPartial(object: DeepPartial<QueryValidatorAccountRequest>): QueryValidatorAccountRequest;
+    fromAmino(object: QueryValidatorAccountRequestAmino): QueryValidatorAccountRequest;
+    toAmino(message: QueryValidatorAccountRequest): QueryValidatorAccountRequestAmino;
+    fromAminoMsg(object: QueryValidatorAccountRequestAminoMsg): QueryValidatorAccountRequest;
+    toAminoMsg(message: QueryValidatorAccountRequest): QueryValidatorAccountRequestAminoMsg;
+    fromProtoMsg(message: QueryValidatorAccountRequestProtoMsg): QueryValidatorAccountRequest;
+    toProto(message: QueryValidatorAccountRequest): Uint8Array;
+    toProtoMsg(message: QueryValidatorAccountRequest): QueryValidatorAccountRequestProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryValidatorAccountResponse is the response type for the
+ * Query/ValidatorAccount RPC method.
+ * @name QueryValidatorAccountResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryValidatorAccountResponse
+ */
+export declare const QueryValidatorAccountResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryValidatorAccountResponse;
+    isAmino(o: any): o is QueryValidatorAccountResponseAmino;
+    encode(message: QueryValidatorAccountResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryValidatorAccountResponse;
+    fromPartial(object: DeepPartial<QueryValidatorAccountResponse>): QueryValidatorAccountResponse;
+    fromAmino(object: QueryValidatorAccountResponseAmino): QueryValidatorAccountResponse;
+    toAmino(message: QueryValidatorAccountResponse): QueryValidatorAccountResponseAmino;
+    fromAminoMsg(object: QueryValidatorAccountResponseAminoMsg): QueryValidatorAccountResponse;
+    toAminoMsg(message: QueryValidatorAccountResponse): QueryValidatorAccountResponseAminoMsg;
+    fromProtoMsg(message: QueryValidatorAccountResponseProtoMsg): QueryValidatorAccountResponse;
+    toProto(message: QueryValidatorAccountResponse): Uint8Array;
+    toProtoMsg(message: QueryValidatorAccountResponse): QueryValidatorAccountResponseProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryBalanceRequest is the request type for the Query/Balance RPC method.
+ * @name QueryBalanceRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryBalanceRequest
+ */
+export declare const QueryBalanceRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryBalanceRequest;
+    isAmino(o: any): o is QueryBalanceRequestAmino;
+    encode(message: QueryBalanceRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryBalanceRequest;
+    fromPartial(object: DeepPartial<QueryBalanceRequest>): QueryBalanceRequest;
+    fromAmino(object: QueryBalanceRequestAmino): QueryBalanceRequest;
+    toAmino(message: QueryBalanceRequest): QueryBalanceRequestAmino;
+    fromAminoMsg(object: QueryBalanceRequestAminoMsg): QueryBalanceRequest;
+    toAminoMsg(message: QueryBalanceRequest): QueryBalanceRequestAminoMsg;
+    fromProtoMsg(message: QueryBalanceRequestProtoMsg): QueryBalanceRequest;
+    toProto(message: QueryBalanceRequest): Uint8Array;
+    toProtoMsg(message: QueryBalanceRequest): QueryBalanceRequestProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryBalanceResponse is the response type for the Query/Balance RPC method.
+ * @name QueryBalanceResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryBalanceResponse
+ */
+export declare const QueryBalanceResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryBalanceResponse;
+    isAmino(o: any): o is QueryBalanceResponseAmino;
+    encode(message: QueryBalanceResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryBalanceResponse;
+    fromPartial(object: DeepPartial<QueryBalanceResponse>): QueryBalanceResponse;
+    fromAmino(object: QueryBalanceResponseAmino): QueryBalanceResponse;
+    toAmino(message: QueryBalanceResponse): QueryBalanceResponseAmino;
+    fromAminoMsg(object: QueryBalanceResponseAminoMsg): QueryBalanceResponse;
+    toAminoMsg(message: QueryBalanceResponse): QueryBalanceResponseAminoMsg;
+    fromProtoMsg(message: QueryBalanceResponseProtoMsg): QueryBalanceResponse;
+    toProto(message: QueryBalanceResponse): Uint8Array;
+    toProtoMsg(message: QueryBalanceResponse): QueryBalanceResponseProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryStorageRequest is the request type for the Query/Storage RPC method.
+ * @name QueryStorageRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryStorageRequest
+ */
+export declare const QueryStorageRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryStorageRequest;
+    isAmino(o: any): o is QueryStorageRequestAmino;
+    encode(message: QueryStorageRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryStorageRequest;
+    fromPartial(object: DeepPartial<QueryStorageRequest>): QueryStorageRequest;
+    fromAmino(object: QueryStorageRequestAmino): QueryStorageRequest;
+    toAmino(message: QueryStorageRequest): QueryStorageRequestAmino;
+    fromAminoMsg(object: QueryStorageRequestAminoMsg): QueryStorageRequest;
+    toAminoMsg(message: QueryStorageRequest): QueryStorageRequestAminoMsg;
+    fromProtoMsg(message: QueryStorageRequestProtoMsg): QueryStorageRequest;
+    toProto(message: QueryStorageRequest): Uint8Array;
+    toProtoMsg(message: QueryStorageRequest): QueryStorageRequestProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryStorageResponse is the response type for the Query/Storage RPC
+ * method.
+ * @name QueryStorageResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryStorageResponse
+ */
+export declare const QueryStorageResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryStorageResponse;
+    isAmino(o: any): o is QueryStorageResponseAmino;
+    encode(message: QueryStorageResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryStorageResponse;
+    fromPartial(object: DeepPartial<QueryStorageResponse>): QueryStorageResponse;
+    fromAmino(object: QueryStorageResponseAmino): QueryStorageResponse;
+    toAmino(message: QueryStorageResponse): QueryStorageResponseAmino;
+    fromAminoMsg(object: QueryStorageResponseAminoMsg): QueryStorageResponse;
+    toAminoMsg(message: QueryStorageResponse): QueryStorageResponseAminoMsg;
+    fromProtoMsg(message: QueryStorageResponseProtoMsg): QueryStorageResponse;
+    toProto(message: QueryStorageResponse): Uint8Array;
+    toProtoMsg(message: QueryStorageResponse): QueryStorageResponseProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryCodeRequest is the request type for the Query/Code RPC method.
+ * @name QueryCodeRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryCodeRequest
+ */
+export declare const QueryCodeRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryCodeRequest;
+    isAmino(o: any): o is QueryCodeRequestAmino;
+    encode(message: QueryCodeRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryCodeRequest;
+    fromPartial(object: DeepPartial<QueryCodeRequest>): QueryCodeRequest;
+    fromAmino(object: QueryCodeRequestAmino): QueryCodeRequest;
+    toAmino(message: QueryCodeRequest): QueryCodeRequestAmino;
+    fromAminoMsg(object: QueryCodeRequestAminoMsg): QueryCodeRequest;
+    toAminoMsg(message: QueryCodeRequest): QueryCodeRequestAminoMsg;
+    fromProtoMsg(message: QueryCodeRequestProtoMsg): QueryCodeRequest;
+    toProto(message: QueryCodeRequest): Uint8Array;
+    toProtoMsg(message: QueryCodeRequest): QueryCodeRequestProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryCodeResponse is the response type for the Query/Code RPC
+ * method.
+ * @name QueryCodeResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryCodeResponse
+ */
+export declare const QueryCodeResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryCodeResponse;
+    isAmino(o: any): o is QueryCodeResponseAmino;
+    encode(message: QueryCodeResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryCodeResponse;
+    fromPartial(object: DeepPartial<QueryCodeResponse>): QueryCodeResponse;
+    fromAmino(object: QueryCodeResponseAmino): QueryCodeResponse;
+    toAmino(message: QueryCodeResponse): QueryCodeResponseAmino;
+    fromAminoMsg(object: QueryCodeResponseAminoMsg): QueryCodeResponse;
+    toAminoMsg(message: QueryCodeResponse): QueryCodeResponseAminoMsg;
+    fromProtoMsg(message: QueryCodeResponseProtoMsg): QueryCodeResponse;
+    toProto(message: QueryCodeResponse): Uint8Array;
+    toProtoMsg(message: QueryCodeResponse): QueryCodeResponseProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryTxLogsRequest is the request type for the Query/TxLogs RPC method.
+ * @name QueryTxLogsRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryTxLogsRequest
+ */
+export declare const QueryTxLogsRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryTxLogsRequest;
+    isAmino(o: any): o is QueryTxLogsRequestAmino;
+    encode(message: QueryTxLogsRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryTxLogsRequest;
+    fromPartial(object: DeepPartial<QueryTxLogsRequest>): QueryTxLogsRequest;
+    fromAmino(object: QueryTxLogsRequestAmino): QueryTxLogsRequest;
+    toAmino(message: QueryTxLogsRequest): QueryTxLogsRequestAmino;
+    fromAminoMsg(object: QueryTxLogsRequestAminoMsg): QueryTxLogsRequest;
+    toAminoMsg(message: QueryTxLogsRequest): QueryTxLogsRequestAminoMsg;
+    fromProtoMsg(message: QueryTxLogsRequestProtoMsg): QueryTxLogsRequest;
+    toProto(message: QueryTxLogsRequest): Uint8Array;
+    toProtoMsg(message: QueryTxLogsRequest): QueryTxLogsRequestProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryTxLogsResponse is the response type for the Query/TxLogs RPC method.
+ * @name QueryTxLogsResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryTxLogsResponse
+ */
+export declare const QueryTxLogsResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryTxLogsResponse;
+    isAmino(o: any): o is QueryTxLogsResponseAmino;
+    encode(message: QueryTxLogsResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryTxLogsResponse;
+    fromPartial(object: DeepPartial<QueryTxLogsResponse>): QueryTxLogsResponse;
+    fromAmino(object: QueryTxLogsResponseAmino): QueryTxLogsResponse;
+    toAmino(message: QueryTxLogsResponse): QueryTxLogsResponseAmino;
+    fromAminoMsg(object: QueryTxLogsResponseAminoMsg): QueryTxLogsResponse;
+    toAminoMsg(message: QueryTxLogsResponse): QueryTxLogsResponseAminoMsg;
+    fromProtoMsg(message: QueryTxLogsResponseProtoMsg): QueryTxLogsResponse;
+    toProto(message: QueryTxLogsResponse): Uint8Array;
+    toProtoMsg(message: QueryTxLogsResponse): QueryTxLogsResponseProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryParamsRequest defines the request type for querying x/vm parameters.
+ * @name QueryParamsRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryParamsRequest
+ */
+export declare const QueryParamsRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryParamsRequest;
+    isAmino(o: any): o is QueryParamsRequestAmino;
+    encode(_: QueryParamsRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsRequest;
+    fromPartial(_: DeepPartial<QueryParamsRequest>): QueryParamsRequest;
+    fromAmino(_: QueryParamsRequestAmino): QueryParamsRequest;
+    toAmino(_: QueryParamsRequest): QueryParamsRequestAmino;
+    fromAminoMsg(object: QueryParamsRequestAminoMsg): QueryParamsRequest;
+    toAminoMsg(message: QueryParamsRequest): QueryParamsRequestAminoMsg;
+    fromProtoMsg(message: QueryParamsRequestProtoMsg): QueryParamsRequest;
+    toProto(message: QueryParamsRequest): Uint8Array;
+    toProtoMsg(message: QueryParamsRequest): QueryParamsRequestProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryParamsResponse defines the response type for querying x/vm parameters.
+ * @name QueryParamsResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryParamsResponse
+ */
+export declare const QueryParamsResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryParamsResponse;
+    isAmino(o: any): o is QueryParamsResponseAmino;
+    encode(message: QueryParamsResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsResponse;
+    fromPartial(object: DeepPartial<QueryParamsResponse>): QueryParamsResponse;
+    fromAmino(object: QueryParamsResponseAmino): QueryParamsResponse;
+    toAmino(message: QueryParamsResponse): QueryParamsResponseAmino;
+    fromAminoMsg(object: QueryParamsResponseAminoMsg): QueryParamsResponse;
+    toAminoMsg(message: QueryParamsResponse): QueryParamsResponseAminoMsg;
+    fromProtoMsg(message: QueryParamsResponseProtoMsg): QueryParamsResponse;
+    toProto(message: QueryParamsResponse): Uint8Array;
+    toProtoMsg(message: QueryParamsResponse): QueryParamsResponseProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * EthCallRequest defines EthCall request
+ * @name EthCallRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.EthCallRequest
+ */
+export declare const EthCallRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is EthCallRequest;
+    isAmino(o: any): o is EthCallRequestAmino;
+    encode(message: EthCallRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EthCallRequest;
+    fromPartial(object: DeepPartial<EthCallRequest>): EthCallRequest;
+    fromAmino(object: EthCallRequestAmino): EthCallRequest;
+    toAmino(message: EthCallRequest): EthCallRequestAmino;
+    fromAminoMsg(object: EthCallRequestAminoMsg): EthCallRequest;
+    toAminoMsg(message: EthCallRequest): EthCallRequestAminoMsg;
+    fromProtoMsg(message: EthCallRequestProtoMsg): EthCallRequest;
+    toProto(message: EthCallRequest): Uint8Array;
+    toProtoMsg(message: EthCallRequest): EthCallRequestProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * EstimateGasResponse defines EstimateGas response
+ * @name EstimateGasResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.EstimateGasResponse
+ */
+export declare const EstimateGasResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is EstimateGasResponse;
+    isAmino(o: any): o is EstimateGasResponseAmino;
+    encode(message: EstimateGasResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EstimateGasResponse;
+    fromPartial(object: DeepPartial<EstimateGasResponse>): EstimateGasResponse;
+    fromAmino(object: EstimateGasResponseAmino): EstimateGasResponse;
+    toAmino(message: EstimateGasResponse): EstimateGasResponseAmino;
+    fromAminoMsg(object: EstimateGasResponseAminoMsg): EstimateGasResponse;
+    toAminoMsg(message: EstimateGasResponse): EstimateGasResponseAminoMsg;
+    fromProtoMsg(message: EstimateGasResponseProtoMsg): EstimateGasResponse;
+    toProto(message: EstimateGasResponse): Uint8Array;
+    toProtoMsg(message: EstimateGasResponse): EstimateGasResponseProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryTraceTxRequest defines TraceTx request
+ * @name QueryTraceTxRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryTraceTxRequest
+ */
+export declare const QueryTraceTxRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryTraceTxRequest;
+    isAmino(o: any): o is QueryTraceTxRequestAmino;
+    encode(message: QueryTraceTxRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryTraceTxRequest;
+    fromPartial(object: DeepPartial<QueryTraceTxRequest>): QueryTraceTxRequest;
+    fromAmino(object: QueryTraceTxRequestAmino): QueryTraceTxRequest;
+    toAmino(message: QueryTraceTxRequest): QueryTraceTxRequestAmino;
+    fromAminoMsg(object: QueryTraceTxRequestAminoMsg): QueryTraceTxRequest;
+    toAminoMsg(message: QueryTraceTxRequest): QueryTraceTxRequestAminoMsg;
+    fromProtoMsg(message: QueryTraceTxRequestProtoMsg): QueryTraceTxRequest;
+    toProto(message: QueryTraceTxRequest): Uint8Array;
+    toProtoMsg(message: QueryTraceTxRequest): QueryTraceTxRequestProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryTraceTxResponse defines TraceTx response
+ * @name QueryTraceTxResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryTraceTxResponse
+ */
+export declare const QueryTraceTxResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryTraceTxResponse;
+    isAmino(o: any): o is QueryTraceTxResponseAmino;
+    encode(message: QueryTraceTxResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryTraceTxResponse;
+    fromPartial(object: DeepPartial<QueryTraceTxResponse>): QueryTraceTxResponse;
+    fromAmino(object: QueryTraceTxResponseAmino): QueryTraceTxResponse;
+    toAmino(message: QueryTraceTxResponse): QueryTraceTxResponseAmino;
+    fromAminoMsg(object: QueryTraceTxResponseAminoMsg): QueryTraceTxResponse;
+    toAminoMsg(message: QueryTraceTxResponse): QueryTraceTxResponseAminoMsg;
+    fromProtoMsg(message: QueryTraceTxResponseProtoMsg): QueryTraceTxResponse;
+    toProto(message: QueryTraceTxResponse): Uint8Array;
+    toProtoMsg(message: QueryTraceTxResponse): QueryTraceTxResponseProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryTraceBlockRequest defines TraceTx request
+ * @name QueryTraceBlockRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryTraceBlockRequest
+ */
+export declare const QueryTraceBlockRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryTraceBlockRequest;
+    isAmino(o: any): o is QueryTraceBlockRequestAmino;
+    encode(message: QueryTraceBlockRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryTraceBlockRequest;
+    fromPartial(object: DeepPartial<QueryTraceBlockRequest>): QueryTraceBlockRequest;
+    fromAmino(object: QueryTraceBlockRequestAmino): QueryTraceBlockRequest;
+    toAmino(message: QueryTraceBlockRequest): QueryTraceBlockRequestAmino;
+    fromAminoMsg(object: QueryTraceBlockRequestAminoMsg): QueryTraceBlockRequest;
+    toAminoMsg(message: QueryTraceBlockRequest): QueryTraceBlockRequestAminoMsg;
+    fromProtoMsg(message: QueryTraceBlockRequestProtoMsg): QueryTraceBlockRequest;
+    toProto(message: QueryTraceBlockRequest): Uint8Array;
+    toProtoMsg(message: QueryTraceBlockRequest): QueryTraceBlockRequestProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryTraceBlockResponse defines TraceBlock response
+ * @name QueryTraceBlockResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryTraceBlockResponse
+ */
+export declare const QueryTraceBlockResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryTraceBlockResponse;
+    isAmino(o: any): o is QueryTraceBlockResponseAmino;
+    encode(message: QueryTraceBlockResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryTraceBlockResponse;
+    fromPartial(object: DeepPartial<QueryTraceBlockResponse>): QueryTraceBlockResponse;
+    fromAmino(object: QueryTraceBlockResponseAmino): QueryTraceBlockResponse;
+    toAmino(message: QueryTraceBlockResponse): QueryTraceBlockResponseAmino;
+    fromAminoMsg(object: QueryTraceBlockResponseAminoMsg): QueryTraceBlockResponse;
+    toAminoMsg(message: QueryTraceBlockResponse): QueryTraceBlockResponseAminoMsg;
+    fromProtoMsg(message: QueryTraceBlockResponseProtoMsg): QueryTraceBlockResponse;
+    toProto(message: QueryTraceBlockResponse): Uint8Array;
+    toProtoMsg(message: QueryTraceBlockResponse): QueryTraceBlockResponseProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryBaseFeeRequest defines the request type for querying the EIP1559 base
+ * fee.
+ * @name QueryBaseFeeRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryBaseFeeRequest
+ */
+export declare const QueryBaseFeeRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryBaseFeeRequest;
+    isAmino(o: any): o is QueryBaseFeeRequestAmino;
+    encode(_: QueryBaseFeeRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryBaseFeeRequest;
+    fromPartial(_: DeepPartial<QueryBaseFeeRequest>): QueryBaseFeeRequest;
+    fromAmino(_: QueryBaseFeeRequestAmino): QueryBaseFeeRequest;
+    toAmino(_: QueryBaseFeeRequest): QueryBaseFeeRequestAmino;
+    fromAminoMsg(object: QueryBaseFeeRequestAminoMsg): QueryBaseFeeRequest;
+    toAminoMsg(message: QueryBaseFeeRequest): QueryBaseFeeRequestAminoMsg;
+    fromProtoMsg(message: QueryBaseFeeRequestProtoMsg): QueryBaseFeeRequest;
+    toProto(message: QueryBaseFeeRequest): Uint8Array;
+    toProtoMsg(message: QueryBaseFeeRequest): QueryBaseFeeRequestProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryBaseFeeResponse returns the EIP1559 base fee.
+ * @name QueryBaseFeeResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryBaseFeeResponse
+ */
+export declare const QueryBaseFeeResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryBaseFeeResponse;
+    isAmino(o: any): o is QueryBaseFeeResponseAmino;
+    encode(message: QueryBaseFeeResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryBaseFeeResponse;
+    fromPartial(object: DeepPartial<QueryBaseFeeResponse>): QueryBaseFeeResponse;
+    fromAmino(object: QueryBaseFeeResponseAmino): QueryBaseFeeResponse;
+    toAmino(message: QueryBaseFeeResponse): QueryBaseFeeResponseAmino;
+    fromAminoMsg(object: QueryBaseFeeResponseAminoMsg): QueryBaseFeeResponse;
+    toAminoMsg(message: QueryBaseFeeResponse): QueryBaseFeeResponseAminoMsg;
+    fromProtoMsg(message: QueryBaseFeeResponseProtoMsg): QueryBaseFeeResponse;
+    toProto(message: QueryBaseFeeResponse): Uint8Array;
+    toProtoMsg(message: QueryBaseFeeResponse): QueryBaseFeeResponseProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryGlobalMinGasPriceRequest defines the request type for querying the
+ * GlobalMinGasPrice
+ * @name QueryGlobalMinGasPriceRequest
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryGlobalMinGasPriceRequest
+ */
+export declare const QueryGlobalMinGasPriceRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryGlobalMinGasPriceRequest;
+    isAmino(o: any): o is QueryGlobalMinGasPriceRequestAmino;
+    encode(_: QueryGlobalMinGasPriceRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryGlobalMinGasPriceRequest;
+    fromPartial(_: DeepPartial<QueryGlobalMinGasPriceRequest>): QueryGlobalMinGasPriceRequest;
+    fromAmino(_: QueryGlobalMinGasPriceRequestAmino): QueryGlobalMinGasPriceRequest;
+    toAmino(_: QueryGlobalMinGasPriceRequest): QueryGlobalMinGasPriceRequestAmino;
+    fromAminoMsg(object: QueryGlobalMinGasPriceRequestAminoMsg): QueryGlobalMinGasPriceRequest;
+    toAminoMsg(message: QueryGlobalMinGasPriceRequest): QueryGlobalMinGasPriceRequestAminoMsg;
+    fromProtoMsg(message: QueryGlobalMinGasPriceRequestProtoMsg): QueryGlobalMinGasPriceRequest;
+    toProto(message: QueryGlobalMinGasPriceRequest): Uint8Array;
+    toProtoMsg(message: QueryGlobalMinGasPriceRequest): QueryGlobalMinGasPriceRequestProtoMsg;
+    registerTypeUrl(): void;
+};
+/**
+ * QueryGlobalMinGasPriceResponse returns the GlobalMinGasPrice
+ * @name QueryGlobalMinGasPriceResponse
+ * @package cosmos.evm.vm.v1
+ * @see proto type: cosmos.evm.vm.v1.QueryGlobalMinGasPriceResponse
+ */
+export declare const QueryGlobalMinGasPriceResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryGlobalMinGasPriceResponse;
+    isAmino(o: any): o is QueryGlobalMinGasPriceResponseAmino;
+    encode(message: QueryGlobalMinGasPriceResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryGlobalMinGasPriceResponse;
+    fromPartial(object: DeepPartial<QueryGlobalMinGasPriceResponse>): QueryGlobalMinGasPriceResponse;
+    fromAmino(object: QueryGlobalMinGasPriceResponseAmino): QueryGlobalMinGasPriceResponse;
+    toAmino(message: QueryGlobalMinGasPriceResponse): QueryGlobalMinGasPriceResponseAmino;
+    fromAminoMsg(object: QueryGlobalMinGasPriceResponseAminoMsg): QueryGlobalMinGasPriceResponse;
+    toAminoMsg(message: QueryGlobalMinGasPriceResponse): QueryGlobalMinGasPriceResponseAminoMsg;
+    fromProtoMsg(message: QueryGlobalMinGasPriceResponseProtoMsg): QueryGlobalMinGasPriceResponse;
+    toProto(message: QueryGlobalMinGasPriceResponse): Uint8Array;
+    toProtoMsg(message: QueryGlobalMinGasPriceResponse): QueryGlobalMinGasPriceResponseProtoMsg;
+    registerTypeUrl(): void;
+};