@xpla/xplajs 1.7.0-beta.0

package/src/ethermint/evm/v1/query.lcd.ts

@@ -0,0 +1,157 @@
+import { MsgEthereumTxResponse } from "./tx";
+import { LCDClient } from "@cosmology/lcd";
+import { QueryAccountRequest, QueryAccountResponse, QueryCosmosAccountRequest, QueryCosmosAccountResponse, QueryValidatorAccountRequest, QueryValidatorAccountResponse, QueryBalanceRequest, QueryBalanceResponse, QueryStorageRequest, QueryStorageResponse, QueryCodeRequest, QueryCodeResponse, QueryParamsRequest, QueryParamsResponse, EthCallRequest, EstimateGasResponse, QueryTraceTxRequest, QueryTraceTxResponse, QueryTraceBlockRequest, QueryTraceBlockResponse, QueryBaseFeeRequest, QueryBaseFeeResponse } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+  }
+  /* Account queries an Ethereum account. */
+  account = async (params: QueryAccountRequest): Promise<QueryAccountResponse> => {
+    const endpoint = `ethermint/evm/v1/account/${params.address}`;
+    return await this.req.get<QueryAccountResponse>(endpoint);
+  };
+  /* CosmosAccount queries an Ethereum account's Cosmos Address. */
+  cosmosAccount = async (params: QueryCosmosAccountRequest): Promise<QueryCosmosAccountResponse> => {
+    const endpoint = `ethermint/evm/v1/cosmos_account/${params.address}`;
+    return await this.req.get<QueryCosmosAccountResponse>(endpoint);
+  };
+  /* ValidatorAccount queries an Ethereum account's from a validator consensus
+   Address. */
+  validatorAccount = async (params: QueryValidatorAccountRequest): Promise<QueryValidatorAccountResponse> => {
+    const endpoint = `ethermint/evm/v1/validator_account/${params.consAddress}`;
+    return await this.req.get<QueryValidatorAccountResponse>(endpoint);
+  };
+  /* Balance queries the balance of a the EVM denomination for a single
+   EthAccount. */
+  balance = async (params: QueryBalanceRequest): Promise<QueryBalanceResponse> => {
+    const endpoint = `ethermint/evm/v1/balances/${params.address}`;
+    return await this.req.get<QueryBalanceResponse>(endpoint);
+  };
+  /* Storage queries the balance of all coins for a single account. */
+  storage = async (params: QueryStorageRequest): Promise<QueryStorageResponse> => {
+    const endpoint = `ethermint/evm/v1/storage/${params.address}/${params.key}`;
+    return await this.req.get<QueryStorageResponse>(endpoint);
+  };
+  /* Code queries the balance of all coins for a single account. */
+  code = async (params: QueryCodeRequest): Promise<QueryCodeResponse> => {
+    const endpoint = `ethermint/evm/v1/codes/${params.address}`;
+    return await this.req.get<QueryCodeResponse>(endpoint);
+  };
+  /* Params queries the parameters of x/evm module. */
+  params = async (_params: QueryParamsRequest = {}): Promise<QueryParamsResponse> => {
+    const endpoint = `ethermint/evm/v1/params`;
+    return await this.req.get<QueryParamsResponse>(endpoint);
+  };
+  /* EthCall implements the `eth_call` rpc api */
+  ethCall = async (params: EthCallRequest): Promise<MsgEthereumTxResponse> => {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.args !== "undefined") {
+      options.params.args = params.args;
+    }
+    if (typeof params?.gasCap !== "undefined") {
+      options.params.gas_cap = params.gasCap;
+    }
+    if (typeof params?.proposerAddress !== "undefined") {
+      options.params.proposer_address = params.proposerAddress;
+    }
+    if (typeof params?.chainId !== "undefined") {
+      options.params.chain_id = params.chainId;
+    }
+    const endpoint = `ethermint/evm/v1/eth_call`;
+    return await this.req.get<MsgEthereumTxResponse>(endpoint, options);
+  };
+  /* EstimateGas implements the `eth_estimateGas` rpc api */
+  estimateGas = async (params: EthCallRequest): Promise<EstimateGasResponse> => {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.args !== "undefined") {
+      options.params.args = params.args;
+    }
+    if (typeof params?.gasCap !== "undefined") {
+      options.params.gas_cap = params.gasCap;
+    }
+    if (typeof params?.proposerAddress !== "undefined") {
+      options.params.proposer_address = params.proposerAddress;
+    }
+    if (typeof params?.chainId !== "undefined") {
+      options.params.chain_id = params.chainId;
+    }
+    const endpoint = `ethermint/evm/v1/estimate_gas`;
+    return await this.req.get<EstimateGasResponse>(endpoint, options);
+  };
+  /* TraceTx implements the `debug_traceTransaction` rpc api */
+  traceTx = async (params: QueryTraceTxRequest): Promise<QueryTraceTxResponse> => {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.msg !== "undefined") {
+      options.params.msg = params.msg;
+    }
+    if (typeof params?.traceConfig !== "undefined") {
+      options.params.trace_config = params.traceConfig;
+    }
+    if (typeof params?.predecessors !== "undefined") {
+      options.params.predecessors = params.predecessors;
+    }
+    if (typeof params?.blockNumber !== "undefined") {
+      options.params.block_number = params.blockNumber;
+    }
+    if (typeof params?.blockHash !== "undefined") {
+      options.params.block_hash = params.blockHash;
+    }
+    if (typeof params?.blockTime !== "undefined") {
+      options.params.block_time = params.blockTime;
+    }
+    if (typeof params?.proposerAddress !== "undefined") {
+      options.params.proposer_address = params.proposerAddress;
+    }
+    if (typeof params?.chainId !== "undefined") {
+      options.params.chain_id = params.chainId;
+    }
+    const endpoint = `ethermint/evm/v1/trace_tx`;
+    return await this.req.get<QueryTraceTxResponse>(endpoint, options);
+  };
+  /* TraceBlock implements the `debug_traceBlockByNumber` and `debug_traceBlockByHash` rpc api */
+  traceBlock = async (params: QueryTraceBlockRequest): Promise<QueryTraceBlockResponse> => {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.txs !== "undefined") {
+      options.params.txs = params.txs;
+    }
+    if (typeof params?.traceConfig !== "undefined") {
+      options.params.trace_config = params.traceConfig;
+    }
+    if (typeof params?.blockNumber !== "undefined") {
+      options.params.block_number = params.blockNumber;
+    }
+    if (typeof params?.blockHash !== "undefined") {
+      options.params.block_hash = params.blockHash;
+    }
+    if (typeof params?.blockTime !== "undefined") {
+      options.params.block_time = params.blockTime;
+    }
+    if (typeof params?.proposerAddress !== "undefined") {
+      options.params.proposer_address = params.proposerAddress;
+    }
+    if (typeof params?.chainId !== "undefined") {
+      options.params.chain_id = params.chainId;
+    }
+    const endpoint = `ethermint/evm/v1/trace_block`;
+    return await this.req.get<QueryTraceBlockResponse>(endpoint, options);
+  };
+  /* 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 = async (_params: QueryBaseFeeRequest = {}): Promise<QueryBaseFeeResponse> => {
+    const endpoint = `ethermint/evm/v1/base_fee`;
+    return await this.req.get<QueryBaseFeeResponse>(endpoint);
+  };
+}

package/src/ethermint/evm/v1/query.rpc.Query.ts

@@ -0,0 +1,164 @@
+import { MsgEthereumTxResponse } from "./tx";
+import { TxRpc } from "../../../types";
+import { BinaryReader } from "../../../binary";
+import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryAccountRequest, QueryAccountResponse, QueryCosmosAccountRequest, QueryCosmosAccountResponse, QueryValidatorAccountRequest, QueryValidatorAccountResponse, QueryBalanceRequest, QueryBalanceResponse, QueryStorageRequest, QueryStorageResponse, QueryCodeRequest, QueryCodeResponse, QueryParamsRequest, QueryParamsResponse, EthCallRequest, EstimateGasResponse, QueryTraceTxRequest, QueryTraceTxResponse, QueryTraceBlockRequest, QueryTraceBlockResponse, QueryBaseFeeRequest, QueryBaseFeeResponse } from "./query";
+/** 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 class QueryClientImpl implements Query {
+  private readonly rpc: TxRpc;
+  constructor(rpc: TxRpc) {
+    this.rpc = rpc;
+  }
+  /* Account queries an Ethereum account. */
+  account = async (request: QueryAccountRequest): Promise<QueryAccountResponse> => {
+    const data = QueryAccountRequest.encode(request).finish();
+    const promise = this.rpc.request("ethermint.evm.v1.Query", "Account", data);
+    return promise.then(data => QueryAccountResponse.decode(new BinaryReader(data)));
+  };
+  /* CosmosAccount queries an Ethereum account's Cosmos Address. */
+  cosmosAccount = async (request: QueryCosmosAccountRequest): Promise<QueryCosmosAccountResponse> => {
+    const data = QueryCosmosAccountRequest.encode(request).finish();
+    const promise = this.rpc.request("ethermint.evm.v1.Query", "CosmosAccount", data);
+    return promise.then(data => QueryCosmosAccountResponse.decode(new BinaryReader(data)));
+  };
+  /* ValidatorAccount queries an Ethereum account's from a validator consensus
+   Address. */
+  validatorAccount = async (request: QueryValidatorAccountRequest): Promise<QueryValidatorAccountResponse> => {
+    const data = QueryValidatorAccountRequest.encode(request).finish();
+    const promise = this.rpc.request("ethermint.evm.v1.Query", "ValidatorAccount", data);
+    return promise.then(data => QueryValidatorAccountResponse.decode(new BinaryReader(data)));
+  };
+  /* Balance queries the balance of a the EVM denomination for a single
+   EthAccount. */
+  balance = async (request: QueryBalanceRequest): Promise<QueryBalanceResponse> => {
+    const data = QueryBalanceRequest.encode(request).finish();
+    const promise = this.rpc.request("ethermint.evm.v1.Query", "Balance", data);
+    return promise.then(data => QueryBalanceResponse.decode(new BinaryReader(data)));
+  };
+  /* Storage queries the balance of all coins for a single account. */
+  storage = async (request: QueryStorageRequest): Promise<QueryStorageResponse> => {
+    const data = QueryStorageRequest.encode(request).finish();
+    const promise = this.rpc.request("ethermint.evm.v1.Query", "Storage", data);
+    return promise.then(data => QueryStorageResponse.decode(new BinaryReader(data)));
+  };
+  /* Code queries the balance of all coins for a single account. */
+  code = async (request: QueryCodeRequest): Promise<QueryCodeResponse> => {
+    const data = QueryCodeRequest.encode(request).finish();
+    const promise = this.rpc.request("ethermint.evm.v1.Query", "Code", data);
+    return promise.then(data => QueryCodeResponse.decode(new BinaryReader(data)));
+  };
+  /* Params queries the parameters of x/evm module. */
+  params = async (request: QueryParamsRequest = {}): Promise<QueryParamsResponse> => {
+    const data = QueryParamsRequest.encode(request).finish();
+    const promise = this.rpc.request("ethermint.evm.v1.Query", "Params", data);
+    return promise.then(data => QueryParamsResponse.decode(new BinaryReader(data)));
+  };
+  /* EthCall implements the `eth_call` rpc api */
+  ethCall = async (request: EthCallRequest): Promise<MsgEthereumTxResponse> => {
+    const data = EthCallRequest.encode(request).finish();
+    const promise = this.rpc.request("ethermint.evm.v1.Query", "EthCall", data);
+    return promise.then(data => MsgEthereumTxResponse.decode(new BinaryReader(data)));
+  };
+  /* EstimateGas implements the `eth_estimateGas` rpc api */
+  estimateGas = async (request: EthCallRequest): Promise<EstimateGasResponse> => {
+    const data = EthCallRequest.encode(request).finish();
+    const promise = this.rpc.request("ethermint.evm.v1.Query", "EstimateGas", data);
+    return promise.then(data => EstimateGasResponse.decode(new BinaryReader(data)));
+  };
+  /* TraceTx implements the `debug_traceTransaction` rpc api */
+  traceTx = async (request: QueryTraceTxRequest): Promise<QueryTraceTxResponse> => {
+    const data = QueryTraceTxRequest.encode(request).finish();
+    const promise = this.rpc.request("ethermint.evm.v1.Query", "TraceTx", data);
+    return promise.then(data => QueryTraceTxResponse.decode(new BinaryReader(data)));
+  };
+  /* TraceBlock implements the `debug_traceBlockByNumber` and `debug_traceBlockByHash` rpc api */
+  traceBlock = async (request: QueryTraceBlockRequest): Promise<QueryTraceBlockResponse> => {
+    const data = QueryTraceBlockRequest.encode(request).finish();
+    const promise = this.rpc.request("ethermint.evm.v1.Query", "TraceBlock", data);
+    return promise.then(data => QueryTraceBlockResponse.decode(new BinaryReader(data)));
+  };
+  /* 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 = async (request: QueryBaseFeeRequest = {}): Promise<QueryBaseFeeResponse> => {
+    const data = QueryBaseFeeRequest.encode(request).finish();
+    const promise = this.rpc.request("ethermint.evm.v1.Query", "BaseFee", data);
+    return promise.then(data => QueryBaseFeeResponse.decode(new BinaryReader(data)));
+  };
+}
+export const createRpcQueryExtension = (base: QueryClient) => {
+  const rpc = createProtobufRpcClient(base);
+  const queryService = new QueryClientImpl(rpc);
+  return {
+    account(request: QueryAccountRequest): Promise<QueryAccountResponse> {
+      return queryService.account(request);
+    },
+    cosmosAccount(request: QueryCosmosAccountRequest): Promise<QueryCosmosAccountResponse> {
+      return queryService.cosmosAccount(request);
+    },
+    validatorAccount(request: QueryValidatorAccountRequest): Promise<QueryValidatorAccountResponse> {
+      return queryService.validatorAccount(request);
+    },
+    balance(request: QueryBalanceRequest): Promise<QueryBalanceResponse> {
+      return queryService.balance(request);
+    },
+    storage(request: QueryStorageRequest): Promise<QueryStorageResponse> {
+      return queryService.storage(request);
+    },
+    code(request: QueryCodeRequest): Promise<QueryCodeResponse> {
+      return queryService.code(request);
+    },
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse> {
+      return queryService.params(request);
+    },
+    ethCall(request: EthCallRequest): Promise<MsgEthereumTxResponse> {
+      return queryService.ethCall(request);
+    },
+    estimateGas(request: EthCallRequest): Promise<EstimateGasResponse> {
+      return queryService.estimateGas(request);
+    },
+    traceTx(request: QueryTraceTxRequest): Promise<QueryTraceTxResponse> {
+      return queryService.traceTx(request);
+    },
+    traceBlock(request: QueryTraceBlockRequest): Promise<QueryTraceBlockResponse> {
+      return queryService.traceBlock(request);
+    },
+    baseFee(request?: QueryBaseFeeRequest): Promise<QueryBaseFeeResponse> {
+      return queryService.baseFee(request);
+    }
+  };
+};

package/src/ethermint/evm/v1/query.rpc.func.d.ts

@@ -0,0 +1,15 @@
+import { MsgEthereumTxResponse } from "./tx";
+import { RpcResolver } from "../../../helper-func-types";
+import { QueryAccountRequest, QueryAccountResponse, QueryCosmosAccountRequest, QueryCosmosAccountResponse, QueryValidatorAccountRequest, QueryValidatorAccountResponse, QueryBalanceRequest, QueryBalanceResponse, QueryStorageRequest, QueryStorageResponse, QueryCodeRequest, QueryCodeResponse, QueryParamsRequest, QueryParamsResponse, EthCallRequest, EstimateGasResponse, QueryTraceTxRequest, QueryTraceTxResponse, QueryTraceBlockRequest, QueryTraceBlockResponse, QueryBaseFeeRequest, QueryBaseFeeResponse } from "./query";
+export declare const createGetAccount: (clientResolver?: RpcResolver) => (request: QueryAccountRequest) => Promise<QueryAccountResponse>;
+export declare const createGetCosmosAccount: (clientResolver?: RpcResolver) => (request: QueryCosmosAccountRequest) => Promise<QueryCosmosAccountResponse>;
+export declare const createGetValidatorAccount: (clientResolver?: RpcResolver) => (request: QueryValidatorAccountRequest) => Promise<QueryValidatorAccountResponse>;
+export declare const createGetBalance: (clientResolver?: RpcResolver) => (request: QueryBalanceRequest) => Promise<QueryBalanceResponse>;
+export declare const createGetStorage: (clientResolver?: RpcResolver) => (request: QueryStorageRequest) => Promise<QueryStorageResponse>;
+export declare const createGetCode: (clientResolver?: RpcResolver) => (request: QueryCodeRequest) => Promise<QueryCodeResponse>;
+export declare const createGetParams: (clientResolver?: RpcResolver) => (request: QueryParamsRequest) => Promise<QueryParamsResponse>;
+export declare const createGetEthCall: (clientResolver?: RpcResolver) => (request: EthCallRequest) => Promise<MsgEthereumTxResponse>;
+export declare const createGetEstimateGas: (clientResolver?: RpcResolver) => (request: EthCallRequest) => Promise<EstimateGasResponse>;
+export declare const createGetTraceTx: (clientResolver?: RpcResolver) => (request: QueryTraceTxRequest) => Promise<QueryTraceTxResponse>;
+export declare const createGetTraceBlock: (clientResolver?: RpcResolver) => (request: QueryTraceBlockRequest) => Promise<QueryTraceBlockResponse>;
+export declare const createGetBaseFee: (clientResolver?: RpcResolver) => (request: QueryBaseFeeRequest) => Promise<QueryBaseFeeResponse>;

package/src/ethermint/evm/v1/query.rpc.func.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGetBaseFee = exports.createGetTraceBlock = exports.createGetTraceTx = exports.createGetEstimateGas = exports.createGetEthCall = exports.createGetParams = exports.createGetCode = exports.createGetStorage = exports.createGetBalance = exports.createGetValidatorAccount = exports.createGetCosmosAccount = exports.createGetAccount = void 0;
+const tx_1 = require("./tx");
+const helper_func_types_1 = require("../../../helper-func-types");
+const query_1 = require("./query");
+const createGetAccount = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryAccountRequest.encode,
+    decode: query_1.QueryAccountResponse.decode,
+    service: "ethermint.evm.v1.Query",
+    method: "Account",
+    clientResolver
+});
+exports.createGetAccount = createGetAccount;
+const createGetCosmosAccount = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryCosmosAccountRequest.encode,
+    decode: query_1.QueryCosmosAccountResponse.decode,
+    service: "ethermint.evm.v1.Query",
+    method: "CosmosAccount",
+    clientResolver
+});
+exports.createGetCosmosAccount = createGetCosmosAccount;
+const createGetValidatorAccount = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryValidatorAccountRequest.encode,
+    decode: query_1.QueryValidatorAccountResponse.decode,
+    service: "ethermint.evm.v1.Query",
+    method: "ValidatorAccount",
+    clientResolver
+});
+exports.createGetValidatorAccount = createGetValidatorAccount;
+const createGetBalance = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryBalanceRequest.encode,
+    decode: query_1.QueryBalanceResponse.decode,
+    service: "ethermint.evm.v1.Query",
+    method: "Balance",
+    clientResolver
+});
+exports.createGetBalance = createGetBalance;
+const createGetStorage = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryStorageRequest.encode,
+    decode: query_1.QueryStorageResponse.decode,
+    service: "ethermint.evm.v1.Query",
+    method: "Storage",
+    clientResolver
+});
+exports.createGetStorage = createGetStorage;
+const createGetCode = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryCodeRequest.encode,
+    decode: query_1.QueryCodeResponse.decode,
+    service: "ethermint.evm.v1.Query",
+    method: "Code",
+    clientResolver
+});
+exports.createGetCode = createGetCode;
+const createGetParams = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryParamsRequest.encode,
+    decode: query_1.QueryParamsResponse.decode,
+    service: "ethermint.evm.v1.Query",
+    method: "Params",
+    clientResolver
+});
+exports.createGetParams = createGetParams;
+const createGetEthCall = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.EthCallRequest.encode,
+    decode: tx_1.MsgEthereumTxResponse.decode,
+    service: "ethermint.evm.v1.Query",
+    method: "EthCall",
+    clientResolver
+});
+exports.createGetEthCall = createGetEthCall;
+const createGetEstimateGas = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.EthCallRequest.encode,
+    decode: query_1.EstimateGasResponse.decode,
+    service: "ethermint.evm.v1.Query",
+    method: "EstimateGas",
+    clientResolver
+});
+exports.createGetEstimateGas = createGetEstimateGas;
+const createGetTraceTx = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryTraceTxRequest.encode,
+    decode: query_1.QueryTraceTxResponse.decode,
+    service: "ethermint.evm.v1.Query",
+    method: "TraceTx",
+    clientResolver
+});
+exports.createGetTraceTx = createGetTraceTx;
+const createGetTraceBlock = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryTraceBlockRequest.encode,
+    decode: query_1.QueryTraceBlockResponse.decode,
+    service: "ethermint.evm.v1.Query",
+    method: "TraceBlock",
+    clientResolver
+});
+exports.createGetTraceBlock = createGetTraceBlock;
+const createGetBaseFee = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryBaseFeeRequest.encode,
+    decode: query_1.QueryBaseFeeResponse.decode,
+    service: "ethermint.evm.v1.Query",
+    method: "BaseFee",
+    clientResolver
+});
+exports.createGetBaseFee = createGetBaseFee;

package/src/ethermint/evm/v1/query.rpc.func.ts

@@ -0,0 +1,87 @@
+import { MsgEthereumTxResponse } from "./tx";
+import { RpcResolver, buildQuery } from "../../../helper-func-types";
+import { QueryAccountRequest, QueryAccountResponse, QueryCosmosAccountRequest, QueryCosmosAccountResponse, QueryValidatorAccountRequest, QueryValidatorAccountResponse, QueryBalanceRequest, QueryBalanceResponse, QueryStorageRequest, QueryStorageResponse, QueryCodeRequest, QueryCodeResponse, QueryParamsRequest, QueryParamsResponse, EthCallRequest, EstimateGasResponse, QueryTraceTxRequest, QueryTraceTxResponse, QueryTraceBlockRequest, QueryTraceBlockResponse, QueryBaseFeeRequest, QueryBaseFeeResponse } from "./query";
+export const createGetAccount = (clientResolver?: RpcResolver) => buildQuery<QueryAccountRequest, QueryAccountResponse>({
+  encode: QueryAccountRequest.encode,
+  decode: QueryAccountResponse.decode,
+  service: "ethermint.evm.v1.Query",
+  method: "Account",
+  clientResolver
+});
+export const createGetCosmosAccount = (clientResolver?: RpcResolver) => buildQuery<QueryCosmosAccountRequest, QueryCosmosAccountResponse>({
+  encode: QueryCosmosAccountRequest.encode,
+  decode: QueryCosmosAccountResponse.decode,
+  service: "ethermint.evm.v1.Query",
+  method: "CosmosAccount",
+  clientResolver
+});
+export const createGetValidatorAccount = (clientResolver?: RpcResolver) => buildQuery<QueryValidatorAccountRequest, QueryValidatorAccountResponse>({
+  encode: QueryValidatorAccountRequest.encode,
+  decode: QueryValidatorAccountResponse.decode,
+  service: "ethermint.evm.v1.Query",
+  method: "ValidatorAccount",
+  clientResolver
+});
+export const createGetBalance = (clientResolver?: RpcResolver) => buildQuery<QueryBalanceRequest, QueryBalanceResponse>({
+  encode: QueryBalanceRequest.encode,
+  decode: QueryBalanceResponse.decode,
+  service: "ethermint.evm.v1.Query",
+  method: "Balance",
+  clientResolver
+});
+export const createGetStorage = (clientResolver?: RpcResolver) => buildQuery<QueryStorageRequest, QueryStorageResponse>({
+  encode: QueryStorageRequest.encode,
+  decode: QueryStorageResponse.decode,
+  service: "ethermint.evm.v1.Query",
+  method: "Storage",
+  clientResolver
+});
+export const createGetCode = (clientResolver?: RpcResolver) => buildQuery<QueryCodeRequest, QueryCodeResponse>({
+  encode: QueryCodeRequest.encode,
+  decode: QueryCodeResponse.decode,
+  service: "ethermint.evm.v1.Query",
+  method: "Code",
+  clientResolver
+});
+export const createGetParams = (clientResolver?: RpcResolver) => buildQuery<QueryParamsRequest, QueryParamsResponse>({
+  encode: QueryParamsRequest.encode,
+  decode: QueryParamsResponse.decode,
+  service: "ethermint.evm.v1.Query",
+  method: "Params",
+  clientResolver
+});
+export const createGetEthCall = (clientResolver?: RpcResolver) => buildQuery<EthCallRequest, MsgEthereumTxResponse>({
+  encode: EthCallRequest.encode,
+  decode: MsgEthereumTxResponse.decode,
+  service: "ethermint.evm.v1.Query",
+  method: "EthCall",
+  clientResolver
+});
+export const createGetEstimateGas = (clientResolver?: RpcResolver) => buildQuery<EthCallRequest, EstimateGasResponse>({
+  encode: EthCallRequest.encode,
+  decode: EstimateGasResponse.decode,
+  service: "ethermint.evm.v1.Query",
+  method: "EstimateGas",
+  clientResolver
+});
+export const createGetTraceTx = (clientResolver?: RpcResolver) => buildQuery<QueryTraceTxRequest, QueryTraceTxResponse>({
+  encode: QueryTraceTxRequest.encode,
+  decode: QueryTraceTxResponse.decode,
+  service: "ethermint.evm.v1.Query",
+  method: "TraceTx",
+  clientResolver
+});
+export const createGetTraceBlock = (clientResolver?: RpcResolver) => buildQuery<QueryTraceBlockRequest, QueryTraceBlockResponse>({
+  encode: QueryTraceBlockRequest.encode,
+  decode: QueryTraceBlockResponse.decode,
+  service: "ethermint.evm.v1.Query",
+  method: "TraceBlock",
+  clientResolver
+});
+export const createGetBaseFee = (clientResolver?: RpcResolver) => buildQuery<QueryBaseFeeRequest, QueryBaseFeeResponse>({
+  encode: QueryBaseFeeRequest.encode,
+  decode: QueryBaseFeeResponse.decode,
+  service: "ethermint.evm.v1.Query",
+  method: "BaseFee",
+  clientResolver
+});