viem 0.0.0 → 0.0.1-alpha.0

package/dist/watchAsset-bb30848d.d.ts

@@ -0,0 +1,535 @@
+import { Chain, Formatter } from './chains.js';
+import { H as Hex, d as BlockTag, M as MergeIntersectionProperties, v as TransactionRequest, K as EstimateGasParameters, A as Address, k as Hash, F as FeeHistory, L as Log, r as RpcTransactionReceipt, T as TransactionReceipt, N as TransactionType, D as Transaction, q as RpcTransaction, Q as Quantity, f as ByteArray } from './rpc-655c0ba4.js';
+import { T as TransactionRequestFormatter, e as Formatted, F as FormattedBlock, B as BlockFormatter, a as FormattedTransaction, g as TransactionFormatter, h as FormattedTransactionReceipt, i as TransactionReceiptFormatter, E as ExtractFormatter } from './transactionRequest-ade896ac.js';
+import { P as PublicClient, T as TestClient, W as WalletClient } from './createWalletClient-c40fef16.js';
+import { B as BaseError } from './BaseError-7688f84e.js';
+import { W as WalletPermission, a as WatchAssetParams } from './eip1193-8f7c22ce.js';
+
+type FilterType = 'transaction' | 'block' | 'event';
+type Filter<TFilterType extends FilterType = 'event'> = {
+    id: Hex;
+    type: TFilterType;
+};
+
+type FormattedCall<TFormatter extends Formatter | undefined = Formatter> = MergeIntersectionProperties<Formatted<TFormatter, TransactionRequest, true>, TransactionRequest>;
+type CallArgs<TChain extends Chain = Chain> = {
+    chain?: TChain;
+    request: FormattedCall<TransactionRequestFormatter<TChain>>;
+} & ({
+    /** 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 CallResponse = {
+    data: Hex | undefined;
+};
+declare function call<TChain extends Chain>(client: PublicClient, { blockNumber, blockTag, chain, request }: CallArgs<TChain>): Promise<CallResponse>;
+
+type CreatePendingTransactionFilterResponse = Filter<'transaction'>;
+declare function createPendingTransactionFilter(client: PublicClient): Promise<CreatePendingTransactionFilterResponse>;
+
+type CreateBlockFilterResponse = Filter<'block'>;
+declare function createBlockFilter(client: PublicClient): Promise<CreateBlockFilterResponse>;
+
+type EstimateGasArgs = {
+    request: 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, request: { 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 GetGasPriceResponse = bigint;
+/**
+ * @description Returns the current price of gas (in wei).
+ */
+declare function getGasPrice(client: PublicClient): Promise<GetGasPriceResponse>;
+
+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>>;
+declare class WaitForTransactionReceiptTimeoutError extends BaseError {
+    name: string;
+    constructor({ hash }: {
+        hash: Hash;
+    });
+}
+
+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> = GetBlockResponse<TChain>;
+type OnBlock<TChain extends Chain = Chain> = (block: OnBlockResponse<TChain>, prevBlock: OnBlockResponse<TChain> | 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 a new block is received. */
+    onBlock: OnBlock<TChain>;
+    /** The callback to call when an error occurred when trying to get for a new block. */
+    onError?: (error: Error) => void;
+    /** Whether or not to include transaction data in the response. */
+    includeTransactions?: boolean;
+    /** Polling frequency (in ms). Defaults to the client's pollingInterval config. */
+    pollingInterval?: number;
+};
+/** @description Watches and returns information for incoming blocks. */
+declare function watchBlocks<TChain extends Chain>(client: PublicClient<any, TChain>, { blockTag, emitMissed, emitOnBegin, onBlock, onError, includeTransactions, pollingInterval, }: WatchBlocksArgs<TChain>): () => 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;
+
+type DropTransactionArgs = {
+    /** The hash of the transaction to drop. */
+    hash: Hash;
+};
+declare function dropTransaction(client: TestClient, { hash }: DropTransactionArgs): Promise<void>;
+
+type GetAutomineResponse = boolean;
+declare function getAutomine(client: TestClient): Promise<GetAutomineResponse>;
+
+declare function getTxpoolContent(client: TestClient): Promise<{
+    pending: Record<`0x${string}`, Record<string, RpcTransaction>>;
+    queued: Record<`0x${string}`, Record<string, RpcTransaction>>;
+}>;
+
+declare function getTxpoolStatus(client: TestClient): Promise<{
+    pending: number;
+    queued: number;
+}>;
+
+type ImpersonateAccountArgs = {
+    /** The account to impersonate. */
+    address: Address;
+};
+declare function impersonateAccount(client: TestClient, { address }: ImpersonateAccountArgs): Promise<void>;
+
+type IncreaseTimeArgs = {
+    /** The amount of seconds to jump forward in time. */
+    seconds: number;
+};
+declare function increaseTime(client: TestClient, { seconds }: IncreaseTimeArgs): Promise<`0x${string}`>;
+
+declare function inspectTxpool(client: TestClient): Promise<{
+    pending: Record<`0x${string}`, Record<string, string>>;
+    queued: Record<`0x${string}`, Record<string, string>>;
+}>;
+
+type MineArgs = {
+    /** Number of blocks to mine. */
+    blocks: number;
+    /** Interval between each block in seconds. */
+    interval?: number;
+};
+declare function mine(client: TestClient, { blocks, interval }: MineArgs): Promise<void>;
+
+declare function removeBlockTimestampInterval(client: TestClient): Promise<void>;
+
+type ResetArgs = {
+    /** The block number to reset from. */
+    blockNumber?: bigint;
+    /** The JSON RPC URL. */
+    jsonRpcUrl?: string;
+};
+declare function reset(client: TestClient, { blockNumber, jsonRpcUrl }?: ResetArgs): Promise<void>;
+
+type RevertArgs = {
+    /** The snapshot ID to revert to. */
+    id: Quantity;
+};
+declare function revert(client: TestClient, { id }: RevertArgs): Promise<void>;
+
+type SendUnsignedTransactionArgs = {
+    request: TransactionRequest;
+};
+type SendUnsignedTransactionResponse = {
+    hash: `0x${string}`;
+};
+declare function sendUnsignedTransaction(client: TestClient, { request }: SendUnsignedTransactionArgs): Promise<SendUnsignedTransactionResponse>;
+
+declare function setAutomine(client: TestClient, enabled: boolean): Promise<void>;
+
+type SetBalanceArgs = {
+    /** The account address. */
+    address: Address;
+    /** Amount (in wei) to set */
+    value: bigint;
+};
+declare function setBalance(client: TestClient, { address, value }: SetBalanceArgs): Promise<void>;
+
+type SetBlockGasLimitArgs = {
+    /** Gas limit (in wei). */
+    gasLimit: bigint;
+};
+declare function setBlockGasLimit(client: TestClient, { gasLimit }: SetBlockGasLimitArgs): Promise<void>;
+
+type SetBlockTimestampIntervalArgs = {
+    /** The interval (in seconds). */
+    interval: number;
+};
+declare function setBlockTimestampInterval(client: TestClient, { interval }: SetBlockTimestampIntervalArgs): Promise<void>;
+
+type SetCodeArgs = {
+    /** The account address. */
+    address: Address;
+    /** The bytecode to set */
+    bytecode: Hex;
+};
+declare function setCode(client: TestClient, { address, bytecode }: SetCodeArgs): Promise<void>;
+
+type SetCoinbaseArgs = {
+    /** The coinbase address. */
+    address: Address;
+};
+declare function setCoinbase(client: TestClient, { address }: SetCoinbaseArgs): Promise<void>;
+
+type SetIntervalMiningArgs = {
+    /** The mining interval. */
+    interval: number;
+};
+declare function setIntervalMining(client: TestClient, { interval }: SetIntervalMiningArgs): Promise<void>;
+
+declare function setLoggingEnabled(client: TestClient, enabled: boolean): Promise<void>;
+
+type SetMinGasPriceArgs = {
+    /** The gas price. */
+    gasPrice: bigint;
+};
+declare function setMinGasPrice(client: TestClient, { gasPrice }: SetMinGasPriceArgs): Promise<void>;
+
+type SetNextBlockBaseFeePerGasArgs = {
+    /** Base fee per gas (in wei). */
+    baseFeePerGas: bigint;
+};
+declare function setNextBlockBaseFeePerGas(client: TestClient, { baseFeePerGas }: SetNextBlockBaseFeePerGasArgs): Promise<void>;
+
+type SetNextBlockTimestampArgs = {
+    /** The timestamp (in seconds). */
+    timestamp: bigint;
+};
+declare function setNextBlockTimestamp(client: TestClient, { timestamp }: SetNextBlockTimestampArgs): Promise<void>;
+
+type SetNonceArgs = {
+    /** The account address. */
+    address: Address;
+    /** The nonce to set. */
+    nonce: number;
+};
+declare function setNonce(client: TestClient, { address, nonce }: SetNonceArgs): Promise<void>;
+
+type SetStorageAtArgs = {
+    /** The account address. */
+    address: Address;
+    /** The storage slot (index). Can either be a number or hash value. */
+    index: number | Hash;
+    /** The value to store as a 32 byte hex string. */
+    value: Hex;
+};
+declare function setStorageAt(client: TestClient, { address, index, value }: SetStorageAtArgs): Promise<void>;
+
+declare function snapshot(client: TestClient): Promise<`0x${string}`>;
+
+type StopImpersonatingAccountArgs = {
+    /** The account to impersonate. */
+    address: Address;
+};
+declare function stopImpersonatingAccount(client: TestClient, { address }: StopImpersonatingAccountArgs): Promise<void>;
+
+declare function addChain(client: WalletClient, chain: Chain): Promise<void>;
+
+type GetPermissionsResponse = WalletPermission[];
+declare function getPermissions(client: WalletClient): Promise<WalletPermission[]>;
+
+declare function requestAccounts(client: WalletClient): Promise<`0x${string}`[]>;
+
+type RequestPermissionsArgs = {
+    eth_accounts: Record<string, any>;
+} & {
+    [key: string]: Record<string, any>;
+};
+type RequestPermissionsResponse = WalletPermission[];
+declare function requestPermissions(client: WalletClient, permissions: RequestPermissionsArgs): Promise<WalletPermission[]>;
+
+type FormattedTransactionRequest<TFormatter extends Formatter | undefined = Formatter> = MergeIntersectionProperties<Formatted<TFormatter, TransactionRequest, true>, TransactionRequest>;
+type SendTransactionArgs<TChain extends Chain = Chain> = {
+    chain?: TChain;
+    request: FormattedTransactionRequest<TransactionRequestFormatter<TChain>>;
+};
+type SendTransactionResponse = {
+    hash: `0x${string}`;
+};
+declare function sendTransaction<TChain extends Chain>(client: WalletClient, { chain, request }: SendTransactionArgs<TChain>): Promise<SendTransactionResponse>;
+declare class InvalidGasArgumentsError extends BaseError {
+    name: string;
+    constructor();
+}
+
+type SignMessageArgs = {
+    from: Address;
+    data: Hex | ByteArray;
+};
+type SignMessageResponse = Hex;
+declare function signMessage(client: WalletClient, { from, data: data_ }: SignMessageArgs): Promise<SignMessageResponse>;
+
+type SwitchChainArgs = {
+    id: Chain['id'];
+};
+declare function switchChain(client: WalletClient, { id }: SwitchChainArgs): Promise<void>;
+
+type WatchAssetArgs = WatchAssetParams;
+type WatchAssetResponse = boolean;
+declare function watchAsset(client: WalletClient, params: WatchAssetParams): Promise<WatchAssetResponse>;
+
+export { SetNextBlockBaseFeePerGasArgs as $, OnBlockNumber as A, OnBlockNumberResponse as B, CallArgs as C, DropTransactionArgs as D, EstimateGasArgs as E, OnBlockResponse as F, GetBalanceArgs as G, OnTransactions as H, ImpersonateAccountArgs as I, OnTransactionsResponse as J, RequestPermissionsResponse as K, RevertArgs as L, MineArgs as M, SendTransactionResponse as N, OnBlock as O, SendUnsignedTransactionArgs as P, SendUnsignedTransactionResponse as Q, ResetArgs as R, SendTransactionArgs as S, SetBalanceArgs as T, SetBlockGasLimitArgs as U, SetCodeArgs as V, SetCoinbaseArgs as W, SetIntervalMiningArgs as X, SetMinGasPriceArgs as Y, SetBlockTimestampIntervalArgs as Z, SetNextBlockTimestampArgs as _, CallResponse as a, switchChain as a$, SetNonceArgs as a0, SetStorageAtArgs as a1, SignMessageArgs as a2, SignMessageResponse as a3, StopImpersonatingAccountArgs as a4, SwitchChainArgs as a5, UninstallFilterArgs as a6, UninstallFilterResponse as a7, WaitForTransactionReceiptArgs as a8, WaitForTransactionReceiptResponse as a9, impersonateAccount as aA, increaseTime as aB, inspectTxpool as aC, mine as aD, removeBlockTimestampInterval as aE, reset as aF, requestAccounts as aG, requestPermissions as aH, revert as aI, sendTransaction as aJ, sendUnsignedTransaction as aK, setAutomine as aL, setBalance as aM, setBlockGasLimit as aN, setBlockTimestampInterval as aO, setCode as aP, setCoinbase as aQ, setIntervalMining as aR, setLoggingEnabled as aS, setMinGasPrice as aT, setNextBlockBaseFeePerGas as aU, setNextBlockTimestamp as aV, setNonce as aW, setStorageAt as aX, signMessage as aY, snapshot as aZ, stopImpersonatingAccount as a_, WatchAssetArgs as aa, WatchAssetResponse as ab, WatchBlockNumberArgs as ac, WatchBlocksArgs as ad, WatchPendingTransactionsArgs as ae, addChain as af, call as ag, createBlockFilter as ah, createPendingTransactionFilter as ai, estimateGas as aj, dropTransaction as ak, getAutomine as al, getBalance as am, getBlock as an, getBlockNumber as ao, getBlockTransactionCount as ap, getChainId as aq, getFeeHistory as ar, getGasPrice as as, getPermissions as at, getTransaction as au, getTransactionConfirmations as av, getTransactionCount as aw, getTransactionReceipt as ax, getTxpoolContent as ay, getTxpoolStatus as az, CreateBlockFilterResponse as b, uninstallFilter as b0, waitForTransactionReceipt as b1, watchAsset as b2, watchBlockNumber as b3, watchBlocks as b4, watchPendingTransactions as b5, getBlockNumberCache as b6, getFilterChanges as b7, ReplacementReason as b8, ReplacementResponse as b9, WaitForTransactionReceiptTimeoutError as ba, FormattedTransactionRequest as bb, InvalidGasArgumentsError as bc, CreatePendingTransactionFilterResponse as c, EstimateGasResponse as d, GetBalanceResponse as e, GetBlockArgs as f, GetBlockNumberArgs as g, GetBlockNumberResponse as h, GetBlockResponse as i, GetBlockTransactionCountArgs as j, GetBlockTransactionCountResponse as k, GetFeeHistoryArgs as l, GetFeeHistoryResponse as m, GetFilterChangesArgs as n, GetFilterChangesResponse as o, GetGasPriceResponse as p, GetPermissionsResponse as q, GetTransactionArgs as r, GetTransactionConfirmationsArgs as s, GetTransactionConfirmationsResponse as t, GetTransactionCountArgs as u, GetTransactionCountResponse as v, GetTransactionResponse as w, GetTransactionReceiptArgs as x, GetTransactionReceiptResponse as y, IncreaseTimeArgs as z };

package/dist/webSocket-14584a7e.d.ts

@@ -0,0 +1,77 @@
+import { B as BaseError } from './BaseError-7688f84e.js';
+import { e as TransportConfig, d as Transport, B as BaseRpcRequests } from './createWalletClient-c40fef16.js';
+import { k as Hash } from './rpc-655c0ba4.js';
+import { a as RpcResponse } from './rpc-3c0e3985.js';
+
+declare class UrlRequiredError extends BaseError {
+    constructor();
+}
+
+type EthereumProvider = {
+    request: BaseRpcRequests['request'];
+};
+type EthereumProviderTransportConfig<TProvider> = {
+    /** The key of the transport. */
+    key?: TransportConfig['key'];
+    /** The name of the transport. */
+    name?: TransportConfig['name'];
+    /** An EIP-1193 or equivalent provider with a "request" function. */
+    provider: TProvider;
+};
+type EthereumProviderTransport = Transport<'ethereumProvider', EthereumProvider['request']>;
+/**
+ * @description Creates a transport based on an EIP-1193 provider (eg. `window.ethereum`).
+ */
+declare function ethereumProvider<TProvider extends EthereumProvider>({ key, name, provider, }: EthereumProviderTransportConfig<TProvider>): EthereumProviderTransport;
+
+type HttpTransportConfig = {
+    /** The key of the HTTP transport. */
+    key?: TransportConfig['key'];
+    /** The name of the HTTP transport. */
+    name?: TransportConfig['name'];
+    /** URL of the JSON-RPC API. Defaults to the chain's public RPC URL. */
+    url?: string;
+};
+type HttpTransport = Transport<'http', {
+    url?: string;
+}>;
+/**
+ * @description Creates a HTTP transport that connects to a JSON-RPC API.
+ */
+declare function http({ key, name, url, }?: HttpTransportConfig): HttpTransport;
+
+type WebSocketTransportSubscribeArgs = {
+    onData: (data: RpcResponse) => void;
+    onError?: (error: any) => void;
+};
+type WebSocketTransportSubscribeResponse = {
+    subscriptionId: Hash;
+    unsubscribe: () => Promise<RpcResponse<boolean>>;
+};
+type WebSocketTransportSubscribe = {
+    subscribe(args: WebSocketTransportSubscribeArgs & {
+        /**
+         * @description Add information about compiled contracts
+         * @link https://hardhat.org/hardhat-network/docs/reference#hardhat_addcompilationresult
+         */
+        params: ['newHeads'];
+    }): Promise<WebSocketTransportSubscribeResponse>;
+};
+type WebSocketTransportConfig = {
+    /** The key of the WebSocket transport. */
+    key?: TransportConfig['key'];
+    /** The name of the WebSocket transport. */
+    name?: TransportConfig['name'];
+    /** URL of the JSON-RPC API. Defaults to the chain's public RPC URL. */
+    url?: string;
+};
+type WebSocketTransport = Transport<'webSocket', {
+    getSocket(): Promise<WebSocket>;
+    subscribe: WebSocketTransportSubscribe['subscribe'];
+}>;
+/**
+ * @description Creates a WebSocket transport that connects to a JSON-RPC API.
+ */
+declare function webSocket({ key, name, url, }?: WebSocketTransportConfig): WebSocketTransport;
+
+export { EthereumProviderTransport as E, HttpTransport as H, UrlRequiredError as U, WebSocketTransport as W, EthereumProviderTransportConfig as a, HttpTransportConfig as b, WebSocketTransportConfig as c, ethereumProvider as e, http as h, webSocket as w };

package/dist/window.d.ts

@@ -0,0 +1,9 @@
+import { R as Requests, E as Events } from './eip1193-8f7c22ce.js';
+import './rpc-655c0ba4.js';
+
+type WindowProvider = Requests & Events;
+declare global {
+    interface Window {
+        ethereum?: WindowProvider;
+    }
+}