@volr/react 0.1.21 → 0.1.22

package/dist/index.cjs

@@ -17945,6 +17945,8 @@ function http(url, config = {}) {
 // ../node_modules/viem/_esm/index.js
 init_encodeFunctionData();
 init_getAddress();
+init_formatEther();
+init_formatUnits();
 
 // src/utils/normalize.ts
 function normalizeHex(value) {
@@ -18102,112 +18104,6 @@ function normalizeCall(call2) {
 function normalizeCalls(calls) {
   return calls.map(normalizeCall);
 }
-
-// src/wallet/preflight.ts
-function extractErrorMessage(err) {
-  if (err && typeof err === "object") {
-    const e = err;
-    const parts = [];
-    if (typeof e.shortMessage === "string") parts.push(e.shortMessage);
-    if (typeof e.message === "string") parts.push(e.message);
-    if (typeof e.cause?.message === "string") parts.push(e.cause.message);
-    if (typeof e.details === "string") parts.push(e.details);
-    const msg = parts.filter(Boolean).join(" | ");
-    if (msg) return msg;
-  }
-  try {
-    return String(err);
-  } catch {
-    return "Unknown error";
-  }
-}
-function isIgnorableFundingError(err, message) {
-  const m = message.toLowerCase();
-  const e = err;
-  const name = typeof e?.name === "string" ? e.name.toLowerCase() : "";
-  if (name === "insufficientfundserror" || name.includes("insufficientfunds")) {
-    return true;
-  }
-  if (typeof e?.code === "string") {
-    const code = e.code.toLowerCase();
-    if (code.includes("execution_reverted") || code.includes("call_exception")) {
-      return false;
-    }
-    if (code.includes("insufficient_funds")) {
-      return true;
-    }
-  }
-  const fundingPatterns = [
-    "insufficient funds for gas * price",
-    "insufficient funds for gas",
-    "for gas * price + value",
-    "not enough funds for l1 fee",
-    "insufficient funds for l1 fee",
-    "insufficient balance for gas",
-    "account balance too low"
-  ];
-  const hasFundingPattern = fundingPatterns.some((pattern) => m.includes(pattern));
-  const hasRevertIndicator = m.includes("revert") || m.includes("execution reverted") || m.includes("call exception") || m.includes("vm execution error");
-  return hasFundingPattern && !hasRevertIndicator;
-}
-async function preflightEstimate(publicClient, from14, calls, opts) {
-  for (let i = 0; i < calls.length; i++) {
-    const c = calls[i];
-    try {
-      await publicClient.estimateGas({
-        account: from14,
-        to: c.target,
-        data: c.data,
-        value: c.value ?? 0n
-      });
-    } catch (e) {
-      const message = extractErrorMessage(e);
-      const tolerateFunding = opts?.tolerateFundingErrors !== false;
-      const isFundingError = isIgnorableFundingError(e, message);
-      if (tolerateFunding && isFundingError) {
-        try {
-          await publicClient.call({
-            account: from14,
-            to: c.target,
-            data: c.data,
-            value: c.value ?? 0n
-          });
-          console.log(
-            `[preflightEstimate] Ignoring funding error for call #${i} (target ${c.target}): ${message}`
-          );
-          continue;
-        } catch (callError) {
-          const callMessage = extractErrorMessage(callError);
-          console.error(
-            `[preflightEstimate] Static call after funding error also failed for call #${i} (target ${c.target}):`,
-            {
-              originalError: { message, errorName: e?.name, errorCode: e?.code },
-              callError: {
-                message: callMessage,
-                name: callError?.name,
-                code: callError?.code
-              }
-            }
-          );
-          throw new Error(
-            `Preflight failed (call #${i} target ${c.target}): ${callMessage}`
-          );
-        }
-      }
-      console.error(
-        `[preflightEstimate] Preflight failed for call #${i} (target ${c.target}):`,
-        {
-          message,
-          errorName: e?.name,
-          errorCode: e?.code,
-          isFundingError,
-          tolerateFunding
-        }
-      );
-      throw new Error(`Preflight failed (call #${i} target ${c.target}): ${message}`);
-    }
-  }
-}
 async function resolveSigner(input) {
   const { explicitSigner, provider, chainId, client, user, setProvider } = input;
   if (explicitSigner) {
@@ -18304,6 +18200,40 @@ function finalizeAuthWithNonce(tempAuth, quote) {
 }
 
 // src/utils/tx-polling.ts
+function extractFailureReason(response) {
+  const reasons = [];
+  const meta = response.meta;
+  if (meta) {
+    if (typeof meta.revertReason === "string" && meta.revertReason) {
+      reasons.push(meta.revertReason);
+    }
+    if (typeof meta.failureReason === "string" && meta.failureReason) {
+      reasons.push(meta.failureReason);
+    }
+    const diag = meta.developerDiagnostics;
+    if (diag) {
+      if (typeof diag.revertReason === "string" && diag.revertReason) {
+        reasons.push(diag.revertReason);
+      }
+      if (typeof diag.error === "string" && diag.error) {
+        reasons.push(diag.error);
+      }
+      const simErrors = diag.simulationErrors;
+      if (Array.isArray(simErrors)) {
+        for (const err of simErrors) {
+          if (typeof err.error === "string") {
+            reasons.push(`Simulation error: ${err.error}`);
+          }
+        }
+      }
+    }
+  }
+  const uniqueReasons = [...new Set(reasons)];
+  if (uniqueReasons.length > 0) {
+    return uniqueReasons.join("; ");
+  }
+  return "Transaction failed on-chain (no specific reason provided)";
+}
 async function pollTransactionStatus(txId, client, maxAttempts = 60, intervalMs = 5e3) {
   for (let attempt = 0; attempt < maxAttempts; attempt++) {
     try {
@@ -18320,15 +18250,17 @@ async function pollTransactionStatus(txId, client, maxAttempts = 60, intervalMs
         };
       }
       if (status === "FAILED") {
-        console.error(`[pollTransactionStatus] Transaction ${txId} failed`);
-        const diag = response.meta?.developerDiagnostics;
-        if (diag) {
-          console.error("[volr][relay] developerDiagnostics:", diag);
+        const failureReason = extractFailureReason(response);
+        console.error(`[pollTransactionStatus] Transaction ${txId} failed: ${failureReason}`);
+        const meta = response.meta;
+        if (meta) {
+          console.error("[pollTransactionStatus] Full meta:", JSON.stringify(meta, null, 2));
         }
         return {
           txId,
           status: "FAILED",
-          txHash
+          txHash,
+          reason: failureReason
         };
       }
       console.log(`[pollTransactionStatus] Transaction ${txId} is ${status}, attempt ${attempt + 1}/${maxAttempts}`);
@@ -18378,19 +18310,6 @@ async function sendCalls(args) {
       keyStorageType: deps.user?.keyStorageType
     });
   }
-  if (opts.preflight !== false) {
-    console.log("[sendCalls] Running preflight estimate...");
-    const tolerateFundingErrors = (opts.mode ?? "sponsored") !== "self";
-    await preflightEstimate(
-      deps.publicClient,
-      normalizedFrom,
-      normalizedCalls,
-      { tolerateFundingErrors }
-    );
-    console.log("[sendCalls] Preflight estimate done");
-  } else {
-    console.log("[sendCalls] Preflight skipped");
-  }
   console.log("[sendCalls] Building temp auth for first precheck...");
   const tempAuthForPrecheck = buildTempAuth({
     chainId,
@@ -18406,11 +18325,34 @@ async function sendCalls(args) {
       auth: tempAuthForPrecheck,
       calls: normalizedCalls
     });
-    console.log("[sendCalls] First precheck done, policyId:", precheckQuote.policyId);
+    console.log("[sendCalls] First precheck done:", {
+      policyId: precheckQuote.policyId,
+      simulationSuccess: precheckQuote.simulationSuccess,
+      estimatedGasPerCall: precheckQuote.estimatedGasPerCall
+    });
   } catch (err) {
     console.error("[sendCalls] First precheck failed:", err);
     throw err instanceof Error ? err : new Error(String(err));
   }
+  if (precheckQuote.simulationSuccess === false && precheckQuote.simulationErrors?.length) {
+    const errors = precheckQuote.simulationErrors;
+    console.error("[sendCalls] Backend simulation failed:", errors);
+    const errorMessages = errors.map(
+      (e) => `Call #${e.index}: ${e.error}${e.revertData ? ` (data: ${e.revertData})` : ""}`
+    ).join("; ");
+    throw new Error(`Transaction simulation failed: ${errorMessages}`);
+  }
+  if (precheckQuote.estimatedGasPerCall?.length) {
+    console.log("[sendCalls] Applying estimated gas limits from backend...");
+    for (let i = 0; i < normalizedCalls.length && i < precheckQuote.estimatedGasPerCall.length; i++) {
+      const estimatedGas = BigInt(precheckQuote.estimatedGasPerCall[i] ?? "0");
+      const currentGas = normalizedCalls[i]?.gasLimit ?? 0n;
+      if (estimatedGas > currentGas) {
+        console.log(`[sendCalls] Call #${i}: updating gasLimit from ${currentGas} to ${estimatedGas}`);
+        normalizedCalls[i].gasLimit = estimatedGas;
+      }
+    }
+  }
   const quotePolicyId = precheckQuote.policyId;
   if (!quotePolicyId) {
     throw new Error("Backend did not return policyId in precheck response");
@@ -18423,6 +18365,7 @@ async function sendCalls(args) {
     from: normalizedFrom,
     policyId: projectPolicyId,
     calls: normalizedCalls,
+    // Now with updated gas limits
     expiresInSec: opts.expiresInSec ?? DEFAULT_EXPIRES_IN_SEC
   });
   let quote;
@@ -19390,6 +19333,219 @@ async function uploadBlobViaPresign(params) {
   }
   return { s3Key };
 }
+
+// src/utils/contract-analysis.ts
+var EIP7702_PREFIX = "0xef0100";
+async function isEIP7702Delegated(publicClient, address) {
+  try {
+    const code = await publicClient.getCode({ address });
+    if (!code || code === "0x" || code.length < 8) {
+      return false;
+    }
+    return code.toLowerCase().startsWith(EIP7702_PREFIX);
+  } catch {
+    return false;
+  }
+}
+async function analyzeContractForEIP7702(publicClient, target, calldata) {
+  const notes = [];
+  let isContract = false;
+  let codeSize = 0;
+  let mayCheckSenderCode = false;
+  let mayUseDelegationGuard = false;
+  try {
+    const code = await publicClient.getCode({ address: target });
+    isContract = !!code && code !== "0x";
+    codeSize = code ? (code.length - 2) / 2 : 0;
+    if (!isContract || !code) {
+      notes.push("Target is not a contract (EOA or empty address)");
+    } else {
+      const codeLower = code.toLowerCase();
+      if (codeLower.includes("3b")) {
+        mayCheckSenderCode = true;
+        notes.push("Contract contains EXTCODESIZE opcode - may check msg.sender.code.length");
+      }
+      if (codeLower.includes("ef0100")) {
+        mayUseDelegationGuard = true;
+        notes.push("Contract contains EIP-7702 prefix bytes - may use DelegationGuard pattern");
+      }
+    }
+  } catch (error) {
+    notes.push(`Failed to fetch contract code: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+  const functionSelector = calldata && calldata.length >= 10 ? calldata.slice(0, 10) : "0x";
+  return {
+    target,
+    isContract,
+    codeSize,
+    mayCheckSenderCode,
+    mayUseDelegationGuard,
+    functionSelector,
+    notes
+  };
+}
+async function diagnoseTransactionFailure(publicClient, from14, target, calldata) {
+  const recommendations = [];
+  const fromCode = await publicClient.getCode({ address: from14 });
+  const fromHasCode = !!fromCode && fromCode !== "0x";
+  const fromIsDelegated = await isEIP7702Delegated(publicClient, from14);
+  const targetAnalysis = await analyzeContractForEIP7702(publicClient, target, calldata);
+  if (!targetAnalysis.isContract) {
+    recommendations.push("Target is not a contract. Verify the target address is correct.");
+  }
+  if (targetAnalysis.mayCheckSenderCode) {
+    recommendations.push(
+      "Target contract may check msg.sender.code.length. This can cause issues because in EIP-7702, the sender EOA temporarily has code."
+    );
+  }
+  if (targetAnalysis.mayUseDelegationGuard) {
+    recommendations.push(
+      "Target contract may use DelegationGuard pattern to block EIP-7702 delegated accounts. This is a security measure some contracts use. You may need to contact the contract developers or use a different approach."
+    );
+  }
+  if (!fromIsDelegated && fromHasCode) {
+    recommendations.push(
+      "Sender address has code but is not EIP-7702 delegated. This may indicate the address is a contract, not an EOA."
+    );
+  }
+  if (recommendations.length === 0) {
+    recommendations.push(
+      "No obvious EIP-7702 compatibility issues detected. The failure may be due to contract logic (e.g., insufficient balance, invalid parameters). Check the contract's requirements and your transaction parameters."
+    );
+  }
+  return {
+    fromAnalysis: {
+      isDelegated: fromIsDelegated,
+      hasCode: fromHasCode
+    },
+    targetAnalysis,
+    recommendations
+  };
+}
+
+// src/utils/wallet-debug.ts
+async function getWalletState(publicClient, address) {
+  const [balance, code, nonce] = await Promise.all([
+    publicClient.getBalance({ address }),
+    publicClient.getCode({ address }),
+    publicClient.getTransactionCount({ address })
+  ]);
+  const hasCode = !!code && code !== "0x";
+  const codeLength = code ? (code.length - 2) / 2 : 0;
+  const isEIP7702Delegated2 = hasCode && code.toLowerCase().startsWith("0xef0100");
+  return {
+    address,
+    ethBalance: formatEther(balance),
+    ethBalanceWei: balance,
+    hasCode,
+    codeLength,
+    nonce,
+    isEIP7702Delegated: isEIP7702Delegated2
+  };
+}
+async function getERC20Balance(publicClient, walletAddress, tokenAddress, decimals = 18) {
+  const balance = await publicClient.readContract({
+    address: tokenAddress,
+    abi: [
+      {
+        name: "balanceOf",
+        type: "function",
+        stateMutability: "view",
+        inputs: [{ name: "account", type: "address" }],
+        outputs: [{ type: "uint256" }]
+      }
+    ],
+    functionName: "balanceOf",
+    args: [walletAddress]
+  });
+  return {
+    address: walletAddress,
+    tokenAddress,
+    balance: formatUnits(balance, decimals),
+    balanceRaw: balance,
+    decimals
+  };
+}
+async function compareWalletStates(publicClient, address1, address2) {
+  const [wallet1, wallet2] = await Promise.all([
+    getWalletState(publicClient, address1),
+    getWalletState(publicClient, address2)
+  ]);
+  const differences = [];
+  if (wallet1.hasCode !== wallet2.hasCode) {
+    differences.push(
+      `Code presence differs: ${address1} has ${wallet1.hasCode ? "code" : "no code"}, ${address2} has ${wallet2.hasCode ? "code" : "no code"}`
+    );
+  }
+  if (wallet1.isEIP7702Delegated !== wallet2.isEIP7702Delegated) {
+    differences.push(
+      `EIP-7702 delegation differs: ${address1} is ${wallet1.isEIP7702Delegated ? "" : "not "}delegated, ${address2} is ${wallet2.isEIP7702Delegated ? "" : "not "}delegated`
+    );
+  }
+  const balanceDiff = wallet1.ethBalanceWei - wallet2.ethBalanceWei;
+  if (balanceDiff !== 0n) {
+    differences.push(
+      `ETH balance differs by ${formatEther(balanceDiff > 0n ? balanceDiff : -balanceDiff)} ETH`
+    );
+  }
+  return { wallet1, wallet2, differences };
+}
+async function compareERC20Balances(publicClient, address1, address2, tokenAddress, decimals = 18) {
+  const [wallet1, wallet2] = await Promise.all([
+    getERC20Balance(publicClient, address1, tokenAddress, decimals),
+    getERC20Balance(publicClient, address2, tokenAddress, decimals)
+  ]);
+  const differenceRaw = wallet1.balanceRaw - wallet2.balanceRaw;
+  return {
+    wallet1,
+    wallet2,
+    difference: formatUnits(differenceRaw > 0n ? differenceRaw : -differenceRaw, decimals),
+    differenceRaw
+  };
+}
+async function debugTransactionFailure(publicClient, failingWallet, workingWallet, tokenAddress, tokenDecimals = 18) {
+  const analysis = [];
+  const stateComparison = await compareWalletStates(
+    publicClient,
+    failingWallet,
+    workingWallet
+  );
+  if (stateComparison.wallet1.isEIP7702Delegated && !stateComparison.wallet2.isEIP7702Delegated) {
+    analysis.push(
+      "The failing wallet has EIP-7702 delegation while the working wallet does not. This may cause issues if the target contract checks msg.sender.code.length or uses DelegationGuard."
+    );
+  }
+  if (stateComparison.wallet1.hasCode && !stateComparison.wallet2.hasCode) {
+    analysis.push(
+      "The failing wallet has code while the working wallet is a pure EOA. Some contracts reject calls from addresses with code."
+    );
+  }
+  let tokenComparison;
+  if (tokenAddress) {
+    tokenComparison = await compareERC20Balances(
+      publicClient,
+      failingWallet,
+      workingWallet,
+      tokenAddress,
+      tokenDecimals
+    );
+    if (tokenComparison.wallet1.balanceRaw < tokenComparison.wallet2.balanceRaw) {
+      analysis.push(
+        `The failing wallet has less token balance (${tokenComparison.wallet1.balance}) than the working wallet (${tokenComparison.wallet2.balance}). Ensure sufficient balance for the transaction.`
+      );
+    }
+  }
+  if (analysis.length === 0) {
+    analysis.push(
+      "No obvious differences found between wallets. The issue may be related to contract-specific state (e.g., positions, allowances, whitelists) or transaction parameters."
+    );
+  }
+  return {
+    stateComparison,
+    tokenComparison,
+    analysis
+  };
+}
 /*! Bundled license information:
 
 @noble/hashes/esm/utils.js:
@@ -19435,11 +19591,19 @@ Object.defineProperty(exports, "uploadBlob", {
 exports.DEFAULT_EXPIRES_IN_SEC = DEFAULT_EXPIRES_IN_SEC;
 exports.DEFAULT_MODE = DEFAULT_MODE;
 exports.VolrProvider = VolrProvider;
+exports.analyzeContractForEIP7702 = analyzeContractForEIP7702;
 exports.buildCall = buildCall;
 exports.buildCalls = buildCalls;
+exports.compareERC20Balances = compareERC20Balances;
+exports.compareWalletStates = compareWalletStates;
 exports.createGetNetworkInfo = createGetNetworkInfo;
 exports.createPasskeyAdapter = createPasskeyAdapter;
+exports.debugTransactionFailure = debugTransactionFailure;
 exports.defaultIdempotencyKey = defaultIdempotencyKey;
+exports.diagnoseTransactionFailure = diagnoseTransactionFailure;
+exports.getERC20Balance = getERC20Balance;
+exports.getWalletState = getWalletState;
+exports.isEIP7702Delegated = isEIP7702Delegated;
 exports.normalizeHex = normalizeHex;
 exports.normalizeHexArray = normalizeHexArray;
 exports.uploadBlobViaPresign = uploadBlobViaPresign;