carbon-js-sdk 0.3.53-dev.1 → 0.3.53-dev.2

package/lib/codec/ethermint/evm/v1/genesis.d.ts

@@ -0,0 +1,43 @@
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+import { Params, State } from "./evm";
+export declare const protobufPackage = "ethermint.evm.v1";
+/** GenesisState defines the evm module's genesis state. */
+export interface GenesisState {
+    /** accounts is an array containing the ethereum genesis accounts. */
+    accounts: GenesisAccount[];
+    /** params defines all the parameters of the module. */
+    params?: Params;
+}
+/**
+ * GenesisAccount defines an account to be initialized in the genesis state.
+ * Its main difference between with Geth's GenesisAccount is that it uses a
+ * custom storage type and that it doesn't contain the private key field.
+ */
+export interface GenesisAccount {
+    /** address defines an ethereum hex formated address of an account */
+    address: string;
+    /** code defines the hex bytes of the account code. */
+    code: string;
+    /** storage defines the set of state key values for the account. */
+    storage: State[];
+}
+export declare const GenesisState: {
+    encode(message: GenesisState, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): GenesisState;
+    fromJSON(object: any): GenesisState;
+    toJSON(message: GenesisState): unknown;
+    fromPartial(object: DeepPartial<GenesisState>): GenesisState;
+};
+export declare const GenesisAccount: {
+    encode(message: GenesisAccount, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): GenesisAccount;
+    fromJSON(object: any): GenesisAccount;
+    toJSON(message: GenesisAccount): unknown;
+    fromPartial(object: DeepPartial<GenesisAccount>): GenesisAccount;
+};
+declare type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export declare type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};

package/lib/codec/ethermint/evm/v1/genesis.js

@@ -0,0 +1,153 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenesisAccount = exports.GenesisState = exports.protobufPackage = void 0;
+/* eslint-disable */
+const long_1 = __importDefault(require("long"));
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const evm_1 = require("./evm");
+exports.protobufPackage = "ethermint.evm.v1";
+const baseGenesisState = {};
+exports.GenesisState = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        for (const v of message.accounts) {
+            exports.GenesisAccount.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.params !== undefined) {
+            evm_1.Params.encode(message.params, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.assign({}, baseGenesisState);
+        message.accounts = [];
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.accounts.push(exports.GenesisAccount.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.params = evm_1.Params.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        var _a;
+        const message = Object.assign({}, baseGenesisState);
+        message.accounts = ((_a = object.accounts) !== null && _a !== void 0 ? _a : []).map((e) => exports.GenesisAccount.fromJSON(e));
+        message.params =
+            object.params !== undefined && object.params !== null
+                ? evm_1.Params.fromJSON(object.params)
+                : undefined;
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.accounts) {
+            obj.accounts = message.accounts.map((e) => e ? exports.GenesisAccount.toJSON(e) : undefined);
+        }
+        else {
+            obj.accounts = [];
+        }
+        message.params !== undefined &&
+            (obj.params = message.params ? evm_1.Params.toJSON(message.params) : undefined);
+        return obj;
+    },
+    fromPartial(object) {
+        var _a;
+        const message = Object.assign({}, baseGenesisState);
+        message.accounts = ((_a = object.accounts) !== null && _a !== void 0 ? _a : []).map((e) => exports.GenesisAccount.fromPartial(e));
+        message.params =
+            object.params !== undefined && object.params !== null
+                ? evm_1.Params.fromPartial(object.params)
+                : undefined;
+        return message;
+    },
+};
+const baseGenesisAccount = { address: "", code: "" };
+exports.GenesisAccount = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.address !== "") {
+            writer.uint32(10).string(message.address);
+        }
+        if (message.code !== "") {
+            writer.uint32(18).string(message.code);
+        }
+        for (const v of message.storage) {
+            evm_1.State.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.assign({}, baseGenesisAccount);
+        message.storage = [];
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.address = reader.string();
+                    break;
+                case 2:
+                    message.code = reader.string();
+                    break;
+                case 3:
+                    message.storage.push(evm_1.State.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        var _a;
+        const message = Object.assign({}, baseGenesisAccount);
+        message.address =
+            object.address !== undefined && object.address !== null
+                ? String(object.address)
+                : "";
+        message.code =
+            object.code !== undefined && object.code !== null
+                ? String(object.code)
+                : "";
+        message.storage = ((_a = object.storage) !== null && _a !== void 0 ? _a : []).map((e) => evm_1.State.fromJSON(e));
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        message.address !== undefined && (obj.address = message.address);
+        message.code !== undefined && (obj.code = message.code);
+        if (message.storage) {
+            obj.storage = message.storage.map((e) => e ? evm_1.State.toJSON(e) : undefined);
+        }
+        else {
+            obj.storage = [];
+        }
+        return obj;
+    },
+    fromPartial(object) {
+        var _a, _b, _c;
+        const message = Object.assign({}, baseGenesisAccount);
+        message.address = (_a = object.address) !== null && _a !== void 0 ? _a : "";
+        message.code = (_b = object.code) !== null && _b !== void 0 ? _b : "";
+        message.storage = ((_c = object.storage) !== null && _c !== void 0 ? _c : []).map((e) => evm_1.State.fromPartial(e));
+        return message;
+    },
+};
+if (minimal_1.default.util.Long !== long_1.default) {
+    minimal_1.default.util.Long = long_1.default;
+    minimal_1.default.configure();
+}

package/lib/codec/ethermint/evm/v1/query.d.ts

@@ -0,0 +1,424 @@
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+import { PageRequest, PageResponse } from "../../../cosmos/base/query/v1beta1/pagination";
+import { Params, TraceConfig, Log } from "./evm";
+import { MsgEthereumTx, MsgEthereumTxResponse } from "./tx";
+export declare const protobufPackage = "ethermint.evm.v1";
+/** QueryAccountRequest is the request type for the Query/Account RPC method. */
+export interface QueryAccountRequest {
+    /** address is the ethereum hex address to query the account for. */
+    address: string;
+}
+/** QueryAccountResponse is the response type for the Query/Account RPC method. */
+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: Long;
+}
+/**
+ * QueryCosmosAccountRequest is the request type for the Query/CosmosAccount RPC
+ * method.
+ */
+export interface QueryCosmosAccountRequest {
+    /** address is the ethereum hex address to query the account for. */
+    address: string;
+}
+/**
+ * QueryCosmosAccountResponse is the response type for the Query/CosmosAccount
+ * RPC method.
+ */
+export interface QueryCosmosAccountResponse {
+    /** cosmos_address is the cosmos address of the account. */
+    cosmosAddress: string;
+    /** sequence is the account's sequence number. */
+    sequence: Long;
+    /** account_number is the account number */
+    accountNumber: Long;
+}
+/**
+ * QueryValidatorAccountRequest is the request type for the
+ * Query/ValidatorAccount RPC method.
+ */
+export interface QueryValidatorAccountRequest {
+    /** cons_address is the validator cons address to query the account for. */
+    consAddress: string;
+}
+/**
+ * QueryValidatorAccountResponse is the response type for the
+ * Query/ValidatorAccount RPC method.
+ */
+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: Long;
+    /** account_number is the account number */
+    accountNumber: Long;
+}
+/** QueryBalanceRequest is the request type for the Query/Balance RPC method. */
+export interface QueryBalanceRequest {
+    /** address is the ethereum hex address to query the balance for. */
+    address: string;
+}
+/** QueryBalanceResponse is the response type for the Query/Balance RPC method. */
+export interface QueryBalanceResponse {
+    /** balance is the balance of the EVM denomination. */
+    balance: string;
+}
+/** QueryStorageRequest is the request type for the Query/Storage RPC method. */
+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;
+}
+/**
+ * QueryStorageResponse is the response type for the Query/Storage RPC
+ * method.
+ */
+export interface QueryStorageResponse {
+    /** value defines the storage state value hash associated with the given key. */
+    value: string;
+}
+/** QueryCodeRequest is the request type for the Query/Code RPC method. */
+export interface QueryCodeRequest {
+    /** address is the ethereum hex address to query the code for. */
+    address: string;
+}
+/**
+ * QueryCodeResponse is the response type for the Query/Code RPC
+ * method.
+ */
+export interface QueryCodeResponse {
+    /** code represents the code bytes from an ethereum address. */
+    code: Uint8Array;
+}
+/** QueryTxLogsRequest is the request type for the Query/TxLogs RPC method. */
+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;
+}
+/** QueryTxLogsResponse is the response type for the Query/TxLogs RPC method. */
+export interface QueryTxLogsResponse {
+    /** logs represents the ethereum logs generated from the given transaction. */
+    logs: Log[];
+    /** pagination defines the pagination in the response. */
+    pagination?: PageResponse;
+}
+/** QueryParamsRequest defines the request type for querying x/evm parameters. */
+export interface QueryParamsRequest {
+}
+/** QueryParamsResponse defines the response type for querying x/evm parameters. */
+export interface QueryParamsResponse {
+    /** params define the evm module parameters. */
+    params?: Params;
+}
+/** EthCallRequest defines EthCall request */
+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: Long;
+    /** 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: Long;
+}
+/** EstimateGasResponse defines EstimateGas response */
+export interface EstimateGasResponse {
+    /** gas returns the estimated gas */
+    gas: Long;
+}
+/** QueryTraceTxRequest defines TraceTx request */
+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: Long;
+    /** 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 the eip155 chain id parsed from the requested block header */
+    chainId: Long;
+}
+/** QueryTraceTxResponse defines TraceTx response */
+export interface QueryTraceTxResponse {
+    /** data is the response serialized in bytes */
+    data: Uint8Array;
+}
+/** QueryTraceBlockRequest defines TraceTx request */
+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: Long;
+    /** 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: Long;
+}
+/** QueryTraceBlockResponse defines TraceBlock response */
+export interface QueryTraceBlockResponse {
+    /** data is the response serialized in bytes */
+    data: Uint8Array;
+}
+/**
+ * QueryBaseFeeRequest defines the request type for querying the EIP1559 base
+ * fee.
+ */
+export interface QueryBaseFeeRequest {
+}
+/** QueryBaseFeeResponse returns the EIP1559 base fee. */
+export interface QueryBaseFeeResponse {
+    /** base_fee is the EIP1559 base fee */
+    baseFee: string;
+}
+export declare const QueryAccountRequest: {
+    encode(message: QueryAccountRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): QueryAccountRequest;
+    fromJSON(object: any): QueryAccountRequest;
+    toJSON(message: QueryAccountRequest): unknown;
+    fromPartial(object: DeepPartial<QueryAccountRequest>): QueryAccountRequest;
+};
+export declare const QueryAccountResponse: {
+    encode(message: QueryAccountResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): QueryAccountResponse;
+    fromJSON(object: any): QueryAccountResponse;
+    toJSON(message: QueryAccountResponse): unknown;
+    fromPartial(object: DeepPartial<QueryAccountResponse>): QueryAccountResponse;
+};
+export declare const QueryCosmosAccountRequest: {
+    encode(message: QueryCosmosAccountRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): QueryCosmosAccountRequest;
+    fromJSON(object: any): QueryCosmosAccountRequest;
+    toJSON(message: QueryCosmosAccountRequest): unknown;
+    fromPartial(object: DeepPartial<QueryCosmosAccountRequest>): QueryCosmosAccountRequest;
+};
+export declare const QueryCosmosAccountResponse: {
+    encode(message: QueryCosmosAccountResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): QueryCosmosAccountResponse;
+    fromJSON(object: any): QueryCosmosAccountResponse;
+    toJSON(message: QueryCosmosAccountResponse): unknown;
+    fromPartial(object: DeepPartial<QueryCosmosAccountResponse>): QueryCosmosAccountResponse;
+};
+export declare const QueryValidatorAccountRequest: {
+    encode(message: QueryValidatorAccountRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): QueryValidatorAccountRequest;
+    fromJSON(object: any): QueryValidatorAccountRequest;
+    toJSON(message: QueryValidatorAccountRequest): unknown;
+    fromPartial(object: DeepPartial<QueryValidatorAccountRequest>): QueryValidatorAccountRequest;
+};
+export declare const QueryValidatorAccountResponse: {
+    encode(message: QueryValidatorAccountResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): QueryValidatorAccountResponse;
+    fromJSON(object: any): QueryValidatorAccountResponse;
+    toJSON(message: QueryValidatorAccountResponse): unknown;
+    fromPartial(object: DeepPartial<QueryValidatorAccountResponse>): QueryValidatorAccountResponse;
+};
+export declare const QueryBalanceRequest: {
+    encode(message: QueryBalanceRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): QueryBalanceRequest;
+    fromJSON(object: any): QueryBalanceRequest;
+    toJSON(message: QueryBalanceRequest): unknown;
+    fromPartial(object: DeepPartial<QueryBalanceRequest>): QueryBalanceRequest;
+};
+export declare const QueryBalanceResponse: {
+    encode(message: QueryBalanceResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): QueryBalanceResponse;
+    fromJSON(object: any): QueryBalanceResponse;
+    toJSON(message: QueryBalanceResponse): unknown;
+    fromPartial(object: DeepPartial<QueryBalanceResponse>): QueryBalanceResponse;
+};
+export declare const QueryStorageRequest: {
+    encode(message: QueryStorageRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): QueryStorageRequest;
+    fromJSON(object: any): QueryStorageRequest;
+    toJSON(message: QueryStorageRequest): unknown;
+    fromPartial(object: DeepPartial<QueryStorageRequest>): QueryStorageRequest;
+};
+export declare const QueryStorageResponse: {
+    encode(message: QueryStorageResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): QueryStorageResponse;
+    fromJSON(object: any): QueryStorageResponse;
+    toJSON(message: QueryStorageResponse): unknown;
+    fromPartial(object: DeepPartial<QueryStorageResponse>): QueryStorageResponse;
+};
+export declare const QueryCodeRequest: {
+    encode(message: QueryCodeRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): QueryCodeRequest;
+    fromJSON(object: any): QueryCodeRequest;
+    toJSON(message: QueryCodeRequest): unknown;
+    fromPartial(object: DeepPartial<QueryCodeRequest>): QueryCodeRequest;
+};
+export declare const QueryCodeResponse: {
+    encode(message: QueryCodeResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): QueryCodeResponse;
+    fromJSON(object: any): QueryCodeResponse;
+    toJSON(message: QueryCodeResponse): unknown;
+    fromPartial(object: DeepPartial<QueryCodeResponse>): QueryCodeResponse;
+};
+export declare const QueryTxLogsRequest: {
+    encode(message: QueryTxLogsRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): QueryTxLogsRequest;
+    fromJSON(object: any): QueryTxLogsRequest;
+    toJSON(message: QueryTxLogsRequest): unknown;
+    fromPartial(object: DeepPartial<QueryTxLogsRequest>): QueryTxLogsRequest;
+};
+export declare const QueryTxLogsResponse: {
+    encode(message: QueryTxLogsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): QueryTxLogsResponse;
+    fromJSON(object: any): QueryTxLogsResponse;
+    toJSON(message: QueryTxLogsResponse): unknown;
+    fromPartial(object: DeepPartial<QueryTxLogsResponse>): QueryTxLogsResponse;
+};
+export declare const QueryParamsRequest: {
+    encode(_: QueryParamsRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): QueryParamsRequest;
+    fromJSON(_: any): QueryParamsRequest;
+    toJSON(_: QueryParamsRequest): unknown;
+    fromPartial(_: DeepPartial<QueryParamsRequest>): QueryParamsRequest;
+};
+export declare const QueryParamsResponse: {
+    encode(message: QueryParamsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): QueryParamsResponse;
+    fromJSON(object: any): QueryParamsResponse;
+    toJSON(message: QueryParamsResponse): unknown;
+    fromPartial(object: DeepPartial<QueryParamsResponse>): QueryParamsResponse;
+};
+export declare const EthCallRequest: {
+    encode(message: EthCallRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): EthCallRequest;
+    fromJSON(object: any): EthCallRequest;
+    toJSON(message: EthCallRequest): unknown;
+    fromPartial(object: DeepPartial<EthCallRequest>): EthCallRequest;
+};
+export declare const EstimateGasResponse: {
+    encode(message: EstimateGasResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): EstimateGasResponse;
+    fromJSON(object: any): EstimateGasResponse;
+    toJSON(message: EstimateGasResponse): unknown;
+    fromPartial(object: DeepPartial<EstimateGasResponse>): EstimateGasResponse;
+};
+export declare const QueryTraceTxRequest: {
+    encode(message: QueryTraceTxRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): QueryTraceTxRequest;
+    fromJSON(object: any): QueryTraceTxRequest;
+    toJSON(message: QueryTraceTxRequest): unknown;
+    fromPartial(object: DeepPartial<QueryTraceTxRequest>): QueryTraceTxRequest;
+};
+export declare const QueryTraceTxResponse: {
+    encode(message: QueryTraceTxResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): QueryTraceTxResponse;
+    fromJSON(object: any): QueryTraceTxResponse;
+    toJSON(message: QueryTraceTxResponse): unknown;
+    fromPartial(object: DeepPartial<QueryTraceTxResponse>): QueryTraceTxResponse;
+};
+export declare const QueryTraceBlockRequest: {
+    encode(message: QueryTraceBlockRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): QueryTraceBlockRequest;
+    fromJSON(object: any): QueryTraceBlockRequest;
+    toJSON(message: QueryTraceBlockRequest): unknown;
+    fromPartial(object: DeepPartial<QueryTraceBlockRequest>): QueryTraceBlockRequest;
+};
+export declare const QueryTraceBlockResponse: {
+    encode(message: QueryTraceBlockResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): QueryTraceBlockResponse;
+    fromJSON(object: any): QueryTraceBlockResponse;
+    toJSON(message: QueryTraceBlockResponse): unknown;
+    fromPartial(object: DeepPartial<QueryTraceBlockResponse>): QueryTraceBlockResponse;
+};
+export declare const QueryBaseFeeRequest: {
+    encode(_: QueryBaseFeeRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): QueryBaseFeeRequest;
+    fromJSON(_: any): QueryBaseFeeRequest;
+    toJSON(_: QueryBaseFeeRequest): unknown;
+    fromPartial(_: DeepPartial<QueryBaseFeeRequest>): QueryBaseFeeRequest;
+};
+export declare const QueryBaseFeeResponse: {
+    encode(message: QueryBaseFeeResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): QueryBaseFeeResponse;
+    fromJSON(object: any): QueryBaseFeeResponse;
+    toJSON(message: QueryBaseFeeResponse): unknown;
+    fromPartial(object: DeepPartial<QueryBaseFeeResponse>): QueryBaseFeeResponse;
+};
+/** Query defines the gRPC querier service. */
+export interface Query {
+    /** Account queries an Ethereum account. */
+    Account(request: QueryAccountRequest): Promise<QueryAccountResponse>;
+    /** CosmosAccount queries an Ethereum account's Cosmos Address. */
+    CosmosAccount(request: QueryCosmosAccountRequest): Promise<QueryCosmosAccountResponse>;
+    /**
+     * ValidatorAccount queries an Ethereum account's from a validator consensus
+     * Address.
+     */
+    ValidatorAccount(request: QueryValidatorAccountRequest): Promise<QueryValidatorAccountResponse>;
+    /**
+     * Balance queries the balance of a the EVM denomination for a single
+     * EthAccount.
+     */
+    Balance(request: QueryBalanceRequest): Promise<QueryBalanceResponse>;
+    /** Storage queries the balance of all coins for a single account. */
+    Storage(request: QueryStorageRequest): Promise<QueryStorageResponse>;
+    /** Code queries the balance of all coins for a single account. */
+    Code(request: QueryCodeRequest): Promise<QueryCodeResponse>;
+    /** Params queries the parameters of x/evm module. */
+    Params(request: QueryParamsRequest): Promise<QueryParamsResponse>;
+    /** EthCall implements the `eth_call` rpc api */
+    EthCall(request: EthCallRequest): Promise<MsgEthereumTxResponse>;
+    /** EstimateGas implements the `eth_estimateGas` rpc api */
+    EstimateGas(request: EthCallRequest): Promise<EstimateGasResponse>;
+    /** TraceTx implements the `debug_traceTransaction` rpc api */
+    TraceTx(request: QueryTraceTxRequest): Promise<QueryTraceTxResponse>;
+    /** TraceBlock implements the `debug_traceBlockByNumber` and `debug_traceBlockByHash` rpc api */
+    TraceBlock(request: QueryTraceBlockRequest): Promise<QueryTraceBlockResponse>;
+    /**
+     * BaseFee queries the base fee of the parent block of the current block,
+     * it's similar to feemarket module's method, but also checks london hardfork status.
+     */
+    BaseFee(request: QueryBaseFeeRequest): Promise<QueryBaseFeeResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    Account(request: QueryAccountRequest): Promise<QueryAccountResponse>;
+    CosmosAccount(request: QueryCosmosAccountRequest): Promise<QueryCosmosAccountResponse>;
+    ValidatorAccount(request: QueryValidatorAccountRequest): Promise<QueryValidatorAccountResponse>;
+    Balance(request: QueryBalanceRequest): Promise<QueryBalanceResponse>;
+    Storage(request: QueryStorageRequest): Promise<QueryStorageResponse>;
+    Code(request: QueryCodeRequest): Promise<QueryCodeResponse>;
+    Params(request: QueryParamsRequest): Promise<QueryParamsResponse>;
+    EthCall(request: EthCallRequest): Promise<MsgEthereumTxResponse>;
+    EstimateGas(request: EthCallRequest): Promise<EstimateGasResponse>;
+    TraceTx(request: QueryTraceTxRequest): Promise<QueryTraceTxResponse>;
+    TraceBlock(request: QueryTraceBlockRequest): Promise<QueryTraceBlockResponse>;
+    BaseFee(request: QueryBaseFeeRequest): Promise<QueryBaseFeeResponse>;
+}
+interface Rpc {
+    request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
+}
+declare type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export declare type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};