viem 0.0.1-alpha.14 → 0.0.1-alpha.16

package/dist/{chunk-DUNJAMH5.mjs → chunk-B7A2CAHU.mjs}

@@ -1,15 +1,15 @@
 import {
-  BaseError,
+  sendTransaction
+} from "./chunk-KCMYVU3Z.mjs";
+import {
   BlockNotFoundError,
   InvalidGasArgumentsError,
   TransactionNotFoundError,
   TransactionReceiptNotFoundError,
   WaitForTransactionReceiptTimeoutError,
-  checksumAddress,
   decodeFunctionResult,
   encodeDeployData,
   encodeFunctionData,
-  encodeHex,
   extract,
   format,
   formatBlock,
@@ -18,14 +18,13 @@ import {
   formatTransaction,
   formatTransactionReceipt,
   formatTransactionRequest,
-  getAddress,
   getCache,
   getContractError,
   hexToNumber,
   numberToHex,
   wait,
   withCache
-} from "./chunk-KB6CBNKW.mjs";
+} from "./chunk-KM6AFT2K.mjs";
 
 // src/actions/public/call.ts
 async function call(client, {
@@ -126,135 +125,6 @@ async function createBlockFilter(client) {
   return { id, type: "block" };
 }
 
-// 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,
-  from,
-  accessList,
-  data,
-  gas,
-  gasPrice,
-  maxFeePerGas,
-  maxPriorityFeePerGas,
-  nonce,
-  to,
-  value,
-  ...rest
-}) {
-  if (maxFeePerGas !== void 0 && maxPriorityFeePerGas !== void 0 && maxFeePerGas < maxPriorityFeePerGas)
-    throw new InvalidGasArgumentsError();
-  const formatter = chain?.formatters?.transactionRequest;
-  const request_ = format(
-    {
-      from,
-      accessList,
-      data,
-      gas,
-      gasPrice,
-      maxFeePerGas,
-      maxPriorityFeePerGas,
-      nonce,
-      to,
-      value,
-      ...extract(rest, { formatter })
-    },
-    {
-      formatter: formatter || formatTransactionRequest
-    }
-  );
-  const hash = await client.request({
-    method: "eth_sendTransaction",
-    params: [request_]
-  });
-  return hash;
-}
-
-// 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/deployContract.ts
 function deployContract(walletClient, { abi, args, bytecode, ...request }) {
   const calldata = encodeDeployData({
@@ -561,98 +431,6 @@ function observe(observerId, callbacks, fn) {
   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;
-      }
-    );
-  });
-}
-
 // src/utils/poll.ts
 function poll(fn, { emitOnBegin, initialWaitTime, interval }) {
   let active = true;
@@ -829,223 +607,95 @@ function watchPendingTransactions(client, {
   });
 }
 
-// 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]
+// 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;
+      }
+    );
   });
 }
 
@@ -1054,15 +704,6 @@ export {
   callContract,
   createPendingTransactionFilter,
   createBlockFilter,
-  addChain,
-  getAccounts,
-  getPermissions,
-  requestAccounts,
-  requestPermissions,
-  sendTransaction,
-  signMessage,
-  switchChain,
-  watchAsset,
   deployContract,
   estimateGas,
   getBalance,
@@ -1084,32 +725,6 @@ export {
   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
+  watchPendingTransactions
 };
+//# sourceMappingURL=chunk-B7A2CAHU.mjs.map