viem 0.0.1-cjs.10 → 0.0.1-sushi.26

package/dist/public.d.ts

@@ -0,0 +1,353 @@
+export { C as CallArgs, a as CallResponse, c as call } from './call-ac509982.js';
+import { H as Hex, X as EstimateGasParameters, b as BlockTag, A as Address, a as Hash, C as Chain, F as FeeHistory, L as Log, f as BlockNumber, Y as FormattedTransaction, Z as TransactionFormatter, V as Formatted, W as ExtractFormatter, O as Formatter, p as RpcTransactionReceipt, T as TransactionReceipt, K as TransactionType, x as Transaction } from './chain-f16512e8.js';
+import { P as PublicClient } from './createPublicClient-b732194e.js';
+import { F as FormattedBlock, B as BlockFormatter, a as FormattedTransactionReceipt, T as TransactionReceiptFormatter } from './transactionReceipt-2a86c7c7.js';
+import { E as EventFilterArgs } from './watchEvent-c346c12d.js';
+export { G as GetBytecodeArgs, a as GetBytecodeResponse, g as getBytecode, w as watchEvent } from './watchEvent-c346c12d.js';
+import { j as EventDefinition } from './contract-9e76e561.js';
+import './transactionRequest-c7794f5e.js';
+import '@wagmi/chains';
+import './eip1193-6f9ba163.js';
+import './createClient-68ee4bb4.js';
+import 'abitype';
+
+type FilterType = 'transaction' | 'block' | 'event';
+type Filter<TFilterType extends FilterType = 'event'> = {
+    id: Hex;
+    type: TFilterType;
+};
+
+type CreatePendingTransactionFilterResponse = Filter<'transaction'>;
+declare function createPendingTransactionFilter(client: PublicClient): Promise<CreatePendingTransactionFilterResponse>;
+
+type CreateBlockFilterResponse = Filter<'block'>;
+declare function createBlockFilter(client: PublicClient): Promise<CreateBlockFilterResponse>;
+
+type EstimateGasArgs = EstimateGasParameters & ({
+    /** The balance of the account at a block number. */
+    blockNumber?: bigint;
+    blockTag?: never;
+} | {
+    blockNumber?: never;
+    /** The balance of the account at a block tag. */
+    blockTag?: BlockTag;
+});
+type EstimateGasResponse = bigint;
+/**
+ * @description Estimates the gas necessary to complete a transaction without submitting it to the network.
+ */
+declare function estimateGas(client: PublicClient, { blockNumber, blockTag, data, from, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, to, value, }: EstimateGasArgs): Promise<EstimateGasResponse>;
+
+type GetBalanceArgs = {
+    /** The address of the account. */
+    address: Address;
+} & ({
+    /** The balance of the account at a block number. */
+    blockNumber?: bigint;
+    blockTag?: never;
+} | {
+    blockNumber?: never;
+    /** The balance of the account at a block tag. */
+    blockTag?: BlockTag;
+});
+type GetBalanceResponse = bigint;
+/**
+ * @description Returns the balance of an address in wei.
+ */
+declare function getBalance(client: PublicClient, { address, blockNumber, blockTag }: GetBalanceArgs): Promise<GetBalanceResponse>;
+
+type GetBlockArgs = {
+    /** Whether or not to include transaction data in the response. */
+    includeTransactions?: boolean;
+} & ({
+    /** Hash of the block. */
+    blockHash?: Hash;
+    blockNumber?: never;
+    blockTag?: never;
+} | {
+    blockHash?: never;
+    /** The block number. */
+    blockNumber?: bigint;
+    blockTag?: never;
+} | {
+    blockHash?: never;
+    blockNumber?: never;
+    /** The block tag. Defaults to 'latest'. */
+    blockTag?: BlockTag;
+});
+type GetBlockResponse<TChain extends Chain = Chain> = FormattedBlock<BlockFormatter<TChain>>;
+declare function getBlock<TChain extends Chain>(client: PublicClient<any, TChain>, { blockHash, blockNumber, blockTag, includeTransactions, }?: GetBlockArgs): Promise<GetBlockResponse<TChain>>;
+
+type GetBlockNumberArgs = {
+    /** The maximum age (in ms) of the cached value. */
+    maxAge?: number;
+};
+type GetBlockNumberResponse = bigint;
+declare function getBlockNumberCache(id: string): {
+    clear: () => void;
+    promise: {
+        clear: () => boolean;
+        get: () => Promise<unknown> | undefined;
+        set: (data: Promise<unknown>) => Map<string, Promise<unknown>>;
+    };
+    response: {
+        clear: () => boolean;
+        get: () => {
+            created: Date;
+            data: unknown;
+        } | undefined;
+        set: (data: {
+            created: Date;
+            data: unknown;
+        }) => Map<string, {
+            created: Date;
+            data: unknown;
+        }>;
+    };
+};
+/**
+ * @description Returns the number of the most recent block seen.
+ */
+declare function getBlockNumber(client: PublicClient, { maxAge }?: GetBlockNumberArgs): Promise<GetBlockNumberResponse>;
+
+type GetBlockTransactionCountArgs = {
+    /** Hash of the block. */
+    blockHash?: Hash;
+    blockNumber?: never;
+    blockTag?: never;
+} | {
+    blockHash?: never;
+    /** The block number. */
+    blockNumber?: bigint;
+    blockTag?: never;
+} | {
+    blockHash?: never;
+    blockNumber?: never;
+    /** The block tag. Defaults to 'latest'. */
+    blockTag?: BlockTag;
+};
+type GetBlockTransactionCountResponse = number;
+declare function getBlockTransactionCount<TChain extends Chain>(client: PublicClient<any, TChain>, { blockHash, blockNumber, blockTag, }?: GetBlockTransactionCountArgs): Promise<GetBlockTransactionCountResponse>;
+
+declare function getChainId(client: PublicClient): Promise<number>;
+
+type GetFeeHistoryArgs = {
+    blockCount: number;
+    rewardPercentiles: number[];
+} & ({
+    blockNumber?: never;
+    blockTag?: BlockTag;
+} | {
+    blockNumber?: bigint;
+    blockTag?: never;
+});
+type GetFeeHistoryResponse = FeeHistory;
+/**
+ * @description Returns a collection of historical gas information.
+ */
+declare function getFeeHistory(client: PublicClient, { blockCount, blockNumber, blockTag, rewardPercentiles, }: GetFeeHistoryArgs): Promise<GetFeeHistoryResponse>;
+
+type GetFilterChangesArgs<TFilterType extends FilterType> = {
+    filter: Filter<TFilterType>;
+};
+type GetFilterChangesResponse<TFilterType extends FilterType> = TFilterType extends 'event' ? Log[] : Hash[];
+declare function getFilterChanges<TFilterType extends FilterType>(client: PublicClient, { filter }: GetFilterChangesArgs<TFilterType>): Promise<GetFilterChangesResponse<TFilterType>>;
+
+type GetFilterLogsArgs = {
+    filter: Filter<'event'>;
+};
+type GetFilterLogsResponse = Log[];
+declare function getFilterLogs<TFilterType extends FilterType>(client: PublicClient, { filter }: GetFilterLogsArgs): Promise<GetFilterLogsResponse>;
+
+type GetGasPriceResponse = bigint;
+/**
+ * @description Returns the current price of gas (in wei).
+ */
+declare function getGasPrice(client: PublicClient): Promise<GetGasPriceResponse>;
+
+type GetLogsArgs<TEventDefinition extends EventDefinition> = {
+    /** Address or list of addresses from which logs originated */
+    address?: Address | Address[];
+} & ({
+    event: TEventDefinition;
+    args?: EventFilterArgs<TEventDefinition>;
+} | {
+    event?: never;
+    args?: never;
+}) & ({
+    /** Block number or tag after which to include logs */
+    fromBlock?: BlockNumber<bigint> | BlockTag;
+    /** Block number or tag before which to include logs */
+    toBlock?: BlockNumber<bigint> | BlockTag;
+    blockHash?: never;
+} | {
+    fromBlock?: never;
+    toBlock?: never;
+    /** Hash of block to include logs from */
+    blockHash?: Hash;
+});
+type GetLogsResponse = Log[];
+/**
+ * @description Returns a collection of event logs.
+ */
+declare function getLogs<TEventDefinition extends EventDefinition>(client: PublicClient, { address, blockHash, fromBlock, toBlock, event, args, }?: GetLogsArgs<TEventDefinition>): Promise<GetLogsResponse>;
+
+type GetTransactionArgs = {
+    /** The block hash */
+    blockHash: Hash;
+    blockNumber?: never;
+    blockTag?: never;
+    hash?: never;
+    /** The index of the transaction on the block. */
+    index: number;
+} | {
+    blockHash?: never;
+    /** The block number */
+    blockNumber: bigint;
+    blockTag?: never;
+    hash?: never;
+    /** The index of the transaction on the block. */
+    index: number;
+} | {
+    blockHash?: never;
+    blockNumber?: never;
+    /** The block tag. */
+    blockTag: BlockTag;
+    hash?: never;
+    /** The index of the transaction on the block. */
+    index: number;
+} | {
+    blockHash?: never;
+    blockNumber?: never;
+    blockTag?: never;
+    /** The hash of the transaction. */
+    hash: Hash;
+    index?: number;
+};
+type GetTransactionResponse<TChain extends Chain = Chain> = FormattedTransaction<TransactionFormatter<TChain>>;
+/** @description Returns information about a transaction given a hash or block identifier. */
+declare function getTransaction<TChain extends Chain>(client: PublicClient<any, TChain>, { blockHash, blockNumber, blockTag, hash, index, }: GetTransactionArgs): Promise<GetTransactionResponse<TChain>>;
+
+type GetTransactionConfirmationsArgs<TChain extends Chain> = {
+    /** The transaction hash. */
+    hash: Hash;
+    transactionReceipt?: never;
+} | {
+    hash?: never;
+    /** The transaction receipt. */
+    transactionReceipt: FormattedTransactionReceipt<TransactionReceiptFormatter<TChain>>;
+};
+type GetTransactionConfirmationsResponse = bigint;
+declare function getTransactionConfirmations<TChain extends Chain>(client: PublicClient<any, TChain>, { hash, transactionReceipt }: GetTransactionConfirmationsArgs<TChain>): Promise<GetTransactionConfirmationsResponse>;
+
+type GetTransactionCountArgs = {
+    /** The account address. */
+    address: Address;
+} & ({
+    /** The block number. */
+    blockNumber?: bigint;
+    blockTag?: never;
+} | {
+    blockNumber?: never;
+    /** The block tag. Defaults to 'latest'. */
+    blockTag?: BlockTag;
+});
+type GetTransactionCountResponse = number;
+/**
+ * @description Returns the number of transactions an account has broadcast / sent.
+ */
+declare function getTransactionCount(client: PublicClient, { address, blockTag, blockNumber }: GetTransactionCountArgs): Promise<GetTransactionCountResponse>;
+
+type GetTransactionReceiptArgs = {
+    /** The hash of the transaction. */
+    hash: Hash;
+};
+type GetTransactionReceiptResponse<TChain extends Chain = Chain> = FormattedTransactionReceipt<TransactionReceiptFormatter<TChain>>;
+declare function getTransactionReceipt<TChain extends Chain>(client: PublicClient<any, TChain>, { hash }: GetTransactionReceiptArgs): Promise<Formatted<ExtractFormatter<TChain, "transactionReceipt", Formatter<RpcTransactionReceipt, TransactionReceipt<bigint, number, "success" | "reverted", TransactionType>>>, TransactionReceipt<bigint, number, "success" | "reverted", TransactionType>, false>>;
+
+type UninstallFilterArgs = {
+    filter: Filter<any>;
+};
+type UninstallFilterResponse = boolean;
+declare function uninstallFilter(client: PublicClient, { filter }: UninstallFilterArgs): Promise<UninstallFilterResponse>;
+
+type ReplacementReason = 'cancelled' | 'replaced' | 'repriced';
+type ReplacementResponse<TChain extends Chain = Chain> = {
+    reason: ReplacementReason;
+    replacedTransaction: Transaction;
+    transaction: Transaction;
+    transactionReceipt: GetTransactionReceiptResponse<TChain>;
+};
+type WaitForTransactionReceiptResponse<TChain extends Chain = Chain> = GetTransactionReceiptResponse<TChain>;
+type WaitForTransactionReceiptArgs<TChain extends Chain = Chain> = {
+    /** The number of confirmations (blocks that have passed) to wait before resolving. */
+    confirmations?: number;
+    /** The hash of the transaction. */
+    hash: Hash;
+    onReplaced?: (response: ReplacementResponse<TChain>) => void;
+    /** Polling frequency (in ms). Defaults to the client's pollingInterval config. */
+    pollingInterval?: number;
+    /** Optional timeout (in milliseconds) to wait before stopping polling. */
+    timeout?: number;
+};
+declare function waitForTransactionReceipt<TChain extends Chain>(client: PublicClient<any, TChain>, { confirmations, hash, onReplaced, pollingInterval, timeout, }: WaitForTransactionReceiptArgs<TChain>): Promise<WaitForTransactionReceiptResponse<TChain>>;
+
+type OnBlockNumberResponse = GetBlockNumberResponse;
+type OnBlockNumber = (blockNumber: OnBlockNumberResponse, prevBlockNumber: OnBlockNumberResponse | undefined) => void;
+type WatchBlockNumberArgs = {
+    /** Whether or not to emit the missed block numbers to the callback. */
+    emitMissed?: boolean;
+    /** Whether or not to emit the latest block number to the callback when the subscription opens. */
+    emitOnBegin?: boolean;
+    /** The callback to call when a new block number is received. */
+    onBlockNumber: OnBlockNumber;
+    /** The callback to call when an error occurred when trying to get for a new block. */
+    onError?: (error: Error) => void;
+    /** Polling frequency (in ms). Defaults to Client's pollingInterval config. */
+    pollingInterval?: number;
+};
+/** @description Watches and returns incoming block numbers. */
+declare function watchBlockNumber(client: PublicClient, { emitOnBegin, emitMissed, onBlockNumber, onError, pollingInterval, }: WatchBlockNumberArgs): () => void;
+
+type OnBlockResponse<TChain extends Chain = Chain, TIncludeTransactions = false> = Omit<GetBlockResponse<TChain>, TIncludeTransactions extends false ? 'transactions' : ''>;
+type OnBlock<TChain extends Chain = Chain, TIncludeTransactions = false> = (block: OnBlockResponse<TChain, TIncludeTransactions>, prevBlock: OnBlockResponse<TChain, TIncludeTransactions> | undefined) => void;
+type WatchBlocksArgs<TChain extends Chain = Chain> = {
+    /** The block tag. Defaults to "latest". */
+    blockTag?: BlockTag;
+    /** Whether or not to emit the missed blocks to the callback. */
+    emitMissed?: boolean;
+    /** Whether or not to emit the block to the callback when the subscription opens. */
+    emitOnBegin?: boolean;
+    /** The callback to call when an error occurred when trying to get for a new block. */
+    onError?: (error: Error) => void;
+    /** Polling frequency (in ms). Defaults to the client's pollingInterval config. */
+    pollingInterval?: number;
+} & ({
+    /** Whether or not to include transaction data in the response. */
+    includeTransactions: true;
+    /** The callback to call when a new block is received. */
+    onBlock: OnBlock<TChain, true>;
+} | {
+    /** Whether or not to include transaction data in the response. */
+    includeTransactions?: false;
+    /** The callback to call when a new block is received. */
+    onBlock: OnBlock<TChain>;
+});
+/** @description Watches and returns information for incoming blocks. */
+declare function watchBlocks<TChain extends Chain, TWatchBlocksArgs extends WatchBlocksArgs<TChain>>(client: PublicClient<any, TChain>, { blockTag, emitMissed, emitOnBegin, onBlock, onError, includeTransactions, pollingInterval, }: TWatchBlocksArgs): () => void;
+
+type OnTransactionsResponse = Hash[];
+type OnTransactions = (transactions: OnTransactionsResponse) => void;
+type WatchPendingTransactionsArgs = {
+    /** Whether or not the transaction hashes should be batched on each invocation. */
+    batch?: boolean;
+    /** The callback to call when an error occurred when trying to get for a new block. */
+    onError?: (error: Error) => void;
+    /** The callback to call when new transactions are received. */
+    onTransactions: OnTransactions;
+    /** Polling frequency (in ms). Defaults to Client's pollingInterval config. */
+    pollingInterval?: number;
+};
+declare function watchPendingTransactions(client: PublicClient, { batch, onError, onTransactions, pollingInterval, }: WatchPendingTransactionsArgs): () => void;
+
+export { CreateBlockFilterResponse, CreatePendingTransactionFilterResponse, EstimateGasArgs, EstimateGasResponse, GetBalanceArgs, GetBalanceResponse, GetBlockArgs, GetBlockNumberArgs, GetBlockNumberResponse, GetBlockResponse, GetBlockTransactionCountArgs, GetBlockTransactionCountResponse, GetFeeHistoryArgs, GetFeeHistoryResponse, GetFilterChangesArgs, GetFilterChangesResponse, GetFilterLogsArgs, GetFilterLogsResponse, GetGasPriceResponse, GetTransactionArgs, GetTransactionConfirmationsArgs, GetTransactionConfirmationsResponse, GetTransactionCountArgs, GetTransactionCountResponse, GetTransactionReceiptArgs, GetTransactionReceiptResponse, GetTransactionResponse, OnBlock, OnBlockNumber, OnBlockNumberResponse, OnBlockResponse, OnTransactions, OnTransactionsResponse, ReplacementReason, ReplacementResponse, UninstallFilterArgs, UninstallFilterResponse, WaitForTransactionReceiptArgs, WaitForTransactionReceiptResponse, WatchBlockNumberArgs, WatchBlocksArgs, WatchPendingTransactionsArgs, createBlockFilter, createPendingTransactionFilter, estimateGas, getBalance, getBlock, getBlockNumber, getBlockNumberCache, getBlockTransactionCount, getChainId, getFeeHistory, getFilterChanges, getFilterLogs, getGasPrice, getLogs, getTransaction, getTransactionConfirmations, getTransactionCount, getTransactionReceipt, uninstallFilter, waitForTransactionReceipt, watchBlockNumber, watchBlocks, watchPendingTransactions };

package/dist/public.js

@@ -0,0 +1,58 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkUTL6F7UNjs = require('./chunk-UTL6F7UN.js');
+require('./chunk-NXCI5KQC.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.call = _chunkUTL6F7UNjs.call; exports.createBlockFilter = _chunkUTL6F7UNjs.createBlockFilter; exports.createPendingTransactionFilter = _chunkUTL6F7UNjs.createPendingTransactionFilter; exports.estimateGas = _chunkUTL6F7UNjs.estimateGas; exports.getBalance = _chunkUTL6F7UNjs.getBalance; exports.getBlock = _chunkUTL6F7UNjs.getBlock; exports.getBlockNumber = _chunkUTL6F7UNjs.getBlockNumber; exports.getBlockNumberCache = _chunkUTL6F7UNjs.getBlockNumberCache; exports.getBlockTransactionCount = _chunkUTL6F7UNjs.getBlockTransactionCount; exports.getBytecode = _chunkUTL6F7UNjs.getBytecode; exports.getChainId = _chunkUTL6F7UNjs.getChainId; exports.getFeeHistory = _chunkUTL6F7UNjs.getFeeHistory; exports.getFilterChanges = _chunkUTL6F7UNjs.getFilterChanges; exports.getFilterLogs = _chunkUTL6F7UNjs.getFilterLogs; exports.getGasPrice = _chunkUTL6F7UNjs.getGasPrice; exports.getLogs = _chunkUTL6F7UNjs.getLogs; exports.getTransaction = _chunkUTL6F7UNjs.getTransaction; exports.getTransactionConfirmations = _chunkUTL6F7UNjs.getTransactionConfirmations; exports.getTransactionCount = _chunkUTL6F7UNjs.getTransactionCount; exports.getTransactionReceipt = _chunkUTL6F7UNjs.getTransactionReceipt; exports.uninstallFilter = _chunkUTL6F7UNjs.uninstallFilter; exports.waitForTransactionReceipt = _chunkUTL6F7UNjs.waitForTransactionReceipt; exports.watchBlockNumber = _chunkUTL6F7UNjs.watchBlockNumber; exports.watchBlocks = _chunkUTL6F7UNjs.watchBlocks; exports.watchEvent = _chunkUTL6F7UNjs.watchEvent; exports.watchPendingTransactions = _chunkUTL6F7UNjs.watchPendingTransactions;
+//# sourceMappingURL=public.js.map

package/dist/public.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":""}

package/dist/public.mjs

@@ -0,0 +1,58 @@
+import {
+  call,
+  createBlockFilter,
+  createPendingTransactionFilter,
+  estimateGas,
+  getBalance,
+  getBlock,
+  getBlockNumber,
+  getBlockNumberCache,
+  getBlockTransactionCount,
+  getBytecode,
+  getChainId,
+  getFeeHistory,
+  getFilterChanges,
+  getFilterLogs,
+  getGasPrice,
+  getLogs,
+  getTransaction,
+  getTransactionConfirmations,
+  getTransactionCount,
+  getTransactionReceipt,
+  uninstallFilter,
+  waitForTransactionReceipt,
+  watchBlockNumber,
+  watchBlocks,
+  watchEvent,
+  watchPendingTransactions
+} from "./chunk-O7T5NQLB.mjs";
+import "./chunk-SD5X7F4U.mjs";
+export {
+  call,
+  createBlockFilter,
+  createPendingTransactionFilter,
+  estimateGas,
+  getBalance,
+  getBlock,
+  getBlockNumber,
+  getBlockNumberCache,
+  getBlockTransactionCount,
+  getBytecode,
+  getChainId,
+  getFeeHistory,
+  getFilterChanges,
+  getFilterLogs,
+  getGasPrice,
+  getLogs,
+  getTransaction,
+  getTransactionConfirmations,
+  getTransactionCount,
+  getTransactionReceipt,
+  uninstallFilter,
+  waitForTransactionReceipt,
+  watchBlockNumber,
+  watchBlocks,
+  watchEvent,
+  watchPendingTransactions
+};
+//# sourceMappingURL=public.mjs.map

package/dist/public.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/readContract-4f6e2692.d.ts

@@ -0,0 +1,10 @@
+import { Abi } from 'abitype';
+import { C as ContractConfig, E as ExtractResultFromAbi } from './contract-9e76e561.js';
+import { P as PublicClient } from './createPublicClient-b732194e.js';
+import { C as CallArgs } from './call-ac509982.js';
+
+type ReadContractArgs<TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = string> = Pick<CallArgs, 'blockNumber' | 'blockTag'> & ContractConfig<TAbi, TFunctionName, 'view' | 'pure'>;
+type ReadContractResponse<TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = string> = ExtractResultFromAbi<TAbi, TFunctionName>;
+declare function readContract<TAbi extends Abi | readonly unknown[], TFunctionName extends string>(client: PublicClient, { abi, address, args, functionName, ...callRequest }: ReadContractArgs<TAbi, TFunctionName>): Promise<ReadContractResponse<TAbi, TFunctionName>>;
+
+export { ReadContractArgs as R, ReadContractResponse as a, readContract as r };

package/dist/rpc-a5a7f376.d.ts

@@ -0,0 +1,121 @@
+import { Abi } from 'abitype';
+import { A as Address, H as Hex } from './chain-f16512e8.js';
+import { D as DecodeErrorResultResponse } from './decodeErrorResult-0b934d23.js';
+import WebSocket from 'isomorphic-ws';
+
+type BaseErrorArgs = {
+    docsPath?: string;
+    metaMessages?: string[];
+} & ({
+    cause?: never;
+    details?: string;
+} | {
+    cause: BaseError | Error;
+    details?: never;
+});
+declare class BaseError extends Error {
+    details: string;
+    docsPath?: string;
+    metaMessages?: string[];
+    shortMessage: string;
+    name: string;
+    constructor(shortMessage: string, args?: BaseErrorArgs);
+}
+
+declare class ContractFunctionExecutionError extends BaseError {
+    abi: Abi;
+    args?: unknown[];
+    cause: BaseError;
+    contractAddress?: Address;
+    formattedArgs?: string;
+    functionName: string;
+    sender?: Address;
+    name: string;
+    constructor(cause: BaseError, { abi, args, contractAddress, docsPath, functionName, sender, }: {
+        abi: Abi;
+        args?: any;
+        contractAddress?: Address;
+        docsPath?: string;
+        functionName: string;
+        sender?: Address;
+    });
+}
+declare class ContractFunctionRevertedError extends BaseError {
+    name: string;
+    data?: DecodeErrorResultResponse;
+    reason?: string;
+    constructor({ abi, data, functionName, message, }: {
+        abi: Abi;
+        data?: Hex;
+        functionName: string;
+        message?: string;
+    });
+}
+declare class ContractFunctionZeroDataError extends BaseError {
+    name: string;
+    constructor({ functionName }: {
+        functionName: string;
+    });
+}
+
+type SuccessResult<T> = {
+    method?: never;
+    result: T;
+    error?: never;
+};
+type ErrorResult<T> = {
+    method?: never;
+    result?: never;
+    error: T;
+};
+type Subscription<TResult, TError> = {
+    method: 'eth_subscription';
+    error?: never;
+    result?: never;
+    params: {
+        subscription: string;
+    } & ({
+        result: TResult;
+        error?: never;
+    } | {
+        result?: never;
+        error: TError;
+    });
+};
+type RpcRequest = {
+    method: string;
+    params?: any[];
+};
+type RpcResponse<TResult = any, TError = any> = {
+    jsonrpc: `${number}`;
+    id: number;
+} & (SuccessResult<TResult> | ErrorResult<TError> | Subscription<TResult, TError>);
+declare function http(url: string, { body, retryDelay, retryCount, timeout, }: {
+    body: RpcRequest;
+    retryDelay?: number;
+    retryCount?: number;
+    timeout?: number;
+}): Promise<RpcResponse<any, any>>;
+type Id = string | number;
+type CallbackFn = (message: any) => void;
+type CallbackMap = Map<Id, CallbackFn>;
+type Socket = WebSocket & {
+    requests: CallbackMap;
+    subscriptions: CallbackMap;
+};
+declare function webSocket(socket: Socket, { body, onData, onError, }: {
+    body: RpcRequest;
+    onData?: (message: RpcResponse) => void;
+    onError?: (message: RpcResponse['error']) => void;
+}): Socket;
+declare function webSocketAsync(socket: Socket, { body, timeout, }: {
+    body: RpcRequest;
+    timeout?: number;
+}): Promise<RpcResponse<any, any>>;
+declare const rpc: {
+    http: typeof http;
+    webSocket: typeof webSocket;
+    webSocketAsync: typeof webSocketAsync;
+};
+
+export { BaseError as B, ContractFunctionExecutionError as C, RpcResponse as R, ContractFunctionRevertedError as a, ContractFunctionZeroDataError as b, rpc as r };

package/dist/sendTransaction-e713f90c.d.ts

@@ -0,0 +1,12 @@
+import { O as Formatter, S as MergeIntersectionProperties, V as Formatted, s as TransactionRequest, C as Chain, a as Hash } from './chain-f16512e8.js';
+import { W as WalletClient } from './createWalletClient-75813d83.js';
+import { T as TransactionRequestFormatter } from './transactionRequest-c7794f5e.js';
+
+type FormattedTransactionRequest<TFormatter extends Formatter | undefined = Formatter> = MergeIntersectionProperties<Formatted<TFormatter, TransactionRequest, true>, TransactionRequest>;
+type SendTransactionArgs<TChain extends Chain = Chain> = FormattedTransactionRequest<TransactionRequestFormatter<TChain>> & {
+    chain?: TChain;
+};
+type SendTransactionResponse = Hash;
+declare function sendTransaction<TChain extends Chain>(client: WalletClient, { chain, from, accessList, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, ...rest }: SendTransactionArgs<TChain>): Promise<SendTransactionResponse>;
+
+export { FormattedTransactionRequest as F, SendTransactionArgs as S, SendTransactionResponse as a, sendTransaction as s };