@rhinestone/deposit-modal 0.0.0-dev-20260608080045

package/dist/chunk-KAWJABTW.mjs

@@ -0,0 +1,3765 @@
+import {
+  CHAIN_BY_ID,
+  NATIVE_TOKEN_ADDRESS,
+  getChainIcon,
+  getChainName,
+  getExplorerTxUrl,
+  getSolanaTokenByMint,
+  getSupportedChainIds,
+  getTargetTokenSymbol,
+  getTokenAddress,
+  getTokenDecimalsByAddress,
+  getTokenIcon,
+  getTokenSymbol,
+  isSolanaCaip2,
+  parseEvmChainId
+} from "./chunk-6YRDD462.mjs";
+
+// src/components/ui/Modal.tsx
+import {
+  useEffect,
+  useRef,
+  useCallback
+} from "react";
+import { createPortal } from "react-dom";
+import { jsx } from "react/jsx-runtime";
+function getFocusableElements(container) {
+  const elements = container.querySelectorAll(
+    'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])'
+  );
+  return Array.from(elements).filter(
+    (el) => !el.hasAttribute("disabled") && el.offsetParent !== null
+  );
+}
+function Modal({
+  isOpen,
+  onClose,
+  children,
+  className = "",
+  inline = false,
+  closeOnOverlayClick = false
+}) {
+  const overlayRef = useRef(null);
+  const contentRef = useRef(null);
+  const previousActiveElement = useRef(null);
+  useEffect(() => {
+    if (isOpen) {
+      previousActiveElement.current = document.activeElement;
+    }
+  }, [isOpen]);
+  useEffect(() => {
+    if (!isOpen && previousActiveElement.current) {
+      previousActiveElement.current.focus();
+      previousActiveElement.current = null;
+    }
+  }, [isOpen]);
+  useEffect(() => {
+    if (isOpen && contentRef.current) {
+      const focusable = getFocusableElements(contentRef.current);
+      if (focusable.length > 0) {
+        focusable[0].focus();
+      } else {
+        contentRef.current.focus();
+      }
+    }
+  }, [isOpen]);
+  useEffect(() => {
+    if (isOpen && !inline) {
+      const originalOverflow = document.body.style.overflow;
+      document.body.style.overflow = "hidden";
+      return () => {
+        document.body.style.overflow = originalOverflow;
+      };
+    }
+  }, [isOpen, inline]);
+  const handleKeyDown = useCallback(
+    (event) => {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        onClose();
+        return;
+      }
+      if (event.key === "Tab" && contentRef.current) {
+        const focusable = getFocusableElements(contentRef.current);
+        if (focusable.length === 0) return;
+        const firstElement = focusable[0];
+        const lastElement = focusable[focusable.length - 1];
+        if (event.shiftKey) {
+          if (document.activeElement === firstElement) {
+            event.preventDefault();
+            lastElement.focus();
+          }
+        } else {
+          if (document.activeElement === lastElement) {
+            event.preventDefault();
+            firstElement.focus();
+          }
+        }
+      }
+    },
+    [onClose]
+  );
+  const handleOverlayClick = useCallback(
+    (event) => {
+      if (closeOnOverlayClick && event.target === overlayRef.current) {
+        onClose();
+      }
+    },
+    [closeOnOverlayClick, onClose]
+  );
+  if (!isOpen) return null;
+  if (inline) {
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref: contentRef,
+        className: `rs-modal-content rs-modal-content--inline ${className}`,
+        tabIndex: -1,
+        children
+      }
+    );
+  }
+  return createPortal(
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref: overlayRef,
+        className: `rs-modal-overlay ${isOpen ? "rs-modal-overlay--open" : ""}`,
+        onClick: handleOverlayClick,
+        onKeyDown: handleKeyDown,
+        role: "dialog",
+        "aria-modal": "true",
+        "aria-labelledby": "rs-modal-title",
+        children: /* @__PURE__ */ jsx(
+          "div",
+          {
+            ref: contentRef,
+            className: `rs-modal-content ${className}`,
+            tabIndex: -1,
+            children
+          }
+        )
+      }
+    ),
+    document.body
+  );
+}
+Modal.displayName = "Modal";
+
+// src/components/ui/Icons.tsx
+import {
+  Wallet,
+  ExternalLink,
+  Coins,
+  Check,
+  ChevronRight,
+  ChevronLeft,
+  ChevronDown,
+  X,
+  HandCoins,
+  History,
+  Info,
+  Copy,
+  ArrowRight,
+  ArrowUpRight,
+  AlertTriangle,
+  Percent,
+  Clock,
+  CirclePlus,
+  CircleArrowOutUpLeft,
+  CreditCard,
+  Landmark,
+  Apple
+} from "lucide-react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var WalletIcon = Wallet;
+var ExternalLinkIcon = ExternalLink;
+var CheckIcon = Check;
+function TransferCryptoIcon() {
+  return /* @__PURE__ */ jsx2(
+    "svg",
+    {
+      width: "24",
+      height: "24",
+      viewBox: "8 8 24 24",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      "aria-hidden": "true",
+      children: /* @__PURE__ */ jsx2(
+        "path",
+        {
+          d: "M26.08 18.37C27.03 18.72 27.87 19.30 28.53 20.07C29.19 20.83 29.65 21.75 29.86 22.73C30.07 23.72 30.03 24.74 29.74 25.71C29.45 26.68 28.92 27.55 28.20 28.26C27.48 28.97 26.59 29.49 25.62 29.76C24.65 30.04 23.63 30.06 22.64 29.83C21.66 29.61 20.75 29.14 20.00 28.47C19.24 27.80 18.67 26.95 18.33 26.00M15 14H16V18M24.70 21.87L25.40 22.58L22.58 25.40M22 16C22 19.31 19.31 22 16 22C12.68 22 10 19.31 10 16C10 12.68 12.68 10 16 10C19.31 10 22 12.68 22 16Z",
+          stroke: "currentColor",
+          strokeWidth: "2",
+          strokeLinecap: "round",
+          strokeLinejoin: "round"
+        }
+      )
+    }
+  );
+}
+var ChevronRightIcon = ChevronRight;
+var ChevronLeftIcon = ChevronLeft;
+var ChevronDownIcon = ChevronDown;
+var CloseIcon = X;
+var HandCoinsIcon = HandCoins;
+var HistoryIcon = History;
+var InfoIcon = Info;
+var CopyIcon = Copy;
+var ArrowUpRightIcon = ArrowUpRight;
+var AlertTriangleIcon = AlertTriangle;
+var PercentIcon = Percent;
+var ClockIcon = Clock;
+var PlusCircleIcon = CirclePlus;
+var CircleArrowOutUpLeftIcon = CircleArrowOutUpLeft;
+var CardIcon = CreditCard;
+var BankIcon = Landmark;
+var AppleIcon = Apple;
+
+// src/components/ui/Callout.tsx
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+function CircleAlertIcon() {
+  return /* @__PURE__ */ jsx3(
+    "svg",
+    {
+      width: "16",
+      height: "16",
+      viewBox: "0 0 16 16",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      "aria-hidden": "true",
+      children: /* @__PURE__ */ jsx3(
+        "path",
+        {
+          d: "M10 5.99L6 9.99M6 5.99L10 9.99M14.66 7.99C14.66 11.68 11.68 14.66 8 14.66C4.31 14.66 1.33 11.68 1.33 7.99C1.33 4.31 4.31 1.33 8 1.33C11.68 1.33 14.66 4.31 14.66 7.99Z",
+          stroke: "currentColor",
+          strokeWidth: "1.33",
+          strokeLinecap: "round",
+          strokeLinejoin: "round"
+        }
+      )
+    }
+  );
+}
+function Callout({ variant = "error", children, role }) {
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `rs-callout rs-callout--${variant}`,
+      role: role ?? (variant === "error" ? "alert" : "status"),
+      children: [
+        /* @__PURE__ */ jsx3("span", { className: "rs-callout-icon", children: variant === "error" ? /* @__PURE__ */ jsx3(CircleAlertIcon, {}) : /* @__PURE__ */ jsx3(AlertTriangleIcon, {}) }),
+        /* @__PURE__ */ jsx3("span", { className: "rs-callout-text", children })
+      ]
+    }
+  );
+}
+Callout.displayName = "Callout";
+
+// src/core/useLatestRef.ts
+import { useEffect as useEffect2, useRef as useRef2 } from "react";
+function useLatestRef(value) {
+  const ref = useRef2(value);
+  useEffect2(() => {
+    ref.current = value;
+  }, [value]);
+  return ref;
+}
+
+// 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/deposit-asset-helpers.ts
+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,
+    token: token.address,
+    symbol: token.symbol,
+    name: token.name,
+    decimals: token.decimals,
+    balance: token.balance,
+    balanceUsd: token.balanceUsd
+  };
+}
+function safeBigInt(value) {
+  if (!value) return BigInt(0);
+  try {
+    return BigInt(value);
+  } catch {
+    return BigInt(0);
+  }
+}
+function portfolioToAssets(tokens) {
+  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;
+    if (balanceB < balanceA) return -1;
+    return 0;
+  });
+}
+function isNativeAsset(asset) {
+  return asset.token.toLowerCase() === "0x0000000000000000000000000000000000000000";
+}
+
+// src/core/deposit-service.ts
+function depositRowToEvent(row) {
+  const status = row.status;
+  if (!status) return void 0;
+  const deposit = {
+    transactionHash: row.txHash,
+    chain: row.chain,
+    amount: row.sourceAmount ?? row.amount,
+    asset: row.token,
+    token: row.token
+  };
+  const source = row.sourceTxHash ? { transactionHash: row.sourceTxHash, chain: row.chain } : { transactionHash: row.txHash, chain: row.chain };
+  const destination = row.destinationTxHash ? {
+    transactionHash: row.destinationTxHash,
+    chain: row.targetChain,
+    amount: row.destinationAmount ?? void 0
+  } : void 0;
+  const time = row.completedAt ?? row.createdAt ?? void 0;
+  if (status === "completed") {
+    return {
+      type: "post-bridge-swap-complete",
+      time: time ?? void 0,
+      data: {
+        deposit,
+        source,
+        ...destination && { destination },
+        ...destination && {
+          swap: { transactionHash: destination.transactionHash }
+        }
+      }
+    };
+  }
+  if (status === "failed" || status === "refunded") {
+    return {
+      type: "bridge-failed",
+      time: time ?? void 0,
+      data: {
+        deposit,
+        source,
+        ...row.errorCode && { error: { code: row.errorCode } }
+      }
+    };
+  }
+  if (status === "processing") {
+    return {
+      type: "bridge-started",
+      time: time ?? void 0,
+      data: {
+        deposit,
+        source
+      }
+    };
+  }
+  return {
+    type: "deposit-received",
+    time: time ?? void 0,
+    data: {
+      transactionHash: row.txHash,
+      chain: row.chain,
+      amount: row.amount,
+      token: row.token
+    }
+  };
+}
+function jsonReplacer(_key, value) {
+  return typeof value === "bigint" ? value.toString() : value;
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : null;
+}
+function toBigInt(value) {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number" && Number.isInteger(value)) return BigInt(value);
+  if (typeof value === "string" && value.trim() !== "") return BigInt(value);
+  throw new Error("Invalid bigint value");
+}
+function normalizeSessionTypedData(raw) {
+  const data = structuredClone(raw);
+  const domain = asRecord(data.domain);
+  if (domain && domain.chainId !== void 0 && domain.chainId !== null) {
+    domain.chainId = toBigInt(domain.chainId);
+  }
+  const message = asRecord(data.message);
+  if (!message || !Array.isArray(message.sessionsAndChainIds)) {
+    return data;
+  }
+  for (const entry of message.sessionsAndChainIds) {
+    const chainSession = asRecord(entry);
+    if (!chainSession) continue;
+    if (chainSession.chainId !== void 0 && chainSession.chainId !== null) {
+      chainSession.chainId = toBigInt(chainSession.chainId);
+    }
+    const session = asRecord(chainSession.session);
+    if (!session) continue;
+    if (session.nonce !== void 0 && session.nonce !== null) {
+      session.nonce = toBigInt(session.nonce);
+    }
+    if (session.expires !== void 0 && session.expires !== null) {
+      session.expires = toBigInt(session.expires);
+    }
+  }
+  return data;
+}
+function normalizeSetupAccountResponse(raw) {
+  const data = raw;
+  return {
+    smartAccount: data.smartAccount,
+    isRegistered: data.isRegistered,
+    targetChain: data.targetChain,
+    targetToken: data.targetToken,
+    needsRegistration: data.needsRegistration,
+    solanaDepositAddress: data.solanaDepositAddress,
+    accountParams: data.accountParams,
+    sessionDetailsUnsigned: data.sessionDetailsUnsigned ? {
+      hashesAndChainIds: data.sessionDetailsUnsigned.hashesAndChainIds.map(
+        (h) => ({
+          chainId: toBigInt(h.chainId),
+          sessionDigest: h.sessionDigest
+        })
+      ),
+      data: normalizeSessionTypedData(data.sessionDetailsUnsigned.data)
+    } : void 0
+  };
+}
+function buildSessionDetails(unsigned, signature) {
+  return {
+    hashesAndChainIds: unsigned.hashesAndChainIds.map((h) => ({
+      chainId: toBigInt(h.chainId),
+      sessionDigest: h.sessionDigest
+    })),
+    signature
+  };
+}
+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)}`;
+  }
+  const PORTFOLIO_CACHE_TTL_MS = 3e4;
+  const portfolioCache = /* @__PURE__ */ new Map();
+  function cachedPortfolio(key, fetcher) {
+    const now = Date.now();
+    const entry = portfolioCache.get(key);
+    if (entry && entry.expiresAt > now) {
+      debugLog(debug, scope, "portfolio:cache-hit", { key });
+      return entry.promise;
+    }
+    const promise = fetcher().catch((err) => {
+      portfolioCache.delete(key);
+      throw err;
+    });
+    portfolioCache.set(key, {
+      promise,
+      expiresAt: now + PORTFOLIO_CACHE_TTL_MS
+    });
+    return promise;
+  }
+  return {
+    async setupAccount(params) {
+      const url = apiUrl("/setup-account");
+      debugLog(debug, scope, "setupAccount:request", {
+        url,
+        ownerAddress: params.ownerAddress,
+        targetChain: params.targetChain,
+        targetToken: params.targetToken,
+        recipient: params.recipient ? shortRef(params.recipient) : void 0,
+        postBridgeActionCount: params.postBridgeActions?.length ?? 0,
+        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 }
+        );
+        const detail = Array.isArray(error.details) ? error.details.map((d) => d?.message).filter(Boolean).join("; ") : void 0;
+        const base = error.error || `Setup account failed: ${response.status}`;
+        throw new Error(detail ? `${base}: ${detail}` : base);
+      }
+      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 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(
+          {
+            account,
+            eoaAddress,
+            sessionOwner
+          },
+          jsonReplacer
+        )
+      });
+      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}`
+        );
+      }
+      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) {
+      return cachedPortfolio(`evm:${address.toLowerCase()}`, async () => {
+        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}`
+          );
+        }
+        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) {
+          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) {
+      return cachedPortfolio(`sol:${address}`, async () => {
+        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 normalized = txHash.startsWith("0x") || txHash.startsWith("0X") ? txHash.toLowerCase() : txHash;
+      const txHashParam = encodeURIComponent(normalized);
+      const url = apiUrl(
+        `/deposits?account=${encodeURIComponent(address)}&txHash=${txHashParam}&limit=1`
+      );
+      const response = await fetch(url, {
+        method: "GET",
+        headers: { "Content-Type": "application/json" },
+        cache: "no-store"
+      });
+      if (!response.ok) {
+        debugLog(debug, scope, "fetchStatus:miss", {
+          address,
+          txHash: shortRef(normalized),
+          status: response.status
+        });
+        return { lastEvent: void 0 };
+      }
+      const body = await response.json();
+      const row = body.deposits?.[0];
+      const lastEvent = row ? depositRowToEvent(row) : void 0;
+      debugLog(debug, scope, "fetchStatus:success", {
+        address,
+        txHash: shortRef(normalized),
+        eventType: lastEvent?.type
+      });
+      return { lastEvent };
+    },
+    async fetchLatestStatus(address) {
+      const url = apiUrl(
+        `/deposits?account=${encodeURIComponent(address)}&limit=1`
+      );
+      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 };
+      }
+      const body = await response.json();
+      const row = body.deposits?.[0];
+      const lastEvent = row ? depositRowToEvent(row) : void 0;
+      debugLog(debug, scope, "fetchLatestStatus:success", {
+        address,
+        eventType: lastEvent?.type
+      });
+      return { lastEvent };
+    },
+    async relayWithdraw(params) {
+      const { smartAccount, chainId, safeAddress, safeTransaction, signature } = params;
+      const url = apiUrl(`/safe/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(
+          {
+            chainId,
+            safeAddress,
+            safeTransaction: {
+              to: safeTransaction.to,
+              value: safeTransaction.value.toString(),
+              data: safeTransaction.data,
+              operation: safeTransaction.operation,
+              safeTxGas: safeTransaction.safeTxGas.toString(),
+              baseGas: safeTransaction.baseGas.toString(),
+              gasPrice: safeTransaction.gasPrice.toString(),
+              gasToken: safeTransaction.gasToken,
+              refundReceiver: safeTransaction.refundReceiver,
+              nonce: safeTransaction.nonce.toString()
+            },
+            signature
+          },
+          jsonReplacer
+        )
+      });
+      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}`
+        );
+      }
+      const result = await response.json();
+      debugLog(debug, scope, "relayWithdraw:success", {
+        smartAccount,
+        chainId,
+        safeAddress,
+        txHash: result?.txHash ? shortRef(result.txHash) : void 0
+      });
+      return result;
+    },
+    async submitPolymarketWithdraw(params) {
+      const { depositWallet, owner, nonce, deadline, calls, signature } = params;
+      const url = apiUrl(`/polymarket/withdraw`);
+      debugLog(debug, scope, "submitPolymarketWithdraw:request", {
+        url,
+        depositWallet,
+        owner,
+        nonce,
+        callCount: calls.length
+      });
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          depositWallet,
+          owner,
+          nonce,
+          deadline,
+          calls,
+          signature
+        })
+      });
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: "Unknown error" }));
+        debugError(debug, scope, "submitPolymarketWithdraw:failed", error, {
+          status: response.status,
+          depositWallet,
+          owner
+        });
+        throw new Error(
+          error.error || `Polymarket withdraw failed: ${response.status}`
+        );
+      }
+      const result = await response.json();
+      debugLog(debug, scope, "submitPolymarketWithdraw:success", {
+        depositWallet,
+        txHash: result?.txHash ? shortRef(result.txHash) : void 0
+      });
+      return result;
+    },
+    async fetchDepositHistory(params) {
+      const searchParams = new URLSearchParams({ recipient: params.recipient });
+      searchParams.set("limit", String(params.limit ?? 20));
+      if (params.cursor) {
+        searchParams.set("cursor", params.cursor);
+      }
+      const url = apiUrl(`/deposits?${searchParams.toString()}`);
+      debugLog(debug, scope, "fetchDepositHistory:request", {
+        url,
+        recipient: shortRef(params.recipient),
+        cursor: params.cursor
+      });
+      const response = await fetch(url, {
+        method: "GET",
+        headers: { "Content-Type": "application/json" },
+        cache: "no-store"
+      });
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: "Unknown error" }));
+        debugError(
+          debug,
+          scope,
+          "fetchDepositHistory:failed",
+          error,
+          { status: response.status, recipient: shortRef(params.recipient) }
+        );
+        throw new Error(
+          error.error || `Deposit history fetch failed: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      const deposits = Array.isArray(data?.deposits) ? data.deposits : [];
+      const nextCursor = data?.nextCursor ?? data?.next_cursor ?? null;
+      debugLog(debug, scope, "fetchDepositHistory:success", {
+        recipient: shortRef(params.recipient),
+        count: deposits.length,
+        hasMore: Boolean(nextCursor)
+      });
+      return { deposits, nextCursor };
+    },
+    async checkLiquidity(params) {
+      if (params.destinationChainId === "solana") {
+        const token = getSolanaTokenByMint(params.destinationToken);
+        return {
+          hasLiquidity: true,
+          symbol: token?.symbol ?? "Token",
+          decimals: token?.decimals ?? 9,
+          unlimited: true,
+          maxAmount: null
+        };
+      }
+      const searchParams = new URLSearchParams({
+        sourceChainId: String(params.sourceChainId),
+        sourceToken: params.sourceToken,
+        destinationChainId: String(params.destinationChainId),
+        destinationToken: params.destinationToken,
+        amount: params.amount
+      });
+      const url = apiUrl(`/liquidity?${searchParams.toString()}`);
+      debugLog(debug, scope, "checkLiquidity:request", {
+        url,
+        sourceChainId: params.sourceChainId,
+        destinationChainId: params.destinationChainId,
+        amount: params.amount
+      });
+      const response = await fetch(url, {
+        method: "GET",
+        headers: { "Content-Type": "application/json" },
+        cache: "no-store"
+      });
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: "Unknown error" }));
+        debugError(debug, scope, "checkLiquidity:failed", error, {
+          status: response.status
+        });
+        throw new Error(
+          error.error || `Liquidity check failed: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      const result = {
+        hasLiquidity: data.hasLiquidity === true,
+        symbol: typeof data.symbol === "string" ? data.symbol : "",
+        decimals: typeof data.decimals === "number" ? data.decimals : 0,
+        unlimited: data.unlimited === true,
+        maxAmount: typeof data.maxAmount === "string" ? data.maxAmount : null
+      };
+      debugLog(debug, scope, "checkLiquidity:success", {
+        hasLiquidity: result.hasLiquidity,
+        unlimited: result.unlimited,
+        maxAmount: result.maxAmount
+      });
+      return result;
+    },
+    async getQuotePreview(params) {
+      const url = apiUrl("/quotes/preview");
+      const body = {
+        account: params.account,
+        sourceChainId: `eip155:${params.sourceChainId}`,
+        sourceToken: params.sourceToken,
+        amount: params.amount
+      };
+      debugLog(debug, scope, "getQuotePreview:request", {
+        url,
+        sourceChainId: body.sourceChainId,
+        sourceToken: params.sourceToken,
+        amount: params.amount
+      });
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body),
+          cache: "no-store"
+        });
+        if (!response.ok) {
+          debugLog(debug, scope, "getQuotePreview:unavailable", {
+            status: response.status
+          });
+          return null;
+        }
+        const quote = await response.json();
+        debugLog(debug, scope, "getQuotePreview:success", {
+          settlementLayer: quote.settlementLayer,
+          totalUsd: quote.fees?.totalUsd
+        });
+        return quote;
+      } catch (error) {
+        debugError(debug, scope, "getQuotePreview:error", error);
+        return null;
+      }
+    },
+    async fetchPrices(symbols) {
+      const list = symbols.filter((s) => s.length > 0);
+      if (list.length === 0) return {};
+      const url = apiUrl(
+        `/prices?${new URLSearchParams({ symbols: list.join(",") }).toString()}`
+      );
+      try {
+        const response = await fetch(url, {
+          method: "GET",
+          headers: { "Content-Type": "application/json" },
+          cache: "no-store"
+        });
+        if (!response.ok) {
+          debugError(debug, scope, "fetchPrices:failed", {
+            status: response.status
+          });
+          return {};
+        }
+        const data = await response.json();
+        return Object.fromEntries(
+          Object.entries(data.prices ?? {}).map(([symbol, price]) => [
+            symbol.toUpperCase(),
+            price
+          ])
+        );
+      } catch (err) {
+        debugError(debug, scope, "fetchPrices:error", err);
+        return {};
+      }
+    },
+    async getSwappedWidgetUrl(params) {
+      const url = apiUrl("/onramp/swapped/widget-url");
+      debugLog(debug, scope, "getSwappedWidgetUrl:request", {
+        smartAccount: shortRef(params.smartAccount),
+        method: params.method
+      });
+      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, "getSwappedWidgetUrl:failed", error, {
+          status: response.status
+        });
+        throw new Error(
+          error.error || `Swapped widget URL failed: ${response.status}`
+        );
+      }
+      const body = await response.json();
+      if (typeof body.url !== "string" || typeof body.currencyCode !== "string" || typeof body.externalCustomerId !== "string") {
+        throw new Error("Swapped widget URL: malformed response");
+      }
+      return {
+        url: body.url,
+        currencyCode: body.currencyCode,
+        sandbox: body.sandbox === true,
+        externalCustomerId: body.externalCustomerId,
+        expiresAt: body.expiresAt
+      };
+    },
+    async getSwappedConnectUrl(params) {
+      const url = apiUrl("/onramp/swapped/connect-url");
+      debugLog(debug, scope, "getSwappedConnectUrl:request", {
+        smartAccount: shortRef(params.smartAccount),
+        connection: params.connection
+      });
+      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, "getSwappedConnectUrl:failed", error, {
+          status: response.status
+        });
+        throw new Error(
+          error.error || `Swapped Connect URL failed: ${response.status}`
+        );
+      }
+      const body = await response.json();
+      if (typeof body.url !== "string" || typeof body.currencyCode !== "string" || typeof body.externalCustomerId !== "string") {
+        throw new Error("Swapped Connect URL: malformed response");
+      }
+      return {
+        url: body.url,
+        currencyCode: body.currencyCode,
+        sandbox: body.sandbox === true,
+        externalCustomerId: body.externalCustomerId,
+        expiresAt: body.expiresAt
+      };
+    },
+    async getSwappedConnectExchanges() {
+      const url = apiUrl("/onramp/swapped/connect-exchanges");
+      debugLog(debug, scope, "getSwappedConnectExchanges:request");
+      const response = await fetch(url, {
+        method: "GET",
+        headers: { "Content-Type": "application/json" },
+        cache: "no-store"
+      });
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: "Unknown error" }));
+        debugError(debug, scope, "getSwappedConnectExchanges:failed", error, {
+          status: response.status
+        });
+        throw new Error(
+          error.error || `Swapped Connect exchanges failed: ${response.status}`
+        );
+      }
+      const body = await response.json();
+      const rawExchanges = Array.isArray(body.exchanges) ? body.exchanges : null;
+      const exchanges = [];
+      let hasMalformedExchange = rawExchanges === null;
+      for (const exchange of rawExchanges ?? []) {
+        if (!exchange || typeof exchange !== "object") {
+          hasMalformedExchange = true;
+          continue;
+        }
+        const raw = exchange;
+        const connection = typeof raw.connection === "string" ? raw.connection : "";
+        const name = typeof raw.name === "string" ? raw.name : "";
+        const logoUrl = typeof raw.logoUrl === "string" || raw.logoUrl === null ? raw.logoUrl : null;
+        if (!connection || !name) {
+          hasMalformedExchange = true;
+          continue;
+        }
+        exchanges.push({ connection, name, logoUrl });
+      }
+      if (hasMalformedExchange || typeof body.fetchedAt !== "string" || typeof body.expiresAt !== "string") {
+        throw new Error("Swapped Connect exchanges: malformed response");
+      }
+      return {
+        exchanges,
+        fetchedAt: body.fetchedAt,
+        expiresAt: body.expiresAt,
+        stale: body.stale === true ? true : void 0
+      };
+    },
+    async fetchSwappedOrderStatus(smartAccount) {
+      const url = apiUrl(
+        `/onramp/swapped/status/${encodeURIComponent(smartAccount)}`
+      );
+      const response = await fetch(url, {
+        method: "GET",
+        headers: { "Content-Type": "application/json" },
+        cache: "no-store"
+      });
+      if (!response.ok) return null;
+      let body = null;
+      try {
+        body = await response.json();
+      } catch {
+        return null;
+      }
+      if (!body || body.ok !== true) return null;
+      const status = typeof body.status === "string" ? body.status : null;
+      const orderId = typeof body.orderId === "string" ? body.orderId : null;
+      if (!status || !orderId) return null;
+      const numericOrNull = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+      return {
+        orderId,
+        status,
+        orderCrypto: typeof body.orderCrypto === "string" ? body.orderCrypto : null,
+        orderCryptoAmount: typeof body.orderCryptoAmount === "string" ? body.orderCryptoAmount : null,
+        transactionId: typeof body.transactionId === "string" ? body.transactionId : null,
+        receivedAt: typeof body.receivedAt === "string" ? body.receivedAt : null,
+        paidAmountUsd: numericOrNull(body.paidAmountUsd),
+        paidAmountEur: numericOrNull(body.paidAmountEur),
+        onrampFeeUsd: numericOrNull(body.onrampFeeUsd),
+        paymentMethod: typeof body.paymentMethod === "string" ? body.paymentMethod : null
+      };
+    }
+  };
+}
+function normalizeDirectPortfolio(data) {
+  const rawTokens = extractArray(data, "tokens") ?? extractArray(
+    data?.data,
+    "tokens"
+  ) ?? [];
+  const totalUsd = extractNumber(data, "totalUsd") ?? extractNumber(data?.data, "totalUsd") ?? 0;
+  const tokens = rawTokens.map((token) => normalizeDirectToken(token)).filter((token) => Boolean(token));
+  return { tokens, totalUsd };
+}
+function extractOrchestratorPortfolio(data) {
+  const portfolio = extractArray(data, "portfolio") ?? extractArray(
+    data?.data,
+    "portfolio"
+  );
+  if (!portfolio || !Array.isArray(portfolio)) return null;
+  return { portfolio };
+}
+function normalizeOrchestratorPortfolio(data) {
+  const tokens = [];
+  for (const tokenData of data.portfolio || []) {
+    const chainBalances = tokenData.tokenChainBalance ?? tokenData.chainBalances ?? [];
+    for (const chainBalance of chainBalances) {
+      const unlocked = chainBalance.balance?.unlocked ?? "0";
+      const normalizedName = tokenData.tokenName.trim();
+      const isNativeSymbol = normalizedName.toUpperCase() === "ETH" || normalizedName.toUpperCase() === "ETHER";
+      const tokenAddress = chainBalance.tokenAddress ?? extractTokenAddress(tokenData, chainBalance.chainId) ?? getTokenAddress(tokenData.tokenName, chainBalance.chainId);
+      const resolvedTokenAddress = isNativeSymbol ? NATIVE_TOKEN_ADDRESS : tokenAddress;
+      if (!resolvedTokenAddress) {
+        continue;
+      }
+      const registrySymbol = getTokenSymbol(resolvedTokenAddress, chainBalance.chainId);
+      const symbol = registrySymbol !== "Token" ? registrySymbol : normalizedName || "Token";
+      const decimals = registrySymbol !== "Token" ? getTokenDecimalsByAddress(resolvedTokenAddress, chainBalance.chainId) : tokenData.tokenDecimals ?? 18;
+      tokens.push({
+        chainId: chainBalance.chainId,
+        address: resolvedTokenAddress,
+        symbol,
+        name: symbol,
+        decimals,
+        balance: unlocked,
+        balanceUsd: 0
+      });
+    }
+  }
+  return {
+    tokens,
+    totalUsd: 0
+  };
+}
+function normalizeDirectToken(token) {
+  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();
+  if (!balanceValue) return null;
+  const address = extractString(token, "address") ?? extractString(token, "tokenAddress") ?? extractString(
+    token.token,
+    "address"
+  ) ?? (typeof chainId === "number" ? getTokenAddress(symbol, chainId) : void 0);
+  if (!address) return null;
+  const balanceUsd = extractNumber(token, "balanceUsd") ?? extractNumber(token, "usdValue") ?? extractNumber(token, "valueUsd") ?? extractNumericString(token, "balanceUsd") ?? extractNumericString(token, "usdValue") ?? extractNumericString(token, "valueUsd") ?? 0;
+  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 = !isSolanaToken && registrySymbol !== "Token" ? getTokenDecimalsByAddress(address, chainId) : backendDecimals ?? 18;
+  return {
+    chainId,
+    address,
+    symbol: resolvedSymbol,
+    name: resolvedSymbol,
+    decimals: resolvedDecimals,
+    balance: balanceValue,
+    balanceUsd
+  };
+}
+function extractTokenAddress(tokenData, chainId) {
+  const token = tokenData;
+  return token.tokenAddress ?? token.address ?? token.addresses?.[chainId] ?? token.token?.address ?? token.token?.addresses?.[chainId];
+}
+function extractArray(data, key) {
+  if (!data || typeof data !== "object") return null;
+  const record = data;
+  const value = record[key];
+  return Array.isArray(value) ? value : null;
+}
+function extractNumber(data, key) {
+  if (!data || typeof data !== "object") return null;
+  const record = data;
+  const value = record[key];
+  return typeof value === "number" ? value : null;
+}
+function extractString(data, key) {
+  if (!data || typeof data !== "object") return null;
+  const record = data;
+  const value = record[key];
+  return typeof value === "string" ? value : null;
+}
+function extractNumericString(data, key) {
+  const value = extractString(data, key);
+  if (!value) return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+// src/core/formatters.ts
+var currencyFormatter = new Intl.NumberFormat("en-US", {
+  style: "currency",
+  currency: "USD",
+  maximumFractionDigits: 2
+});
+var tokenFormatter = new Intl.NumberFormat("en-US", {
+  minimumFractionDigits: 2,
+  maximumFractionDigits: 5
+});
+function isUnsupportedChainSwitchError(error) {
+  if (!error) return false;
+  const name = error instanceof Error ? error.name : "";
+  const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
+  return name === "SwitchChainNotSupportedError" || message.includes("does not support programmatic chain switching") || message.includes("switch chain not supported") || message.includes("method not found") || message.includes("does not exist") || message.includes("is not available");
+}
+function formatUserError(raw) {
+  const lower = raw.toLowerCase();
+  if (lower.includes("user rejected") || lower.includes("user denied")) {
+    return "Transaction cancelled";
+  }
+  if (lower.includes("insufficient funds")) {
+    return "Insufficient funds for this transaction";
+  }
+  if (lower.includes("nonce too low") || lower.includes("nonce too high")) {
+    return "Transaction conflict \u2014 please try again";
+  }
+  if (lower.includes("execution reverted")) {
+    return "Transaction would fail on-chain";
+  }
+  if (lower.includes("timed out") || lower.includes("took too long")) {
+    return "Request timed out \u2014 please try again";
+  }
+  if (lower.includes("econnrefused") || lower.includes("econnreset") || lower.includes("enotfound") || lower.includes("fetch failed")) {
+    return "Service unavailable \u2014 please try again";
+  }
+  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";
+  }
+  if (lower.includes("rate limit") || lower.includes("429")) {
+    return "Rate limited \u2014 please try again shortly";
+  }
+  let cleaned = raw;
+  const stripMarkers = [
+    "\n\nRequest Arguments:",
+    "\nRaw Call Arguments:",
+    "\nRequest body:",
+    "\nContract Call:",
+    "\nDocs:",
+    "\nDetails:",
+    "\nVersion:",
+    "\nURL:"
+  ];
+  for (const marker of stripMarkers) {
+    const idx = cleaned.indexOf(marker);
+    if (idx !== -1) {
+      cleaned = cleaned.slice(0, idx).trim();
+    }
+  }
+  cleaned = cleaned.replace(/https?:\/\/\S+/g, "").trim();
+  if (cleaned.length === 0) {
+    return "An unexpected error occurred";
+  }
+  if (cleaned.length > 120) {
+    return cleaned.slice(0, 120) + "...";
+  }
+  return cleaned;
+}
+
+// src/core/public-client.ts
+import { createPublicClient, http } from "viem";
+import { hyperliquid } from "viem/chains";
+var clientCache = /* @__PURE__ */ new Map();
+function getPublicClient(chainId) {
+  let client = clientCache.get(chainId);
+  if (!client) {
+    const chain = CHAIN_BY_ID[chainId];
+    client = createPublicClient({
+      chain,
+      transport: http()
+    });
+    clientCache.set(chainId, client);
+  }
+  return client;
+}
+var hyperEvmClient;
+function getHyperEvmReadClient() {
+  if (!hyperEvmClient) {
+    hyperEvmClient = createPublicClient({
+      chain: hyperliquid,
+      transport: http()
+    });
+  }
+  return hyperEvmClient;
+}
+
+// src/core/theme.ts
+var RADIUS_SCALE = {
+  none: { sm: "0", md: "0", lg: "0" },
+  sm: { sm: "4px", md: "6px", lg: "8px" },
+  md: { sm: "8px", md: "10px", lg: "14px" },
+  lg: { sm: "10px", md: "14px", lg: "18px" },
+  full: { sm: "9999px", md: "9999px", lg: "9999px" }
+};
+function setVar(targets, prop, value) {
+  for (const el of targets) {
+    el.style.setProperty(prop, value);
+  }
+}
+function clearVar(targets, prop) {
+  for (const el of targets) {
+    el.style.removeProperty(prop);
+  }
+}
+function normalizeHex(input) {
+  const v = input.trim().replace(/^#/, "");
+  if (/^[0-9a-fA-F]{3}$/.test(v)) {
+    return v.split("").map((c) => c + c).join("").toLowerCase();
+  }
+  if (/^[0-9a-fA-F]{6}$/.test(v)) return v.toLowerCase();
+  return null;
+}
+function hexToHsl(hex) {
+  const normalized = normalizeHex(hex);
+  if (!normalized) return null;
+  const r = parseInt(normalized.slice(0, 2), 16) / 255;
+  const g = parseInt(normalized.slice(2, 4), 16) / 255;
+  const b = parseInt(normalized.slice(4, 6), 16) / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const l = (max + min) / 2;
+  let h = 0;
+  let s = 0;
+  if (max !== min) {
+    const d = max - min;
+    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    switch (max) {
+      case r:
+        h = (g - b) / d + (g < b ? 6 : 0);
+        break;
+      case g:
+        h = (b - r) / d + 2;
+        break;
+      case b:
+        h = (r - g) / d + 4;
+        break;
+    }
+    h *= 60;
+  }
+  return { h, s: s * 100, l: l * 100 };
+}
+var clamp = (n, lo, hi) => Math.max(lo, Math.min(hi, n));
+var hsl = ({ h, s, l }) => `hsl(${h.toFixed(1)} ${clamp(s, 0, 100).toFixed(1)}% ${clamp(l, 0, 100).toFixed(1)}%)`;
+function deriveCustomPrimary(baseHex) {
+  const base = hexToHsl(baseHex);
+  if (!base) return null;
+  const { h, s, l } = base;
+  const direction = l < 25 ? 1 : -1;
+  const hoverL = clamp(l + 8 * direction, 4, 96);
+  const activeL = clamp(l + 14 * direction, 2, 98);
+  const disabledBg = {
+    h,
+    s: clamp(s * 0.25, 0, 20),
+    l: clamp(l > 75 ? l - 15 : 88, 12, 92)
+  };
+  const disabledFg = {
+    h,
+    s: clamp(s * 0.35, 0, 25),
+    l: clamp(l > 75 ? 35 : 45, 30, 60)
+  };
+  const norm = normalizeHex(baseHex);
+  const ch = (i) => {
+    const v = parseInt(norm.slice(i, i + 2), 16) / 255;
+    return v <= 0.03928 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+  };
+  const y = 0.2126 * ch(0) + 0.7152 * ch(2) + 0.0722 * ch(4);
+  const foreground = y > 0.45 ? "#18181b" : "#fafafa";
+  return {
+    base: hsl({ h, s, l }),
+    hover: hsl({ h, s, l: hoverL }),
+    active: hsl({ h, s, l: activeL }),
+    disabledBg: hsl(disabledBg),
+    disabledFg: hsl(disabledFg),
+    foreground
+  };
+}
+var CUSTOM_PRIMARY_VARS = [
+  "--rs-primary",
+  "--rs-primary-hover",
+  "--rs-primary-active",
+  "--rs-primary-disabled-bg",
+  "--rs-primary-disabled-fg",
+  "--rs-primary-foreground",
+  "--rs-border-accent"
+];
+function applyTheme(element, theme) {
+  if (!element) return;
+  const parent = element.parentElement;
+  const targets = parent?.classList.contains("rs-modal-content") ? [element, parent] : [element];
+  if (theme?.mode) {
+    for (const t of targets) t.setAttribute("data-theme", theme.mode);
+  } else {
+    for (const t of targets) t.removeAttribute("data-theme");
+  }
+  if (theme?.fontColor) {
+    setVar(targets, "--rs-foreground", theme.fontColor);
+  }
+  if (theme?.iconColor) {
+    setVar(targets, "--rs-icon", theme.iconColor);
+  }
+  if (theme?.ctaColor) {
+    const derived = deriveCustomPrimary(theme.ctaColor);
+    if (derived) {
+      setVar(targets, "--rs-primary", derived.base);
+      setVar(
+        targets,
+        "--rs-primary-hover",
+        theme.ctaHoverColor ?? derived.hover
+      );
+      setVar(targets, "--rs-primary-active", derived.active);
+      setVar(targets, "--rs-primary-disabled-bg", derived.disabledBg);
+      setVar(targets, "--rs-primary-disabled-fg", derived.disabledFg);
+      setVar(targets, "--rs-primary-foreground", derived.foreground);
+      setVar(targets, "--rs-border-accent", derived.base);
+    } else {
+      setVar(targets, "--rs-primary", theme.ctaColor);
+      setVar(targets, "--rs-border-accent", theme.ctaColor);
+      setVar(
+        targets,
+        "--rs-primary-hover",
+        theme.ctaHoverColor ?? theme.ctaColor
+      );
+    }
+  } else {
+    for (const v of CUSTOM_PRIMARY_VARS) clearVar(targets, v);
+    if (theme?.ctaHoverColor) {
+      setVar(targets, "--rs-primary-hover", theme.ctaHoverColor);
+    }
+  }
+  if (theme?.borderColor) {
+    setVar(targets, "--rs-border", theme.borderColor);
+    setVar(targets, "--rs-border-surface", theme.borderColor);
+  }
+  if (theme?.backgroundColor) {
+    setVar(targets, "--rs-background", theme.backgroundColor);
+  }
+  if (theme?.radius) {
+    const scale = RADIUS_SCALE[theme.radius];
+    setVar(targets, "--rs-radius-sm", scale.sm);
+    setVar(targets, "--rs-radius-md", scale.md);
+    setVar(targets, "--rs-radius-lg", scale.lg);
+    setVar(targets, "--rs-radius", scale.md);
+  }
+}
+
+// src/components/ui/BodyHeader.tsx
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+function BodyHeader({
+  icon,
+  title,
+  subtitle,
+  variant = "default"
+}) {
+  const iconClasses = [
+    "rs-body-header-icon",
+    variant === "success" ? "rs-body-header-icon--success" : "",
+    variant === "error" ? "rs-body-header-icon--error" : ""
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxs2("div", { className: "rs-body-header", children: [
+    /* @__PURE__ */ jsx4("div", { className: iconClasses, children: icon }),
+    /* @__PURE__ */ jsxs2("div", { className: "rs-body-header-text", children: [
+      /* @__PURE__ */ jsx4("h2", { className: "rs-body-header-title", children: title }),
+      subtitle && /* @__PURE__ */ jsx4("p", { className: "rs-body-header-subtitle", children: subtitle })
+    ] })
+  ] });
+}
+BodyHeader.displayName = "BodyHeader";
+
+// src/components/ui/PoweredBy.tsx
+import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+var rhinestoneLogo = /* @__PURE__ */ jsxs3(
+  "svg",
+  {
+    className: "rs-powered-by-logo",
+    viewBox: "0 0 72 16",
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg",
+    "aria-hidden": "true",
+    children: [
+      /* @__PURE__ */ jsxs3("g", { fill: "currentColor", clipPath: "url(#rs-pb-clip)", children: [
+        /* @__PURE__ */ jsx5(
+          "path",
+          {
+            opacity: "0.5",
+            fillRule: "evenodd",
+            clipRule: "evenodd",
+            d: "M10.48 14.82a4.3 4.3 0 0 1-2.9 1 4.3 4.3 0 0 1-2.4-1 25 25 0 0 1-2.08-1.95l-.13-.13c-.78-.78-1.46-1.46-1.94-2.08a4.3 4.3 0 0 1-1-2.9c.05-.96.48-1.72 1-2.4a25 25 0 0 1 1.94-2.08l.07-.06.06-.07a25 25 0 0 1 2.08-1.94 4.3 4.3 0 0 1 2.9-1c.96.05 1.73.48 2.4 1 .62.49 1.3 1.17 2.08 1.94l.13.13c.77.78 1.46 1.46 1.94 2.09a4.3 4.3 0 0 1 1 2.9 4.3 4.3 0 0 1-1 2.39c-.48.62-1.17 1.3-1.94 2.08l-.07.07-.06.06c-.78.78-1.46 1.46-2.08 1.94m-8.9-6.63c.07 1.02.9 1.86 2.56 3.52s2.5 2.5 3.53 2.56h.32c1.03-.06 1.86-.9 3.53-2.56s2.5-2.5 2.56-3.52v-.33c-.07-1.03-.9-1.86-2.56-3.52-1.67-1.67-2.5-2.5-3.53-2.56h-.32c-1.03.06-1.86.89-3.53 2.56-1.66 1.66-2.5 2.5-2.56 3.52z"
+          }
+        ),
+        /* @__PURE__ */ jsx5("path", { d: "M3.66 8.01q.02-.27.28-.35a4.6 4.6 0 0 0 2.53-1.48q.72-.8 1-2.05a.4.4 0 0 1 .36-.29c.17 0 .32.12.36.29a4.6 4.6 0 0 0 1.47 2.52c.55.49 1.21.8 2.06 1a.4.4 0 0 1 .28.36.4.4 0 0 1-.28.36 4.6 4.6 0 0 0-2.53 1.47 4.6 4.6 0 0 0-1 2.06.4.4 0 0 1-.36.28.4.4 0 0 1-.36-.28A4.6 4.6 0 0 0 6 9.38a4.6 4.6 0 0 0-2.06-1.01.4.4 0 0 1-.28-.36m26.46-3.44c0 .51.38.87.96.87s.95-.36.95-.87c0-.52-.37-.86-.95-.86s-.96.34-.96.86m.2 1.44v5.33h1.53V6.01zm-4.4 5.33h-1.55V3.88h1.54v2.98c.25-.5.8-1.01 1.6-1.01 1.29 0 1.87.83 1.87 2.28v3.21h-1.54V8.3c0-.77-.34-1.16-.92-1.16-.67 0-1 .53-1 1.3zm-4.45 0h-1.54V6.01h1.54l-.27 1.22a.1.1 0 0 0 .02.1.1.1 0 0 0 .1.04q.09 0 .1-.09c.24-.84.93-1.36 1.64-1.36q.4.01.57.05v1.42l-.67-.04c-.67 0-1.5.31-1.5 2zm13 0h-1.55V6.01h1.54l-.02.9a1.8 1.8 0 0 1 1.61-1.06c1.3 0 1.88.83 1.88 2.28v3.21H36.4V8.3c0-.77-.35-1.16-.93-1.16-.67 0-1 .53-1 1.3z" }),
+        /* @__PURE__ */ jsx5(
+          "path",
+          {
+            fillRule: "evenodd",
+            clipRule: "evenodd",
+            d: "M38.74 8.69c0 1.63 1.01 2.82 2.7 2.82 1.51 0 2.32-.82 2.55-1.73l-1.43-.26c-.1.37-.47.82-1.12.82-.67 0-1.23-.6-1.24-1.31H44q.05-.19.06-.56a2.55 2.55 0 0 0-2.6-2.63c-1.5 0-2.72 1.2-2.72 2.85m3.82-.58h-2.3a1.2 1.2 0 0 1 1.18-1.13c.6 0 1.14.45 1.12 1.13"
+          }
+        ),
+        /* @__PURE__ */ jsx5("path", { d: "M47.1 11.51c-1.2 0-2.33-.41-2.55-1.65l1.43-.21q.27.8 1.1.79c.5 0 .77-.24.77-.55 0-.27-.2-.45-.75-.55l-.5-.1c-1.1-.24-1.77-.74-1.77-1.63 0-1.06.91-1.78 2.25-1.78 1.26 0 2.2.59 2.32 1.68l-1.41.22c-.07-.52-.43-.82-.91-.82-.5 0-.75.26-.75.57 0 .25.17.42.63.51l.5.1c1.28.26 1.94.77 1.94 1.75 0 1.01-1.03 1.66-2.3 1.66" }),
+        /* @__PURE__ */ jsx5(
+          "path",
+          {
+            fillRule: "evenodd",
+            clipRule: "evenodd",
+            d: "M54.44 8.68c0 1.53 1.08 2.83 2.78 2.83s2.79-1.3 2.79-2.83c0-1.55-1.1-2.84-2.79-2.84-1.7 0-2.78 1.29-2.78 2.84m4.02 0c0 .98-.59 1.45-1.24 1.45-.64 0-1.23-.47-1.23-1.45 0-.97.59-1.47 1.23-1.47.65 0 1.24.48 1.24 1.47"
+          }
+        ),
+        /* @__PURE__ */ jsx5("path", { d: "M62.4 11.34h-1.53V6.01h1.54l-.02.9a1.8 1.8 0 0 1 1.6-1.06c1.3 0 1.89.83 1.89 2.28v3.21h-1.54V8.3c0-.77-.34-1.16-.93-1.16-.66 0-1 .53-1 1.3z" }),
+        /* @__PURE__ */ jsx5(
+          "path",
+          {
+            fillRule: "evenodd",
+            clipRule: "evenodd",
+            d: "M66.68 8.69c0 1.63 1.02 2.82 2.71 2.82 1.51 0 2.31-.82 2.55-1.73l-1.44-.26c-.1.37-.47.82-1.12.82-.67 0-1.23-.6-1.24-1.31h3.8q.06-.19.06-.56a2.55 2.55 0 0 0-2.6-2.63c-1.5 0-2.72 1.2-2.72 2.85m3.82-.58h-2.3a1.2 1.2 0 0 1 1.18-1.13c.6 0 1.15.45 1.12 1.13"
+          }
+        ),
+        /* @__PURE__ */ jsx5("path", { d: "M52.44 9.05V7.26h1.53V6h-1.53V4.42h-1.53V6h-1.1v1.26h1.1v1.85l.02.49a1.9 1.9 0 0 0 1.67 1.67c.22.03.47.03.62.03h.65V9.87h-.61c-.4 0-.59 0-.7-.12-.12-.11-.12-.3-.12-.64z" })
+      ] }),
+      /* @__PURE__ */ jsx5("defs", { children: /* @__PURE__ */ jsx5("clipPath", { id: "rs-pb-clip", children: /* @__PURE__ */ jsx5("path", { fill: "#fff", d: "M0 0h72v16H0z" }) }) })
+    ]
+  }
+);
+function PoweredBy() {
+  return /* @__PURE__ */ jsxs3("div", { className: "rs-powered-by", "aria-label": "Powered by Rhinestone", children: [
+    /* @__PURE__ */ jsx5("span", { children: "Powered by" }),
+    /* @__PURE__ */ jsx5(
+      "a",
+      {
+        className: "rs-powered-by-link",
+        href: "https://www.rhinestone.dev",
+        target: "_blank",
+        rel: "noopener noreferrer",
+        children: rhinestoneLogo
+      }
+    )
+  ] });
+}
+PoweredBy.displayName = "PoweredBy";
+
+// src/components/ui/Spinner.tsx
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+function Spinner({ className }) {
+  return /* @__PURE__ */ jsxs4(
+    "svg",
+    {
+      className: `rs-spinner ${className || ""}`,
+      fill: "none",
+      viewBox: "0 0 20 21",
+      children: [
+        /* @__PURE__ */ jsx6(
+          "path",
+          {
+            d: "M10 0.5C8.02 0.5 6.08 1.08 4.44 2.18C2.79 3.28 1.51 4.84 0.76 6.67C0.00 8.50 -0.19 10.51 0.19 12.45C0.57 14.39 1.53 16.17 2.92 17.57C4.32 18.96 6.10 19.92 8.04 20.30C9.98 20.69 11.99 20.49 13.82 19.73C15.65 18.98 17.21 17.70 18.31 16.05C19.41 14.41 20 12.47 20 10.5C20 7.84 18.94 5.30 17.07 3.42C15.19 1.55 12.65 0.5 10 0.5ZM10 17.77C8.56 17.77 7.15 17.34 5.95 16.54C4.76 15.74 3.83 14.61 3.28 13.28C2.73 11.95 2.58 10.49 2.86 9.08C3.14 7.67 3.84 6.37 4.85 5.35C5.87 4.34 7.17 3.64 8.58 3.36C9.99 3.08 11.45 3.23 12.78 3.78C14.11 4.33 15.24 5.26 16.04 6.45C16.84 7.65 17.27 9.06 17.27 10.5C17.27 12.42 16.50 14.27 15.14 15.64C13.77 17.00 11.92 17.77 10 17.77Z",
+            fill: "currentColor",
+            opacity: 0.3
+          }
+        ),
+        /* @__PURE__ */ jsx6(
+          "path",
+          {
+            d: "M10 3.22C11.74 3.22 13.42 3.84 14.75 4.95C16.08 6.07 16.96 7.61 17.25 9.31C17.30 9.64 17.46 9.94 17.71 10.15C17.96 10.37 18.28 10.49 18.62 10.5C18.82 10.50 19.01 10.45 19.20 10.37C19.38 10.29 19.54 10.16 19.67 10.01C19.80 9.86 19.89 9.68 19.95 9.49C20.00 9.30 20.01 9.10 19.98 8.90C19.59 6.56 18.38 4.42 16.55 2.88C14.72 1.34 12.40 0.5 10 0.5C7.59 0.5 5.27 1.34 3.44 2.88C1.61 4.42 0.40 6.56 0.01 8.90C-0.01 9.10 -0.00 9.30 0.04 9.49C0.10 9.68 0.19 9.86 0.32 10.01C0.45 10.16 0.61 10.29 0.79 10.37C0.98 10.45 1.17 10.50 1.37 10.5C1.71 10.49 2.03 10.37 2.28 10.15C2.53 9.94 2.69 9.64 2.74 9.31C3.03 7.61 3.91 6.07 5.24 4.95C6.57 3.84 8.25 3.22 10 3.22Z",
+            fill: "currentColor"
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/components/ui/ListRow.tsx
+import { Fragment, jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+function ListRow({
+  leading,
+  leadingMedia,
+  title,
+  subtitle,
+  meta,
+  trailing,
+  action,
+  className = "",
+  onClick,
+  disabled,
+  ...props
+}) {
+  const inner = /* @__PURE__ */ jsxs5(Fragment, { children: [
+    leadingMedia ? /* @__PURE__ */ jsx7("span", { className: "rs-list-row-leading rs-list-row-leading--media", children: /* @__PURE__ */ jsx7("img", { src: leadingMedia, alt: "" }) }) : leading ? /* @__PURE__ */ jsx7("span", { className: "rs-list-row-leading", children: leading }) : null,
+    /* @__PURE__ */ jsxs5("div", { className: "rs-list-row-body", children: [
+      /* @__PURE__ */ jsxs5("div", { className: "rs-list-row-text", children: [
+        /* @__PURE__ */ jsx7("span", { className: "rs-list-row-title", children: title }),
+        subtitle && /* @__PURE__ */ jsx7("span", { className: "rs-list-row-subtitle", children: subtitle })
+      ] }),
+      action ? /* @__PURE__ */ jsx7(
+        "button",
+        {
+          type: "button",
+          className: "rs-list-row-action",
+          disabled,
+          onClick: (e) => {
+            e.stopPropagation();
+            action.onClick();
+          },
+          children: action.label
+        }
+      ) : meta && /* @__PURE__ */ jsx7("div", { className: "rs-list-row-meta", children: meta })
+    ] }),
+    /* @__PURE__ */ jsx7("span", { className: "rs-list-row-chevron", children: trailing ?? /* @__PURE__ */ jsx7(ChevronRightIcon, {}) })
+  ] });
+  if (action) {
+    const handleKey = (e) => {
+      if (disabled) return;
+      if (e.key === "Enter" || e.key === " ") {
+        e.preventDefault();
+        onClick?.(e);
+      }
+    };
+    return /* @__PURE__ */ jsx7(
+      "div",
+      {
+        className: `rs-list-row ${className}`.trim(),
+        role: "button",
+        tabIndex: disabled ? -1 : 0,
+        "aria-disabled": disabled || void 0,
+        onClick: disabled ? void 0 : (e) => onClick?.(e),
+        onKeyDown: handleKey,
+        children: inner
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx7(
+    "button",
+    {
+      type: "button",
+      className: `rs-list-row ${className}`.trim(),
+      onClick,
+      disabled,
+      ...props,
+      children: inner
+    }
+  );
+}
+ListRow.displayName = "ListRow";
+
+// src/components/ui/WalletBadgeIcons/RabbyIcon.tsx
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+function RabbyIcon() {
+  return /* @__PURE__ */ jsxs6(
+    "svg",
+    {
+      width: "20",
+      height: "20",
+      viewBox: "0 0 20 20",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      children: [
+        /* @__PURE__ */ jsxs6("g", { clipPath: "url(#rs-rabby-clip)", children: [
+          /* @__PURE__ */ jsx8(
+            "mask",
+            {
+              id: "rs-rabby-mask",
+              style: { maskType: "luminance" },
+              maskUnits: "userSpaceOnUse",
+              x: "0",
+              y: "0",
+              width: "20",
+              height: "20",
+              children: /* @__PURE__ */ jsx8(
+                "path",
+                {
+                  d: "M20 10C20 4.47 15.52 0 10 0C4.47 0 0 4.47 0 10C0 15.52 4.47 20 10 20C15.52 20 20 15.52 20 10Z",
+                  fill: "white"
+                }
+              )
+            }
+          ),
+          /* @__PURE__ */ jsxs6("g", { mask: "url(#rs-rabby-mask)", children: [
+            /* @__PURE__ */ jsx8(
+              "path",
+              {
+                d: "M20 10C20 4.47 15.52 0 10 0C4.47 0 0 4.47 0 10C0 15.52 4.47 20 10 20C15.52 20 20 15.52 20 10Z",
+                fill: "#7084FF"
+              }
+            ),
+            /* @__PURE__ */ jsx8(
+              "path",
+              {
+                d: "M17.25 10.86C17.82 9.57 14.98 5.97 12.26 4.47C10.55 3.31 8.77 3.47 8.41 3.98C7.62 5.10 11.03 6.05 13.32 7.16C12.83 7.37 12.36 7.76 12.09 8.25C11.24 7.31 9.37 6.51 7.18 7.16C5.70 7.59 4.47 8.62 3.99 10.18C3.85 10.11 3.70 10.09 3.54 10.10C3.39 10.11 3.24 10.16 3.11 10.25C2.98 10.33 2.87 10.45 2.80 10.58C2.72 10.72 2.69 10.87 2.69 11.03C2.69 11.55 3.10 11.96 3.62 11.96C3.71 11.96 4.01 11.90 4.01 11.90L8.77 11.93C6.87 14.96 5.36 15.41 5.36 15.93C5.36 16.46 6.80 16.32 7.34 16.12C9.93 15.18 12.71 12.26 13.19 11.42C15.19 11.67 16.87 11.70 17.25 10.86Z",
+                fill: "url(#rs-rabby-grad0)"
+              }
+            ),
+            /* @__PURE__ */ jsx8(
+              "path",
+              {
+                fillRule: "evenodd",
+                clipRule: "evenodd",
+                d: "M13.31 7.15L13.32 7.16C13.42 7.11 13.41 6.96 13.38 6.83C13.31 6.55 12.16 5.41 11.07 4.90C9.60 4.20 8.51 4.23 8.35 4.56C8.65 5.18 10.04 5.76 11.50 6.36C12.12 6.62 12.75 6.88 13.31 7.15Z",
+                fill: "url(#rs-rabby-grad1)"
+              }
+            ),
+            /* @__PURE__ */ jsx8(
+              "path",
+              {
+                fillRule: "evenodd",
+                clipRule: "evenodd",
+                d: "M11.45 13.38C11.11 13.26 10.77 13.15 10.43 13.07C10.84 12.33 10.92 11.25 10.54 10.56C10.00 9.60 9.32 9.08 7.73 9.08C6.87 9.08 4.53 9.38 4.48 11.34C4.48 11.54 4.48 11.73 4.50 11.90L8.77 11.93C8.20 12.85 7.66 13.53 7.18 14.05C7.75 14.19 8.22 14.32 8.65 14.43C9.06 14.54 9.43 14.63 9.82 14.73C10.41 14.30 10.96 13.83 11.45 13.38Z",
+                fill: "url(#rs-rabby-grad2)"
+              }
+            ),
+            /* @__PURE__ */ jsx8(
+              "path",
+              {
+                d: "M3.94 11.70C4.11 13.19 4.96 13.77 6.68 13.94C8.40 14.12 9.39 14.00 10.71 14.12C11.81 14.22 12.79 14.78 13.15 14.59C13.48 14.42 13.30 13.78 12.86 13.38C12.29 12.85 11.50 12.49 10.12 12.36C10.39 11.60 10.32 10.54 9.89 9.96C9.27 9.12 8.13 8.75 6.68 8.91C5.17 9.08 3.72 9.83 3.94 11.70Z",
+                fill: "url(#rs-rabby-grad3)"
+              }
+            )
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs6("defs", { children: [
+          /* @__PURE__ */ jsxs6(
+            "linearGradient",
+            {
+              id: "rs-rabby-grad0",
+              x1: "7.00",
+              y1: "9.72",
+              x2: "17.13",
+              y2: "12.58",
+              gradientUnits: "userSpaceOnUse",
+              children: [
+                /* @__PURE__ */ jsx8("stop", { stopColor: "white" }),
+                /* @__PURE__ */ jsx8("stop", { offset: "1", stopColor: "white" })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxs6(
+            "linearGradient",
+            {
+              id: "rs-rabby-grad1",
+              x1: "15.42",
+              y1: "9.53",
+              x2: "8.09",
+              y2: "2.21",
+              gradientUnits: "userSpaceOnUse",
+              children: [
+                /* @__PURE__ */ jsx8("stop", { stopColor: "#8697FF" }),
+                /* @__PURE__ */ jsx8("stop", { offset: "1", stopColor: "#8697FF", stopOpacity: "0" })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxs6(
+            "linearGradient",
+            {
+              id: "rs-rabby-grad2",
+              x1: "11.65",
+              y1: "13.64",
+              x2: "4.63",
+              y2: "9.61",
+              gradientUnits: "userSpaceOnUse",
+              children: [
+                /* @__PURE__ */ jsx8("stop", { stopColor: "#8697FF" }),
+                /* @__PURE__ */ jsx8("stop", { offset: "1", stopColor: "#8697FF", stopOpacity: "0" })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxs6(
+            "linearGradient",
+            {
+              id: "rs-rabby-grad3",
+              x1: "7.61",
+              y1: "9.64",
+              x2: "12.37",
+              y2: "15.67",
+              gradientUnits: "userSpaceOnUse",
+              children: [
+                /* @__PURE__ */ jsx8("stop", { stopColor: "white" }),
+                /* @__PURE__ */ jsx8("stop", { offset: "0.98", stopColor: "#D1D8FF" })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx8("clipPath", { id: "rs-rabby-clip", children: /* @__PURE__ */ jsx8("rect", { width: "20", height: "20", fill: "white" }) })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/components/ui/WalletBadgeIcons/PhantomIcon.tsx
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+function PhantomIcon() {
+  return /* @__PURE__ */ jsxs7(
+    "svg",
+    {
+      width: "20",
+      height: "20",
+      viewBox: "0 0 20 20",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      children: [
+        /* @__PURE__ */ jsx9(
+          "path",
+          {
+            d: "M15.18 0H4.81C2.15 0 0 2.15 0 4.81V15.18C0 17.84 2.15 20 4.81 20H15.18C17.84 20 20 17.84 20 15.18V4.81C20 2.15 17.84 0 15.18 0Z",
+            fill: "#AB9FF2"
+          }
+        ),
+        /* @__PURE__ */ jsx9(
+          "path",
+          {
+            fillRule: "evenodd",
+            clipRule: "evenodd",
+            d: "M8.61 12.94C7.77 14.23 6.37 15.85 4.50 15.85C3.62 15.85 2.77 15.49 2.77 13.91C2.77 9.89 8.26 3.67 13.35 3.67C16.25 3.67 17.40 5.68 17.40 7.96C17.40 10.89 15.50 14.24 13.61 14.24C13.01 14.24 12.72 13.91 12.72 13.39C12.72 13.25 12.74 13.10 12.79 12.94C12.14 14.04 10.90 15.07 9.73 15.07C8.88 15.07 8.45 14.53 8.45 13.78C8.45 13.51 8.51 13.23 8.61 12.94ZM15.49 7.88C15.49 8.54 15.10 8.88 14.66 8.88C14.21 8.88 13.83 8.54 13.83 7.88C13.83 7.21 14.21 6.88 14.66 6.88C15.10 6.88 15.49 7.22 15.49 7.88ZM13.00 7.88C13.00 8.54 12.60 8.88 12.17 8.88C11.72 8.88 11.33 8.54 11.33 7.88C11.33 7.22 11.72 6.88 12.17 6.88C12.60 6.88 13.00 7.22 13.00 7.88",
+            fill: "#FFFDF8"
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/components/ui/WalletBadgeIcons/WalletConnectIcon.tsx
+import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
+function WalletConnectIcon() {
+  return /* @__PURE__ */ jsxs8(
+    "svg",
+    {
+      width: "20",
+      height: "20",
+      viewBox: "0 0 20 20",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      children: [
+        /* @__PURE__ */ jsx10("rect", { width: "20", height: "20", rx: "2.5", fill: "#3B99FC" }),
+        /* @__PURE__ */ jsx10(
+          "path",
+          {
+            d: "M6.18 7.96a5.36 5.36 0 0 1 7.64 0l.25.26a.26.26 0 0 1 0 .37l-.87.87a.13.13 0 0 1-.19 0l-.35-.35a3.74 3.74 0 0 0-5.32 0l-.38.37a.13.13 0 0 1-.19 0l-.86-.86a.26.26 0 0 1 0-.37l.27-.29Zm9.43 1.79.78.78a.26.26 0 0 1 0 .37l-3.54 3.54a.26.26 0 0 1-.37 0l-2.51-2.5a.07.07 0 0 0-.09 0l-2.51 2.5a.26.26 0 0 1-.37 0L3.46 10.9a.26.26 0 0 1 0-.37l.78-.78a.26.26 0 0 1 .37 0l2.5 2.5a.07.07 0 0 0 .1 0L9.72 9.75a.26.26 0 0 1 .37 0l2.5 2.5a.07.07 0 0 0 .1 0l2.5-2.5a.26.26 0 0 1 .37 0Z",
+            fill: "#fff"
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/components/ui/WalletBadgeIcons/EthBadgeIcon.tsx
+import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
+function EthBadgeIcon() {
+  return /* @__PURE__ */ jsxs9(
+    "svg",
+    {
+      width: "20",
+      height: "20",
+      viewBox: "0 0 20 20",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      children: [
+        /* @__PURE__ */ jsx11(
+          "path",
+          {
+            d: "M9.99 19.93C15.48 19.93 19.93 15.48 19.93 9.99C19.93 4.51 15.48 0.06 9.99 0.06C4.51 0.06 0.06 4.51 0.06 9.99C0.06 15.48 4.51 19.93 9.99 19.93Z",
+            fill: "#E3E3E3"
+          }
+        ),
+        /* @__PURE__ */ jsx11("path", { d: "M10.00 2.18L14.69 9.99L10.02 7.98L10.00 2.18Z", fill: "#2F3030" }),
+        /* @__PURE__ */ jsx11("path", { d: "M5.31 9.99L9.98 2.18L10.00 7.98L5.31 9.99Z", fill: "#828384" }),
+        /* @__PURE__ */ jsx11("path", { d: "M9.98 12.80L5.31 10.04L10.00 8.11L9.98 12.80Z", fill: "#343535" }),
+        /* @__PURE__ */ jsx11("path", { d: "M14.69 10.04L10.02 8.11L10.00 12.80L14.69 10.04Z", fill: "#131313" }),
+        /* @__PURE__ */ jsx11("path", { d: "M10.00 14.00L14.69 11.24L10.00 17.80V14.00Z", fill: "#2F3030" }),
+        /* @__PURE__ */ jsx11("path", { d: "M10.00 14.00L5.31 11.24L10.00 17.80V14.00Z", fill: "#828384" })
+      ]
+    }
+  );
+}
+
+// src/components/ui/WalletBadgeIcons/SolBadgeIcon.tsx
+import { jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
+function SolBadgeIcon() {
+  return /* @__PURE__ */ jsxs10(
+    "svg",
+    {
+      width: "20",
+      height: "20",
+      viewBox: "0 0 20 20",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      children: [
+        /* @__PURE__ */ jsx12("rect", { width: "20", height: "20", rx: "10", fill: "#0C0C0C" }),
+        /* @__PURE__ */ jsx12(
+          "path",
+          {
+            fillRule: "evenodd",
+            clipRule: "evenodd",
+            d: "M4.62 9.04H13.87C13.99 9.04 14.10 9.08 14.18 9.17L15.64 10.64C15.91 10.91 15.72 11.38 15.34 11.38H6.08C5.97 11.38 5.86 11.33 5.78 11.25L4.31 9.78C4.04 9.51 4.23 9.04 4.62 9.04ZM4.31 7.09L5.77 5.62C5.86 5.53 5.97 5.49 6.08 5.49H15.33C15.71 5.49 15.91 5.95 15.63 6.22L14.17 7.70C14.09 7.78 13.98 7.82 13.87 7.82H4.62C4.23 7.82 4.04 7.36 4.31 7.09ZM15.64 13.34L14.17 14.81C14.09 14.89 13.98 14.94 13.87 14.94H4.62C4.23 14.94 4.04 14.48 4.31 14.20L5.77 12.73C5.86 12.65 5.97 12.60 6.08 12.60H15.33C15.72 12.6 15.91 13.06 15.64 13.34Z",
+            fill: "url(#rs-sol-badge-grad)"
+          }
+        ),
+        /* @__PURE__ */ jsx12("defs", { children: /* @__PURE__ */ jsxs10(
+          "linearGradient",
+          {
+            id: "rs-sol-badge-grad",
+            x1: "4.85",
+            y1: "15.34",
+            x2: "15.11",
+            y2: "5.08",
+            gradientUnits: "userSpaceOnUse",
+            children: [
+              /* @__PURE__ */ jsx12("stop", { stopColor: "#CB4EE8" }),
+              /* @__PURE__ */ jsx12("stop", { offset: "1", stopColor: "#10F4B1" })
+            ]
+          }
+        ) })
+      ]
+    }
+  );
+}
+
+// src/components/ui/WalletBadgeIcons/BaseBadgeIcon.tsx
+import { jsx as jsx13, jsxs as jsxs11 } from "react/jsx-runtime";
+function BaseBadgeIcon() {
+  return /* @__PURE__ */ jsxs11(
+    "svg",
+    {
+      width: "20",
+      height: "20",
+      viewBox: "0 0 111 111",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      children: [
+        /* @__PURE__ */ jsx13("circle", { cx: "55.5", cy: "55.5", r: "55.5", fill: "#0052FF" }),
+        /* @__PURE__ */ jsx13(
+          "path",
+          {
+            d: "M54.92 93.4c20.94 0 37.92-16.97 37.92-37.92S75.86 17.55 54.92 17.55c-19.49 0-35.57 14.72-37.65 33.64h49.82v5.54h-49.82C19.35 75.67 35.42 93.4 54.92 93.4z",
+            fill: "#fff"
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/components/ui/WalletBadgeIcons/index.tsx
+import { jsx as jsx14, jsxs as jsxs12 } from "react/jsx-runtime";
+function WalletBadgeIcons() {
+  return /* @__PURE__ */ jsxs12("span", { className: "rs-list-row-meta-icons", children: [
+    /* @__PURE__ */ jsx14("span", { children: /* @__PURE__ */ jsx14(RabbyIcon, {}) }),
+    /* @__PURE__ */ jsx14("span", { children: /* @__PURE__ */ jsx14(PhantomIcon, {}) }),
+    /* @__PURE__ */ jsx14("span", { children: /* @__PURE__ */ jsx14(WalletConnectIcon, {}) })
+  ] });
+}
+WalletBadgeIcons.displayName = "WalletBadgeIcons";
+function ChainBadgeIcons() {
+  return /* @__PURE__ */ jsxs12("span", { className: "rs-list-row-meta-icons", children: [
+    /* @__PURE__ */ jsx14("span", { children: /* @__PURE__ */ jsx14(EthBadgeIcon, {}) }),
+    /* @__PURE__ */ jsx14("span", { children: /* @__PURE__ */ jsx14(SolBadgeIcon, {}) }),
+    /* @__PURE__ */ jsx14("span", { children: /* @__PURE__ */ jsx14(BaseBadgeIcon, {}) })
+  ] });
+}
+ChainBadgeIcons.displayName = "ChainBadgeIcons";
+
+// src/components/steps/ConnectStep.tsx
+import { Fragment as Fragment2, jsx as jsx15, jsxs as jsxs13 } from "react/jsx-runtime";
+function formatBalanceUsd(value) {
+  if (!Number.isFinite(value) || value <= 0) return "$0.00";
+  return `$${value.toFixed(2)}`;
+}
+function fiatIcon(name) {
+  if (name === "apple") return /* @__PURE__ */ jsx15(AppleIcon, {});
+  if (name === "bank") return /* @__PURE__ */ jsx15(BankIcon, {});
+  return /* @__PURE__ */ jsx15(CardIcon, {});
+}
+function shorten(addr) {
+  return addr.length > 12 ? `${addr.slice(0, 6)}...${addr.slice(-4)}` : addr;
+}
+function renderWalletLeading(row) {
+  if (row.icon) {
+    return /* @__PURE__ */ jsx15(
+      "img",
+      {
+        src: row.icon,
+        alt: "",
+        style: { width: 24, height: 24, borderRadius: 6 }
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx15(WalletIcon, {});
+}
+var TRANSFER_CRYPTO_LEADING = /* @__PURE__ */ jsx15(TransferCryptoIcon, {});
+var WALLET_LEADING = /* @__PURE__ */ jsx15(WalletIcon, {});
+var SMALL_SPINNER = /* @__PURE__ */ jsx15(Spinner, { className: "rs-spinner--sm" });
+var CONNECT_META = /* @__PURE__ */ jsxs13(Fragment2, { children: [
+  /* @__PURE__ */ jsx15(WalletBadgeIcons, {}),
+  "+100 wallets"
+] });
+var EXTRA_CHAIN_COUNT = Math.max(0, getSupportedChainIds().length - 3);
+var CHAIN_BADGE_META = /* @__PURE__ */ jsxs13(Fragment2, { children: [
+  /* @__PURE__ */ jsx15(ChainBadgeIcons, {}),
+  EXTRA_CHAIN_COUNT > 0 ? `+${EXTRA_CHAIN_COUNT} chains` : "All chains"
+] });
+function renderRowTrailing(state) {
+  if (state === "loading") {
+    return SMALL_SPINNER;
+  }
+  return void 0;
+}
+function ConnectStep({
+  walletRows,
+  onConfirmWallet,
+  onSelectTransferCrypto,
+  transferCryptoState,
+  transferCryptoErrorReason,
+  onSelectPayWithCard,
+  fiatPaymentMethods,
+  onSelectFiatMethod,
+  onSelectFundFromExchange,
+  onRequestConnect,
+  onConnect,
+  onDisconnect,
+  dappImports,
+  onSelectDappImport,
+  title = "Deposit",
+  subtitle
+}) {
+  const rows = walletRows ?? [];
+  const handleConnect = onConnect ?? onRequestConnect;
+  const hasReownWallet = rows.some(
+    (row) => row.kind === "external" || row.kind === "solana"
+  );
+  const showDappImports = (dappImports?.length ?? 0) > 0;
+  const defaultSubtitle = onSelectTransferCrypto ? "Add money to your balance" : "Choose a wallet to continue";
+  return /* @__PURE__ */ jsxs13("div", { className: "rs-screen", children: [
+    /* @__PURE__ */ jsxs13("div", { className: "rs-screen-body rs-screen-body--gap-32", children: [
+      /* @__PURE__ */ jsx15(
+        BodyHeader,
+        {
+          icon: /* @__PURE__ */ jsx15(HandCoinsIcon, {}),
+          title,
+          subtitle: subtitle ?? defaultSubtitle
+        }
+      ),
+      /* @__PURE__ */ jsxs13("div", { className: "rs-list", children: [
+        onSelectTransferCrypto && /* @__PURE__ */ jsx15(
+          ListRow,
+          {
+            leading: TRANSFER_CRYPTO_LEADING,
+            title: "Transfer crypto",
+            subtitle: transferCryptoState === "error" ? transferCryptoErrorReason ?? "Couldn't prepare account \u2014 tap to retry" : "Instant - No limit",
+            meta: CHAIN_BADGE_META,
+            onClick: onSelectTransferCrypto
+          }
+        ),
+        fiatPaymentMethods && fiatPaymentMethods.length > 0 && onSelectFiatMethod ? fiatPaymentMethods.map((opt) => /* @__PURE__ */ jsx15(
+          ListRow,
+          {
+            leading: fiatIcon(opt.icon),
+            title: opt.label,
+            subtitle: opt.sublabel,
+            onClick: () => onSelectFiatMethod(opt.method)
+          },
+          opt.method
+        )) : onSelectPayWithCard && /* @__PURE__ */ jsx15(
+          ListRow,
+          {
+            leading: /* @__PURE__ */ jsx15(CardIcon, {}),
+            title: "Pay with Card",
+            subtitle: "Buy crypto with card or bank",
+            onClick: onSelectPayWithCard
+          }
+        ),
+        onSelectFundFromExchange && /* @__PURE__ */ jsx15(
+          ListRow,
+          {
+            leading: /* @__PURE__ */ jsx15(BankIcon, {}),
+            title: "Fund from Exchange",
+            subtitle: "Use Coinbase, Binance, MetaMask\u2026",
+            onClick: onSelectFundFromExchange
+          }
+        ),
+        rows.map((row) => {
+          const collapseToExternal = Boolean(onSelectTransferCrypto) && row.kind !== "solana";
+          const subtitleText = row.state === "loading" ? "Preparing\u2026" : row.state === "error" ? row.errorReason ?? "Couldn't prepare wallet \u2014 tap to retry" : shorten(row.address);
+          return /* @__PURE__ */ jsx15(
+            ListRow,
+            {
+              leading: renderWalletLeading(row),
+              title: collapseToExternal ? "External wallet" : row.label,
+              subtitle: subtitleText,
+              onClick: () => onConfirmWallet?.(row.id),
+              disabled: row.state === "loading",
+              trailing: renderRowTrailing(row.state)
+            },
+            row.id
+          );
+        }),
+        !hasReownWallet && handleConnect && /* @__PURE__ */ jsx15(
+          ListRow,
+          {
+            leading: WALLET_LEADING,
+            title: "Connect wallet",
+            subtitle: "Instant - No limit",
+            meta: CONNECT_META,
+            onClick: handleConnect
+          }
+        ),
+        showDappImports && dappImports?.map((row) => {
+          if (!hasReownWallet) {
+            return /* @__PURE__ */ jsx15(
+              ListRow,
+              {
+                leading: row.icon,
+                title: row.label,
+                subtitle: "Connect wallet to view balance",
+                onClick: handleConnect,
+                disabled: !handleConnect
+              },
+              row.id
+            );
+          }
+          if (row.status === "loading" || row.status === "needs-connect") {
+            return /* @__PURE__ */ jsx15(
+              ListRow,
+              {
+                leading: row.icon,
+                title: row.label,
+                subtitle: "Checking balance\u2026",
+                disabled: true,
+                trailing: SMALL_SPINNER
+              },
+              row.id
+            );
+          }
+          if (row.status.enabled) {
+            return /* @__PURE__ */ jsx15(
+              ListRow,
+              {
+                leading: row.icon,
+                title: row.label,
+                subtitle: formatBalanceUsd(row.status.balanceUsd),
+                onClick: () => onSelectDappImport?.(row.id)
+              },
+              row.id
+            );
+          }
+          if (row.status.retryable) {
+            return /* @__PURE__ */ jsx15(
+              ListRow,
+              {
+                leading: row.icon,
+                title: row.label,
+                subtitle: row.status.reason,
+                onClick: () => onSelectDappImport?.(row.id)
+              },
+              row.id
+            );
+          }
+          return /* @__PURE__ */ jsx15(
+            ListRow,
+            {
+              leading: row.icon,
+              title: row.label,
+              subtitle: row.status.reason,
+              disabled: true
+            },
+            row.id
+          );
+        })
+      ] })
+    ] }),
+    onDisconnect && hasReownWallet && /* @__PURE__ */ jsx15("div", { className: "rs-screen-tight-row", children: /* @__PURE__ */ jsx15(
+      "button",
+      {
+        type: "button",
+        className: "rs-connect-wallet-manage",
+        onClick: onDisconnect,
+        children: "Disconnect wallet"
+      }
+    ) }),
+    /* @__PURE__ */ jsx15(PoweredBy, {})
+  ] });
+}
+ConnectStep.displayName = "ConnectStep";
+
+// src/components/steps/ProcessingStep.tsx
+import { useCallback as useCallback3, useEffect as useEffect4, useRef as useRef4, useState as useState2 } from "react";
+import { formatUnits } from "viem";
+
+// src/components/ui/Button.tsx
+import { Fragment as Fragment3, jsx as jsx16, jsxs as jsxs14 } from "react/jsx-runtime";
+function Button({
+  children,
+  variant = "accent",
+  size = "default",
+  loading = false,
+  loadingText,
+  fullWidth = false,
+  disabled,
+  className = "",
+  ...props
+}) {
+  const classes = [
+    "rs-button",
+    `rs-button--${variant}`,
+    `rs-button--size-${size}`,
+    fullWidth ? "rs-button--full-width" : "",
+    className
+  ].filter(Boolean).join(" ");
+  const showInlineLoadingText = loading && loadingText !== void 0;
+  return /* @__PURE__ */ jsx16(
+    "button",
+    {
+      className: classes,
+      disabled: disabled || loading,
+      "aria-busy": loading || void 0,
+      ...props,
+      children: showInlineLoadingText ? /* @__PURE__ */ jsxs14("span", { className: "rs-button__loading-row", children: [
+        /* @__PURE__ */ jsx16(Spinner, { className: "rs-spinner--sm" }),
+        /* @__PURE__ */ jsx16("span", { children: loadingText })
+      ] }) : /* @__PURE__ */ jsxs14(Fragment3, { children: [
+        /* @__PURE__ */ jsx16("span", { className: loading ? "rs-button__content--hidden" : "", children }),
+        loading && /* @__PURE__ */ jsx16("span", { className: "rs-button__spinner", children: /* @__PURE__ */ jsx16(Spinner, { className: "rs-spinner--sm" }) })
+      ] })
+    }
+  );
+}
+Button.displayName = "Button";
+
+// src/components/ui/Tooltip.tsx
+import {
+  useState,
+  useRef as useRef3,
+  useEffect as useEffect3,
+  useCallback as useCallback2
+} from "react";
+import { createPortal as createPortal2 } from "react-dom";
+import { jsx as jsx17, jsxs as jsxs15 } from "react/jsx-runtime";
+function Tooltip({ content, children, className }) {
+  const [open, setOpen] = useState(false);
+  const [position, setPosition] = useState(null);
+  const triggerRef = useRef3(null);
+  const bubbleRef = useRef3(null);
+  const updatePosition = useCallback2(() => {
+    const trigger = triggerRef.current;
+    if (!trigger) return;
+    const rect = trigger.getBoundingClientRect();
+    setPosition({
+      top: rect.top,
+      left: rect.left + rect.width / 2
+    });
+  }, []);
+  useEffect3(() => {
+    if (!open) return;
+    updatePosition();
+    function handleOutside(event) {
+      const target = event.target;
+      if (!target) return;
+      if (triggerRef.current?.contains(target)) return;
+      if (bubbleRef.current?.contains(target)) return;
+      setOpen(false);
+    }
+    function handleKey(event) {
+      if (event.key === "Escape") setOpen(false);
+    }
+    document.addEventListener("mousedown", handleOutside);
+    document.addEventListener("touchstart", handleOutside, { passive: true });
+    document.addEventListener("keydown", handleKey);
+    window.addEventListener("scroll", updatePosition, true);
+    window.addEventListener("resize", updatePosition);
+    return () => {
+      document.removeEventListener("mousedown", handleOutside);
+      document.removeEventListener("touchstart", handleOutside);
+      document.removeEventListener("keydown", handleKey);
+      window.removeEventListener("scroll", updatePosition, true);
+      window.removeEventListener("resize", updatePosition);
+    };
+  }, [open, updatePosition]);
+  return /* @__PURE__ */ jsxs15(
+    "span",
+    {
+      ref: triggerRef,
+      className: `rs-tooltip ${className ?? ""}`,
+      onMouseEnter: () => setOpen(true),
+      onMouseLeave: () => setOpen(false),
+      children: [
+        /* @__PURE__ */ jsx17(
+          "span",
+          {
+            className: "rs-tooltip-trigger",
+            role: "button",
+            tabIndex: 0,
+            "aria-label": content,
+            onClick: (event) => {
+              event.stopPropagation();
+              event.preventDefault();
+              setOpen((value) => !value);
+            },
+            onKeyDown: (event) => {
+              if (event.key === "Enter" || event.key === " ") {
+                event.preventDefault();
+                setOpen((value) => !value);
+              }
+            },
+            children
+          }
+        ),
+        open && position && typeof document !== "undefined" && createPortal2(
+          /* @__PURE__ */ jsx17(
+            "span",
+            {
+              ref: bubbleRef,
+              className: "rs-tooltip-bubble",
+              role: "tooltip",
+              style: { top: position.top, left: position.left },
+              children: content
+            }
+          ),
+          document.body
+        )
+      ]
+    }
+  );
+}
+Tooltip.displayName = "Tooltip";
+
+// src/core/webhook.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  const caipMatch = trimmed.match(/^eip155:(\d+)$/);
+  if (caipMatch?.[1]) {
+    const parsed2 = Number(caipMatch[1]);
+    return Number.isFinite(parsed2) ? parsed2 : void 0;
+  }
+  const parsed = Number(trimmed);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function asAmount(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value.toString();
+  }
+  return void 0;
+}
+function asAddress(value) {
+  if (typeof value !== "string") return void 0;
+  return /^0x[a-fA-F0-9]{40}$/.test(value) ? value : void 0;
+}
+function getEventTxHash(event) {
+  if (!event?.type) return void 0;
+  if (event.type === "deposit-received") {
+    return asString(event.data?.transactionHash);
+  }
+  if (event.type === "bridge-started" || event.type === "bridge-complete") {
+    const deposit = isRecord(event.data?.deposit) ? event.data.deposit : void 0;
+    const source = isRecord(event.data?.source) ? event.data.source : void 0;
+    return asString(deposit?.transactionHash) ?? asString(source?.transactionHash);
+  }
+  if (event.type === "bridge-failed" || event.type === "error") {
+    const deposit = isRecord(event.data?.deposit) ? event.data.deposit : void 0;
+    const source = isRecord(event.data?.source) ? event.data.source : void 0;
+    return asString(deposit?.transactionHash) ?? asString(source?.transactionHash);
+  }
+  if (event.type === "post-bridge-swap-complete" || event.type === "post-bridge-swap-failed") {
+    const deposit = isRecord(event.data?.deposit) ? event.data.deposit : void 0;
+    return asString(deposit?.transactionHash);
+  }
+  return void 0;
+}
+function getEventSourceDetails(event) {
+  if (!event?.type || !isRecord(event.data)) return {};
+  if (event.type === "deposit-received") {
+    return {
+      chainId: asNumber(event.data.chain),
+      amount: asAmount(event.data.amount),
+      token: asAddress(event.data.token)
+    };
+  }
+  const source = isRecord(event.data.source) ? event.data.source : void 0;
+  const deposit = isRecord(event.data.deposit) ? event.data.deposit : void 0;
+  if (event.type === "bridge-started" || event.type === "bridge-complete" || event.type === "bridge-failed" || event.type === "error" || event.type === "post-bridge-swap-complete" || event.type === "post-bridge-swap-failed") {
+    return {
+      chainId: asNumber(source?.chain) ?? asNumber(deposit?.chain),
+      amount: asAmount(source?.amount) ?? asAmount(deposit?.amount),
+      token: asAddress(source?.asset) ?? asAddress(deposit?.asset) ?? asAddress(deposit?.token)
+    };
+  }
+  return {};
+}
+function isDepositEvent(event) {
+  return event?.type === "deposit-received" || event?.type === "bridge-started" || event?.type === "bridge-complete" || event?.type === "bridge-failed" || event?.type === "post-bridge-swap-complete" || event?.type === "post-bridge-swap-failed" || event?.type === "error";
+}
+function isFailedEvent(event) {
+  return event?.type === "bridge-failed" || event?.type === "post-bridge-swap-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;
+}
+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) {
+    return { message: toUserFacingFailure(backendMessage), code };
+  }
+  if (code) {
+    return { message: `Bridge failed (${code})`, code };
+  }
+  return { message: "Bridge failed" };
+}
+function failureMessageForEvent(event) {
+  if (event?.type === "error") {
+    const message = isRecord(event.data) ? asString(event.data.message) : void 0;
+    return message ?? "Unknown error";
+  }
+  return formatBridgeFailedMessage(event).message;
+}
+
+// src/components/steps/ProcessingStep.tsx
+import { Fragment as Fragment4, jsx as jsx18, jsxs as jsxs16 } from "react/jsx-runtime";
+function SuccessBadge() {
+  return /* @__PURE__ */ jsxs16(
+    "svg",
+    {
+      width: "40",
+      height: "40",
+      viewBox: "0 0 40 40",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      "aria-hidden": "true",
+      children: [
+        /* @__PURE__ */ jsx18(
+          "rect",
+          {
+            width: "40",
+            height: "40",
+            rx: "8",
+            fill: "var(--rs-icon-wrapper-bg)"
+          }
+        ),
+        /* @__PURE__ */ jsx18(
+          "path",
+          {
+            d: "M28 14L17 25L12 20",
+            stroke: "var(--rs-icon-wrapper-icon)",
+            strokeWidth: "2",
+            strokeLinecap: "round",
+            strokeLinejoin: "round"
+          }
+        )
+      ]
+    }
+  );
+}
+function FailedBadge() {
+  return /* @__PURE__ */ jsxs16(
+    "svg",
+    {
+      width: "40",
+      height: "40",
+      viewBox: "0 0 40 40",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      "aria-hidden": "true",
+      children: [
+        /* @__PURE__ */ jsx18("rect", { width: "40", height: "40", rx: "8", fill: "#FB2C36" }),
+        /* @__PURE__ */ jsx18(
+          "path",
+          {
+            d: "M26 14L14 26M14 14L26 26",
+            stroke: "white",
+            strokeWidth: "2",
+            strokeLinecap: "round",
+            strokeLinejoin: "round"
+          }
+        )
+      ]
+    }
+  );
+}
+var INITIAL_POLL_INTERVAL = 3e3;
+var MAX_POLL_INTERVAL = 3e4;
+var BACKOFF_MULTIPLIER = 1.5;
+var ESCALATED_DELAY_MS = 10 * 60 * 1e3;
+var SOFT_DELAY_MS = {
+  confirming: 90 * 1e3,
+  received: 90 * 1e3,
+  bridging: 4 * 60 * 1e3
+};
+var PHASE_TIMINGS_PREFIX = "rhinestone:phase-timings";
+var STABLECOIN_SYMBOLS = /* @__PURE__ */ new Set([
+  "USDC",
+  "USDT",
+  "DAI",
+  "FRAX",
+  "PYUSD",
+  "USDP",
+  "TUSD",
+  "GUSD",
+  "USDS",
+  "LUSD",
+  "BUSD",
+  "USDE"
+]);
+function maxFractionDigitsFor(symbol) {
+  if (!symbol) return 6;
+  return STABLECOIN_SYMBOLS.has(symbol.toUpperCase()) ? 3 : 6;
+}
+var PAYMENT_METHOD_LABELS = {
+  creditcard: "Card",
+  debitcard: "Card",
+  card: "Card",
+  "apple-pay": "Apple Pay",
+  applepay: "Apple Pay",
+  "google-pay": "Google Pay",
+  googlepay: "Google Pay",
+  "bank-transfer": "Bank Transfer",
+  banktransfer: "Bank Transfer",
+  sepa: "SEPA",
+  "open-banking": "Open Banking",
+  "krak-pay": "Kraken Pay",
+  krakpay: "Kraken Pay",
+  kraken: "Kraken",
+  coinbase: "Coinbase",
+  binance: "Binance"
+};
+function formatPaymentMethod(method) {
+  const key = method.trim().toLowerCase();
+  if (PAYMENT_METHOD_LABELS[key]) return PAYMENT_METHOD_LABELS[key];
+  return key.replace(/[-_]+/g, " ").split(" ").filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function loadPhaseTimings(txHash) {
+  if (typeof window === "undefined") return null;
+  try {
+    const raw = window.localStorage.getItem(`${PHASE_TIMINGS_PREFIX}:${txHash}`);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.startedAt !== "number") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function savePhaseTimings(txHash, timings) {
+  if (typeof window === "undefined") return;
+  try {
+    window.localStorage.setItem(
+      `${PHASE_TIMINGS_PREFIX}:${txHash}`,
+      JSON.stringify(timings)
+    );
+  } catch {
+  }
+}
+function isEventForTx(event, txHash) {
+  const eventTxHash = getEventTxHash(event);
+  if (!eventTxHash) return false;
+  return txRefsMatch(eventTxHash, txHash);
+}
+function parseWebhookTimestamp(event) {
+  if (typeof event?.time !== "string") return void 0;
+  const timestamp = Date.parse(event.time);
+  return Number.isFinite(timestamp) ? timestamp : void 0;
+}
+function syncPhaseTimings(previous, event) {
+  if (!event?.type) return previous;
+  const timestamp = parseWebhookTimestamp(event) ?? Date.now();
+  const setReceived = (event.type === "deposit-received" || event.type === "bridge-started" || event.type === "bridge-complete" || event.type === "bridge-failed" || event.type === "post-bridge-swap-complete" || event.type === "post-bridge-swap-failed" || event.type === "error") && previous.receivedAt === void 0;
+  const setBridging = (event.type === "bridge-started" || event.type === "bridge-complete" || event.type === "post-bridge-swap-complete") && previous.bridgingAt === void 0;
+  const setCompleted = (event.type === "bridge-complete" || event.type === "post-bridge-swap-complete") && previous.completedAt === void 0;
+  if (!setReceived && !setBridging && !setCompleted) return previous;
+  return {
+    ...previous,
+    ...setReceived && { receivedAt: timestamp },
+    ...setBridging && { bridgingAt: timestamp },
+    ...setCompleted && { completedAt: timestamp }
+  };
+}
+function formatTimer(seconds) {
+  const safe = Math.max(0, seconds);
+  const mins = Math.floor(safe / 60);
+  const secs = safe % 60;
+  return `${mins}:${String(secs).padStart(2, "0")}`;
+}
+function TickerChar({ value }) {
+  const [current, setCurrent] = useState2(value);
+  const [previous, setPrevious] = useState2(null);
+  const [animKey, setAnimKey] = useState2(0);
+  useEffect4(() => {
+    if (value === current) return;
+    setPrevious(current);
+    setCurrent(value);
+    setAnimKey((k) => k + 1);
+    const timeout = setTimeout(() => setPrevious(null), 360);
+    return () => clearTimeout(timeout);
+  }, [value, current]);
+  return /* @__PURE__ */ jsxs16("span", { className: "rs-ticker-slot", children: [
+    previous !== null && /* @__PURE__ */ jsx18("span", { className: "rs-ticker-out", children: previous }, `out-${animKey}`),
+    /* @__PURE__ */ jsx18("span", { className: "rs-ticker-in", children: current }, `in-${animKey}`)
+  ] });
+}
+function Ticker({ value }) {
+  return /* @__PURE__ */ jsx18("span", { className: "rs-ticker", "aria-label": value, children: value.split("").map((char, index) => (
+    // Position-stable key so each slot keeps its own animation state.
+    // eslint-disable-next-line react/no-array-index-key
+    /* @__PURE__ */ jsx18(TickerChar, { value: char }, index)
+  )) });
+}
+function getPhaseStartTime(phaseId, phaseTimings) {
+  if (phaseId === "confirming") return phaseTimings.startedAt;
+  if (phaseId === "received") {
+    return phaseTimings.receivedAt ?? phaseTimings.startedAt;
+  }
+  return phaseTimings.bridgingAt ?? phaseTimings.receivedAt ?? phaseTimings.startedAt;
+}
+function getFailedPhaseId(phaseTimings) {
+  if (phaseTimings.bridgingAt !== void 0) return "bridging";
+  if (phaseTimings.receivedAt !== void 0) return "received";
+  return "confirming";
+}
+function getCurrentPhaseId(state, phaseTimings) {
+  if (state.type === "failed") {
+    return getFailedPhaseId(phaseTimings);
+  }
+  if (state.type === "complete") {
+    return void 0;
+  }
+  if (state.lastEvent?.type === "bridge-started" || state.lastEvent?.type === "bridge-complete")
+    return "bridging";
+  if (state.lastEvent?.type === "deposit-received") return "received";
+  return "confirming";
+}
+function ProcessingStep({
+  smartAccount,
+  solanaDepositAddress,
+  txHash,
+  sourceChain,
+  sourceToken,
+  targetChain,
+  amount,
+  sourceSymbol: providedSourceSymbol,
+  sourceDecimals: providedSourceDecimals,
+  amountUsd,
+  hasPostBridgeActions,
+  service,
+  directTransfer,
+  flowLabel = "deposit",
+  debug,
+  targetToken,
+  uiConfig,
+  quotedFeeAmount,
+  quotedFeeSymbol,
+  balanceAfterUsd,
+  isSwappedOrder,
+  onClose,
+  onNewDeposit,
+  onRetry,
+  onDepositComplete,
+  onDepositFailed,
+  onError
+}) {
+  const startTimeRef = useRef4(Date.now());
+  const pollIntervalRef = useRef4(INITIAL_POLL_INTERVAL);
+  const pollTimeoutRef = useRef4(null);
+  const escalatedDelayRef = useRef4(false);
+  const processingContextRef = useLatestRef({
+    amount,
+    sourceChain,
+    sourceToken,
+    sourceDecimals: providedSourceDecimals,
+    amountUsd,
+    targetChain,
+    targetToken,
+    hasPostBridgeActions
+  });
+  const onDepositCompleteRef = useLatestRef(onDepositComplete);
+  const onDepositFailedRef = useLatestRef(onDepositFailed);
+  const onErrorRef = useLatestRef(onError);
+  const [state, setState] = useState2(
+    directTransfer ? { type: "complete" } : { type: "processing" }
+  );
+  const [elapsedSeconds, setElapsedSeconds] = useState2(0);
+  const [phaseTimings, setPhaseTimings] = useState2(() => {
+    const saved = loadPhaseTimings(txHash);
+    if (saved) {
+      startTimeRef.current = saved.startedAt;
+      return saved;
+    }
+    return { startedAt: startTimeRef.current };
+  });
+  const [hasEscalatedDelay, setHasEscalatedDelay] = useState2(false);
+  const updatePhaseTimings = useCallback3(
+    (updater) => {
+      setPhaseTimings((previous) => {
+        const next = updater(previous);
+        savePhaseTimings(txHash, next);
+        return next;
+      });
+    },
+    [txHash]
+  );
+  useEffect4(() => {
+    if (!directTransfer) return;
+    const completedAt = Date.now();
+    updatePhaseTimings(() => ({
+      startedAt: startTimeRef.current,
+      completedAt,
+      endedAt: completedAt
+    }));
+    debugLog(debug, "processing", "direct-transfer:complete", {
+      txHash,
+      flowLabel
+    });
+    const context = processingContextRef.current;
+    onDepositCompleteRef.current?.(txHash, void 0, {
+      amount: context.amount,
+      sourceChain: context.sourceChain,
+      sourceToken: context.sourceToken,
+      sourceDecimals: context.sourceDecimals,
+      amountUsd: context.amountUsd,
+      targetChain: context.targetChain,
+      targetToken: context.targetToken
+    });
+  }, [
+    debug,
+    directTransfer,
+    flowLabel,
+    onDepositCompleteRef,
+    processingContextRef,
+    txHash,
+    updatePhaseTimings
+  ]);
+  useEffect4(() => {
+    if (directTransfer || state.type !== "processing") return;
+    const updateElapsed = () => {
+      setElapsedSeconds(
+        Math.floor((Date.now() - startTimeRef.current) / 1e3)
+      );
+    };
+    updateElapsed();
+    const intervalId = setInterval(updateElapsed, 1e3);
+    return () => clearInterval(intervalId);
+  }, [directTransfer, state.type]);
+  useEffect4(() => {
+    if (state.type === "processing") return;
+    const endedAt = state.type === "complete" ? phaseTimings.completedAt ?? Date.now() : Date.now();
+    setElapsedSeconds(Math.floor((endedAt - startTimeRef.current) / 1e3));
+    updatePhaseTimings(
+      (previous) => previous.endedAt !== void 0 ? previous : { ...previous, endedAt }
+    );
+  }, [phaseTimings.completedAt, state.type, updatePhaseTimings]);
+  useEffect4(() => {
+    if (!state.lastEvent) return;
+    updatePhaseTimings(
+      (previous) => syncPhaseTimings(previous, state.lastEvent)
+    );
+  }, [state.lastEvent?.time, state.lastEvent?.type, updatePhaseTimings]);
+  const [swappedFiatContext, setSwappedFiatContext] = useState2(null);
+  useEffect4(() => {
+    let cancelled = false;
+    service.fetchSwappedOrderStatus(smartAccount).then((res) => {
+      if (cancelled || !res) return;
+      if (res.transactionId != null) {
+        if (res.transactionId.toLowerCase() !== txHash.toLowerCase()) return;
+      } else if (!isSwappedOrder) {
+        return;
+      }
+      setSwappedFiatContext({
+        paidAmountUsd: res.paidAmountUsd,
+        paidAmountEur: res.paidAmountEur,
+        onrampFeeUsd: res.onrampFeeUsd,
+        paymentMethod: res.paymentMethod
+      });
+    }).catch(() => {
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [service, smartAccount, txHash, isSwappedOrder]);
+  useEffect4(() => {
+    if (directTransfer) return;
+    if (state.type !== "processing") {
+      pollIntervalRef.current = INITIAL_POLL_INTERVAL;
+      return;
+    }
+    let isMounted = true;
+    async function pollStatus() {
+      try {
+        const account = sourceChain === "solana" && solanaDepositAddress ? solanaDepositAddress : smartAccount;
+        debugLog(debug, "processing", "poll:request", {
+          account,
+          txHash,
+          intervalMs: pollIntervalRef.current
+        });
+        const data = await service.fetchStatus(account, txHash);
+        const lastEvent2 = data.lastEvent;
+        const eventMatchesTx = isEventForTx(lastEvent2, txHash);
+        const eventForCurrentTx = eventMatchesTx ? lastEvent2 : void 0;
+        if (lastEvent2) {
+          const eventData = lastEvent2.data;
+          debugLog(debug, "processing", "poll:event", {
+            type: lastEvent2.type,
+            matchesTx: eventMatchesTx,
+            intentId: eventData?.intentId
+          });
+        }
+        if (!isMounted) return;
+        const awaitingPostBridgeSwap = processingContextRef.current.hasPostBridgeActions;
+        if (eventForCurrentTx?.type === "post-bridge-swap-complete") {
+          setState({ type: "complete", lastEvent: eventForCurrentTx });
+          const swapTxHash = eventForCurrentTx.data?.swap?.transactionHash;
+          debugLog(debug, "processing", "state:complete", {
+            txHash,
+            destinationTxHash: swapTxHash,
+            event: eventForCurrentTx.type
+          });
+          const context = processingContextRef.current;
+          onDepositCompleteRef.current?.(txHash, swapTxHash, {
+            amount: context.amount,
+            sourceChain: context.sourceChain,
+            sourceToken: context.sourceToken,
+            sourceDecimals: context.sourceDecimals,
+            amountUsd: context.amountUsd,
+            targetChain: context.targetChain,
+            targetToken: context.targetToken
+          });
+          return;
+        }
+        if (eventForCurrentTx?.type === "post-bridge-swap-failed") {
+          const formatted = formatBridgeFailedMessage(eventForCurrentTx);
+          setState({
+            type: "failed",
+            message: formatted.message,
+            lastEvent: eventForCurrentTx
+          });
+          debugLog(debug, "processing", "state:failed", {
+            txHash,
+            message: formatted.message,
+            code: formatted.code
+          });
+          onDepositFailedRef.current?.(txHash, formatted.message);
+          return;
+        }
+        if (eventForCurrentTx?.type === "bridge-complete" && !awaitingPostBridgeSwap) {
+          setState({ type: "complete", lastEvent: eventForCurrentTx });
+          const destinationTxHash2 = eventForCurrentTx.data?.destination?.transactionHash;
+          debugLog(debug, "processing", "state:complete", {
+            txHash,
+            destinationTxHash: destinationTxHash2,
+            event: eventForCurrentTx.type
+          });
+          const context = processingContextRef.current;
+          onDepositCompleteRef.current?.(txHash, destinationTxHash2, {
+            amount: context.amount,
+            sourceChain: context.sourceChain,
+            sourceToken: context.sourceToken,
+            sourceDecimals: context.sourceDecimals,
+            amountUsd: context.amountUsd,
+            targetChain: context.targetChain,
+            targetToken: context.targetToken
+          });
+          return;
+        }
+        if (eventForCurrentTx?.type === "bridge-failed") {
+          const formatted = formatBridgeFailedMessage(eventForCurrentTx);
+          setState({
+            type: "failed",
+            message: formatted.message,
+            lastEvent: eventForCurrentTx
+          });
+          debugLog(debug, "processing", "state:failed", {
+            txHash,
+            message: formatted.message,
+            code: formatted.code
+          });
+          onDepositFailedRef.current?.(txHash, formatted.message);
+          return;
+        }
+        if (eventForCurrentTx?.type === "error") {
+          const errorMessage = eventForCurrentTx.data?.message ?? "Unknown error";
+          setState({
+            type: "failed",
+            message: errorMessage,
+            lastEvent: eventForCurrentTx
+          });
+          debugLog(debug, "processing", "state:error-event", {
+            txHash,
+            message: errorMessage
+          });
+          onDepositFailedRef.current?.(txHash, errorMessage);
+          return;
+        }
+        setState((previous) => ({
+          type: "processing",
+          lastEvent: eventForCurrentTx ?? previous.lastEvent
+        }));
+        scheduleNextPoll();
+      } catch (error) {
+        debugError(debug, "processing", "poll:failure", error, {
+          smartAccount,
+          txHash,
+          intervalMs: pollIntervalRef.current
+        });
+        scheduleNextPoll();
+      }
+    }
+    function scheduleNextPoll() {
+      if (!isMounted) return;
+      pollTimeoutRef.current = setTimeout(() => {
+        pollIntervalRef.current = Math.min(
+          pollIntervalRef.current * BACKOFF_MULTIPLIER,
+          MAX_POLL_INTERVAL
+        );
+        debugLog(debug, "processing", "poll:scheduled", {
+          nextIntervalMs: pollIntervalRef.current
+        });
+        pollStatus();
+      }, pollIntervalRef.current);
+    }
+    pollStatus();
+    return () => {
+      isMounted = false;
+      if (pollTimeoutRef.current) {
+        clearTimeout(pollTimeoutRef.current);
+      }
+    };
+  }, [
+    debug,
+    directTransfer,
+    onDepositCompleteRef,
+    onDepositFailedRef,
+    processingContextRef,
+    service,
+    smartAccount,
+    solanaDepositAddress,
+    sourceChain,
+    state.type,
+    txHash
+  ]);
+  useEffect4(() => {
+    if (directTransfer || state.type !== "processing") return;
+    const timeoutId = setTimeout(() => {
+      if (escalatedDelayRef.current) return;
+      escalatedDelayRef.current = true;
+      setHasEscalatedDelay(true);
+      const message = "Transfer is taking longer than expected. Your funds are safe and processing will continue automatically.";
+      debugLog(debug, "processing", "state:delay-escalated", {
+        txHash,
+        timeoutMs: ESCALATED_DELAY_MS
+      });
+      onErrorRef.current?.(message, "PROCESS_TIMEOUT");
+    }, ESCALATED_DELAY_MS);
+    return () => clearTimeout(timeoutId);
+  }, [debug, directTransfer, onErrorRef, state.type, txHash]);
+  const isComplete = state.type === "complete";
+  const isFailed = state.type === "failed";
+  const isProcessing = state.type === "processing";
+  const lastEvent = state.lastEvent;
+  const failureMessage = state.type === "failed" ? state.message : void 0;
+  const timelineNowMs = phaseTimings.endedAt ?? Date.now();
+  const flowNoun = flowLabel === "withdraw" ? "withdrawal" : "deposit";
+  const flowCapitalized = flowLabel === "withdraw" ? "Withdrawal" : "Deposit";
+  const isPostBridgeSwapEvent = lastEvent?.type === "post-bridge-swap-complete" || lastEvent?.type === "post-bridge-swap-failed";
+  const destinationTxHash = isPostBridgeSwapEvent ? lastEvent?.data?.swap?.transactionHash || null : lastEvent?.data?.destination?.transactionHash || null;
+  const sourceDetails = getEventSourceDetails(lastEvent);
+  const displaySourceChain = sourceDetails.chainId ?? sourceChain;
+  const displaySourceToken = sourceDetails.token ?? sourceToken;
+  const displayAmount = sourceDetails.amount ?? amount;
+  const sourceExplorerUrl = getExplorerTxUrl(displaySourceChain, txHash);
+  const destExplorerUrl = destinationTxHash ? getExplorerTxUrl(targetChain, destinationTxHash) : null;
+  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 amountMaxDigits = maxFractionDigitsFor(sourceSymbol);
+  const formattedReceivedAmount = (() => {
+    try {
+      const raw = formatUnits(BigInt(displayAmount), sourceDecimals);
+      const numeric = Number(raw);
+      if (!Number.isFinite(numeric)) return raw;
+      return numeric.toLocaleString("en-US", {
+        minimumFractionDigits: 2,
+        maximumFractionDigits: amountMaxDigits
+      });
+    } catch {
+      return Number(displayAmount).toLocaleString("en-US", {
+        minimumFractionDigits: 2,
+        maximumFractionDigits: amountMaxDigits
+      });
+    }
+  })();
+  const destinationAmountRaw = (() => {
+    const dest = lastEvent?.data?.destination;
+    if (!dest || dest.amount === void 0) return void 0;
+    try {
+      return BigInt(dest.amount);
+    } catch {
+      return void 0;
+    }
+  })();
+  const sourceAmountRaw = (() => {
+    try {
+      return BigInt(displayAmount);
+    } catch {
+      return void 0;
+    }
+  })();
+  const bridgingCostRaw = sourceAmountRaw !== void 0 && destinationAmountRaw !== void 0 && sourceAmountRaw > destinationAmountRaw ? sourceAmountRaw - destinationAmountRaw : void 0;
+  const formattedDestinationAmount = destinationAmountRaw !== void 0 ? (() => {
+    try {
+      const raw = formatUnits(destinationAmountRaw, sourceDecimals);
+      const numeric = Number(raw);
+      if (!Number.isFinite(numeric)) return raw;
+      return numeric.toLocaleString("en-US", {
+        minimumFractionDigits: 2,
+        maximumFractionDigits: amountMaxDigits
+      });
+    } catch {
+      return void 0;
+    }
+  })() : void 0;
+  const formattedBridgingCost = bridgingCostRaw !== void 0 ? (() => {
+    try {
+      const raw = formatUnits(bridgingCostRaw, sourceDecimals);
+      const numeric = Number(raw);
+      if (!Number.isFinite(numeric)) return raw;
+      return numeric.toLocaleString("en-US", {
+        minimumFractionDigits: 2,
+        maximumFractionDigits: amountMaxDigits
+      });
+    } catch {
+      return void 0;
+    }
+  })() : void 0;
+  const currentPhaseId = getCurrentPhaseId(state, phaseTimings);
+  const activePhaseStartedAt = currentPhaseId ? getPhaseStartTime(currentPhaseId, phaseTimings) : void 0;
+  const activePhaseElapsedMs = isProcessing && activePhaseStartedAt !== void 0 ? timelineNowMs - activePhaseStartedAt : 0;
+  const delayPhaseId = isProcessing && currentPhaseId && activePhaseElapsedMs >= SOFT_DELAY_MS[currentPhaseId] ? currentPhaseId : void 0;
+  void delayPhaseId;
+  void hasEscalatedDelay;
+  const targetSymbol = (() => {
+    const resolved = getTargetTokenSymbol(targetToken, targetChain);
+    return resolved !== "Token" ? resolved : providedSourceSymbol ?? "USDC";
+  })();
+  const targetTokenIcon = getTokenIcon(targetSymbol);
+  const sourceChainIcon = getChainIcon(displaySourceChain);
+  const targetChainIcon = getChainIcon(targetChain);
+  const sourceTokenIcon = getTokenIcon(sourceSymbol);
+  const sourceChainName = getChainName(displaySourceChain);
+  const targetChainName = getChainName(targetChain);
+  const timerText = formatTimer(elapsedSeconds);
+  const feeSponsored = uiConfig?.feeSponsored ?? false;
+  const feeTooltip = uiConfig?.feeTooltip ?? (feeSponsored ? "Network fees are sponsored for this deposit." : "Network fees apply.");
+  const stateTitle = isComplete ? `${flowCapitalized} successful` : isFailed ? `${flowCapitalized} failed` : "Processing...";
+  const handleRetry = onRetry ?? onNewDeposit;
+  const headerContent = isComplete ? /* @__PURE__ */ jsxs16("div", { className: "rs-body-header", children: [
+    /* @__PURE__ */ jsx18(SuccessBadge, {}),
+    /* @__PURE__ */ jsx18("div", { className: "rs-body-header-text", children: /* @__PURE__ */ jsx18("h2", { className: "rs-body-header-title", children: stateTitle }) })
+  ] }) : isFailed ? /* @__PURE__ */ jsxs16("div", { className: "rs-body-header", children: [
+    /* @__PURE__ */ jsx18(FailedBadge, {}),
+    /* @__PURE__ */ jsx18("div", { className: "rs-body-header-text", children: /* @__PURE__ */ jsx18("h2", { className: "rs-body-header-title", children: stateTitle }) })
+  ] }) : /* @__PURE__ */ jsx18(BodyHeader, { icon: /* @__PURE__ */ jsx18(WalletIcon, {}), title: stateTitle });
+  return /* @__PURE__ */ jsxs16("div", { className: "rs-screen", children: [
+    /* @__PURE__ */ jsxs16("div", { className: "rs-screen-body rs-screen-body--gap-32", children: [
+      headerContent,
+      /* @__PURE__ */ jsxs16("div", { className: "rs-review-details", children: [
+        /* @__PURE__ */ jsxs16("div", { className: "rs-review-detail-row", children: [
+          /* @__PURE__ */ jsx18("span", { children: "Source chain" }),
+          /* @__PURE__ */ jsxs16("span", { className: "rs-review-detail-value", children: [
+            /* @__PURE__ */ jsx18("span", { children: sourceChainName }),
+            sourceChainIcon && /* @__PURE__ */ jsx18("span", { className: "rs-review-detail-icon", children: /* @__PURE__ */ jsx18("img", { src: sourceChainIcon, alt: "" }) }),
+            isSwappedOrder && sourceExplorerUrl && /* @__PURE__ */ jsx18(
+              "a",
+              {
+                href: sourceExplorerUrl,
+                target: "_blank",
+                rel: "noopener noreferrer",
+                className: "rs-review-detail-link",
+                "aria-label": "View source transaction",
+                children: /* @__PURE__ */ jsx18(ExternalLinkIcon, {})
+              }
+            )
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs16("div", { className: "rs-review-detail-row", children: [
+          /* @__PURE__ */ jsx18("span", { children: "Destination chain" }),
+          /* @__PURE__ */ jsxs16("span", { className: "rs-review-detail-value", children: [
+            /* @__PURE__ */ jsx18("span", { children: targetChainName }),
+            targetChainIcon && /* @__PURE__ */ jsx18("span", { className: "rs-review-detail-icon", children: /* @__PURE__ */ jsx18("img", { src: targetChainIcon, alt: "" }) }),
+            isSwappedOrder && destExplorerUrl && /* @__PURE__ */ jsx18(
+              "a",
+              {
+                href: destExplorerUrl,
+                target: "_blank",
+                rel: "noopener noreferrer",
+                className: "rs-review-detail-link",
+                "aria-label": "View destination transaction",
+                children: /* @__PURE__ */ jsx18(ExternalLinkIcon, {})
+              }
+            )
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs16("div", { className: "rs-review-detail-row", children: [
+          /* @__PURE__ */ jsx18("span", { children: isProcessing ? "Time elapsed" : "Total time" }),
+          /* @__PURE__ */ jsx18("span", { className: "rs-review-detail-value", children: /* @__PURE__ */ jsx18(Ticker, { value: timerText }) })
+        ] }),
+        isSwappedOrder ? /* @__PURE__ */ jsxs16(Fragment4, { children: [
+          swappedFiatContext?.paidAmountUsd != null && /* @__PURE__ */ jsxs16("div", { className: "rs-review-detail-row", children: [
+            /* @__PURE__ */ jsx18("span", { children: "You pay" }),
+            /* @__PURE__ */ jsxs16("span", { className: "rs-review-detail-value", children: [
+              "$",
+              swappedFiatContext.paidAmountUsd.toFixed(2),
+              swappedFiatContext.paymentMethod && /* @__PURE__ */ jsxs16("span", { style: { color: "#71717b", marginLeft: 6 }, children: [
+                "via",
+                " ",
+                formatPaymentMethod(swappedFiatContext.paymentMethod)
+              ] })
+            ] })
+          ] }),
+          swappedFiatContext?.onrampFeeUsd != null && /* @__PURE__ */ jsxs16("div", { className: "rs-review-detail-row", children: [
+            /* @__PURE__ */ jsx18("span", { children: "On-ramp fee" }),
+            /* @__PURE__ */ jsxs16("span", { className: "rs-review-detail-value", children: [
+              "$",
+              swappedFiatContext.onrampFeeUsd.toFixed(2)
+            ] })
+          ] }),
+          formattedBridgingCost && /* @__PURE__ */ jsxs16("div", { className: "rs-review-detail-row", children: [
+            /* @__PURE__ */ jsx18("span", { children: "Bridging cost" }),
+            /* @__PURE__ */ jsxs16("span", { className: "rs-review-detail-value", children: [
+              /* @__PURE__ */ jsxs16("span", { children: [
+                formattedBridgingCost,
+                " ",
+                sourceSymbol
+              ] }),
+              sourceTokenIcon && /* @__PURE__ */ jsx18("span", { className: "rs-review-detail-icon", children: /* @__PURE__ */ jsx18("img", { src: sourceTokenIcon, alt: "" }) })
+            ] })
+          ] })
+        ] }) : /* @__PURE__ */ jsxs16("div", { className: "rs-review-detail-row", children: [
+          /* @__PURE__ */ jsx18("span", { children: isProcessing ? "You send" : "You sent" }),
+          /* @__PURE__ */ jsxs16("span", { className: "rs-review-detail-value", children: [
+            /* @__PURE__ */ jsxs16("span", { children: [
+              formattedReceivedAmount,
+              " ",
+              sourceSymbol
+            ] }),
+            sourceTokenIcon && /* @__PURE__ */ jsx18("span", { className: "rs-review-detail-icon", children: /* @__PURE__ */ jsx18("img", { src: sourceTokenIcon, alt: "" }) })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs16("div", { className: "rs-review-detail-row", children: [
+          /* @__PURE__ */ jsx18("span", { children: isProcessing ? "Receive" : "Received" }),
+          /* @__PURE__ */ jsxs16("span", { className: "rs-review-detail-value", children: [
+            /* @__PURE__ */ jsx18("span", { children: formattedDestinationAmount ? `${formattedDestinationAmount} ${targetSymbol}` : `~${formattedReceivedAmount} ${targetSymbol}` }),
+            targetTokenIcon && /* @__PURE__ */ jsx18("span", { className: "rs-review-detail-icon", children: /* @__PURE__ */ jsx18("img", { src: targetTokenIcon, alt: "" }) })
+          ] })
+        ] }),
+        isFailed && balanceAfterUsd !== void 0 && /* @__PURE__ */ jsxs16("div", { className: "rs-review-detail-row", children: [
+          /* @__PURE__ */ jsx18("span", { children: "Balance" }),
+          /* @__PURE__ */ jsxs16("span", { className: "rs-review-detail-value", children: [
+            "$",
+            balanceAfterUsd.toFixed(2)
+          ] })
+        ] }),
+        isSwappedOrder ? quotedFeeAmount !== void 0 && /* @__PURE__ */ jsxs16("div", { className: "rs-review-detail-row", children: [
+          /* @__PURE__ */ jsx18("span", { children: "Fees" }),
+          /* @__PURE__ */ jsxs16("span", { className: "rs-review-detail-value", children: [
+            /* @__PURE__ */ jsxs16(
+              "span",
+              {
+                style: feeSponsored ? { textDecoration: "line-through" } : void 0,
+                children: [
+                  quotedFeeAmount,
+                  " ",
+                  quotedFeeSymbol ?? sourceSymbol
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsx18(Tooltip, { content: feeTooltip, children: /* @__PURE__ */ jsx18(
+              "span",
+              {
+                className: "rs-review-detail-info",
+                "aria-label": "Fee info",
+                children: /* @__PURE__ */ jsx18(InfoIcon, {})
+              }
+            ) })
+          ] })
+        ] }) : (() => {
+          const feeValue = quotedFeeAmount ?? formattedBridgingCost;
+          if (feeValue === void 0) return null;
+          return /* @__PURE__ */ jsxs16("div", { className: "rs-review-detail-row", children: [
+            /* @__PURE__ */ jsx18("span", { children: "Fees" }),
+            /* @__PURE__ */ jsxs16("span", { className: "rs-review-detail-value", children: [
+              /* @__PURE__ */ jsxs16(
+                "span",
+                {
+                  style: feeSponsored ? { textDecoration: "line-through" } : void 0,
+                  children: [
+                    feeValue,
+                    " ",
+                    quotedFeeSymbol ?? sourceSymbol
+                  ]
+                }
+              ),
+              /* @__PURE__ */ jsx18(Tooltip, { content: feeTooltip, children: /* @__PURE__ */ jsx18(
+                "span",
+                {
+                  className: "rs-review-detail-info",
+                  "aria-label": "Fee info",
+                  children: /* @__PURE__ */ jsx18(InfoIcon, {})
+                }
+              ) })
+            ] })
+          ] });
+        })()
+      ] }),
+      isFailed && failureMessage && /* @__PURE__ */ jsx18(Callout, { variant: "error", children: failureMessage }),
+      isProcessing && /* @__PURE__ */ jsx18(
+        Button,
+        {
+          fullWidth: true,
+          disabled: true,
+          loading: true,
+          loadingText: "Submitting transaction\u2026",
+          children: "Submitting transaction\u2026"
+        }
+      ),
+      isComplete && /* @__PURE__ */ jsxs16("div", { className: "rs-screen-button-row", children: [
+        onNewDeposit && /* @__PURE__ */ jsxs16(Button, { variant: "outline", onClick: onNewDeposit, fullWidth: true, children: [
+          "New ",
+          flowNoun
+        ] }),
+        onClose && /* @__PURE__ */ jsx18(Button, { onClick: onClose, fullWidth: true, children: "Done" })
+      ] }),
+      isFailed && /* @__PURE__ */ jsxs16("div", { className: "rs-screen-button-row", children: [
+        onClose && /* @__PURE__ */ jsx18(Button, { variant: "outline", onClick: onClose, fullWidth: true, children: "Cancel" }),
+        handleRetry && /* @__PURE__ */ jsx18(Button, { onClick: handleRetry, fullWidth: true, children: "Try again" })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx18(PoweredBy, {})
+  ] });
+}
+
+// src/core/safe.ts
+import {
+  concat,
+  encodeFunctionData,
+  erc20Abi,
+  hashTypedData,
+  pad,
+  parseEventLogs,
+  toHex,
+  zeroAddress
+} from "viem";
+var SAFE_ABI = [
+  {
+    type: "function",
+    name: "isOwner",
+    stateMutability: "view",
+    inputs: [{ name: "owner", type: "address" }],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "nonce",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "execTransaction",
+    stateMutability: "payable",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "data", type: "bytes" },
+      { name: "operation", type: "uint8" },
+      { name: "safeTxGas", type: "uint256" },
+      { name: "baseGas", type: "uint256" },
+      { name: "gasPrice", type: "uint256" },
+      { name: "gasToken", type: "address" },
+      { name: "refundReceiver", type: "address" },
+      { name: "signatures", type: "bytes" }
+    ],
+    outputs: [{ name: "success", type: "bool" }]
+  },
+  {
+    type: "event",
+    name: "ExecutionSuccess",
+    inputs: [
+      { name: "txHash", type: "bytes32", indexed: true },
+      { name: "payment", type: "uint256", indexed: false }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "ExecutionFailure",
+    inputs: [
+      { name: "txHash", type: "bytes32", indexed: true },
+      { name: "payment", type: "uint256", indexed: false }
+    ],
+    anonymous: false
+  }
+];
+async function executeSafeEthTransfer(params) {
+  const {
+    walletClient,
+    publicClient,
+    safeAddress,
+    recipient,
+    amount,
+    chainId
+  } = params;
+  const account = walletClient.account;
+  const chain = walletClient.chain;
+  if (!account || !chain) {
+    throw new Error("Wallet not connected");
+  }
+  if (chain.id !== chainId) {
+    throw new Error(`Switch to ${getChainName(chainId)} to sign`);
+  }
+  const isOwner = await publicClient.readContract({
+    address: safeAddress,
+    abi: SAFE_ABI,
+    functionName: "isOwner",
+    args: [account.address]
+  });
+  if (!isOwner) {
+    throw new Error("Connected wallet is not a Safe owner");
+  }
+  const safeTx = {
+    to: recipient,
+    value: amount,
+    data: "0x",
+    operation: 0,
+    safeTxGas: 0n,
+    baseGas: 0n,
+    gasPrice: 0n,
+    gasToken: zeroAddress,
+    refundReceiver: zeroAddress
+  };
+  const signature = concat([
+    pad(account.address, { size: 32 }),
+    pad(toHex(0), { size: 32 }),
+    toHex(1, { size: 1 })
+  ]);
+  const txHash = await walletClient.writeContract({
+    account,
+    chain,
+    address: safeAddress,
+    abi: SAFE_ABI,
+    functionName: "execTransaction",
+    args: [
+      safeTx.to,
+      safeTx.value,
+      safeTx.data,
+      safeTx.operation,
+      safeTx.safeTxGas,
+      safeTx.baseGas,
+      safeTx.gasPrice,
+      safeTx.gasToken,
+      safeTx.refundReceiver,
+      signature
+    ]
+  });
+  const receipt = await publicClient.waitForTransactionReceipt({
+    hash: txHash
+  });
+  const safeLogs = receipt.logs.filter(
+    (log) => log.address.toLowerCase() === safeAddress.toLowerCase()
+  );
+  const parsed = parseEventLogs({
+    abi: SAFE_ABI,
+    logs: safeLogs,
+    strict: false
+  });
+  const failed = parsed.find((log) => log.eventName === "ExecutionFailure");
+  if (failed) {
+    throw new Error("Safe transaction failed");
+  }
+  const succeeded = parsed.find((log) => log.eventName === "ExecutionSuccess");
+  if (!succeeded) {
+    throw new Error("Safe transaction status unavailable");
+  }
+  return { txHash };
+}
+async function executeSafeErc20Transfer(params) {
+  const {
+    walletClient,
+    publicClient,
+    safeAddress,
+    tokenAddress,
+    recipient,
+    amount,
+    chainId
+  } = params;
+  const account = walletClient.account;
+  const chain = walletClient.chain;
+  if (!account || !chain) {
+    throw new Error("Wallet not connected");
+  }
+  if (chain.id !== chainId) {
+    throw new Error(`Switch to ${getChainName(chainId)} to sign`);
+  }
+  const isOwner = await publicClient.readContract({
+    address: safeAddress,
+    abi: SAFE_ABI,
+    functionName: "isOwner",
+    args: [account.address]
+  });
+  if (!isOwner) {
+    throw new Error("Connected wallet is not a Safe owner");
+  }
+  const data = encodeFunctionData({
+    abi: erc20Abi,
+    functionName: "transfer",
+    args: [recipient, amount]
+  });
+  const safeTx = {
+    to: tokenAddress,
+    value: 0n,
+    data,
+    operation: 0,
+    safeTxGas: 0n,
+    baseGas: 0n,
+    gasPrice: 0n,
+    gasToken: zeroAddress,
+    refundReceiver: zeroAddress
+  };
+  const signature = concat([
+    pad(account.address, { size: 32 }),
+    pad(toHex(0), { size: 32 }),
+    toHex(1, { size: 1 })
+  ]);
+  const txHash = await walletClient.writeContract({
+    account,
+    chain,
+    address: safeAddress,
+    abi: SAFE_ABI,
+    functionName: "execTransaction",
+    args: [
+      safeTx.to,
+      safeTx.value,
+      safeTx.data,
+      safeTx.operation,
+      safeTx.safeTxGas,
+      safeTx.baseGas,
+      safeTx.gasPrice,
+      safeTx.gasToken,
+      safeTx.refundReceiver,
+      signature
+    ]
+  });
+  const receipt = await publicClient.waitForTransactionReceipt({
+    hash: txHash
+  });
+  const safeLogs = receipt.logs.filter(
+    (log) => log.address.toLowerCase() === safeAddress.toLowerCase()
+  );
+  const parsed = parseEventLogs({
+    abi: SAFE_ABI,
+    logs: safeLogs,
+    strict: false
+  });
+  const failed = parsed.find((log) => log.eventName === "ExecutionFailure");
+  if (failed) {
+    throw new Error("Safe transaction failed");
+  }
+  const succeeded = parsed.find((log) => log.eventName === "ExecutionSuccess");
+  if (!succeeded) {
+    throw new Error("Safe transaction status unavailable");
+  }
+  return { txHash };
+}
+var SAFE_TX_TYPES = {
+  SafeTx: [
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "data", type: "bytes" },
+    { name: "operation", type: "uint8" },
+    { name: "safeTxGas", type: "uint256" },
+    { name: "baseGas", type: "uint256" },
+    { name: "gasPrice", type: "uint256" },
+    { name: "gasToken", type: "address" },
+    { name: "refundReceiver", type: "address" },
+    { name: "nonce", type: "uint256" }
+  ]
+};
+async function buildSafeTransaction(params) {
+  const { publicClient, safeAddress, to, value, data, chainId } = params;
+  const nonce = await publicClient.readContract({
+    address: safeAddress,
+    abi: SAFE_ABI,
+    functionName: "nonce"
+  });
+  const message = {
+    to,
+    value,
+    data,
+    operation: 0,
+    safeTxGas: 0n,
+    baseGas: 0n,
+    gasPrice: 0n,
+    gasToken: zeroAddress,
+    refundReceiver: zeroAddress,
+    nonce
+  };
+  const safeTxHash = hashTypedData({
+    domain: { chainId, verifyingContract: safeAddress },
+    types: SAFE_TX_TYPES,
+    primaryType: "SafeTx",
+    message
+  });
+  return {
+    chainId,
+    safeAddress,
+    safeTxHash,
+    typedData: {
+      domain: { chainId, verifyingContract: safeAddress },
+      types: SAFE_TX_TYPES,
+      primaryType: "SafeTx",
+      message
+    }
+  };
+}
+
+// src/core/session-owner.ts
+import { isAddress } from "viem";
+import {
+  generatePrivateKey,
+  privateKeyToAccount
+} from "viem/accounts";
+var STORAGE_PREFIX = "rhinestone:session-owner";
+function storageKey(eoaAddress) {
+  return `${STORAGE_PREFIX}:${eoaAddress.toLowerCase()}`;
+}
+function loadSessionOwnerFromStorage(eoaAddress) {
+  if (typeof window === "undefined") return null;
+  const raw = window.localStorage.getItem(storageKey(eoaAddress));
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed.privateKey) return null;
+    const account = privateKeyToAccount(parsed.privateKey);
+    return {
+      privateKey: parsed.privateKey,
+      address: account.address
+    };
+  } catch {
+    return null;
+  }
+}
+function saveSessionOwnerToStorage(eoaAddress, privateKey, address) {
+  if (typeof window === "undefined") return;
+  if (!isAddress(address)) return;
+  const payload = {
+    privateKey,
+    address,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  window.localStorage.setItem(storageKey(eoaAddress), JSON.stringify(payload));
+}
+function createSessionOwnerKey() {
+  const privateKey = generatePrivateKey();
+  const account = privateKeyToAccount(privateKey);
+  return {
+    privateKey,
+    account,
+    address: account.address
+  };
+}
+function accountFromPrivateKey(privateKey) {
+  return privateKeyToAccount(privateKey);
+}
+
+export {
+  Modal,
+  WalletIcon,
+  ExternalLinkIcon,
+  CheckIcon,
+  TransferCryptoIcon,
+  ChevronLeftIcon,
+  ChevronDownIcon,
+  CloseIcon,
+  HandCoinsIcon,
+  HistoryIcon,
+  InfoIcon,
+  CopyIcon,
+  ArrowUpRightIcon,
+  AlertTriangleIcon,
+  PercentIcon,
+  ClockIcon,
+  PlusCircleIcon,
+  CircleArrowOutUpLeftIcon,
+  BankIcon,
+  Callout,
+  BodyHeader,
+  PoweredBy,
+  Spinner,
+  ConnectStep,
+  useLatestRef,
+  Button,
+  debugLog,
+  debugError,
+  getAssetId,
+  portfolioToAssets,
+  isNativeAsset,
+  buildSessionDetails,
+  createDepositService,
+  currencyFormatter,
+  tokenFormatter,
+  isUnsupportedChainSwitchError,
+  formatUserError,
+  Tooltip,
+  getEventTxHash,
+  getEventSourceDetails,
+  isDepositEvent,
+  isFailedEvent,
+  txRefsMatch,
+  failureMessageForEvent,
+  ProcessingStep,
+  SAFE_ABI,
+  executeSafeEthTransfer,
+  executeSafeErc20Transfer,
+  buildSafeTransaction,
+  getPublicClient,
+  getHyperEvmReadClient,
+  loadSessionOwnerFromStorage,
+  saveSessionOwnerToStorage,
+  createSessionOwnerKey,
+  accountFromPrivateKey,
+  applyTheme
+};