@volr/react 0.1.20 → 0.1.22

package/dist/index.cjs

@@ -9330,6 +9330,21 @@ var APIClient = class {
   }
 };
 
+// src/config/backend.ts
+var DEFAULT_API_BASE_URL = "https://api.volr.io";
+function resolveApiBaseUrl(config) {
+  const anyConfig = config;
+  const devOverride = anyConfig.__devApiBaseUrl;
+  if (devOverride && typeof devOverride === "string") {
+    return devOverride.replace(/\/+$/, "");
+  }
+  const override = anyConfig.apiBaseUrl;
+  if (override && typeof override === "string") {
+    return override.replace(/\/+$/, "");
+  }
+  return DEFAULT_API_BASE_URL;
+}
+
 // src/headless/auth-sync.ts
 var SessionSync = class {
   constructor() {
@@ -9343,11 +9358,12 @@ var SessionSync = class {
     }
     if (typeof window !== "undefined") {
       window.addEventListener("storage", (e) => {
-        if (e.key === STORAGE_KEYS.accessToken || e.key === STORAGE_KEYS.user) {
+        if (e.key === STORAGE_KEYS.accessToken || e.key === STORAGE_KEYS.refreshToken || e.key === STORAGE_KEYS.user) {
           this.notifyListeners({
             type: "REFRESH",
             payload: {
-              accessToken: safeStorage.getItem(STORAGE_KEYS.accessToken) || ""
+              accessToken: safeStorage.getItem(STORAGE_KEYS.accessToken) || "",
+              refreshToken: safeStorage.getItem(STORAGE_KEYS.refreshToken)
             }
           });
         }
@@ -9401,19 +9417,63 @@ var SessionSync = class {
   }
 };
 
-// src/config/backend.ts
-var DEFAULT_API_BASE_URL = "https://api.volr.io";
-function resolveApiBaseUrl(config) {
-  const anyConfig = config;
-  const devOverride = anyConfig.__devApiBaseUrl;
-  if (devOverride && typeof devOverride === "string") {
-    return devOverride.replace(/\/+$/, "");
-  }
-  const override = anyConfig.apiBaseUrl;
-  if (override && typeof override === "string") {
-    return override.replace(/\/+$/, "");
-  }
-  return DEFAULT_API_BASE_URL;
+// src/react/hooks/useSessionSync.ts
+function useSessionSync({
+  client,
+  config,
+  setAccessTokenState,
+  setRefreshTokenState,
+  setUser,
+  setProviderState
+}) {
+  const syncRef = react.useRef(null);
+  react.useEffect(() => {
+    syncRef.current = new SessionSync();
+    const unsubscribe = syncRef.current.subscribe((event) => {
+      if (event.type === "LOGIN") {
+        client.setAccessToken(event.payload.accessToken);
+        setAccessTokenState(event.payload.accessToken);
+        client.setRefreshToken(event.payload.refreshToken);
+        setRefreshTokenState(event.payload.refreshToken);
+        setUser(event.payload.user);
+        safeStorage.setItem(
+          STORAGE_KEYS.user,
+          JSON.stringify(event.payload.user)
+        );
+        client.setApiKey(config.projectApiKey);
+      } else if (event.type === "LOGOUT") {
+        client.setAccessToken(null);
+        client.setRefreshToken(null);
+        setAccessTokenState(null);
+        setRefreshTokenState(null);
+        setUser(null);
+        setProviderState(null);
+        safeStorage.removeItem(STORAGE_KEYS.user);
+        safeStorage.removeItem(STORAGE_KEYS.provider);
+      } else if (event.type === "REFRESH") {
+        client.setAccessToken(event.payload.accessToken);
+        setAccessTokenState(event.payload.accessToken);
+        if (event.payload.refreshToken) {
+          client.setRefreshToken(event.payload.refreshToken);
+          setRefreshTokenState(event.payload.refreshToken);
+        }
+      } else if (event.type === "PROVIDER_SET") {
+        setUser(
+          (prev) => prev ? {
+            ...prev,
+            keyStorageType: event.payload.keyStorageType,
+            address: event.payload.address
+          } : null
+        );
+        safeStorage.setItem(STORAGE_KEYS.provider, event.payload.keyStorageType);
+      }
+    });
+    return () => {
+      unsubscribe();
+      syncRef.current?.destroy();
+    };
+  }, [client, config.projectApiKey, setAccessTokenState, setRefreshTokenState, setUser, setProviderState]);
+  return syncRef;
 }
 
 // src/config/webauthn.ts
@@ -9676,6 +9736,120 @@ async function restorePasskey(params) {
     provider
   };
 }
+
+// src/react/hooks/useAutoRecover.ts
+function useAutoRecover({
+  client,
+  config,
+  setAccessTokenState,
+  setRefreshTokenState,
+  setUser,
+  setProviderState,
+  setProvider,
+  setIsLoading
+}) {
+  const REQUIRE_USER_GESTURE_TO_RESTORE = true;
+  const hasRecoveredRef = react.useRef(false);
+  const restorationAttemptedRef = react.useRef(false);
+  react.useEffect(() => {
+    if (config.autoRecoverOnLogin !== false && !hasRecoveredRef.current) {
+      hasRecoveredRef.current = true;
+      const recover = async () => {
+        try {
+          setIsLoading(true);
+          if (!client.getRefreshToken()) {
+            console.log("[Provider] No refresh token found, skipping auto-recover");
+            setIsLoading(false);
+            return;
+          }
+          const refreshedUser = await client.refreshSession();
+          console.log("[Provider] Session refreshed, user:", refreshedUser);
+          setAccessTokenState(client.getAccessToken());
+          setRefreshTokenState(client.getRefreshToken());
+          if (refreshedUser) {
+            setUser(refreshedUser);
+            if (!REQUIRE_USER_GESTURE_TO_RESTORE) ; else if (refreshedUser.keyStorageType === "passkey") {
+              console.log("[Provider] TTL=0 mode: Provider restoration deferred");
+              if (!refreshedUser.blobUrl || !refreshedUser.prfInput) {
+                console.warn("[Provider] Passkey user missing blobUrl or prfInput");
+              }
+            }
+          } else {
+            const userStr = safeStorage.getItem(STORAGE_KEYS.user);
+            if (userStr) {
+              try {
+                setUser(JSON.parse(userStr));
+              } catch {
+                safeStorage.removeItem(STORAGE_KEYS.user);
+              }
+            }
+          }
+        } catch {
+          client.setAccessToken(null);
+          client.setRefreshToken(null);
+          setAccessTokenState(null);
+          setRefreshTokenState(null);
+          setUser(null);
+          setProviderState(null);
+          safeStorage.removeItem(STORAGE_KEYS.user);
+          safeStorage.removeItem(STORAGE_KEYS.provider);
+        } finally {
+          setIsLoading(false);
+        }
+      };
+      recover();
+    } else {
+      setIsLoading(false);
+    }
+  }, [client, config.autoRecoverOnLogin, setAccessTokenState, setRefreshTokenState, setUser, setProviderState, setProvider, setIsLoading]);
+}
+function useWalletEvents({
+  user,
+  logout,
+  setUser,
+  setProviderState
+}) {
+  react.useEffect(() => {
+    if (!user) return;
+    if (typeof window === "undefined" || !window.ethereum) {
+      return;
+    }
+    const ethereum = window.ethereum;
+    const handleAccountsChanged = (accounts) => {
+      console.log("[Provider] accountsChanged event:", accounts);
+      if (accounts.length === 0) {
+        console.warn("[Provider] Wallet disconnected, logging out...");
+        setTimeout(() => logout(), 3e3);
+      } else if (user.evmAddress && accounts[0].toLowerCase() !== user.evmAddress.toLowerCase()) {
+        console.warn("[Provider] Account changed, logging out in 3 seconds...");
+        setTimeout(() => logout(), 3e3);
+      }
+    };
+    const handleChainChanged = (chainIdHex) => {
+      const newChainId = parseInt(chainIdHex, 16);
+      console.log("[Provider] chainChanged event:", newChainId);
+      setUser(
+        (prev) => prev ? { ...prev, lastWalletChainId: newChainId } : null
+      );
+      window.location.reload();
+    };
+    const handleDisconnect = () => {
+      console.log("[Provider] disconnect event");
+      setProviderState(null);
+      safeStorage.removeItem(STORAGE_KEYS.provider);
+    };
+    ethereum.on("accountsChanged", handleAccountsChanged);
+    ethereum.on("chainChanged", handleChainChanged);
+    ethereum.on("disconnect", handleDisconnect);
+    return () => {
+      ethereum.removeListener("accountsChanged", handleAccountsChanged);
+      ethereum.removeListener("chainChanged", handleChainChanged);
+      ethereum.removeListener("disconnect", handleDisconnect);
+    };
+  }, [user, logout, setUser, setProviderState]);
+}
+
+// src/utils/json.ts
 function serializeBigIntDeep(obj) {
   if (obj === null || obj === void 0) {
     return obj;
@@ -9697,8 +9871,62 @@ function serializeBigIntDeep(obj) {
   }
   return obj;
 }
+
+// src/react/hooks/useVolrActions.ts
+function useVolrActions({
+  client,
+  setError
+}) {
+  const precheck = react.useCallback(
+    async (input) => {
+      try {
+        setError(null);
+        await client.ensureAccessToken();
+        const response = await client.post(
+          "/wallet/precheck",
+          input
+        );
+        return response.quote;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error("Precheck failed");
+        const diag = err?.response?.data?.error?.developerDiagnostics;
+        if (diag) {
+          console.error("[volr][precheck] developerDiagnostics:", diag);
+        }
+        setError(error);
+        throw error;
+      }
+    },
+    [client, setError]
+  );
+  const relay = react.useCallback(
+    async (input, opts) => {
+      try {
+        setError(null);
+        await client.ensureAccessToken();
+        const idempotencyKey = opts?.idempotencyKey ?? (typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : `${Date.now()}-${Math.random()}`);
+        const serializedInput = serializeBigIntDeep(input);
+        const response = await client.post(
+          "/wallet/relay",
+          serializedInput,
+          idempotencyKey
+        );
+        return response;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error("Relay failed");
+        const diag = err?.response?.data?.error?.developerDiagnostics;
+        if (diag) {
+          console.error("[volr][relay] developerDiagnostics:", diag);
+        }
+        setError(error);
+        throw error;
+      }
+    },
+    [client, setError]
+  );
+  return { precheck, relay };
+}
 function VolrProvider({ config, children }) {
-  const REQUIRE_USER_GESTURE_TO_RESTORE = true;
   const providerCountRef = react.useRef(0);
   react.useEffect(() => {
     providerCountRef.current++;
@@ -9747,45 +9975,14 @@ function VolrProvider({ config, children }) {
   const [refreshToken, setRefreshTokenState] = react.useState(() => {
     return client.getRefreshToken();
   });
-  const syncRef = react.useRef(null);
-  react.useEffect(() => {
-    syncRef.current = new SessionSync();
-    const unsubscribe = syncRef.current.subscribe((event) => {
-      if (event.type === "LOGIN") {
-        client.setAccessToken(event.payload.accessToken);
-        setAccessTokenState(event.payload.accessToken);
-        setUser(event.payload.user);
-        safeStorage.setItem(
-          STORAGE_KEYS.user,
-          JSON.stringify(event.payload.user)
-        );
-        client.setApiKey(config.projectApiKey);
-      } else if (event.type === "LOGOUT") {
-        client.setAccessToken(null);
-        client.setRefreshToken(null);
-        setAccessTokenState(null);
-        setRefreshTokenState(null);
-        setUser(null);
-        setProviderState(null);
-        safeStorage.removeItem(STORAGE_KEYS.user);
-        safeStorage.removeItem(STORAGE_KEYS.provider);
-      } else if (event.type === "REFRESH") {
-        client.setAccessToken(event.payload.accessToken);
-        setAccessTokenState(event.payload.accessToken);
-      } else if (event.type === "PROVIDER_SET") {
-        setUser((prev) => ({
-          ...prev,
-          keyStorageType: event.payload.keyStorageType,
-          address: event.payload.address
-        }));
-        safeStorage.setItem(STORAGE_KEYS.provider, event.payload.keyStorageType);
-      }
-    });
-    return () => {
-      unsubscribe();
-      syncRef.current?.destroy();
-    };
-  }, [client, config.projectApiKey]);
+  const syncRef = useSessionSync({
+    client,
+    config,
+    setAccessTokenState,
+    setRefreshTokenState,
+    setUser,
+    setProviderState
+  });
   const setProvider = react.useCallback(
     async (newProvider) => {
       try {
@@ -9817,108 +10014,22 @@ function VolrProvider({ config, children }) {
         throw error2;
       }
     },
-    [client, user]
-  );
-  const hasRecoveredRef = react.useRef(false);
-  const restorationAttemptedRef = react.useRef(false);
-  react.useEffect(() => {
-    if (config.autoRecoverOnLogin !== false && !hasRecoveredRef.current) {
-      hasRecoveredRef.current = true;
-      const recover = async () => {
-        try {
-          setIsLoading(true);
-          if (!client.getRefreshToken()) {
-            console.log("[Provider] No refresh token found, skipping auto-recover");
-            setIsLoading(false);
-            return;
-          }
-          const refreshedUser = await client.refreshSession();
-          console.log("[Provider] Session refreshed, user:", refreshedUser);
-          setAccessTokenState(client.getAccessToken());
-          setRefreshTokenState(client.getRefreshToken());
-          if (refreshedUser) {
-            setUser(refreshedUser);
-            if (!REQUIRE_USER_GESTURE_TO_RESTORE) ; else if (refreshedUser.keyStorageType === "passkey") {
-              console.log("[Provider] TTL=0 mode: Provider restoration deferred");
-              if (!refreshedUser.blobUrl || !refreshedUser.prfInput) {
-                console.warn("[Provider] Passkey user missing blobUrl or prfInput");
-              }
-            }
-          } else {
-            const userStr = safeStorage.getItem(STORAGE_KEYS.user);
-            if (userStr) {
-              try {
-                setUser(JSON.parse(userStr));
-              } catch {
-                safeStorage.removeItem(STORAGE_KEYS.user);
-              }
-            }
-          }
-        } catch {
-          client.setAccessToken(null);
-          client.setRefreshToken(null);
-          setAccessTokenState(null);
-          setRefreshTokenState(null);
-          setUser(null);
-          setProviderState(null);
-          safeStorage.removeItem(STORAGE_KEYS.user);
-          safeStorage.removeItem(STORAGE_KEYS.provider);
-        } finally {
-          setIsLoading(false);
-        }
-      };
-      recover();
-    } else {
-      setIsLoading(false);
-    }
-  }, [client, config.autoRecoverOnLogin]);
-  const precheck = react.useCallback(
-    async (input) => {
-      try {
-        setError(null);
-        await client.ensureAccessToken();
-        const response = await client.post(
-          "/wallet/precheck",
-          input
-        );
-        return response.quote;
-      } catch (err) {
-        const error2 = err instanceof Error ? err : new Error("Precheck failed");
-        const diag = err?.response?.data?.error?.developerDiagnostics;
-        if (diag) {
-          console.error("[volr][precheck] developerDiagnostics:", diag);
-        }
-        setError(error2);
-        throw error2;
-      }
-    },
-    [client]
-  );
-  const relay = react.useCallback(
-    async (input, opts) => {
-      try {
-        setError(null);
-        await client.ensureAccessToken();
-        const idempotencyKey = opts?.idempotencyKey ?? (typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : `${Date.now()}-${Math.random()}`);
-        const serializedInput = serializeBigIntDeep(input);
-        const response = await client.post(
-          "/wallet/relay",
-          serializedInput,
-          idempotencyKey
-        );
-        return response;
-      } catch (err) {
-        const error2 = err instanceof Error ? err : new Error("Relay failed");
-        const diag = err?.response?.data?.error?.developerDiagnostics;
-        if (diag) {
-          console.error("[volr][relay] developerDiagnostics:", diag);
-        }
-        setError(error2);
-        throw error2;
-      }
-    },
-    [client]
+    [client, user, syncRef]
   );
+  useAutoRecover({
+    client,
+    config,
+    setAccessTokenState,
+    setRefreshTokenState,
+    setUser,
+    setProviderState,
+    setProvider,
+    setIsLoading
+  });
+  const { precheck, relay } = useVolrActions({
+    client,
+    setError
+  });
   const logout = react.useCallback(async () => {
     try {
       setError(null);
@@ -9938,45 +10049,13 @@ function VolrProvider({ config, children }) {
       setError(error2);
       throw error2;
     }
-  }, [client]);
-  react.useEffect(() => {
-    if (!user) return;
-    if (typeof window === "undefined" || !window.ethereum) {
-      return;
-    }
-    const ethereum = window.ethereum;
-    const handleAccountsChanged = (accounts) => {
-      console.log("[Provider] accountsChanged event:", accounts);
-      if (accounts.length === 0) {
-        console.warn("[Provider] Wallet disconnected, logging out...");
-        setTimeout(() => logout(), 3e3);
-      } else if (user.evmAddress && accounts[0].toLowerCase() !== user.evmAddress.toLowerCase()) {
-        console.warn("[Provider] Account changed, logging out in 3 seconds...");
-        setTimeout(() => logout(), 3e3);
-      }
-    };
-    const handleChainChanged = (chainIdHex) => {
-      const newChainId = parseInt(chainIdHex, 16);
-      console.log("[Provider] chainChanged event:", newChainId);
-      setUser(
-        (prev) => prev ? { ...prev, lastWalletChainId: newChainId } : null
-      );
-      window.location.reload();
-    };
-    const handleDisconnect = () => {
-      console.log("[Provider] disconnect event");
-      setProviderState(null);
-      safeStorage.removeItem(STORAGE_KEYS.provider);
-    };
-    ethereum.on("accountsChanged", handleAccountsChanged);
-    ethereum.on("chainChanged", handleChainChanged);
-    ethereum.on("disconnect", handleDisconnect);
-    return () => {
-      ethereum.removeListener("accountsChanged", handleAccountsChanged);
-      ethereum.removeListener("chainChanged", handleChainChanged);
-      ethereum.removeListener("disconnect", handleDisconnect);
-    };
-  }, [user, logout, setUser]);
+  }, [client, syncRef]);
+  useWalletEvents({
+    user,
+    logout,
+    setUser,
+    setProviderState
+  });
   const publicValue = react.useMemo(
     () => ({
       config,
@@ -17866,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) {
@@ -18023,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) {
@@ -18225,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 {
@@ -18241,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}`);
@@ -18299,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,
@@ -18327,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");
@@ -18344,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;
@@ -18562,6 +18584,10 @@ function useVolrLogin() {
       setAccessToken(accessToken);
       if (refreshToken) {
         setRefreshToken(refreshToken);
+      } else {
+        console.warn(
+          "[useVolrLogin] Access token received but refresh token is missing. Check if backend is updated to return refresh token in body."
+        );
       }
       if (userFromServer) {
         setUser(toVolrUser(userFromServer));
@@ -19307,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:
@@ -19352,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;