viem 0.0.0 → 0.0.1-alpha.0

package/dist/chunk-JSYJDK4W.js

@@ -0,0 +1,1032 @@
+import {
+  BaseError,
+  __publicField,
+  checksumAddress,
+  encodeHex,
+  format,
+  formatBlock,
+  formatFeeHistory,
+  formatLog,
+  formatTransaction,
+  formatTransactionReceipt,
+  formatTransactionRequest,
+  getAddress,
+  getCache,
+  hexToNumber,
+  numberToHex,
+  wait,
+  withCache
+} from "./chunk-GI67STNV.js";
+
+// src/actions/wallet/addChain.ts
+async function addChain(client, chain) {
+  const { id, name, nativeCurrency, rpcUrls, blockExplorers } = chain;
+  await client.request({
+    method: "wallet_addEthereumChain",
+    params: [
+      {
+        chainId: numberToHex(id),
+        chainName: name,
+        nativeCurrency,
+        rpcUrls: rpcUrls.default.http,
+        blockExplorerUrls: blockExplorers ? Object.values(blockExplorers).map(({ url }) => url) : void 0
+      }
+    ]
+  });
+}
+
+// src/actions/wallet/getAccounts.ts
+async function getAccounts(client) {
+  const addresses = await client.request({ method: "eth_accounts" });
+  return addresses.map((address) => checksumAddress(address));
+}
+
+// src/actions/wallet/getPermissions.ts
+async function getPermissions(client) {
+  const permissions = await client.request({ method: "wallet_getPermissions" });
+  return permissions;
+}
+
+// src/actions/wallet/requestAccounts.ts
+async function requestAccounts(client) {
+  const addresses = await client.request({ method: "eth_requestAccounts" });
+  return addresses.map((address) => getAddress(address));
+}
+
+// src/actions/wallet/requestPermissions.ts
+async function requestPermissions(client, permissions) {
+  return client.request({
+    method: "wallet_requestPermissions",
+    params: [permissions]
+  });
+}
+
+// src/actions/wallet/sendTransaction.ts
+async function sendTransaction(client, { chain, request }) {
+  if (request.maxFeePerGas !== void 0 && request.maxPriorityFeePerGas !== void 0 && request.maxFeePerGas < request.maxPriorityFeePerGas)
+    throw new InvalidGasArgumentsError();
+  const request_ = format(request, {
+    formatter: chain?.formatters?.transactionRequest || formatTransactionRequest
+  });
+  const hash = await client.request({
+    method: "eth_sendTransaction",
+    params: [request_]
+  });
+  return { hash };
+}
+var InvalidGasArgumentsError = class extends BaseError {
+  constructor() {
+    super("`maxFeePerGas` cannot be less than `maxPriorityFeePerGas`");
+    __publicField(this, "name", "InvalidGasArgumentsError");
+  }
+};
+
+// src/actions/wallet/signMessage.ts
+async function signMessage(client, { from, data: data_ }) {
+  let data;
+  if (typeof data_ === "string") {
+    if (!data_.startsWith("0x"))
+      throw new BaseError(
+        `data ("${data_}") must be a hex value. Encode it first to a hex with the \`encodeHex\` util.`,
+        {
+          docsPath: "/TODO"
+        }
+      );
+    data = data_;
+  } else {
+    data = encodeHex(data_);
+  }
+  const signed = await client.request({
+    method: "personal_sign",
+    params: [data, from]
+  });
+  return signed;
+}
+
+// src/actions/wallet/switchChain.ts
+async function switchChain(client, { id }) {
+  await client.request({
+    method: "wallet_switchEthereumChain",
+    params: [
+      {
+        chainId: numberToHex(id)
+      }
+    ]
+  });
+}
+
+// src/actions/wallet/watchAsset.ts
+async function watchAsset(client, params) {
+  const added = await client.request({
+    method: "wallet_watchAsset",
+    params: [params]
+  });
+  return added;
+}
+
+// src/actions/public/call.ts
+async function call(client, { blockNumber, blockTag = "latest", chain, request }) {
+  if (request.maxFeePerGas !== void 0 && request.maxPriorityFeePerGas !== void 0 && request.maxFeePerGas < request.maxPriorityFeePerGas)
+    throw new InvalidGasArgumentsError();
+  const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
+  const request_ = format(request, {
+    formatter: chain?.formatters?.transactionRequest || formatTransactionRequest
+  });
+  const data = await client.request({
+    method: "eth_call",
+    params: [request_, blockNumberHex || blockTag]
+  });
+  if (data === "0x")
+    return { data: void 0 };
+  return { data };
+}
+
+// src/actions/public/createPendingTransactionFilter.ts
+async function createPendingTransactionFilter(client) {
+  const id = await client.request({
+    method: "eth_newPendingTransactionFilter"
+  });
+  return { id, type: "transaction" };
+}
+
+// src/actions/public/createBlockFilter.ts
+async function createBlockFilter(client) {
+  const id = await client.request({
+    method: "eth_newBlockFilter"
+  });
+  return { id, type: "block" };
+}
+
+// src/actions/public/estimateGas.ts
+async function estimateGas(client, {
+  blockNumber,
+  blockTag = "latest",
+  request: {
+    data,
+    from,
+    gas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    to,
+    value
+  }
+}) {
+  const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
+  const parameters = {
+    data,
+    from,
+    gas: gas ? numberToHex(gas) : void 0,
+    gasPrice: gasPrice ? numberToHex(gasPrice) : void 0,
+    maxFeePerGas: maxFeePerGas ? numberToHex(maxFeePerGas) : void 0,
+    maxPriorityFeePerGas: maxPriorityFeePerGas ? numberToHex(maxPriorityFeePerGas) : void 0,
+    to,
+    value: value ? numberToHex(value) : void 0
+  };
+  const balance = await client.request({
+    method: "eth_estimateGas",
+    params: [parameters, blockNumberHex || blockTag]
+  });
+  return BigInt(balance);
+}
+
+// src/actions/public/getBalance.ts
+async function getBalance(client, { address, blockNumber, blockTag = "latest" }) {
+  const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
+  const balance = await client.request({
+    method: "eth_getBalance",
+    params: [address, blockNumberHex || blockTag]
+  });
+  return BigInt(balance);
+}
+
+// src/actions/public/getBlock.ts
+async function getBlock(client, {
+  blockHash,
+  blockNumber,
+  blockTag = "latest",
+  includeTransactions = false
+} = {}) {
+  const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
+  let block = null;
+  if (blockHash) {
+    block = await client.request({
+      method: "eth_getBlockByHash",
+      params: [blockHash, includeTransactions]
+    });
+  } else {
+    block = await client.request({
+      method: "eth_getBlockByNumber",
+      params: [blockNumberHex || blockTag, includeTransactions]
+    });
+  }
+  if (!block)
+    throw new BlockNotFoundError({ blockHash, blockNumber });
+  return format(block, {
+    formatter: client.chain?.formatters?.block || formatBlock
+  });
+}
+var BlockNotFoundError = class extends BaseError {
+  constructor({
+    blockHash,
+    blockNumber
+  }) {
+    let identifier = "Block";
+    if (blockHash)
+      identifier = `Block at hash "${blockHash}"`;
+    if (blockNumber)
+      identifier = `Block at number "${blockNumber}"`;
+    super(`${identifier} could not be found.`);
+    __publicField(this, "name", "BlockNotFoundError");
+  }
+};
+
+// src/actions/public/getBlockNumber.ts
+var cacheKey = (id) => `blockNumber.${id}`;
+function getBlockNumberCache(id) {
+  return getCache(cacheKey(id));
+}
+async function getBlockNumber(client, { maxAge = client.pollingInterval } = {}) {
+  const blockNumberHex = await withCache(
+    () => client.request({
+      method: "eth_blockNumber"
+    }),
+    { cacheKey: cacheKey(client.uid), maxAge }
+  );
+  return BigInt(blockNumberHex);
+}
+
+// src/actions/public/getBlockTransactionCount.ts
+async function getBlockTransactionCount(client, {
+  blockHash,
+  blockNumber,
+  blockTag = "latest"
+} = {}) {
+  const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
+  let count = null;
+  if (blockHash) {
+    count = await client.request({
+      method: "eth_getBlockTransactionCountByHash",
+      params: [blockHash]
+    });
+  } else {
+    count = await client.request({
+      method: "eth_getBlockTransactionCountByNumber",
+      params: [blockNumberHex || blockTag]
+    });
+  }
+  return hexToNumber(count);
+}
+
+// src/actions/public/getChainId.ts
+async function getChainId(client) {
+  const chainIdHex = await client.request({ method: "eth_chainId" });
+  return hexToNumber(chainIdHex);
+}
+
+// src/actions/public/getFeeHistory.ts
+async function getFeeHistory(client, {
+  blockCount,
+  blockNumber,
+  blockTag = "latest",
+  rewardPercentiles
+}) {
+  const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
+  const feeHistory = await client.request({
+    method: "eth_feeHistory",
+    params: [
+      numberToHex(blockCount),
+      blockNumberHex || blockTag,
+      rewardPercentiles
+    ]
+  });
+  return formatFeeHistory(feeHistory);
+}
+
+// src/actions/public/getFilterChanges.ts
+async function getFilterChanges(client, { filter }) {
+  const logs = await client.request({
+    method: "eth_getFilterChanges",
+    params: [filter.id]
+  });
+  return logs.map(
+    (log) => typeof log === "string" ? log : formatLog(log)
+  );
+}
+
+// src/actions/public/getGasPrice.ts
+async function getGasPrice(client) {
+  const gasPrice = await client.request({
+    method: "eth_gasPrice"
+  });
+  return BigInt(gasPrice);
+}
+
+// src/actions/public/getTransaction.ts
+async function getTransaction(client, {
+  blockHash,
+  blockNumber,
+  blockTag = "latest",
+  hash,
+  index
+}) {
+  const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
+  let transaction = null;
+  if (hash) {
+    transaction = await client.request({
+      method: "eth_getTransactionByHash",
+      params: [hash]
+    });
+  } else if (blockHash) {
+    transaction = await client.request({
+      method: "eth_getTransactionByBlockHashAndIndex",
+      params: [blockHash, numberToHex(index)]
+    });
+  } else if (blockNumberHex || blockTag) {
+    transaction = await client.request({
+      method: "eth_getTransactionByBlockNumberAndIndex",
+      params: [blockNumberHex || blockTag, numberToHex(index)]
+    });
+  }
+  if (!transaction)
+    throw new TransactionNotFoundError({
+      blockHash,
+      blockNumber,
+      blockTag,
+      hash,
+      index
+    });
+  return format(transaction, {
+    formatter: client.chain?.formatters?.transaction || formatTransaction
+  });
+}
+var TransactionNotFoundError = class extends BaseError {
+  constructor({
+    blockHash,
+    blockNumber,
+    blockTag,
+    hash,
+    index
+  }) {
+    let identifier = "Transaction";
+    if (blockTag && index !== void 0)
+      identifier = `Transaction at block time "${blockTag}" at index "${index}"`;
+    if (blockHash && index !== void 0)
+      identifier = `Transaction at block hash "${blockHash}" at index "${index}"`;
+    if (blockNumber && index !== void 0)
+      identifier = `Transaction at block number "${blockNumber}" at index "${index}"`;
+    if (hash)
+      identifier = `Transaction with hash "${hash}"`;
+    super(`${identifier} could not be found.`);
+    __publicField(this, "name", "TransactionNotFoundError");
+  }
+};
+
+// src/actions/public/getTransactionConfirmations.ts
+async function getTransactionConfirmations(client, { hash, transactionReceipt }) {
+  const [blockNumber, transaction] = await Promise.all([
+    getBlockNumber(client),
+    hash ? getTransaction(client, { hash }) : void 0
+  ]);
+  const transactionBlockNumber = transactionReceipt?.blockNumber || transaction?.blockNumber;
+  if (!transactionBlockNumber)
+    return 0n;
+  return blockNumber - transactionBlockNumber + 1n;
+}
+
+// src/actions/public/getTransactionCount.ts
+async function getTransactionCount(client, { address, blockTag = "latest", blockNumber }) {
+  const count = await client.request({
+    method: "eth_getTransactionCount",
+    params: [address, blockNumber ? numberToHex(blockNumber) : blockTag]
+  });
+  return hexToNumber(count ?? "0x0");
+}
+
+// src/actions/public/getTransactionReceipt.ts
+async function getTransactionReceipt(client, { hash }) {
+  const receipt = await client.request({
+    method: "eth_getTransactionReceipt",
+    params: [hash]
+  });
+  if (!receipt)
+    throw new TransactionReceiptNotFoundError({ hash });
+  return format(receipt, {
+    formatter: client.chain?.formatters?.transactionReceipt || formatTransactionReceipt
+  });
+}
+var TransactionReceiptNotFoundError = class extends BaseError {
+  constructor({ hash }) {
+    super(
+      `Transaction receipt with hash "${hash}" could not be found. The Transaction may not be processed on a block yet.`
+    );
+    __publicField(this, "name", "TransactionReceiptNotFoundError");
+  }
+};
+
+// src/actions/public/uninstallFilter.ts
+async function uninstallFilter(client, { filter }) {
+  return client.request({
+    method: "eth_uninstallFilter",
+    params: [filter.id]
+  });
+}
+
+// src/utils/observe.ts
+var listenersCache = /* @__PURE__ */ new Map();
+var cleanupCache = /* @__PURE__ */ new Map();
+var callbackCount = 0;
+function observe(observerId, callbacks, fn) {
+  const callbackId = ++callbackCount;
+  const getListeners = () => listenersCache.get(observerId) || [];
+  const unsubscribe = () => {
+    const listeners2 = getListeners();
+    listenersCache.set(
+      observerId,
+      listeners2.filter((cb) => cb.id !== callbackId)
+    );
+  };
+  const unwatch = () => {
+    const cleanup2 = cleanupCache.get(observerId);
+    if (getListeners().length === 1 && cleanup2)
+      cleanup2();
+    unsubscribe();
+  };
+  const listeners = getListeners();
+  listenersCache.set(observerId, [
+    ...listeners,
+    { id: callbackId, fns: callbacks }
+  ]);
+  if (listeners && listeners.length > 0)
+    return unwatch;
+  let emit = {};
+  for (const key in callbacks) {
+    emit[key] = (...args) => {
+      const listeners2 = getListeners();
+      if (listeners2.length === 0)
+        return;
+      listeners2.forEach((listener) => listener.fns[key]?.(...args));
+    };
+  }
+  const cleanup = fn(emit);
+  if (typeof cleanup === "function")
+    cleanupCache.set(observerId, cleanup);
+  return unwatch;
+}
+
+// src/actions/public/waitForTransactionReceipt.ts
+async function waitForTransactionReceipt(client, {
+  confirmations = 1,
+  hash,
+  onReplaced,
+  pollingInterval = client.pollingInterval,
+  timeout
+}) {
+  const observerId = JSON.stringify([
+    "waitForTransactionReceipt",
+    client.uid,
+    hash
+  ]);
+  let transaction;
+  let replacedTransaction;
+  let receipt;
+  return new Promise((resolve, reject) => {
+    if (timeout)
+      setTimeout(
+        () => reject(new WaitForTransactionReceiptTimeoutError({ hash })),
+        timeout
+      );
+    const unobserve = observe(
+      observerId,
+      { onReplaced, resolve, reject },
+      (emit) => {
+        const unwatch = watchBlockNumber(client, {
+          emitMissed: true,
+          emitOnBegin: true,
+          pollingInterval,
+          async onBlockNumber(blockNumber) {
+            const done = async (fn) => {
+              unwatch();
+              fn();
+              unobserve();
+            };
+            try {
+              if (receipt) {
+                if (blockNumber - receipt.blockNumber + 1n < confirmations)
+                  return;
+                done(() => emit.resolve(receipt));
+                return;
+              }
+              transaction = await getTransaction(client, { hash });
+              receipt = await getTransactionReceipt(client, { hash });
+              if (blockNumber - receipt.blockNumber + 1n < confirmations)
+                return;
+              done(() => emit.resolve(receipt));
+            } catch (err) {
+              if (transaction && (err instanceof TransactionNotFoundError || err instanceof TransactionReceiptNotFoundError)) {
+                replacedTransaction = transaction;
+                const block = await getBlock(client, {
+                  blockNumber,
+                  includeTransactions: true
+                });
+                const replacementTransaction = block.transactions.find(
+                  ({ from, nonce }) => from === replacedTransaction.from && nonce === replacedTransaction.nonce
+                );
+                if (!replacementTransaction)
+                  return;
+                receipt = await getTransactionReceipt(client, {
+                  hash: replacementTransaction.hash
+                });
+                if (blockNumber - receipt.blockNumber + 1n < confirmations)
+                  return;
+                let reason = "replaced";
+                if (replacementTransaction.to === replacedTransaction.to && replacementTransaction.value === replacedTransaction.value) {
+                  reason = "repriced";
+                } else if (replacementTransaction.from === replacementTransaction.to && replacementTransaction.value === 0n) {
+                  reason = "cancelled";
+                }
+                done(() => {
+                  emit.onReplaced?.({
+                    reason,
+                    replacedTransaction,
+                    transaction: replacementTransaction,
+                    transactionReceipt: receipt
+                  });
+                  emit.resolve(receipt);
+                });
+              } else {
+                done(() => emit.reject(err));
+              }
+            }
+          }
+        });
+        return unwatch;
+      }
+    );
+  });
+}
+var WaitForTransactionReceiptTimeoutError = class extends BaseError {
+  constructor({ hash }) {
+    super(
+      `Timed out while waiting for transaction with hash "${hash}" to be confirmed.`
+    );
+    __publicField(this, "name", "WaitForTransactionReceiptTimeoutError");
+  }
+};
+
+// src/utils/poll.ts
+function poll(fn, { emitOnBegin, initialWaitTime, interval }) {
+  let active = true;
+  const unwatch = () => active = false;
+  const watch = async () => {
+    let data;
+    if (emitOnBegin)
+      data = await fn({ unpoll: unwatch });
+    const initialWait = await initialWaitTime?.(data) ?? interval;
+    await wait(initialWait);
+    const poll2 = async () => {
+      if (!active)
+        return;
+      await fn({ unpoll: unwatch });
+      await wait(interval);
+      poll2();
+    };
+    poll2();
+  };
+  watch();
+  return unwatch;
+}
+
+// src/actions/public/watchBlockNumber.ts
+function watchBlockNumber(client, {
+  emitOnBegin = false,
+  emitMissed = false,
+  onBlockNumber,
+  onError,
+  pollingInterval = client.pollingInterval
+}) {
+  const observerId = JSON.stringify([
+    "watchBlockNumber",
+    client.uid,
+    emitOnBegin,
+    emitMissed,
+    pollingInterval
+  ]);
+  let prevBlockNumber;
+  return observe(
+    observerId,
+    { onBlockNumber, onError },
+    (emit) => poll(
+      async () => {
+        try {
+          const blockNumber = await getBlockNumber(client, { maxAge: 0 });
+          if (prevBlockNumber) {
+            if (blockNumber === prevBlockNumber)
+              return;
+            if (blockNumber - prevBlockNumber > 1 && emitMissed) {
+              for (let i = prevBlockNumber + 1n; i < blockNumber; i++) {
+                emit.onBlockNumber(i, prevBlockNumber);
+                prevBlockNumber = i;
+              }
+            }
+          }
+          prevBlockNumber = blockNumber;
+          emit.onBlockNumber(blockNumber, prevBlockNumber);
+        } catch (err) {
+          emit.onError?.(err);
+        }
+      },
+      {
+        emitOnBegin,
+        interval: pollingInterval
+      }
+    )
+  );
+}
+
+// src/actions/public/watchBlocks.ts
+function watchBlocks(client, {
+  blockTag = "latest",
+  emitMissed = false,
+  emitOnBegin = false,
+  onBlock,
+  onError,
+  includeTransactions = false,
+  pollingInterval = client.pollingInterval
+}) {
+  const observerId = JSON.stringify([
+    "watchBlocks",
+    client.uid,
+    emitMissed,
+    emitOnBegin,
+    includeTransactions,
+    pollingInterval
+  ]);
+  let prevBlock;
+  return observe(
+    observerId,
+    { onBlock, onError },
+    (emit) => poll(
+      async () => {
+        try {
+          const block = await getBlock(client, {
+            blockTag,
+            includeTransactions
+          });
+          if (block.number && prevBlock?.number) {
+            if (block.number === prevBlock.number)
+              return;
+            if (block.number - prevBlock.number > 1 && emitMissed) {
+              for (let i = prevBlock?.number + 1n; i < block.number; i++) {
+                const block2 = await getBlock(client, {
+                  blockNumber: i,
+                  includeTransactions
+                });
+                emit.onBlock(block2, prevBlock);
+                prevBlock = block2;
+              }
+            }
+          }
+          emit.onBlock(block, prevBlock);
+          prevBlock = block;
+        } catch (err) {
+          emit.onError?.(err);
+        }
+      },
+      {
+        emitOnBegin,
+        interval: pollingInterval
+      }
+    )
+  );
+}
+
+// src/actions/public/watchPendingTransactions.ts
+function watchPendingTransactions(client, {
+  batch = true,
+  onError,
+  onTransactions,
+  pollingInterval = client.pollingInterval
+}) {
+  const observerId = JSON.stringify([
+    "watchPendingTransactions",
+    client.uid,
+    batch,
+    pollingInterval
+  ]);
+  return observe(observerId, { onTransactions, onError }, (emit) => {
+    let filter;
+    const unwatch = poll(
+      async () => {
+        try {
+          if (!filter) {
+            try {
+              filter = await createPendingTransactionFilter(client);
+              return;
+            } catch (err) {
+              unwatch();
+              throw err;
+            }
+          }
+          const hashes = await getFilterChanges(client, { filter });
+          if (batch)
+            emit.onTransactions(hashes);
+          else
+            hashes.forEach((hash) => emit.onTransactions([hash]));
+        } catch (err) {
+          emit.onError?.(err);
+        }
+      },
+      {
+        emitOnBegin: true,
+        interval: pollingInterval
+      }
+    );
+    return async () => {
+      if (filter)
+        await uninstallFilter(client, { filter });
+      unwatch();
+    };
+  });
+}
+
+// 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: hexToNumber(pending),
+    queued: hexToNumber(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: [numberToHex(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: [numberToHex(blocks), numberToHex(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_ = formatTransactionRequest(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, numberToHex(value)]
+  });
+}
+
+// src/actions/test/setBlockGasLimit.ts
+async function setBlockGasLimit(client, { gasLimit }) {
+  return await client.request({
+    method: "evm_setBlockGasLimit",
+    params: [numberToHex(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: [numberToHex(gasPrice)]
+  });
+}
+
+// src/actions/test/setNextBlockBaseFeePerGas.ts
+async function setNextBlockBaseFeePerGas(client, { baseFeePerGas }) {
+  return await client.request({
+    method: `${client.mode}_setNextBlockBaseFeePerGas`,
+    params: [numberToHex(baseFeePerGas)]
+  });
+}
+
+// src/actions/test/setNextBlockTimestamp.ts
+async function setNextBlockTimestamp(client, { timestamp }) {
+  return await client.request({
+    method: `evm_setNextBlockTimestamp`,
+    params: [numberToHex(timestamp)]
+  });
+}
+
+// src/actions/test/setNonce.ts
+async function setNonce(client, { address, nonce }) {
+  return await client.request({
+    method: `${client.mode}_setNonce`,
+    params: [address, numberToHex(nonce)]
+  });
+}
+
+// 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" ? numberToHex(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]
+  });
+}
+
+export {
+  addChain,
+  getAccounts,
+  getPermissions,
+  requestAccounts,
+  requestPermissions,
+  sendTransaction,
+  signMessage,
+  switchChain,
+  watchAsset,
+  call,
+  createPendingTransactionFilter,
+  createBlockFilter,
+  estimateGas,
+  getBalance,
+  getBlock,
+  getBlockNumberCache,
+  getBlockNumber,
+  getBlockTransactionCount,
+  getChainId,
+  getFeeHistory,
+  getFilterChanges,
+  getGasPrice,
+  getTransaction,
+  getTransactionConfirmations,
+  getTransactionCount,
+  getTransactionReceipt,
+  uninstallFilter,
+  waitForTransactionReceipt,
+  watchBlockNumber,
+  watchBlocks,
+  watchPendingTransactions,
+  dropTransaction,
+  getAutomine,
+  getTxpoolContent,
+  getTxpoolStatus,
+  impersonateAccount,
+  increaseTime,
+  inspectTxpool,
+  mine,
+  removeBlockTimestampInterval,
+  reset,
+  revert,
+  sendUnsignedTransaction,
+  setAutomine,
+  setBalance,
+  setBlockGasLimit,
+  setBlockTimestampInterval,
+  setCode,
+  setCoinbase,
+  setIntervalMining,
+  setLoggingEnabled,
+  setMinGasPrice,
+  setNextBlockBaseFeePerGas,
+  setNextBlockTimestamp,
+  setNonce,
+  setStorageAt,
+  snapshot,
+  stopImpersonatingAccount
+};