viem 0.0.1-alpha.9 → 0.0.1-sushi.25

package/dist/public.js

@@ -0,0 +1,58 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkN2P6N5MLjs = require('./chunk-N2P6N5ML.js');
+require('./chunk-LBSHIBU7.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.call = _chunkN2P6N5MLjs.call; exports.createBlockFilter = _chunkN2P6N5MLjs.createBlockFilter; exports.createPendingTransactionFilter = _chunkN2P6N5MLjs.createPendingTransactionFilter; exports.estimateGas = _chunkN2P6N5MLjs.estimateGas; exports.getBalance = _chunkN2P6N5MLjs.getBalance; exports.getBlock = _chunkN2P6N5MLjs.getBlock; exports.getBlockNumber = _chunkN2P6N5MLjs.getBlockNumber; exports.getBlockNumberCache = _chunkN2P6N5MLjs.getBlockNumberCache; exports.getBlockTransactionCount = _chunkN2P6N5MLjs.getBlockTransactionCount; exports.getBytecode = _chunkN2P6N5MLjs.getBytecode; exports.getChainId = _chunkN2P6N5MLjs.getChainId; exports.getFeeHistory = _chunkN2P6N5MLjs.getFeeHistory; exports.getFilterChanges = _chunkN2P6N5MLjs.getFilterChanges; exports.getFilterLogs = _chunkN2P6N5MLjs.getFilterLogs; exports.getGasPrice = _chunkN2P6N5MLjs.getGasPrice; exports.getLogs = _chunkN2P6N5MLjs.getLogs; exports.getTransaction = _chunkN2P6N5MLjs.getTransaction; exports.getTransactionConfirmations = _chunkN2P6N5MLjs.getTransactionConfirmations; exports.getTransactionCount = _chunkN2P6N5MLjs.getTransactionCount; exports.getTransactionReceipt = _chunkN2P6N5MLjs.getTransactionReceipt; exports.uninstallFilter = _chunkN2P6N5MLjs.uninstallFilter; exports.waitForTransactionReceipt = _chunkN2P6N5MLjs.waitForTransactionReceipt; exports.watchBlockNumber = _chunkN2P6N5MLjs.watchBlockNumber; exports.watchBlocks = _chunkN2P6N5MLjs.watchBlocks; exports.watchEvent = _chunkN2P6N5MLjs.watchEvent; exports.watchPendingTransactions = _chunkN2P6N5MLjs.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-P73S5JV4.mjs";
+import "./chunk-ZRHPJRBJ.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 };

package/dist/test.d.ts

@@ -0,0 +1,161 @@
+import { a as Hash, o as RpcTransaction, A as Address, Q as Quantity, s as TransactionRequest, H as Hex } from './chain-f16512e8.js';
+import { T as TestClient } from './createTestClient-dedf321e.js';
+import '@wagmi/chains';
+import './eip1193-6f9ba163.js';
+import './createClient-68ee4bb4.js';
+
+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 = TransactionRequest;
+type SendUnsignedTransactionResponse = Hash;
+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>;
+
+declare function setRpcUrl(client: TestClient, jsonRpcUrl: string): 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>;
+
+export { DropTransactionArgs, ImpersonateAccountArgs, IncreaseTimeArgs, MineArgs, ResetArgs, RevertArgs, SendUnsignedTransactionArgs, SendUnsignedTransactionResponse, SetBalanceArgs, SetBlockGasLimitArgs, SetBlockTimestampIntervalArgs, SetCodeArgs, SetCoinbaseArgs, SetIntervalMiningArgs, SetMinGasPriceArgs, SetNextBlockBaseFeePerGasArgs, SetNextBlockTimestampArgs, SetNonceArgs, SetStorageAtArgs, StopImpersonatingAccountArgs, dropTransaction, getAutomine, getTxpoolContent, getTxpoolStatus, impersonateAccount, increaseTime, inspectTxpool, mine, removeBlockTimestampInterval, reset, revert, sendUnsignedTransaction, setAutomine, setBalance, setBlockGasLimit, setBlockTimestampInterval, setCode, setCoinbase, setIntervalMining, setLoggingEnabled, setMinGasPrice, setNextBlockBaseFeePerGas, setNextBlockTimestamp, setNonce, setRpcUrl, setStorageAt, snapshot, stopImpersonatingAccount };

package/dist/test.js

@@ -0,0 +1,264 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+var _chunkLBSHIBU7js = require('./chunk-LBSHIBU7.js');
+
+// src/actions/test/dropTransaction.ts
+async function dropTransaction(client, { hash }) {
+  return await client.request({
+    method: `${client.mode}_dropTransaction`,
+    params: [hash]
+  });
+}
+
+// src/actions/test/getAutomine.ts
+async function getAutomine(client) {
+  return await client.request({
+    method: `${client.mode}_getAutomine`
+  });
+}
+
+// src/actions/test/getTxpoolContent.ts
+async function getTxpoolContent(client) {
+  return await client.request({
+    method: "txpool_content"
+  });
+}
+
+// src/actions/test/getTxpoolStatus.ts
+async function getTxpoolStatus(client) {
+  const { pending, queued } = await client.request({
+    method: "txpool_status"
+  });
+  return {
+    pending: _chunkLBSHIBU7js.hexToNumber.call(void 0, pending),
+    queued: _chunkLBSHIBU7js.hexToNumber.call(void 0, queued)
+  };
+}
+
+// src/actions/test/impersonateAccount.ts
+async function impersonateAccount(client, { address }) {
+  return await client.request({
+    method: `${client.mode}_impersonateAccount`,
+    params: [address]
+  });
+}
+
+// src/actions/test/increaseTime.ts
+async function increaseTime(client, { seconds }) {
+  return await client.request({
+    method: "evm_increaseTime",
+    params: [_chunkLBSHIBU7js.numberToHex.call(void 0, seconds)]
+  });
+}
+
+// src/actions/test/inspectTxpool.ts
+async function inspectTxpool(client) {
+  return await client.request({
+    method: "txpool_inspect"
+  });
+}
+
+// src/actions/test/mine.ts
+async function mine(client, { blocks, interval }) {
+  return await client.request({
+    method: `${client.mode}_mine`,
+    params: [_chunkLBSHIBU7js.numberToHex.call(void 0, blocks), _chunkLBSHIBU7js.numberToHex.call(void 0, interval || 0)]
+  });
+}
+
+// src/actions/test/removeBlockTimestampInterval.ts
+async function removeBlockTimestampInterval(client) {
+  return await client.request({
+    method: `${client.mode}_removeBlockTimestampInterval`
+  });
+}
+
+// src/actions/test/reset.ts
+async function reset(client, { blockNumber, jsonRpcUrl } = {}) {
+  return await client.request({
+    method: `${client.mode}_reset`,
+    params: [{ forking: { blockNumber: Number(blockNumber), jsonRpcUrl } }]
+  });
+}
+
+// src/actions/test/revert.ts
+async function revert(client, { id }) {
+  return await client.request({
+    method: "evm_revert",
+    params: [id]
+  });
+}
+
+// src/actions/test/sendUnsignedTransaction.ts
+async function sendUnsignedTransaction(client, request) {
+  const request_ = _chunkLBSHIBU7js.formatTransactionRequest.call(void 0, request);
+  const hash = await client.request({
+    method: "eth_sendUnsignedTransaction",
+    params: [request_]
+  });
+  return hash;
+}
+
+// src/actions/test/setAutomine.ts
+async function setAutomine(client, enabled) {
+  return await client.request({
+    method: "evm_setAutomine",
+    params: [enabled]
+  });
+}
+
+// src/actions/test/setBalance.ts
+async function setBalance(client, { address, value }) {
+  return await client.request({
+    method: `${client.mode}_setBalance`,
+    params: [address, _chunkLBSHIBU7js.numberToHex.call(void 0, value)]
+  });
+}
+
+// src/actions/test/setBlockGasLimit.ts
+async function setBlockGasLimit(client, { gasLimit }) {
+  return await client.request({
+    method: "evm_setBlockGasLimit",
+    params: [_chunkLBSHIBU7js.numberToHex.call(void 0, gasLimit)]
+  });
+}
+
+// src/actions/test/setBlockTimestampInterval.ts
+async function setBlockTimestampInterval(client, { interval }) {
+  return await client.request({
+    method: `${client.mode}_setBlockTimestampInterval`,
+    params: [interval]
+  });
+}
+
+// src/actions/test/setCode.ts
+async function setCode(client, { address, bytecode }) {
+  return await client.request({
+    method: `${client.mode}_setCode`,
+    params: [address, bytecode]
+  });
+}
+
+// src/actions/test/setCoinbase.ts
+async function setCoinbase(client, { address }) {
+  return await client.request({
+    method: `${client.mode}_setCoinbase`,
+    params: [address]
+  });
+}
+
+// src/actions/test/setIntervalMining.ts
+async function setIntervalMining(client, { interval }) {
+  return await client.request({
+    method: "evm_setIntervalMining",
+    params: [interval]
+  });
+}
+
+// src/actions/test/setLoggingEnabled.ts
+async function setLoggingEnabled(client, enabled) {
+  return await client.request({
+    method: `${client.mode}_setLoggingEnabled`,
+    params: [enabled]
+  });
+}
+
+// src/actions/test/setMinGasPrice.ts
+async function setMinGasPrice(client, { gasPrice }) {
+  return await client.request({
+    method: `${client.mode}_setMinGasPrice`,
+    params: [_chunkLBSHIBU7js.numberToHex.call(void 0, gasPrice)]
+  });
+}
+
+// src/actions/test/setNextBlockBaseFeePerGas.ts
+async function setNextBlockBaseFeePerGas(client, { baseFeePerGas }) {
+  return await client.request({
+    method: `${client.mode}_setNextBlockBaseFeePerGas`,
+    params: [_chunkLBSHIBU7js.numberToHex.call(void 0, baseFeePerGas)]
+  });
+}
+
+// src/actions/test/setNextBlockTimestamp.ts
+async function setNextBlockTimestamp(client, { timestamp }) {
+  return await client.request({
+    method: "evm_setNextBlockTimestamp",
+    params: [_chunkLBSHIBU7js.numberToHex.call(void 0, timestamp)]
+  });
+}
+
+// src/actions/test/setNonce.ts
+async function setNonce(client, { address, nonce }) {
+  return await client.request({
+    method: `${client.mode}_setNonce`,
+    params: [address, _chunkLBSHIBU7js.numberToHex.call(void 0, nonce)]
+  });
+}
+
+// src/actions/test/setRpcUrl.ts
+async function setRpcUrl(client, jsonRpcUrl) {
+  return await client.request({
+    method: `${client.mode}_setRpcUrl`,
+    params: [jsonRpcUrl]
+  });
+}
+
+// src/actions/test/setStorageAt.ts
+async function setStorageAt(client, { address, index, value }) {
+  return await client.request({
+    method: `${client.mode}_setStorageAt`,
+    params: [
+      address,
+      typeof index === "number" ? _chunkLBSHIBU7js.numberToHex.call(void 0, index) : index,
+      value
+    ]
+  });
+}
+
+// src/actions/test/snapshot.ts
+async function snapshot(client) {
+  return await client.request({
+    method: "evm_snapshot"
+  });
+}
+
+// src/actions/test/stopImpersonatingAccount.ts
+async function stopImpersonatingAccount(client, { address }) {
+  return await client.request({
+    method: `${client.mode}_stopImpersonatingAccount`,
+    params: [address]
+  });
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.dropTransaction = dropTransaction; exports.getAutomine = getAutomine; exports.getTxpoolContent = getTxpoolContent; exports.getTxpoolStatus = getTxpoolStatus; exports.impersonateAccount = impersonateAccount; exports.increaseTime = increaseTime; exports.inspectTxpool = inspectTxpool; exports.mine = mine; exports.removeBlockTimestampInterval = removeBlockTimestampInterval; exports.reset = reset; exports.revert = revert; exports.sendUnsignedTransaction = sendUnsignedTransaction; exports.setAutomine = setAutomine; exports.setBalance = setBalance; exports.setBlockGasLimit = setBlockGasLimit; exports.setBlockTimestampInterval = setBlockTimestampInterval; exports.setCode = setCode; exports.setCoinbase = setCoinbase; exports.setIntervalMining = setIntervalMining; exports.setLoggingEnabled = setLoggingEnabled; exports.setMinGasPrice = setMinGasPrice; exports.setNextBlockBaseFeePerGas = setNextBlockBaseFeePerGas; exports.setNextBlockTimestamp = setNextBlockTimestamp; exports.setNonce = setNonce; exports.setRpcUrl = setRpcUrl; exports.setStorageAt = setStorageAt; exports.snapshot = snapshot; exports.stopImpersonatingAccount = stopImpersonatingAccount;
+//# sourceMappingURL=test.js.map