ox/dist/zod/internal/rpcSchemas/Eth.js

Ethereum Standard Library

/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
import * as z_AccountProof from '../../AccountProof.js';
import * as z_Address from '../../Address.js';
import * as z_Block from '../../Block.js';
import * as z_BlockOverrides from '../../BlockOverrides.js';
import * as z_Fee from '../../Fee.js';
import * as z_Filter from '../../Filter.js';
import * as z_Hex from '../../Hex.js';
import * as z_Log from '../../Log.js';
import * as z_Number from '../../Number.js';
import * as z_StateOverrides from '../../StateOverrides.js';
import * as z_Transaction from '../../Transaction.js';
import * as z_TransactionReceipt from '../../TransactionReceipt.js';
import * as z_TransactionRequest from '../../TransactionRequest.js';
import * as z_Uint from '../../Uint.js';
import * as z from 'zod/mini';
import { from } from './from.js';
const NoParams = z.optional(z.tuple([]));
/** Block number (hex) or block tag. */
const BlockNumberOrTag = z.union([z_Block.Number, z_Block.Tag]);
/** Block number (hex), block tag, or block identifier. */
const BlockNumberOrTagOrIdentifier = z.union([
    z_Block.Number,
    z_Block.Tag,
    z_Block.Identifier,
]);
/** A block in any of its wire forms. */
const Block = z.union([
    z_Block.Block,
    z_Block.WithTransactions,
    z_Block.Pending,
    z_Block.PendingWithTransactions,
]);
/** A transaction in any of its wire forms. */
const Transaction = z.union([z_Transaction.Transaction, z_Transaction.Pending]);
/** Call request shape shared by `eth_call` / `eth_estimateGas`. */
const Call = z.union([
    z.tuple([z_TransactionRequest.TransactionRequestToRpc]),
    z.tuple([
        z_TransactionRequest.TransactionRequestToRpc,
        BlockNumberOrTagOrIdentifier,
    ]),
    z.tuple([
        z_TransactionRequest.TransactionRequestToRpc,
        BlockNumberOrTagOrIdentifier,
        z_StateOverrides.StateOverrides,
    ]),
    z.tuple([
        z_TransactionRequest.TransactionRequestToRpc,
        BlockNumberOrTagOrIdentifier,
        z_StateOverrides.StateOverrides,
        z_BlockOverrides.BlockOverrides,
    ]),
]);
export const eth_accounts = from({
    method: 'eth_accounts',
    params: NoParams,
    returns: z.array(z_Address.Address),
});
export const eth_blobBaseFee = from({
    method: 'eth_blobBaseFee',
    params: NoParams,
    returns: z_Uint.Uint,
});
export const eth_blockNumber = from({
    method: 'eth_blockNumber',
    params: NoParams,
    returns: z_Uint.Uint,
});
export const eth_call = from({
    method: 'eth_call',
    params: Call,
    returns: z_Hex.Hex,
});
export const eth_chainId = from({
    method: 'eth_chainId',
    params: NoParams,
    returns: z_Number.Number,
});
export const eth_coinbase = from({
    method: 'eth_coinbase',
    params: NoParams,
    returns: z_Address.Address,
});
export const eth_estimateGas = from({
    method: 'eth_estimateGas',
    params: Call,
    returns: z_Uint.Uint,
});
export const eth_feeHistory = from({
    method: 'eth_feeHistory',
    params: z.tuple([
        z_Hex.Hex,
        BlockNumberOrTag,
        z.union([z.array(z.number()), z.undefined()]),
    ]),
    returns: z_Fee.FeeHistory,
});
export const eth_gasPrice = from({
    method: 'eth_gasPrice',
    params: NoParams,
    returns: z_Uint.Uint,
});
export const eth_getBalance = from({
    method: 'eth_getBalance',
    params: z.tuple([z_Address.Address, BlockNumberOrTagOrIdentifier]),
    returns: z_Uint.Uint,
});
export const eth_getBlockByHash = from({
    method: 'eth_getBlockByHash',
    params: z.tuple([z_Hex.Hex, z.boolean()]),
    returns: z.nullable(Block),
});
export const eth_getBlockByNumber = from({
    method: 'eth_getBlockByNumber',
    params: z.tuple([BlockNumberOrTag, z.boolean()]),
    returns: z.nullable(Block),
});
export const eth_getBlockTransactionCountByHash = from({
    method: 'eth_getBlockTransactionCountByHash',
    params: z.tuple([z_Hex.Hex]),
    returns: z_Number.Number,
});
export const eth_getBlockTransactionCountByNumber = from({
    method: 'eth_getBlockTransactionCountByNumber',
    params: z.tuple([BlockNumberOrTag]),
    returns: z_Number.Number,
});
export const eth_getCode = from({
    method: 'eth_getCode',
    params: z.tuple([z_Address.Address, BlockNumberOrTagOrIdentifier]),
    returns: z_Hex.Hex,
});
export const eth_getFilterChanges = from({
    method: 'eth_getFilterChanges',
    params: z.tuple([z_Hex.Hex]),
    returns: z.union([z.array(z_Log.Log), z.array(z_Hex.Hex)]),
});
export const eth_getFilterLogs = from({
    method: 'eth_getFilterLogs',
    params: z.tuple([z_Hex.Hex]),
    returns: z.array(z_Log.Log),
});
export const eth_getLogs = from({
    method: 'eth_getLogs',
    params: z.tuple([z_Filter.Filter]),
    returns: z.array(z_Log.Log),
});
export const eth_getProof = from({
    method: 'eth_getProof',
    params: z.tuple([
        z_Address.Address,
        z.array(z_Hex.Hex),
        BlockNumberOrTagOrIdentifier,
    ]),
    returns: z_AccountProof.AccountProof,
});
export const eth_getRawTransactionByHash = from({
    method: 'eth_getRawTransactionByHash',
    params: z.tuple([z_Hex.Hex]),
    returns: z.nullable(z_Hex.Hex),
});
export const eth_getStorageAt = from({
    method: 'eth_getStorageAt',
    params: z.tuple([z_Address.Address, z_Hex.Hex, BlockNumberOrTagOrIdentifier]),
    returns: z_Hex.Hex,
});
export const eth_getTransactionByBlockHashAndIndex = from({
    method: 'eth_getTransactionByBlockHashAndIndex',
    params: z.tuple([z_Hex.Hex, z_Hex.Hex]),
    returns: z.nullable(Transaction),
});
export const eth_getTransactionByBlockNumberAndIndex = from({
    method: 'eth_getTransactionByBlockNumberAndIndex',
    params: z.tuple([BlockNumberOrTag, z_Hex.Hex]),
    returns: z.nullable(Transaction),
});
export const eth_getTransactionByHash = from({
    method: 'eth_getTransactionByHash',
    params: z.tuple([z_Hex.Hex]),
    returns: z.nullable(Transaction),
});
export const eth_getTransactionCount = from({
    method: 'eth_getTransactionCount',
    params: z.tuple([z_Address.Address, BlockNumberOrTagOrIdentifier]),
    returns: z_Number.Number,
});
export const eth_getTransactionReceipt = from({
    method: 'eth_getTransactionReceipt',
    params: z.tuple([z_Hex.Hex]),
    returns: z.nullable(z_TransactionReceipt.TransactionReceipt),
});
export const eth_getUncleCountByBlockHash = from({
    method: 'eth_getUncleCountByBlockHash',
    params: z.tuple([z_Hex.Hex]),
    returns: z_Number.Number,
});
export const eth_getUncleCountByBlockNumber = from({
    method: 'eth_getUncleCountByBlockNumber',
    params: z.tuple([BlockNumberOrTag]),
    returns: z_Number.Number,
});
export const eth_maxPriorityFeePerGas = from({
    method: 'eth_maxPriorityFeePerGas',
    params: NoParams,
    returns: z_Uint.Uint,
});
export const eth_newBlockFilter = from({
    method: 'eth_newBlockFilter',
    params: NoParams,
    returns: z_Hex.Hex,
});
export const eth_newFilter = from({
    method: 'eth_newFilter',
    params: z.tuple([z_Filter.Filter]),
    returns: z_Hex.Hex,
});
export const eth_newPendingTransactionFilter = from({
    method: 'eth_newPendingTransactionFilter',
    params: NoParams,
    returns: z_Hex.Hex,
});
export const eth_protocolVersion = from({
    method: 'eth_protocolVersion',
    params: NoParams,
    returns: z.string(),
});
export const eth_requestAccounts = from({
    method: 'eth_requestAccounts',
    params: NoParams,
    returns: z.array(z_Address.Address),
});
export const eth_sendRawTransaction = from({
    method: 'eth_sendRawTransaction',
    params: z.tuple([z_Hex.Hex]),
    returns: z_Hex.Hex,
});
export const eth_sendRawTransactionSync = from({
    method: 'eth_sendRawTransactionSync',
    params: z.union([z.tuple([z_Hex.Hex]), z.tuple([z_Hex.Hex, z.number()])]),
    returns: z_TransactionReceipt.TransactionReceipt,
});
export const eth_sendTransaction = from({
    method: 'eth_sendTransaction',
    params: z.tuple([z_TransactionRequest.TransactionRequestToRpc]),
    returns: z_Hex.Hex,
});
export const eth_simulateV1 = from({
    method: 'eth_simulateV1',
    params: z.tuple([
        z.object({
            blockStateCalls: z.array(z.object({
                blockOverrides: z.optional(z_BlockOverrides.BlockOverrides),
                calls: z.optional(z.array(z_TransactionRequest.TransactionRequestToRpc)),
                stateOverrides: z.optional(z_StateOverrides.StateOverrides),
            })),
            returnFullTransactions: z.optional(z.boolean()),
            traceTransfers: z.optional(z.boolean()),
            validation: z.optional(z.boolean()),
        }),
        BlockNumberOrTagOrIdentifier,
    ]),
    returns: z.array(z.intersection(Block, z.object({
        calls: z.optional(z.array(z.object({
            error: z.optional(z.object({
                data: z.optional(z_Hex.Hex),
                code: z.number(),
                message: z.string(),
            })),
            logs: z.optional(z.array(z_Log.Log)),
            gasUsed: z_Hex.Hex,
            returnData: z_Hex.Hex,
            status: z_Hex.Hex,
        }))),
    }))),
});
export const eth_signTransaction = from({
    method: 'eth_signTransaction',
    params: z.tuple([z_TransactionRequest.TransactionRequestToRpc]),
    returns: z_Hex.Hex,
});
export const eth_signTypedData_v4 = from({
    method: 'eth_signTypedData_v4',
    params: z.tuple([z_Address.Address, z.string()]),
    returns: z_Hex.Hex,
});
export const eth_uninstallFilter = from({
    method: 'eth_uninstallFilter',
    params: z.tuple([z_Hex.Hex]),
    returns: z.boolean(),
});
//# sourceMappingURL=Eth.js.map