@xpla/xpla-react 1.7.0-beta.0 → 1.7.0-beta.10

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

@@ -0,0 +1,27 @@
+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 useGetAccount: <TData = QueryAccountResponse>({ request, options, clientResolver, customizedQueryKey, }: import("../../../react-query").UseQueryParams<QueryAccountRequest, QueryAccountResponse, TData>) => import("@tanstack/react-query").UseQueryResult<TData, Error>;
+export declare const createGetCosmosAccount: (clientResolver?: RpcResolver) => (request: QueryCosmosAccountRequest) => Promise<QueryCosmosAccountResponse>;
+export declare const useGetCosmosAccount: <TData = QueryCosmosAccountResponse>({ request, options, clientResolver, customizedQueryKey, }: import("../../../react-query").UseQueryParams<QueryCosmosAccountRequest, QueryCosmosAccountResponse, TData>) => import("@tanstack/react-query").UseQueryResult<TData, Error>;
+export declare const createGetValidatorAccount: (clientResolver?: RpcResolver) => (request: QueryValidatorAccountRequest) => Promise<QueryValidatorAccountResponse>;
+export declare const useGetValidatorAccount: <TData = QueryValidatorAccountResponse>({ request, options, clientResolver, customizedQueryKey, }: import("../../../react-query").UseQueryParams<QueryValidatorAccountRequest, QueryValidatorAccountResponse, TData>) => import("@tanstack/react-query").UseQueryResult<TData, Error>;
+export declare const createGetBalance: (clientResolver?: RpcResolver) => (request: QueryBalanceRequest) => Promise<QueryBalanceResponse>;
+export declare const useGetBalance: <TData = QueryBalanceResponse>({ request, options, clientResolver, customizedQueryKey, }: import("../../../react-query").UseQueryParams<QueryBalanceRequest, QueryBalanceResponse, TData>) => import("@tanstack/react-query").UseQueryResult<TData, Error>;
+export declare const createGetStorage: (clientResolver?: RpcResolver) => (request: QueryStorageRequest) => Promise<QueryStorageResponse>;
+export declare const useGetStorage: <TData = QueryStorageResponse>({ request, options, clientResolver, customizedQueryKey, }: import("../../../react-query").UseQueryParams<QueryStorageRequest, QueryStorageResponse, TData>) => import("@tanstack/react-query").UseQueryResult<TData, Error>;
+export declare const createGetCode: (clientResolver?: RpcResolver) => (request: QueryCodeRequest) => Promise<QueryCodeResponse>;
+export declare const useGetCode: <TData = QueryCodeResponse>({ request, options, clientResolver, customizedQueryKey, }: import("../../../react-query").UseQueryParams<QueryCodeRequest, QueryCodeResponse, TData>) => import("@tanstack/react-query").UseQueryResult<TData, Error>;
+export declare const createGetParams: (clientResolver?: RpcResolver) => (request: QueryParamsRequest) => Promise<QueryParamsResponse>;
+export declare const useGetParams: <TData = QueryParamsResponse>({ request, options, clientResolver, customizedQueryKey, }: import("../../../react-query").UseQueryParams<QueryParamsRequest, QueryParamsResponse, TData>) => import("@tanstack/react-query").UseQueryResult<TData, Error>;
+export declare const createGetEthCall: (clientResolver?: RpcResolver) => (request: EthCallRequest) => Promise<MsgEthereumTxResponse>;
+export declare const useGetEthCall: <TData = MsgEthereumTxResponse>({ request, options, clientResolver, customizedQueryKey, }: import("../../../react-query").UseQueryParams<EthCallRequest, MsgEthereumTxResponse, TData>) => import("@tanstack/react-query").UseQueryResult<TData, Error>;
+export declare const createGetEstimateGas: (clientResolver?: RpcResolver) => (request: EthCallRequest) => Promise<EstimateGasResponse>;
+export declare const useGetEstimateGas: <TData = EstimateGasResponse>({ request, options, clientResolver, customizedQueryKey, }: import("../../../react-query").UseQueryParams<EthCallRequest, EstimateGasResponse, TData>) => import("@tanstack/react-query").UseQueryResult<TData, Error>;
+export declare const createGetTraceTx: (clientResolver?: RpcResolver) => (request: QueryTraceTxRequest) => Promise<QueryTraceTxResponse>;
+export declare const useGetTraceTx: <TData = QueryTraceTxResponse>({ request, options, clientResolver, customizedQueryKey, }: import("../../../react-query").UseQueryParams<QueryTraceTxRequest, QueryTraceTxResponse, TData>) => import("@tanstack/react-query").UseQueryResult<TData, Error>;
+export declare const createGetTraceBlock: (clientResolver?: RpcResolver) => (request: QueryTraceBlockRequest) => Promise<QueryTraceBlockResponse>;
+export declare const useGetTraceBlock: <TData = QueryTraceBlockResponse>({ request, options, clientResolver, customizedQueryKey, }: import("../../../react-query").UseQueryParams<QueryTraceBlockRequest, QueryTraceBlockResponse, TData>) => import("@tanstack/react-query").UseQueryResult<TData, Error>;
+export declare const createGetBaseFee: (clientResolver?: RpcResolver) => (request: QueryBaseFeeRequest) => Promise<QueryBaseFeeResponse>;
+export declare const useGetBaseFee: <TData = QueryBaseFeeResponse>({ request, options, clientResolver, customizedQueryKey, }: import("../../../react-query").UseQueryParams<QueryBaseFeeRequest, QueryBaseFeeResponse, TData>) => import("@tanstack/react-query").UseQueryResult<TData, Error>;

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

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGetBaseFee = exports.createGetBaseFee = exports.useGetTraceBlock = exports.createGetTraceBlock = exports.useGetTraceTx = exports.createGetTraceTx = exports.useGetEstimateGas = exports.createGetEstimateGas = exports.useGetEthCall = exports.createGetEthCall = exports.useGetParams = exports.createGetParams = exports.useGetCode = exports.createGetCode = exports.useGetStorage = exports.createGetStorage = exports.useGetBalance = exports.createGetBalance = exports.useGetValidatorAccount = exports.createGetValidatorAccount = exports.useGetCosmosAccount = exports.createGetCosmosAccount = exports.useGetAccount = exports.createGetAccount = void 0;
+const tx_1 = require("./tx");
+const helper_func_types_1 = require("../../../helper-func-types");
+const react_query_1 = require("../../../react-query");
+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;
+exports.useGetAccount = (0, react_query_1.buildUseQuery)({
+    builderQueryFn: exports.createGetAccount,
+    queryKeyPrefix: "AccountQuery"
+});
+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;
+exports.useGetCosmosAccount = (0, react_query_1.buildUseQuery)({
+    builderQueryFn: exports.createGetCosmosAccount,
+    queryKeyPrefix: "CosmosAccountQuery"
+});
+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;
+exports.useGetValidatorAccount = (0, react_query_1.buildUseQuery)({
+    builderQueryFn: exports.createGetValidatorAccount,
+    queryKeyPrefix: "ValidatorAccountQuery"
+});
+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;
+exports.useGetBalance = (0, react_query_1.buildUseQuery)({
+    builderQueryFn: exports.createGetBalance,
+    queryKeyPrefix: "BalanceQuery"
+});
+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;
+exports.useGetStorage = (0, react_query_1.buildUseQuery)({
+    builderQueryFn: exports.createGetStorage,
+    queryKeyPrefix: "StorageQuery"
+});
+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;
+exports.useGetCode = (0, react_query_1.buildUseQuery)({
+    builderQueryFn: exports.createGetCode,
+    queryKeyPrefix: "CodeQuery"
+});
+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;
+exports.useGetParams = (0, react_query_1.buildUseQuery)({
+    builderQueryFn: exports.createGetParams,
+    queryKeyPrefix: "ParamsQuery"
+});
+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;
+exports.useGetEthCall = (0, react_query_1.buildUseQuery)({
+    builderQueryFn: exports.createGetEthCall,
+    queryKeyPrefix: "EthCallQuery"
+});
+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;
+exports.useGetEstimateGas = (0, react_query_1.buildUseQuery)({
+    builderQueryFn: exports.createGetEstimateGas,
+    queryKeyPrefix: "EstimateGasQuery"
+});
+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;
+exports.useGetTraceTx = (0, react_query_1.buildUseQuery)({
+    builderQueryFn: exports.createGetTraceTx,
+    queryKeyPrefix: "TraceTxQuery"
+});
+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;
+exports.useGetTraceBlock = (0, react_query_1.buildUseQuery)({
+    builderQueryFn: exports.createGetTraceBlock,
+    queryKeyPrefix: "TraceBlockQuery"
+});
+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;
+exports.useGetBaseFee = (0, react_query_1.buildUseQuery)({
+    builderQueryFn: exports.createGetBaseFee,
+    queryKeyPrefix: "BaseFeeQuery"
+});

package/ethermint/evm/v1/tx.d.ts

@@ -0,0 +1,452 @@
+import { Any, AnyAmino } from "../../../google/protobuf/any";
+import { Params, ParamsAmino, AccessTuple, AccessTupleAmino, Log, LogAmino } from "./evm";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/** MsgEthereumTx encapsulates an Ethereum transaction as an SDK message. */
+export interface MsgEthereumTx {
+    /** data is inner transaction data of the Ethereum transaction */
+    data?: Any;
+    /** size is the encoded storage size of the transaction (DEPRECATED) */
+    size: number;
+    /** hash of the transaction in hex format */
+    hash: string;
+    /**
+     * from is the ethereum signer address in hex format. This address value is checked
+     * against the address derived from the signature (V, R, S) using the
+     * secp256k1 elliptic curve
+     */
+    from: string;
+}
+export interface MsgEthereumTxProtoMsg {
+    typeUrl: "/ethermint.evm.v1.MsgEthereumTx";
+    value: Uint8Array;
+}
+/** MsgEthereumTx encapsulates an Ethereum transaction as an SDK message. */
+export interface MsgEthereumTxAmino {
+    /** data is inner transaction data of the Ethereum transaction */
+    data?: AnyAmino;
+    /** size is the encoded storage size of the transaction (DEPRECATED) */
+    size: number;
+    /** hash of the transaction in hex format */
+    hash: string;
+    /**
+     * from is the ethereum signer address in hex format. This address value is checked
+     * against the address derived from the signature (V, R, S) using the
+     * secp256k1 elliptic curve
+     */
+    from: string;
+}
+export interface MsgEthereumTxAminoMsg {
+    type: "ethermint/MsgEthereumTx";
+    value: MsgEthereumTxAmino;
+}
+/**
+ * LegacyTx is the transaction data of regular Ethereum transactions.
+ * NOTE: All non-protected transactions (i.e non EIP155 signed) will fail if the
+ * AllowUnprotectedTxs parameter is disabled.
+ */
+export interface LegacyTx {
+    /** nonce corresponds to the account nonce (transaction sequence). */
+    nonce: bigint;
+    /** gas_price defines the value for each gas unit */
+    gasPrice: string;
+    /** gas defines the gas limit defined for the transaction. */
+    gas: bigint;
+    /** to is the hex formatted address of the recipient */
+    to: string;
+    /** value defines the unsigned integer value of the transaction amount. */
+    value: string;
+    /** data is the data payload bytes of the transaction. */
+    data: Uint8Array;
+    /** v defines the signature value */
+    v: Uint8Array;
+    /** r defines the signature value */
+    r: Uint8Array;
+    /** s define the signature value */
+    s: Uint8Array;
+}
+export interface LegacyTxProtoMsg {
+    typeUrl: "/ethermint.evm.v1.LegacyTx";
+    value: Uint8Array;
+}
+/**
+ * LegacyTx is the transaction data of regular Ethereum transactions.
+ * NOTE: All non-protected transactions (i.e non EIP155 signed) will fail if the
+ * AllowUnprotectedTxs parameter is disabled.
+ */
+export interface LegacyTxAmino {
+    /** nonce corresponds to the account nonce (transaction sequence). */
+    nonce: string;
+    /** gas_price defines the value for each gas unit */
+    gas_price: string;
+    /** gas defines the gas limit defined for the transaction. */
+    gas: string;
+    /** to is the hex formatted address of the recipient */
+    to: string;
+    /** value defines the unsigned integer value of the transaction amount. */
+    value: string;
+    /** data is the data payload bytes of the transaction. */
+    data: string;
+    /** v defines the signature value */
+    v: string;
+    /** r defines the signature value */
+    r: string;
+    /** s define the signature value */
+    s: string;
+}
+export interface LegacyTxAminoMsg {
+    type: "/ethermint.evm.v1.LegacyTx";
+    value: LegacyTxAmino;
+}
+/** AccessListTx is the data of EIP-2930 access list transactions. */
+export interface AccessListTx {
+    /** chain_id of the destination EVM chain */
+    chainId: string;
+    /** nonce corresponds to the account nonce (transaction sequence). */
+    nonce: bigint;
+    /** gas_price defines the value for each gas unit */
+    gasPrice: string;
+    /** gas defines the gas limit defined for the transaction. */
+    gas: bigint;
+    /** to is the recipient address in hex format */
+    to: string;
+    /** value defines the unsigned integer value of the transaction amount. */
+    value: string;
+    /** data is the data payload bytes of the transaction. */
+    data: Uint8Array;
+    /** accesses is an array of access tuples */
+    accesses: AccessTuple[];
+    /** v defines the signature value */
+    v: Uint8Array;
+    /** r defines the signature value */
+    r: Uint8Array;
+    /** s define the signature value */
+    s: Uint8Array;
+}
+export interface AccessListTxProtoMsg {
+    typeUrl: "/ethermint.evm.v1.AccessListTx";
+    value: Uint8Array;
+}
+/** AccessListTx is the data of EIP-2930 access list transactions. */
+export interface AccessListTxAmino {
+    /** chain_id of the destination EVM chain */
+    chain_id: string;
+    /** nonce corresponds to the account nonce (transaction sequence). */
+    nonce: string;
+    /** gas_price defines the value for each gas unit */
+    gas_price: string;
+    /** gas defines the gas limit defined for the transaction. */
+    gas: string;
+    /** to is the recipient address in hex format */
+    to: string;
+    /** value defines the unsigned integer value of the transaction amount. */
+    value: string;
+    /** data is the data payload bytes of the transaction. */
+    data: string;
+    /** accesses is an array of access tuples */
+    accesses: AccessTupleAmino[];
+    /** v defines the signature value */
+    v: string;
+    /** r defines the signature value */
+    r: string;
+    /** s define the signature value */
+    s: string;
+}
+export interface AccessListTxAminoMsg {
+    type: "/ethermint.evm.v1.AccessListTx";
+    value: AccessListTxAmino;
+}
+/** DynamicFeeTx is the data of EIP-1559 dynamic fee transactions. */
+export interface DynamicFeeTx {
+    /** chain_id of the destination EVM chain */
+    chainId: string;
+    /** nonce corresponds to the account nonce (transaction sequence). */
+    nonce: bigint;
+    /** gas_tip_cap defines the max value for the gas tip */
+    gasTipCap: string;
+    /** gas_fee_cap defines the max value for the gas fee */
+    gasFeeCap: string;
+    /** gas defines the gas limit defined for the transaction. */
+    gas: bigint;
+    /** to is the hex formatted address of the recipient */
+    to: string;
+    /** value defines the transaction amount. */
+    value: string;
+    /** data is the data payload bytes of the transaction. */
+    data: Uint8Array;
+    /** accesses is an array of access tuples */
+    accesses: AccessTuple[];
+    /** v defines the signature value */
+    v: Uint8Array;
+    /** r defines the signature value */
+    r: Uint8Array;
+    /** s define the signature value */
+    s: Uint8Array;
+}
+export interface DynamicFeeTxProtoMsg {
+    typeUrl: "/ethermint.evm.v1.DynamicFeeTx";
+    value: Uint8Array;
+}
+/** DynamicFeeTx is the data of EIP-1559 dynamic fee transactions. */
+export interface DynamicFeeTxAmino {
+    /** chain_id of the destination EVM chain */
+    chain_id: string;
+    /** nonce corresponds to the account nonce (transaction sequence). */
+    nonce: string;
+    /** gas_tip_cap defines the max value for the gas tip */
+    gas_tip_cap: string;
+    /** gas_fee_cap defines the max value for the gas fee */
+    gas_fee_cap: string;
+    /** gas defines the gas limit defined for the transaction. */
+    gas: string;
+    /** to is the hex formatted address of the recipient */
+    to: string;
+    /** value defines the transaction amount. */
+    value: string;
+    /** data is the data payload bytes of the transaction. */
+    data: string;
+    /** accesses is an array of access tuples */
+    accesses: AccessTupleAmino[];
+    /** v defines the signature value */
+    v: string;
+    /** r defines the signature value */
+    r: string;
+    /** s define the signature value */
+    s: string;
+}
+export interface DynamicFeeTxAminoMsg {
+    type: "/ethermint.evm.v1.DynamicFeeTx";
+    value: DynamicFeeTxAmino;
+}
+/** ExtensionOptionsEthereumTx is an extension option for ethereum transactions */
+export interface ExtensionOptionsEthereumTx {
+}
+export interface ExtensionOptionsEthereumTxProtoMsg {
+    typeUrl: "/ethermint.evm.v1.ExtensionOptionsEthereumTx";
+    value: Uint8Array;
+}
+/** ExtensionOptionsEthereumTx is an extension option for ethereum transactions */
+export interface ExtensionOptionsEthereumTxAmino {
+}
+export interface ExtensionOptionsEthereumTxAminoMsg {
+    type: "/ethermint.evm.v1.ExtensionOptionsEthereumTx";
+    value: ExtensionOptionsEthereumTxAmino;
+}
+/** MsgEthereumTxResponse defines the Msg/EthereumTx response type. */
+export interface MsgEthereumTxResponse {
+    /**
+     * hash of the ethereum transaction in hex format. This hash differs from the
+     * Tendermint sha256 hash of the transaction bytes. See
+     * https://github.com/tendermint/tendermint/issues/6539 for reference
+     */
+    hash: string;
+    /**
+     * logs contains the transaction hash and the proto-compatible ethereum
+     * logs.
+     */
+    logs: Log[];
+    /**
+     * 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;
+    /** gas_used specifies how much gas was consumed by the transaction */
+    gasUsed: bigint;
+}
+export interface MsgEthereumTxResponseProtoMsg {
+    typeUrl: "/ethermint.evm.v1.MsgEthereumTxResponse";
+    value: Uint8Array;
+}
+/** MsgEthereumTxResponse defines the Msg/EthereumTx response type. */
+export interface MsgEthereumTxResponseAmino {
+    /**
+     * hash of the ethereum transaction in hex format. This hash differs from the
+     * Tendermint sha256 hash of the transaction bytes. See
+     * https://github.com/tendermint/tendermint/issues/6539 for reference
+     */
+    hash: string;
+    /**
+     * logs contains the transaction hash and the proto-compatible ethereum
+     * logs.
+     */
+    logs: LogAmino[];
+    /**
+     * 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;
+    /** gas_used specifies how much gas was consumed by the transaction */
+    gas_used: string;
+}
+export interface MsgEthereumTxResponseAminoMsg {
+    type: "/ethermint.evm.v1.MsgEthereumTxResponse";
+    value: MsgEthereumTxResponseAmino;
+}
+/** MsgUpdateParams defines a Msg for updating the x/evm module parameters. */
+export interface MsgUpdateParams {
+    /** authority is the address of the governance account. */
+    authority: string;
+    /**
+     * params defines the x/evm parameters to update.
+     * NOTE: All parameters must be supplied.
+     */
+    params: Params;
+}
+export interface MsgUpdateParamsProtoMsg {
+    typeUrl: "/ethermint.evm.v1.MsgUpdateParams";
+    value: Uint8Array;
+}
+/** MsgUpdateParams defines a Msg for updating the x/evm module parameters. */
+export interface MsgUpdateParamsAmino {
+    /** authority is the address of the governance account. */
+    authority: string;
+    /**
+     * params defines the x/evm parameters to update.
+     * NOTE: All parameters must be supplied.
+     */
+    params: ParamsAmino;
+}
+export interface MsgUpdateParamsAminoMsg {
+    type: "ethermint/x/evm/MsgUpdateParams";
+    value: MsgUpdateParamsAmino;
+}
+/**
+ * MsgUpdateParamsResponse defines the response structure for executing a
+ * MsgUpdateParams message.
+ */
+export interface MsgUpdateParamsResponse {
+}
+export interface MsgUpdateParamsResponseProtoMsg {
+    typeUrl: "/ethermint.evm.v1.MsgUpdateParamsResponse";
+    value: Uint8Array;
+}
+/**
+ * MsgUpdateParamsResponse defines the response structure for executing a
+ * MsgUpdateParams message.
+ */
+export interface MsgUpdateParamsResponseAmino {
+}
+export interface MsgUpdateParamsResponseAminoMsg {
+    type: "/ethermint.evm.v1.MsgUpdateParamsResponse";
+    value: MsgUpdateParamsResponseAmino;
+}
+export declare const MsgEthereumTx: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is MsgEthereumTx;
+    isAmino(o: any): o is MsgEthereumTxAmino;
+    encode(message: MsgEthereumTx, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgEthereumTx;
+    fromPartial(object: DeepPartial<MsgEthereumTx>): MsgEthereumTx;
+    fromAmino(object: MsgEthereumTxAmino): MsgEthereumTx;
+    toAmino(message: MsgEthereumTx): MsgEthereumTxAmino;
+    fromAminoMsg(object: MsgEthereumTxAminoMsg): MsgEthereumTx;
+    toAminoMsg(message: MsgEthereumTx): MsgEthereumTxAminoMsg;
+    fromProtoMsg(message: MsgEthereumTxProtoMsg): MsgEthereumTx;
+    toProto(message: MsgEthereumTx): Uint8Array;
+    toProtoMsg(message: MsgEthereumTx): MsgEthereumTxProtoMsg;
+};
+export declare const LegacyTx: {
+    typeUrl: string;
+    is(o: any): o is LegacyTx;
+    isAmino(o: any): o is LegacyTxAmino;
+    encode(message: LegacyTx, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): LegacyTx;
+    fromPartial(object: DeepPartial<LegacyTx>): LegacyTx;
+    fromAmino(object: LegacyTxAmino): LegacyTx;
+    toAmino(message: LegacyTx): LegacyTxAmino;
+    fromAminoMsg(object: LegacyTxAminoMsg): LegacyTx;
+    fromProtoMsg(message: LegacyTxProtoMsg): LegacyTx;
+    toProto(message: LegacyTx): Uint8Array;
+    toProtoMsg(message: LegacyTx): LegacyTxProtoMsg;
+};
+export declare const AccessListTx: {
+    typeUrl: string;
+    is(o: any): o is AccessListTx;
+    isAmino(o: any): o is AccessListTxAmino;
+    encode(message: AccessListTx, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): AccessListTx;
+    fromPartial(object: DeepPartial<AccessListTx>): AccessListTx;
+    fromAmino(object: AccessListTxAmino): AccessListTx;
+    toAmino(message: AccessListTx): AccessListTxAmino;
+    fromAminoMsg(object: AccessListTxAminoMsg): AccessListTx;
+    fromProtoMsg(message: AccessListTxProtoMsg): AccessListTx;
+    toProto(message: AccessListTx): Uint8Array;
+    toProtoMsg(message: AccessListTx): AccessListTxProtoMsg;
+};
+export declare const DynamicFeeTx: {
+    typeUrl: string;
+    is(o: any): o is DynamicFeeTx;
+    isAmino(o: any): o is DynamicFeeTxAmino;
+    encode(message: DynamicFeeTx, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): DynamicFeeTx;
+    fromPartial(object: DeepPartial<DynamicFeeTx>): DynamicFeeTx;
+    fromAmino(object: DynamicFeeTxAmino): DynamicFeeTx;
+    toAmino(message: DynamicFeeTx): DynamicFeeTxAmino;
+    fromAminoMsg(object: DynamicFeeTxAminoMsg): DynamicFeeTx;
+    fromProtoMsg(message: DynamicFeeTxProtoMsg): DynamicFeeTx;
+    toProto(message: DynamicFeeTx): Uint8Array;
+    toProtoMsg(message: DynamicFeeTx): DynamicFeeTxProtoMsg;
+};
+export declare const ExtensionOptionsEthereumTx: {
+    typeUrl: string;
+    is(o: any): o is ExtensionOptionsEthereumTx;
+    isAmino(o: any): o is ExtensionOptionsEthereumTxAmino;
+    encode(_: ExtensionOptionsEthereumTx, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ExtensionOptionsEthereumTx;
+    fromPartial(_: DeepPartial<ExtensionOptionsEthereumTx>): ExtensionOptionsEthereumTx;
+    fromAmino(_: ExtensionOptionsEthereumTxAmino): ExtensionOptionsEthereumTx;
+    toAmino(_: ExtensionOptionsEthereumTx): ExtensionOptionsEthereumTxAmino;
+    fromAminoMsg(object: ExtensionOptionsEthereumTxAminoMsg): ExtensionOptionsEthereumTx;
+    fromProtoMsg(message: ExtensionOptionsEthereumTxProtoMsg): ExtensionOptionsEthereumTx;
+    toProto(message: ExtensionOptionsEthereumTx): Uint8Array;
+    toProtoMsg(message: ExtensionOptionsEthereumTx): ExtensionOptionsEthereumTxProtoMsg;
+};
+export declare const MsgEthereumTxResponse: {
+    typeUrl: string;
+    is(o: any): o is MsgEthereumTxResponse;
+    isAmino(o: any): o is MsgEthereumTxResponseAmino;
+    encode(message: MsgEthereumTxResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgEthereumTxResponse;
+    fromPartial(object: DeepPartial<MsgEthereumTxResponse>): MsgEthereumTxResponse;
+    fromAmino(object: MsgEthereumTxResponseAmino): MsgEthereumTxResponse;
+    toAmino(message: MsgEthereumTxResponse): MsgEthereumTxResponseAmino;
+    fromAminoMsg(object: MsgEthereumTxResponseAminoMsg): MsgEthereumTxResponse;
+    fromProtoMsg(message: MsgEthereumTxResponseProtoMsg): MsgEthereumTxResponse;
+    toProto(message: MsgEthereumTxResponse): Uint8Array;
+    toProtoMsg(message: MsgEthereumTxResponse): MsgEthereumTxResponseProtoMsg;
+};
+export declare const MsgUpdateParams: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is MsgUpdateParams;
+    isAmino(o: any): o is MsgUpdateParamsAmino;
+    encode(message: MsgUpdateParams, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgUpdateParams;
+    fromPartial(object: DeepPartial<MsgUpdateParams>): MsgUpdateParams;
+    fromAmino(object: MsgUpdateParamsAmino): MsgUpdateParams;
+    toAmino(message: MsgUpdateParams): MsgUpdateParamsAmino;
+    fromAminoMsg(object: MsgUpdateParamsAminoMsg): MsgUpdateParams;
+    toAminoMsg(message: MsgUpdateParams): MsgUpdateParamsAminoMsg;
+    fromProtoMsg(message: MsgUpdateParamsProtoMsg): MsgUpdateParams;
+    toProto(message: MsgUpdateParams): Uint8Array;
+    toProtoMsg(message: MsgUpdateParams): MsgUpdateParamsProtoMsg;
+};
+export declare const MsgUpdateParamsResponse: {
+    typeUrl: string;
+    is(o: any): o is MsgUpdateParamsResponse;
+    isAmino(o: any): o is MsgUpdateParamsResponseAmino;
+    encode(_: MsgUpdateParamsResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgUpdateParamsResponse;
+    fromPartial(_: DeepPartial<MsgUpdateParamsResponse>): MsgUpdateParamsResponse;
+    fromAmino(_: MsgUpdateParamsResponseAmino): MsgUpdateParamsResponse;
+    toAmino(_: MsgUpdateParamsResponse): MsgUpdateParamsResponseAmino;
+    fromAminoMsg(object: MsgUpdateParamsResponseAminoMsg): MsgUpdateParamsResponse;
+    fromProtoMsg(message: MsgUpdateParamsResponseProtoMsg): MsgUpdateParamsResponse;
+    toProto(message: MsgUpdateParamsResponse): Uint8Array;
+    toProtoMsg(message: MsgUpdateParamsResponse): MsgUpdateParamsResponseProtoMsg;
+};