@multiplatform.one/web3 7.23.2 → 7.25.0

package/dist/cjs/clients/evm.cjs

@@ -22,10 +22,98 @@ var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
 }), mod);
 var evm_exports = {};
 __export(evm_exports, {
+  ReceiptPendingError: () => ReceiptPendingError,
+  ReceiptWaitAbortedError: () => ReceiptWaitAbortedError,
+  TransactionReplacedError: () => TransactionReplacedError,
+  TransactionRevertedError: () => TransactionRevertedError,
+  classifyTxError: () => classifyTxError,
   evmClient: () => evmClient
 });
 module.exports = __toCommonJS(evm_exports);
 var import_viem = require("viem");
+class ReceiptPendingError extends Error {
+  constructor(hash, chainId, options) {
+    super(`${options.label ?? "transaction"} ${hash} on chain ${chainId} ${options.detail}; it may still land, so do not resend it`, {
+      cause: options.cause
+    });
+    this.hash = hash;
+    this.chainId = chainId;
+    this.name = "ReceiptPendingError";
+    this.explorerUrl = options.explorerUrl;
+    this.nonce = options.nonce;
+  }
+  hash;
+  chainId;
+  mayStillLand = true;
+  explorerUrl;
+  /** Known once the node has seen the transaction. Keep it with the hash to resume the wait. */
+  nonce;
+}
+class ReceiptWaitAbortedError extends Error {
+  constructor(hash, chainId, nonce, cause) {
+    super(`stopped waiting for transaction ${hash} on chain ${chainId}`, {
+      cause
+    });
+    this.hash = hash;
+    this.chainId = chainId;
+    this.nonce = nonce;
+    this.name = "AbortError";
+  }
+  hash;
+  chainId;
+  nonce;
+  mayStillLand = true;
+}
+class TransactionRevertedError extends Error {
+  constructor(receipt, chainId, label = "transaction") {
+    super(`${label} ${receipt.transactionHash} reverted in block ${receipt.blockNumber}`);
+    this.receipt = receipt;
+    this.chainId = chainId;
+    this.name = "TransactionRevertedError";
+    this.hash = receipt.transactionHash;
+  }
+  receipt;
+  chainId;
+  mayStillLand = false;
+  hash;
+}
+class TransactionReplacedError extends Error {
+  constructor(hash, chainId, reason, replacement) {
+    super(`transaction ${hash} was ${reason === "unmatched" ? "superseded" : reason}${replacement ? ` by ${replacement.transactionHash}` : ""}: another transaction took its nonce`);
+    this.hash = hash;
+    this.chainId = chainId;
+    this.reason = reason;
+    this.replacement = replacement;
+    this.name = "TransactionReplacedError";
+  }
+  hash;
+  chainId;
+  reason;
+  replacement;
+  mayStillLand = false;
+}
+function causes(error) {
+  const chain = [];
+  for (let e = error; e && typeof e === "object" && chain.length < 16; e = e.cause) {
+    if (chain.includes(e)) break;
+    chain.push(e);
+  }
+  return chain;
+}
+function classifyTxError(error) {
+  const chain = causes(error);
+  const pendingAt = chain.findIndex(e => e.mayStillLand === true || e.name === "WaitForTransactionReceiptTimeoutError" || e.name === "TransactionReplacedError" && e.reason === "unmatched");
+  const abortedAt = chain.findIndex(e => e.name === "AbortError" && typeof e.mayStillLand === "boolean");
+  if (abortedAt >= 0 && (pendingAt < 0 || abortedAt <= pendingAt)) return "aborted";
+  if (pendingAt >= 0) return "pending";
+  if (chain.some(e => e.name === "UserRejectedRequestError" || e.code === 4001 || e.name === "TransactionReplacedError" && e.reason === "cancelled")) {
+    return "user-rejected";
+  }
+  if (chain.some(e => e.name === "ContractFunctionRevertedError" || e.name === "ExecutionRevertedError" || e.receipt?.status === "reverted")) {
+    return "reverted";
+  }
+  return "failed";
+}
 const erc20WriteAbi = [{
   type: "function",
   name: "transfer",
@@ -86,16 +174,208 @@ function evmClient(config) {
       chain
     });
   };
-  const approveAndWait = async (token, spender, amount) => {
+  const explorer = chain.blockExplorers?.default.url.replace(/\/+$/, "");
+  const explorerTxUrl = hash => explorer ? `${explorer}/tx/${hash}` : void 0;
+  const missing = name => error => {
+    if (error?.name === name) return void 0;
+    throw error;
+  };
+  const getReceipt = hash => publicClient.getTransactionReceipt({
+    hash
+  }).catch(missing("TransactionReceiptNotFoundError"));
+  const getTransaction = hash => publicClient.getTransaction({
+    hash
+  }).catch(missing("TransactionNotFoundError"));
+  const sameAddress = (a, b) => !!a && !!b && a.toLowerCase() === b.toLowerCase();
+  const nonceBlock = async (count, nonce, taken, free) => {
+    let hi = taken;
+    let lo = -1n;
+    if (free !== void 0 && free < hi) lo = free;else {
+      for (let step = 1n; hi - step >= 0n; step *= 2n) {
+        const probe = hi - step;
+        if ((await count(probe)) <= nonce) {
+          lo = probe;
+          break;
+        }
+        hi = probe;
+      }
+    }
+    while (hi - lo > 1n) {
+      const mid = (lo + hi) / 2n;
+      if ((await count(mid)) > nonce) hi = mid;else lo = mid;
+    }
+    return {
+      block: hi,
+      free: lo >= 0n ? lo : void 0
+    };
+  };
+  const replacementReason = (taker, original) => {
+    if (original && sameAddress(taker.to, original.to) && taker.value === original.value && taker.input === original.input) {
+      return "repriced";
+    }
+    if (sameAddress(taker.to, taker.from) && taker.value === 0n) return "cancelled";
+    return original ? "replaced" : "unmatched";
+  };
+  const after = (ms, fire) => {
+    const step = 2 ** 31 - 1;
+    let cancel = () => {};
+    const arm = left => {
+      const id = setTimeout(() => left > step ? arm(left - step) : fire(), Math.min(left, step));
+      cancel = () => clearTimeout(id);
+    };
+    arm(Math.max(0, ms));
+    return () => cancel();
+  };
+  const backoff = failures => {
+    const ceiling = Math.min(3e4, Math.max(1, publicClient.pollingInterval) * 2 ** Math.min(failures - 1, 16));
+    return ceiling / 2 + Math.random() * ceiling / 2;
+  };
+  const waitForReceipt = async (hash, options = {}, label) => {
+    const {
+      signal
+    } = options;
+    const confirmations = BigInt(Math.max(1, options.confirmations ?? 1));
+    const {
+      timeout
+    } = options;
+    const deadline = timeout !== void 0 && Number.isFinite(timeout) && timeout > 0 ? Date.now() + timeout : void 0;
+    let target = hash;
+    let original;
+    let nonce = options.nonce;
+    let freeBlock;
+    let failures = 0;
+    let lastError;
+    const aborted = () => new ReceiptWaitAbortedError(hash, chain.id, nonce, signal?.reason);
+    const timedOut = () => new ReceiptPendingError(hash, chain.id, {
+      detail: `has no receipt after ${timeout} ms`,
+      explorerUrl: explorerTxUrl(hash),
+      nonce,
+      cause: lastError,
+      label
+    });
+    let ended = false;
+    const track = () => {
+      if (ended || signal?.aborted || nonce === void 0) return;
+      try {
+        options.onTrack?.({
+          hash: target,
+          nonce
+        });
+      } catch {}
+    };
+    if (signal?.aborted) throw aborted();
+    const guard = (promise, onStop = () => {}) => new Promise((resolve, reject) => {
+      let cancelTimer = () => {};
+      const cleanup = () => {
+        cancelTimer();
+        signal?.removeEventListener("abort", stop);
+      };
+      const give = error => {
+        cleanup();
+        onStop();
+        reject(error);
+      };
+      const stop = () => give(aborted());
+      promise.then(resolve, reject).finally(cleanup);
+      if (signal?.aborted) return stop();
+      signal?.addEventListener("abort", stop, {
+        once: true
+      });
+      if (deadline !== void 0) cancelTimer = after(deadline - Date.now(), () => give(timedOut()));
+    });
+    const rpc = call => {
+      if (ended || signal?.aborted) throw aborted();
+      return call();
+    };
+    const countAt = (address, blockNumber) => rpc(() => publicClient.getTransactionCount({
+      address,
+      blockNumber
+    }));
+    const poll = async () => {
+      const head = await rpc(() => publicClient.getBlockNumber({
+        cacheTime: 0
+      }));
+      const receipt = await rpc(() => getReceipt(target));
+      if (receipt) return head - receipt.blockNumber + 1n >= confirmations ? receipt : void 0;
+      if (!original) {
+        original = await rpc(() => getTransaction(target));
+        if (original && original.nonce !== nonce) {
+          nonce = original.nonce;
+          track();
+        }
+      }
+      if (nonce === void 0) return void 0;
+      const from = original?.from ?? account.address;
+      if ((await countAt(from, head)) <= nonce) {
+        freeBlock = head;
+        return void 0;
+      }
+      const found = await nonceBlock(n => countAt(from, n), nonce, head, freeBlock);
+      freeBlock = found.free;
+      const block = await rpc(() => publicClient.getBlock({
+        blockNumber: found.block,
+        includeTransactions: true
+      }));
+      const taker = block.transactions.find(tx => sameAddress(tx.from, from) && tx.nonce === nonce);
+      if (!taker || taker.hash === target) {
+        if (!taker) freeBlock = void 0;
+        return void 0;
+      }
+      const reason = replacementReason(taker, original);
+      if (reason === "repriced") {
+        target = taker.hash;
+        original = taker;
+        track();
+        return void 0;
+      }
+      if (head - found.block + 1n < confirmations) return void 0;
+      const replacement = await rpc(() => getReceipt(taker.hash));
+      throw new TransactionReplacedError(hash, chain.id, reason, replacement);
+    };
+    try {
+      for (;;) {
+        try {
+          const receipt = await guard(poll());
+          if (receipt) return receipt;
+          failures = 0;
+        } catch (error) {
+          if (error instanceof TransactionReplacedError || error instanceof ReceiptWaitAbortedError || error instanceof ReceiptPendingError) {
+            throw error;
+          }
+          lastError = error;
+          failures++;
+        }
+        if (deadline !== void 0 && Date.now() >= deadline) throw timedOut();
+        const pause = failures ? backoff(failures) : publicClient.pollingInterval;
+        let wake = () => {};
+        await guard(new Promise(resolve => {
+          wake = after(pause, () => resolve(void 0));
+        }), () => wake());
+      }
+    } finally {
+      ended = true;
+    }
+  };
+  const confirmTransaction = async (hash, options, label) => {
+    const receipt = await waitForReceipt(hash, options, label);
+    if (receipt.status !== "success") throw new TransactionRevertedError(receipt, chain.id, label);
+    return receipt;
+  };
+  const approveAndWait = async (token, spender, amount, options) => {
+    if (options.signal?.aborted) {
+      throw Object.assign(new Error("stopped before sending the approval", {
+        cause: options.signal.reason
+      }), {
+        name: "AbortError",
+        mayStillLand: false
+      });
+    }
     const hash = await erc20.approve({
       token,
       spender,
       amount
     });
-    const receipt = await publicClient.waitForTransactionReceipt({
-      hash
-    });
-    if (receipt.status !== "success") throw new Error(`approve ${hash} reverted`);
+    await confirmTransaction(hash, options, "approve");
     return hash;
   };
   const erc20 = {
@@ -137,12 +417,20 @@ function evmClient(config) {
     async ensureAllowance({
       token,
       spender,
-      amount
+      amount,
+      timeout,
+      signal
     }) {
       const current = await erc20.allowance(token, spender);
       if (current >= amount) return null;
-      if (current > 0n) await approveAndWait(token, spender, 0n);
-      return approveAndWait(token, spender, amount);
+      if (current > 0n) await approveAndWait(token, spender, 0n, {
+        timeout,
+        signal
+      });
+      return approveAndWait(token, spender, amount, {
+        timeout,
+        signal
+      });
     }
   };
   return {
@@ -163,9 +451,9 @@ function evmClient(config) {
       ...parameters
     }),
     writeContract,
-    waitForTransactionReceipt: hash => publicClient.waitForTransactionReceipt({
-      hash
-    }),
+    waitForTransactionReceipt: (hash, options) => waitForReceipt(hash, options),
+    confirmTransaction: (hash, options) => confirmTransaction(hash, options),
+    explorerTxUrl,
     erc20
   };
 }