@rhinestone/deposit-modal 0.1.40 → 0.1.41

package/dist/{chunk-IC2M2DZ7.mjs → chunk-QIK6ONMQ.mjs}

@@ -7,7 +7,7 @@ import {
   getTokenAddress,
   getTokenDecimalsByAddress,
   getTokenSymbol
-} from "./chunk-I7RYTI4G.mjs";
+} from "./chunk-ZJQZEIHA.mjs";
 
 // src/components/ui/Modal.tsx
 import {
@@ -139,6 +139,79 @@ function Modal({
 }
 Modal.displayName = "Modal";
 
+// src/core/debug.ts
+function truncateString(value, max = 240) {
+  if (value.length <= max) return value;
+  return `${value.slice(0, max)}...`;
+}
+function normalizeForLog(value, depth = 0) {
+  if (depth > 3) return "[MaxDepth]";
+  if (value === null || value === void 0) return value;
+  if (typeof value === "bigint") return value.toString();
+  if (typeof value === "string") return truncateString(value);
+  if (typeof value === "number" || typeof value === "boolean") return value;
+  if (value instanceof Error) {
+    return {
+      name: value.name,
+      message: value.message,
+      stack: value.stack ? truncateString(value.stack, 600) : void 0
+    };
+  }
+  if (Array.isArray(value)) {
+    return value.slice(0, 12).map((entry) => normalizeForLog(entry, depth + 1));
+  }
+  if (typeof value === "object") {
+    const input = value;
+    const output = {};
+    for (const [key, raw] of Object.entries(input)) {
+      const keyLower = key.toLowerCase();
+      if (keyLower.includes("signature") || keyLower.includes("privatekey") || keyLower.includes("sessiondetails")) {
+        output[key] = "[Redacted]";
+        continue;
+      }
+      output[key] = normalizeForLog(raw, depth + 1);
+    }
+    return output;
+  }
+  return String(value);
+}
+function debugLog(enabled, scope, message, data) {
+  if (!enabled) return;
+  if (data === void 0) {
+    console.log(`[deposit-modal:${scope}] ${message}`);
+    return;
+  }
+  console.log(
+    `[deposit-modal:${scope}] ${message}`,
+    normalizeForLog(data)
+  );
+}
+function debugError(enabled, scope, message, error, data) {
+  if (!enabled) return;
+  const payload = data === void 0 ? { error: normalizeForLog(error) } : { error: normalizeForLog(error), meta: normalizeForLog(data) };
+  console.error(`[deposit-modal:${scope}] ${message}`, payload);
+}
+
+// src/core/caip.ts
+var SOLANA_MAINNET_GENESIS = "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+var SOLANA_MAINNET_CAIP2 = `solana:${SOLANA_MAINNET_GENESIS}`;
+function toEvmCaip2(chainId) {
+  return `eip155:${chainId}`;
+}
+function parseEvmChainId(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value !== "string") return null;
+  const match = value.match(/^eip155:(\d+)$/);
+  if (!match?.[1]) return null;
+  const parsed = Number.parseInt(match[1], 10);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function isSolanaCaip2(value) {
+  return typeof value === "string" && value.startsWith("solana:");
+}
+
 // src/core/deposit-service.ts
 function jsonReplacer(_key, value) {
   return typeof value === "bigint" ? value.toString() : value;
@@ -187,6 +260,7 @@ function normalizeSetupAccountResponse(raw) {
     targetChain: data.targetChain,
     targetToken: data.targetToken,
     needsRegistration: data.needsRegistration,
+    solanaDepositAddress: data.solanaDepositAddress,
     accountParams: data.accountParams,
     sessionDetailsUnsigned: data.sessionDetailsUnsigned ? {
       hashesAndChainIds: data.sessionDetailsUnsigned.hashesAndChainIds.map(
@@ -208,30 +282,67 @@ function buildSessionDetails(unsigned, signature) {
     signature
   };
 }
-function createDepositService(baseUrl) {
+function createDepositService(baseUrl, options) {
   const normalizedBaseUrl = baseUrl.replace(/\/$/, "");
+  const debug = options?.debug === true;
+  const scope = options?.debugScope ?? "service";
   function apiUrl(path) {
     const normalizedPath = path.startsWith("/") ? path : `/${path}`;
     return `${normalizedBaseUrl}${normalizedPath}`;
   }
+  function shortRef(value) {
+    if (value.length <= 20) return value;
+    return `${value.slice(0, 10)}...${value.slice(-8)}`;
+  }
   return {
     async setupAccount(params) {
-      const response = await fetch(apiUrl("/setup-account"), {
+      const url = apiUrl("/setup-account");
+      debugLog(debug, scope, "setupAccount:request", {
+        url,
+        ownerAddress: params.ownerAddress,
+        targetChain: params.targetChain,
+        targetToken: params.targetToken,
+        forceRegister: params.forceRegister
+      });
+      const response = await fetch(url, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(params)
       });
       if (!response.ok) {
         const error = await response.json().catch(() => ({ error: "Unknown error" }));
+        debugError(
+          debug,
+          scope,
+          "setupAccount:failed",
+          error,
+          { status: response.status, ownerAddress: params.ownerAddress }
+        );
         throw new Error(
           error.error || `Setup account failed: ${response.status}`
         );
       }
-      return normalizeSetupAccountResponse(await response.json());
+      const normalized = normalizeSetupAccountResponse(await response.json());
+      debugLog(debug, scope, "setupAccount:success", {
+        smartAccount: normalized.smartAccount,
+        needsRegistration: normalized.needsRegistration,
+        isRegistered: normalized.isRegistered,
+        hasSolanaDepositAddress: Boolean(normalized.solanaDepositAddress)
+      });
+      return normalized;
     },
     async registerAccount(params) {
       const { eoaAddress, sessionOwner, ...account } = params;
-      const response = await fetch(apiUrl("/register"), {
+      const url = apiUrl("/register");
+      debugLog(debug, scope, "registerAccount:request", {
+        url,
+        address: params.address,
+        targetChain: params.target.chain,
+        targetToken: params.target.token,
+        eoaAddress,
+        sessionOwner
+      });
+      const response = await fetch(url, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(
@@ -245,19 +356,41 @@ function createDepositService(baseUrl) {
       });
       if (!response.ok) {
         const error = await response.json().catch(() => ({ error: "Unknown error" }));
+        debugError(
+          debug,
+          scope,
+          "registerAccount:failed",
+          error,
+          { status: response.status, address: params.address }
+        );
         throw new Error(
           error.error || `Registration failed: ${response.status}`
         );
       }
-      return response.json();
+      const result = await response.json();
+      debugLog(debug, scope, "registerAccount:success", {
+        address: params.address,
+        evmDepositAddress: result?.evmDepositAddress,
+        hasSolanaDepositAddress: Boolean(result?.solanaDepositAddress)
+      });
+      return result;
     },
     async fetchPortfolio(address) {
-      const response = await fetch(apiUrl(`/portfolio/${address}`), {
+      const url = apiUrl(`/portfolio/${address}`);
+      debugLog(debug, scope, "fetchPortfolio:request", { url, address });
+      const response = await fetch(url, {
         method: "GET",
         headers: { "Content-Type": "application/json" }
       });
       if (!response.ok) {
         const error = await response.json().catch(() => ({ error: "Unknown error" }));
+        debugError(
+          debug,
+          scope,
+          "fetchPortfolio:failed",
+          error,
+          { status: response.status, address }
+        );
         throw new Error(
           error.error || `Portfolio fetch failed: ${response.status}`
         );
@@ -265,18 +398,95 @@ function createDepositService(baseUrl) {
       const data = await response.json();
       const direct = normalizeDirectPortfolio(data);
       if (direct.tokens.length > 0) {
+        debugLog(debug, scope, "fetchPortfolio:success", {
+          address,
+          source: "direct",
+          tokenCount: direct.tokens.length,
+          totalUsd: direct.totalUsd
+        });
         return direct;
       }
       const portfolioData = extractOrchestratorPortfolio(data);
       if (portfolioData) {
-        return normalizeOrchestratorPortfolio(portfolioData);
+        const normalized = normalizeOrchestratorPortfolio(portfolioData);
+        debugLog(debug, scope, "fetchPortfolio:success", {
+          address,
+          source: "orchestrator",
+          tokenCount: normalized.tokens.length,
+          totalUsd: normalized.totalUsd
+        });
+        return normalized;
       }
+      debugLog(debug, scope, "fetchPortfolio:empty", { address });
       return { tokens: [], totalUsd: 0 };
     },
+    async fetchSolanaPortfolio(address) {
+      const url = apiUrl(`/portfolio/solana/${address}`);
+      debugLog(debug, scope, "fetchSolanaPortfolio:request", { url, address });
+      const response = await fetch(url, {
+        method: "GET",
+        headers: { "Content-Type": "application/json" }
+      });
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: "Unknown error" }));
+        debugError(
+          debug,
+          scope,
+          "fetchSolanaPortfolio:failed",
+          error,
+          { status: response.status, address }
+        );
+        throw new Error(
+          error.error || `Solana portfolio fetch failed: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      const normalized = normalizeDirectPortfolio(data);
+      debugLog(debug, scope, "fetchSolanaPortfolio:success", {
+        address,
+        tokenCount: normalized.tokens.length,
+        totalUsd: normalized.totalUsd
+      });
+      return normalized;
+    },
+    async checkAccount(address) {
+      const url = apiUrl(`/check/${address}`);
+      debugLog(debug, scope, "checkAccount:request", { url, address });
+      const response = await fetch(url, {
+        method: "GET",
+        headers: { "Content-Type": "application/json" }
+      });
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: "Unknown error" }));
+        debugError(
+          debug,
+          scope,
+          "checkAccount:failed",
+          error,
+          { status: response.status, address }
+        );
+        throw new Error(error.error || `Account check failed: ${response.status}`);
+      }
+      const data = await response.json();
+      const result = {
+        isRegistered: data?.isRegistered === true,
+        targetChain: data?.targetChain,
+        targetToken: data?.targetToken
+      };
+      debugLog(debug, scope, "checkAccount:success", {
+        address,
+        isRegistered: result.isRegistered,
+        targetChain: result.targetChain,
+        targetToken: result.targetToken
+      });
+      return result;
+    },
     async fetchStatus(address, txHash) {
-      const txHashParam = encodeURIComponent(txHash.toLowerCase());
+      const normalized = txHash.startsWith("0x") || txHash.startsWith("0X") ? txHash.toLowerCase() : txHash;
+      const txHashParam = encodeURIComponent(normalized);
+      const url = apiUrl(`/status/${address}?txHash=${txHashParam}`);
       const response = await fetch(
-        apiUrl(`/status/${address}?txHash=${txHashParam}`),
+        url,
         {
           method: "GET",
           headers: { "Content-Type": "application/json" },
@@ -284,24 +494,53 @@ function createDepositService(baseUrl) {
         }
       );
       if (!response.ok) {
+        debugLog(debug, scope, "fetchStatus:miss", {
+          address,
+          txHash: shortRef(normalized),
+          status: response.status
+        });
         return { lastEvent: void 0 };
       }
-      return response.json();
+      const result = await response.json();
+      debugLog(debug, scope, "fetchStatus:success", {
+        address,
+        txHash: shortRef(normalized),
+        eventType: result?.lastEvent?.type
+      });
+      return result;
     },
     async fetchLatestStatus(address) {
-      const response = await fetch(apiUrl(`/status/${address}`), {
+      const url = apiUrl(`/status/${address}`);
+      const response = await fetch(url, {
         method: "GET",
         headers: { "Content-Type": "application/json" },
         cache: "no-store"
       });
       if (!response.ok) {
+        debugLog(debug, scope, "fetchLatestStatus:miss", {
+          address,
+          status: response.status
+        });
         return { lastEvent: void 0 };
       }
-      return response.json();
+      const result = await response.json();
+      debugLog(debug, scope, "fetchLatestStatus:success", {
+        address,
+        eventType: result?.lastEvent?.type
+      });
+      return result;
     },
     async relayWithdraw(params) {
       const { smartAccount, chainId, safeAddress, safeTransaction, signature } = params;
-      const response = await fetch(apiUrl(`/relay-withdraw`), {
+      const url = apiUrl(`/relay-withdraw`);
+      debugLog(debug, scope, "relayWithdraw:request", {
+        url,
+        smartAccount,
+        chainId,
+        safeAddress,
+        to: safeTransaction.to
+      });
+      const response = await fetch(url, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(
@@ -327,11 +566,31 @@ function createDepositService(baseUrl) {
       });
       if (!response.ok) {
         const error = await response.json().catch(() => ({ error: "Unknown error" }));
+        debugError(
+          debug,
+          scope,
+          "relayWithdraw:failed",
+          error,
+          {
+            status: response.status,
+            smartAccount,
+            chainId,
+            safeAddress,
+            signature
+          }
+        );
         throw new Error(
           error.error || `Relay withdraw failed: ${response.status}`
         );
       }
-      return response.json();
+      const result = await response.json();
+      debugLog(debug, scope, "relayWithdraw:success", {
+        smartAccount,
+        chainId,
+        safeAddress,
+        txHash: result?.txHash ? shortRef(result.txHash) : void 0
+      });
+      return result;
     }
   };
 }
@@ -385,8 +644,10 @@ function normalizeOrchestratorPortfolio(data) {
   };
 }
 function normalizeDirectToken(token) {
-  const chainId = extractNumber(token, "chainId") ?? extractNumber(token.chain, "id");
-  if (!chainId) return null;
+  const rawChainId = extractNumber(token, "chainId") ?? extractNumber(token.chain, "id");
+  const rawChainString = extractString(token, "chainId") ?? extractString(token.chain, "id");
+  const chainId = rawChainId ?? (rawChainString ? isSolanaCaip2(rawChainString) || rawChainString.toLowerCase() === "solana" ? "solana" : parseEvmChainId(rawChainString) : null);
+  if (chainId === null) return null;
   const symbol = extractString(token, "symbol") ?? extractString(token, "tokenSymbol") ?? extractString(token, "tokenName") ?? extractString(token, "name");
   if (!symbol) return null;
   const balanceValue = extractString(token, "balance") ?? extractString(token, "amount") ?? extractString(token, "value") ?? extractString(token, "rawBalance") ?? extractNumber(token, "balance")?.toString() ?? extractNumber(token, "amount")?.toString() ?? extractNumber(token, "value")?.toString() ?? extractNumber(token, "rawBalance")?.toString();
@@ -394,17 +655,17 @@ function normalizeDirectToken(token) {
   const address = extractString(token, "address") ?? extractString(token, "tokenAddress") ?? extractString(
     token.token,
     "address"
-  ) ?? getTokenAddress(symbol, chainId);
+  ) ?? (typeof chainId === "number" ? getTokenAddress(symbol, chainId) : void 0);
   if (!address) return null;
-  const addressAsToken = address;
   const balanceUsd = extractNumber(token, "balanceUsd") ?? extractNumber(token, "usdValue") ?? extractNumber(token, "valueUsd") ?? extractNumericString(token, "balanceUsd") ?? extractNumericString(token, "usdValue") ?? extractNumericString(token, "valueUsd") ?? 0;
-  const registrySymbol = getTokenSymbol(addressAsToken, chainId);
-  const resolvedSymbol = registrySymbol !== "Token" ? registrySymbol : symbol;
+  const isSolanaToken = chainId === "solana";
+  const registrySymbol = isSolanaToken ? "Token" : getTokenSymbol(address, chainId);
+  const resolvedSymbol = isSolanaToken ? symbol : registrySymbol !== "Token" ? registrySymbol : symbol;
   const backendDecimals = extractNumber(token, "decimals") ?? extractNumber(token, "tokenDecimals");
-  const resolvedDecimals = registrySymbol !== "Token" ? getTokenDecimalsByAddress(addressAsToken, chainId) : backendDecimals ?? 18;
+  const resolvedDecimals = !isSolanaToken && registrySymbol !== "Token" ? getTokenDecimalsByAddress(address, chainId) : backendDecimals ?? 18;
   return {
     chainId,
-    address: addressAsToken,
+    address,
     symbol: resolvedSymbol,
     name: resolvedSymbol,
     decimals: resolvedDecimals,
@@ -443,7 +704,12 @@ function extractNumericString(data, key) {
 function getAssetId(asset) {
   return `${asset.chainId}:${asset.token.toLowerCase()}`;
 }
+function isEvmAddress(value) {
+  return /^0x[a-fA-F0-9]{40}$/.test(value);
+}
 function portfolioTokenToAsset(token) {
+  if (typeof token.chainId !== "number") return null;
+  if (!isEvmAddress(token.address)) return null;
   return {
     id: getAssetId({ chainId: token.chainId, token: token.address }),
     chainId: token.chainId,
@@ -456,7 +722,7 @@ function portfolioTokenToAsset(token) {
   };
 }
 function portfolioToAssets(tokens) {
-  return tokens.map(portfolioTokenToAsset).sort((a, b) => {
+  return tokens.map(portfolioTokenToAsset).filter((token) => token !== null).sort((a, b) => {
     const balanceA = safeBigInt(a.balance);
     const balanceB = safeBigInt(b.balance);
     if (balanceB > balanceA) return 1;
@@ -499,6 +765,9 @@ function formatUserError(raw) {
   if (lower.includes("execution reverted")) {
     return "Transaction would fail on-chain";
   }
+  if (lower.includes("recent blockhash") || lower.includes("latest blockhash")) {
+    return "Solana RPC unavailable \u2014 please retry";
+  }
   if (lower.includes("network") || lower.includes("disconnected")) {
     return "Network error \u2014 check your connection";
   }
@@ -698,12 +967,13 @@ function ChevronRightIcon() {
 import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
 function rowIcon(kind) {
   if (kind === "connected") return /* @__PURE__ */ jsx5(WalletIcon, {});
+  if (kind === "solana") return /* @__PURE__ */ jsx5(ExternalLinkIcon, {});
   return /* @__PURE__ */ jsx5(ExternalLinkIcon, {});
 }
 function ConnectStep({
   walletOptions,
-  selectedAddress,
-  onSelectAddress,
+  selectedWalletId,
+  onSelectWallet,
   onSelectTransferCrypto,
   onRequestConnect,
   onConnect,
@@ -714,20 +984,23 @@ function ConnectStep({
 }) {
   const hasWalletOptions = (walletOptions?.length ?? 0) > 0;
   if (hasWalletOptions) {
-    const hasExternalWallet = walletOptions?.some((option) => option.kind === "external") ?? false;
-    const showConnectDifferentWalletOption = Boolean(onConnect) && !hasExternalWallet;
+    const hasReownWallet = walletOptions?.some(
+      (option) => option.kind === "external" || option.kind === "solana"
+    ) ?? false;
+    const showConnectDifferentWalletOption = Boolean(onConnect) && !hasReownWallet;
     return /* @__PURE__ */ jsxs4("div", { className: "rs-step", children: [
       /* @__PURE__ */ jsxs4("div", { className: "rs-connect-centered rs-connect-centered--wallets", children: [
         /* @__PURE__ */ jsxs4("div", { className: "rs-connect-wallet-list", children: [
           walletOptions?.map((option) => {
-            const isSelected = option.address.toLowerCase() === (selectedAddress ?? "").toLowerCase();
-            const shortAddress = `${option.address.slice(0, 6)}...${option.address.slice(-4)}`;
+            const isSelected = option.id === selectedWalletId;
+            const rawAddress = option.address ?? option.solanaAddress ?? option.id;
+            const shortAddress = rawAddress.length > 12 ? `${rawAddress.slice(0, 6)}...${rawAddress.slice(-4)}` : rawAddress;
             return /* @__PURE__ */ jsxs4(
               "button",
               {
                 type: "button",
                 className: `rs-connect-wallet-row ${isSelected ? "rs-connect-wallet-row--selected" : ""}`,
-                onClick: () => onSelectAddress?.(option.address),
+                onClick: () => onSelectWallet?.(option.id),
                 children: [
                   /* @__PURE__ */ jsx5(
                     "div",
@@ -750,7 +1023,7 @@ function ConnectStep({
                   /* @__PURE__ */ jsx5("div", { className: "rs-connect-wallet-indicator", children: isSelected ? /* @__PURE__ */ jsx5(CheckIcon, {}) : /* @__PURE__ */ jsx5(ChevronRightIcon, {}) })
                 ]
               },
-              `${option.label}-${option.address}`
+              option.id
             );
           }),
           showConnectDifferentWalletOption && /* @__PURE__ */ jsxs4(
@@ -786,7 +1059,9 @@ function ConnectStep({
             }
           )
         ] }),
-        (onDisconnect || onConnect) && walletOptions?.some((option) => option.kind === "external") && /* @__PURE__ */ jsx5(
+        (onDisconnect || onConnect) && walletOptions?.some(
+          (option) => option.kind === "external" || option.kind === "solana"
+        ) && /* @__PURE__ */ jsx5(
           "button",
           {
             type: "button",
@@ -802,7 +1077,7 @@ function ConnectStep({
           onClick: onContinue,
           variant: "accent",
           fullWidth: true,
-          disabled: !selectedAddress || !onContinue,
+          disabled: !selectedWalletId || !onContinue,
           children: continueButtonLabel
         }
       ) })
@@ -1059,6 +1334,15 @@ function getEventSourceDetails(event) {
 function isDepositEvent(event) {
   return event?.type === "deposit-received" || event?.type === "bridge-started" || event?.type === "bridge-complete" || event?.type === "bridge-failed" || event?.type === "error";
 }
+function isHexString(value) {
+  return value.startsWith("0x") || value.startsWith("0X");
+}
+function txRefsMatch(a, b) {
+  if (isHexString(a) && isHexString(b)) {
+    return a.toLowerCase() === b.toLowerCase();
+  }
+  return a === b;
+}
 
 // src/components/steps/ProcessingStep.tsx
 import { Fragment, jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
@@ -1069,15 +1353,32 @@ var PROCESS_TIMEOUT_MS = 10 * 60 * 1e3;
 function isEventForTx(event, txHash) {
   const eventTxHash = getEventTxHash(event);
   if (!eventTxHash) return false;
-  return eventTxHash.toLowerCase() === txHash.toLowerCase();
+  return txRefsMatch(eventTxHash, txHash);
 }
 function formatBridgeFailedMessage(event) {
   const eventData = event?.data ?? {};
   const code = typeof eventData.errorCode === "string" ? eventData.errorCode : void 0;
   const backendMessage = typeof eventData.message === "string" ? eventData.message.trim() : "";
+  function toUserFacingFailure(raw) {
+    const lower = raw.toLowerCase();
+    if (lower.includes("insufficient funds")) {
+      return "Deposit was received, but processing could not continue due to insufficient funds. Please retry.";
+    }
+    if (lower.includes("no valid quote available")) {
+      return "No bridge route is currently available for this transfer. Please try again shortly.";
+    }
+    if (lower.includes("simulation failed")) {
+      return "Transfer processing failed during simulation. Please retry.";
+    }
+    if (raw.length > 220) {
+      return "Transfer processing failed. Please retry.";
+    }
+    return raw;
+  }
   if (backendMessage.length > 0) {
+    const userMessage = toUserFacingFailure(backendMessage);
     return {
-      message: backendMessage,
+      message: userMessage,
       code
     };
   }
@@ -1093,6 +1394,8 @@ function ProcessingStep({
   sourceToken,
   targetChain,
   amount,
+  sourceSymbol: providedSourceSymbol,
+  sourceDecimals: providedSourceDecimals,
   waitForFinalTx,
   service,
   directTransfer,
@@ -1112,10 +1415,14 @@ function ProcessingStep({
   const intervalRef = useRef2(null);
   useEffect2(() => {
     if (directTransfer) {
+      debugLog(debug, "processing", "direct-transfer:complete", {
+        txHash,
+        flowLabel
+      });
       onDepositComplete?.(txHash);
       return;
     }
-  }, [directTransfer, txHash, onDepositComplete]);
+  }, [debug, directTransfer, flowLabel, txHash, onDepositComplete]);
   useEffect2(() => {
     if (directTransfer) return;
     startTimeRef.current = Date.now();
@@ -1146,28 +1453,41 @@ function ProcessingStep({
     let isMounted = true;
     async function pollStatus() {
       try {
+        debugLog(debug, "processing", "poll:request", {
+          smartAccount,
+          txHash,
+          intervalMs: pollIntervalRef.current
+        });
         const data = await service.fetchStatus(smartAccount, txHash);
         const lastEvent2 = data.lastEvent;
         const eventMatchesTx = isEventForTx(lastEvent2, txHash);
         const eventForCurrentTx = eventMatchesTx ? lastEvent2 : void 0;
-        if (debug && lastEvent2) {
+        if (lastEvent2) {
           const eventData = lastEvent2.data;
-          console.log("[deposit-modal] status poll", {
+          debugLog(debug, "processing", "poll:event", {
             type: lastEvent2.type,
             matchesTx: eventMatchesTx,
-            intentId: eventData?.intentId,
-            data: eventData
+            intentId: eventData?.intentId
           });
         }
         if (!isMounted) return;
         if (eventForCurrentTx?.type === "bridge-complete") {
           setState({ type: "complete", lastEvent: eventForCurrentTx });
           const destinationTxHash2 = eventForCurrentTx.data?.destination?.transactionHash;
+          debugLog(debug, "processing", "state:complete", {
+            txHash,
+            destinationTxHash: destinationTxHash2,
+            event: eventForCurrentTx.type
+          });
           onDepositComplete?.(txHash, destinationTxHash2);
           return;
         }
         if (!waitForFinalTx && eventForCurrentTx?.type === "bridge-started") {
           setState({ type: "complete", lastEvent: eventForCurrentTx });
+          debugLog(debug, "processing", "state:early-complete", {
+            txHash,
+            event: eventForCurrentTx.type
+          });
           onDepositComplete?.(txHash);
           return;
         }
@@ -1178,6 +1498,11 @@ function ProcessingStep({
             message: formatted.message,
             lastEvent: eventForCurrentTx
           });
+          debugLog(debug, "processing", "state:failed", {
+            txHash,
+            message: formatted.message,
+            code: formatted.code
+          });
           onDepositFailed?.(txHash, formatted.message);
           return;
         }
@@ -1188,12 +1513,21 @@ function ProcessingStep({
             message: errorMessage,
             lastEvent: eventForCurrentTx
           });
+          debugLog(debug, "processing", "state:error-event", {
+            txHash,
+            message: errorMessage
+          });
           onDepositFailed?.(txHash, errorMessage);
           return;
         }
         setState({ type: "processing", lastEvent: eventForCurrentTx });
         scheduleNextPoll();
-      } catch {
+      } catch (error) {
+        debugError(debug, "processing", "poll:failure", error, {
+          smartAccount,
+          txHash,
+          intervalMs: pollIntervalRef.current
+        });
         scheduleNextPoll();
       }
     }
@@ -1204,6 +1538,9 @@ function ProcessingStep({
           pollIntervalRef.current * BACKOFF_MULTIPLIER,
           MAX_POLL_INTERVAL
         );
+        debugLog(debug, "processing", "poll:scheduled", {
+          nextIntervalMs: pollIntervalRef.current
+        });
         pollStatus();
       }, pollIntervalRef.current);
     }
@@ -1215,6 +1552,7 @@ function ProcessingStep({
       }
     };
   }, [
+    debug,
     directTransfer,
     state.type,
     smartAccount,
@@ -1235,6 +1573,10 @@ function ProcessingStep({
     }
     processTimeoutRef.current = setTimeout(() => {
       const message = "We couldn't confirm your transfer. Please contact support if funds do not arrive.";
+      debugLog(debug, "processing", "state:timeout", {
+        txHash,
+        timeoutMs: PROCESS_TIMEOUT_MS
+      });
       setState({ type: "error", message });
       onError?.(message, "PROCESS_TIMEOUT");
     }, PROCESS_TIMEOUT_MS);
@@ -1244,7 +1586,7 @@ function ProcessingStep({
         processTimeoutRef.current = null;
       }
     };
-  }, [directTransfer, state.type, onError]);
+  }, [debug, directTransfer, state.type, txHash, onError]);
   const isError = state.type === "error" || state.type === "failed";
   const isComplete = state.type === "complete";
   const isProcessing = state.type === "processing";
@@ -1266,11 +1608,9 @@ function ProcessingStep({
     const secs = seconds % 60;
     return `${mins}m ${secs}s`;
   };
-  const sourceSymbol = getTokenSymbol(displaySourceToken, displaySourceChain);
-  const sourceDecimals = getTokenDecimalsByAddress(
-    displaySourceToken,
-    displaySourceChain
-  );
+  const isEvmSourceToken = /^0x[a-fA-F0-9]{40}$/.test(displaySourceToken);
+  const sourceSymbol = displaySourceChain === "solana" ? providedSourceSymbol ?? "SOL" : isEvmSourceToken ? getTokenSymbol(displaySourceToken, displaySourceChain) : providedSourceSymbol ?? "Token";
+  const sourceDecimals = displaySourceChain === "solana" ? providedSourceDecimals ?? 9 : isEvmSourceToken ? getTokenDecimalsByAddress(displaySourceToken, displaySourceChain) : providedSourceDecimals ?? 18;
   const formattedReceivedAmount = (() => {
     try {
       const raw = formatUnits(BigInt(displayAmount), sourceDecimals);
@@ -1645,6 +1985,9 @@ export {
   Spinner,
   Button,
   ConnectStep,
+  debugLog,
+  debugError,
+  toEvmCaip2,
   buildSessionDetails,
   createDepositService,
   getAssetId,
@@ -1659,8 +2002,8 @@ export {
   tokenFormatter,
   formatUserError,
   getEventTxHash,
-  getEventSourceDetails,
   isDepositEvent,
+  txRefsMatch,
   ProcessingStep,
   getPublicClient,
   applyTheme