example-js-sdk 0.0.1

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

@@ -0,0 +1,451 @@
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+import { PageRequest, PageResponse } from "../../../cosmos/base/query/v1beta1/pagination";
+import { Log, Params, TraceConfig } 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): QueryAccountRequest;
+    fromJSON(object: any): QueryAccountRequest;
+    toJSON(message: QueryAccountRequest): unknown;
+    create(base?: DeepPartial<QueryAccountRequest>): QueryAccountRequest;
+    fromPartial(object: DeepPartial<QueryAccountRequest>): QueryAccountRequest;
+};
+export declare const QueryAccountResponse: {
+    encode(message: QueryAccountResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryAccountResponse;
+    fromJSON(object: any): QueryAccountResponse;
+    toJSON(message: QueryAccountResponse): unknown;
+    create(base?: DeepPartial<QueryAccountResponse>): QueryAccountResponse;
+    fromPartial(object: DeepPartial<QueryAccountResponse>): QueryAccountResponse;
+};
+export declare const QueryCosmosAccountRequest: {
+    encode(message: QueryCosmosAccountRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryCosmosAccountRequest;
+    fromJSON(object: any): QueryCosmosAccountRequest;
+    toJSON(message: QueryCosmosAccountRequest): unknown;
+    create(base?: DeepPartial<QueryCosmosAccountRequest>): QueryCosmosAccountRequest;
+    fromPartial(object: DeepPartial<QueryCosmosAccountRequest>): QueryCosmosAccountRequest;
+};
+export declare const QueryCosmosAccountResponse: {
+    encode(message: QueryCosmosAccountResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryCosmosAccountResponse;
+    fromJSON(object: any): QueryCosmosAccountResponse;
+    toJSON(message: QueryCosmosAccountResponse): unknown;
+    create(base?: DeepPartial<QueryCosmosAccountResponse>): QueryCosmosAccountResponse;
+    fromPartial(object: DeepPartial<QueryCosmosAccountResponse>): QueryCosmosAccountResponse;
+};
+export declare const QueryValidatorAccountRequest: {
+    encode(message: QueryValidatorAccountRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryValidatorAccountRequest;
+    fromJSON(object: any): QueryValidatorAccountRequest;
+    toJSON(message: QueryValidatorAccountRequest): unknown;
+    create(base?: DeepPartial<QueryValidatorAccountRequest>): QueryValidatorAccountRequest;
+    fromPartial(object: DeepPartial<QueryValidatorAccountRequest>): QueryValidatorAccountRequest;
+};
+export declare const QueryValidatorAccountResponse: {
+    encode(message: QueryValidatorAccountResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryValidatorAccountResponse;
+    fromJSON(object: any): QueryValidatorAccountResponse;
+    toJSON(message: QueryValidatorAccountResponse): unknown;
+    create(base?: DeepPartial<QueryValidatorAccountResponse>): QueryValidatorAccountResponse;
+    fromPartial(object: DeepPartial<QueryValidatorAccountResponse>): QueryValidatorAccountResponse;
+};
+export declare const QueryBalanceRequest: {
+    encode(message: QueryBalanceRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryBalanceRequest;
+    fromJSON(object: any): QueryBalanceRequest;
+    toJSON(message: QueryBalanceRequest): unknown;
+    create(base?: DeepPartial<QueryBalanceRequest>): QueryBalanceRequest;
+    fromPartial(object: DeepPartial<QueryBalanceRequest>): QueryBalanceRequest;
+};
+export declare const QueryBalanceResponse: {
+    encode(message: QueryBalanceResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryBalanceResponse;
+    fromJSON(object: any): QueryBalanceResponse;
+    toJSON(message: QueryBalanceResponse): unknown;
+    create(base?: DeepPartial<QueryBalanceResponse>): QueryBalanceResponse;
+    fromPartial(object: DeepPartial<QueryBalanceResponse>): QueryBalanceResponse;
+};
+export declare const QueryStorageRequest: {
+    encode(message: QueryStorageRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryStorageRequest;
+    fromJSON(object: any): QueryStorageRequest;
+    toJSON(message: QueryStorageRequest): unknown;
+    create(base?: DeepPartial<QueryStorageRequest>): QueryStorageRequest;
+    fromPartial(object: DeepPartial<QueryStorageRequest>): QueryStorageRequest;
+};
+export declare const QueryStorageResponse: {
+    encode(message: QueryStorageResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryStorageResponse;
+    fromJSON(object: any): QueryStorageResponse;
+    toJSON(message: QueryStorageResponse): unknown;
+    create(base?: DeepPartial<QueryStorageResponse>): QueryStorageResponse;
+    fromPartial(object: DeepPartial<QueryStorageResponse>): QueryStorageResponse;
+};
+export declare const QueryCodeRequest: {
+    encode(message: QueryCodeRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryCodeRequest;
+    fromJSON(object: any): QueryCodeRequest;
+    toJSON(message: QueryCodeRequest): unknown;
+    create(base?: DeepPartial<QueryCodeRequest>): QueryCodeRequest;
+    fromPartial(object: DeepPartial<QueryCodeRequest>): QueryCodeRequest;
+};
+export declare const QueryCodeResponse: {
+    encode(message: QueryCodeResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryCodeResponse;
+    fromJSON(object: any): QueryCodeResponse;
+    toJSON(message: QueryCodeResponse): unknown;
+    create(base?: DeepPartial<QueryCodeResponse>): QueryCodeResponse;
+    fromPartial(object: DeepPartial<QueryCodeResponse>): QueryCodeResponse;
+};
+export declare const QueryTxLogsRequest: {
+    encode(message: QueryTxLogsRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryTxLogsRequest;
+    fromJSON(object: any): QueryTxLogsRequest;
+    toJSON(message: QueryTxLogsRequest): unknown;
+    create(base?: DeepPartial<QueryTxLogsRequest>): QueryTxLogsRequest;
+    fromPartial(object: DeepPartial<QueryTxLogsRequest>): QueryTxLogsRequest;
+};
+export declare const QueryTxLogsResponse: {
+    encode(message: QueryTxLogsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryTxLogsResponse;
+    fromJSON(object: any): QueryTxLogsResponse;
+    toJSON(message: QueryTxLogsResponse): unknown;
+    create(base?: DeepPartial<QueryTxLogsResponse>): QueryTxLogsResponse;
+    fromPartial(object: DeepPartial<QueryTxLogsResponse>): QueryTxLogsResponse;
+};
+export declare const QueryParamsRequest: {
+    encode(_: QueryParamsRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryParamsRequest;
+    fromJSON(_: any): QueryParamsRequest;
+    toJSON(_: QueryParamsRequest): unknown;
+    create(base?: DeepPartial<QueryParamsRequest>): QueryParamsRequest;
+    fromPartial(_: DeepPartial<QueryParamsRequest>): QueryParamsRequest;
+};
+export declare const QueryParamsResponse: {
+    encode(message: QueryParamsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryParamsResponse;
+    fromJSON(object: any): QueryParamsResponse;
+    toJSON(message: QueryParamsResponse): unknown;
+    create(base?: DeepPartial<QueryParamsResponse>): QueryParamsResponse;
+    fromPartial(object: DeepPartial<QueryParamsResponse>): QueryParamsResponse;
+};
+export declare const EthCallRequest: {
+    encode(message: EthCallRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): EthCallRequest;
+    fromJSON(object: any): EthCallRequest;
+    toJSON(message: EthCallRequest): unknown;
+    create(base?: DeepPartial<EthCallRequest>): EthCallRequest;
+    fromPartial(object: DeepPartial<EthCallRequest>): EthCallRequest;
+};
+export declare const EstimateGasResponse: {
+    encode(message: EstimateGasResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): EstimateGasResponse;
+    fromJSON(object: any): EstimateGasResponse;
+    toJSON(message: EstimateGasResponse): unknown;
+    create(base?: DeepPartial<EstimateGasResponse>): EstimateGasResponse;
+    fromPartial(object: DeepPartial<EstimateGasResponse>): EstimateGasResponse;
+};
+export declare const QueryTraceTxRequest: {
+    encode(message: QueryTraceTxRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryTraceTxRequest;
+    fromJSON(object: any): QueryTraceTxRequest;
+    toJSON(message: QueryTraceTxRequest): unknown;
+    create(base?: DeepPartial<QueryTraceTxRequest>): QueryTraceTxRequest;
+    fromPartial(object: DeepPartial<QueryTraceTxRequest>): QueryTraceTxRequest;
+};
+export declare const QueryTraceTxResponse: {
+    encode(message: QueryTraceTxResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryTraceTxResponse;
+    fromJSON(object: any): QueryTraceTxResponse;
+    toJSON(message: QueryTraceTxResponse): unknown;
+    create(base?: DeepPartial<QueryTraceTxResponse>): QueryTraceTxResponse;
+    fromPartial(object: DeepPartial<QueryTraceTxResponse>): QueryTraceTxResponse;
+};
+export declare const QueryTraceBlockRequest: {
+    encode(message: QueryTraceBlockRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryTraceBlockRequest;
+    fromJSON(object: any): QueryTraceBlockRequest;
+    toJSON(message: QueryTraceBlockRequest): unknown;
+    create(base?: DeepPartial<QueryTraceBlockRequest>): QueryTraceBlockRequest;
+    fromPartial(object: DeepPartial<QueryTraceBlockRequest>): QueryTraceBlockRequest;
+};
+export declare const QueryTraceBlockResponse: {
+    encode(message: QueryTraceBlockResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryTraceBlockResponse;
+    fromJSON(object: any): QueryTraceBlockResponse;
+    toJSON(message: QueryTraceBlockResponse): unknown;
+    create(base?: DeepPartial<QueryTraceBlockResponse>): QueryTraceBlockResponse;
+    fromPartial(object: DeepPartial<QueryTraceBlockResponse>): QueryTraceBlockResponse;
+};
+export declare const QueryBaseFeeRequest: {
+    encode(_: QueryBaseFeeRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryBaseFeeRequest;
+    fromJSON(_: any): QueryBaseFeeRequest;
+    toJSON(_: QueryBaseFeeRequest): unknown;
+    create(base?: DeepPartial<QueryBaseFeeRequest>): QueryBaseFeeRequest;
+    fromPartial(_: DeepPartial<QueryBaseFeeRequest>): QueryBaseFeeRequest;
+};
+export declare const QueryBaseFeeResponse: {
+    encode(message: QueryBaseFeeResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): QueryBaseFeeResponse;
+    fromJSON(object: any): QueryBaseFeeResponse;
+    toJSON(message: QueryBaseFeeResponse): unknown;
+    create(base?: DeepPartial<QueryBaseFeeResponse>): QueryBaseFeeResponse;
+    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;
+    private readonly service;
+    constructor(rpc: Rpc, opts?: {
+        service?: string;
+    });
+    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>;
+}
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export 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 {};