@rhinestone/deposit-modal 0.12.2 → 0.14.0

package/dist/{chunk-FXXUIK4E.mjs → chunk-IN77XSWO.mjs}

@@ -1,11 +1,10 @@
 import {
-  SERVICE_HEADERS
-} from "./chunk-IAGFDSNC.mjs";
+  MODAL_VERSION,
+  serviceHeaders
+} from "./chunk-K4H6TGBE.mjs";
 import {
-  CHAIN_BY_ID,
   CHAIN_DISPLAY_ORDER,
   HYPERCORE_CHAIN_ID,
-  HYPERCORE_MAINNET_CAIP2,
   HYPERCORE_SOURCE_TOKENS,
   HYPERCORE_SPOT_CAIP2,
   ICON_CDN,
@@ -27,7 +26,7 @@ import {
   setRuntimeTokens,
   toEvmCaip2,
   tokenIconUrl
-} from "./chunk-3STTWRAN.mjs";
+} from "./chunk-VUATPOWJ.mjs";
 
 // src/components/ui/Modal.tsx
 import {
@@ -85,7 +84,7 @@ function Modal({
     (event) => {
       if (event.key === "Escape") {
         event.preventDefault();
-        onClose();
+        onClose("escape");
         return;
       }
       if (event.key === "Tab" && contentRef.current) {
@@ -111,7 +110,7 @@ function Modal({
   const handleOverlayClick = useCallback(
     (event) => {
       if (closeOnOverlayClick && event.target === overlayRef.current) {
-        onClose();
+        onClose("overlay");
       }
     },
     [closeOnOverlayClick, onClose]
@@ -172,9 +171,6 @@ import {
   ArrowRight,
   ArrowUpRight,
   AlertTriangle,
-  Percent,
-  Clock,
-  CirclePlus,
   CircleArrowOutUpLeft,
   CreditCard,
   Landmark,
@@ -218,9 +214,6 @@ 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;
@@ -467,7 +460,7 @@ function normalizeForLog(value, depth = 0) {
     const output = {};
     for (const [key, raw] of Object.entries(input)) {
       const keyLower = key.toLowerCase();
-      if (keyLower.includes("signature") || keyLower.includes("privatekey") || keyLower.includes("sessiondetails")) {
+      if (keyLower.includes("signature") || keyLower.includes("privatekey") || keyLower.includes("sessiondetails") || keyLower.includes("rpcurl") || keyLower.includes("apikey") || keyLower.includes("authorization")) {
         output[key] = "[Redacted]";
         continue;
       }
@@ -579,17 +572,14 @@ function parseChainCatalog(body) {
   return { all, byCaip2, byChainId };
 }
 function aliasHyperCoreOrigin(byCaip2, all) {
+  if (byCaip2.has(HYPERCORE_SPOT_CAIP2)) return;
   const origin = all.find((c) => isHyperCoreCaip2(c.caip2) && c.deposit) ?? all.find((c) => isHyperCoreCaip2(c.caip2));
-  if (!origin) return;
-  byCaip2.set(HYPERCORE_MAINNET_CAIP2, origin);
-  if (!byCaip2.has(HYPERCORE_SPOT_CAIP2)) {
-    byCaip2.set(HYPERCORE_SPOT_CAIP2, origin);
-  }
+  if (origin) byCaip2.set(HYPERCORE_SPOT_CAIP2, origin);
 }
 function catalogKeyForChain(chainId) {
   if (chainId === "solana") return SOLANA_MAINNET_CAIP2;
   if (chainId === "hypercore" || chainId === HYPERCORE_CHAIN_ID) {
-    return HYPERCORE_MAINNET_CAIP2;
+    return HYPERCORE_SPOT_CAIP2;
   }
   return chainId;
 }
@@ -817,7 +807,8 @@ function parseQuoteOutput(raw) {
   };
 }
 function parseFeeLine(raw) {
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return null;
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+    return null;
   const line = raw;
   const usd = line.usd;
   if (typeof usd !== "number" || !Number.isFinite(usd) || usd < 0) return null;
@@ -854,6 +845,13 @@ function resolveAppFeeBps(appFees, sourceChainCaip2, sourceToken) {
   const bps = override ?? appFees?.feeBps ?? 0;
   return bps > 0 ? bps : 0;
 }
+var PermitDepositSubmitError = class extends Error {
+  constructor(message, safeToTransfer) {
+    super(message);
+    this.safeToTransfer = safeToTransfer;
+    this.name = "PermitDepositSubmitError";
+  }
+};
 function createDepositService(baseUrl, options) {
   const normalizedBaseUrl = baseUrl.replace(/\/$/, "");
   const debug = options?.debug === true;
@@ -894,7 +892,7 @@ function createDepositService(baseUrl, options) {
     try {
       const response = await fetch(apiUrl("/qr/tokens"), {
         method: "GET",
-        headers: SERVICE_HEADERS
+        headers: serviceHeaders()
       });
       if (!response.ok) {
         debugLog(debug, scope, "getTopTokens:unavailable", {
@@ -921,7 +919,7 @@ function createDepositService(baseUrl, options) {
     try {
       const response = await fetch(apiUrl("/chains"), {
         method: "GET",
-        headers: SERVICE_HEADERS
+        headers: serviceHeaders()
       });
       if (!response.ok) {
         debugLog(debug, scope, "getChains:unavailable", {
@@ -975,18 +973,15 @@ function createDepositService(baseUrl, options) {
       });
       const response = await fetch(url, {
         method: "POST",
-        headers: SERVICE_HEADERS,
+        headers: serviceHeaders(),
         body: JSON.stringify({ account: params })
       });
       if (!response.ok) {
         const error = await response.json().catch(() => ({ error: "Unknown error" }));
-        debugError(
-          debug,
-          scope,
-          "registerManagedAccount:failed",
-          error,
-          { status: response.status, salt: params.salt }
-        );
+        debugError(debug, scope, "registerManagedAccount:failed", error, {
+          status: response.status,
+          salt: params.salt
+        });
         const detail = Array.isArray(error.details) ? error.details.map((d) => d?.message).filter(Boolean).join("; ") : void 0;
         const base = error.error || `Account registration failed: ${response.status}`;
         throw new Error(detail ? `${base}: ${detail}` : base);
@@ -1003,100 +998,104 @@ function createDepositService(baseUrl, options) {
       };
     },
     async fetchPortfolio(address, options2) {
-      return cachedPortfolio(`evm:${address.toLowerCase()}`, async () => {
-        const url = apiUrl(`/portfolio/${address}?includeUnsupported=true`);
-        debugLog(debug, scope, "fetchPortfolio:request", { url, address });
-        const response = await fetch(url, {
-          method: "GET",
-          headers: SERVICE_HEADERS
-        });
-        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 cachedPortfolio(
+        `evm:${address.toLowerCase()}`,
+        async () => {
+          const url = apiUrl(`/portfolio/${address}?includeUnsupported=true`);
+          debugLog(debug, scope, "fetchPortfolio:request", { url, address });
+          const response = await fetch(url, {
+            method: "GET",
+            headers: serviceHeaders()
           });
-          return direct;
-        }
-        const portfolioData = extractOrchestratorPortfolio(data);
-        if (portfolioData) {
-          const normalized = normalizeOrchestratorPortfolio(portfolioData);
-          debugLog(debug, scope, "fetchPortfolio:success", {
+          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 };
+        },
+        options2?.forceRefresh
+      );
+    },
+    async fetchSolanaPortfolio(address, options2) {
+      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: serviceHeaders()
+          });
+          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,
-            source: "orchestrator",
             tokenCount: normalized.tokens.length,
             totalUsd: normalized.totalUsd
           });
           return normalized;
-        }
-        debugLog(debug, scope, "fetchPortfolio:empty", { address });
-        return { tokens: [], totalUsd: 0 };
-      }, options2?.forceRefresh);
-    },
-    async fetchSolanaPortfolio(address, options2) {
-      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: SERVICE_HEADERS
-        });
-        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;
-      }, options2?.forceRefresh);
+        },
+        options2?.forceRefresh
+      );
     },
     async checkAccount(address) {
       const url = apiUrl(`/check/${address}`);
       debugLog(debug, scope, "checkAccount:request", { url, address });
       const response = await fetch(url, {
         method: "GET",
-        headers: SERVICE_HEADERS
+        headers: serviceHeaders()
       });
       if (!response.ok) {
         const error = await response.json().catch(() => ({ error: "Unknown error" }));
-        debugError(
-          debug,
-          scope,
-          "checkAccount:failed",
-          error,
-          { status: response.status, address }
+        debugError(debug, scope, "checkAccount:failed", error, {
+          status: response.status,
+          address
+        });
+        throw new Error(
+          error.error || `Account check failed: ${response.status}`
         );
-        throw new Error(error.error || `Account check failed: ${response.status}`);
       }
       const data = await response.json();
       const result = {
@@ -1116,11 +1115,13 @@ function createDepositService(baseUrl, options) {
       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`
+        `/deposits?account=${encodeURIComponent(
+          address
+        )}&txHash=${txHashParam}&limit=1`
       );
       const response = await fetch(url, {
         method: "GET",
-        headers: SERVICE_HEADERS,
+        headers: serviceHeaders(),
         cache: "no-store"
       });
       if (!response.ok) {
@@ -1148,7 +1149,7 @@ function createDepositService(baseUrl, options) {
       );
       const response = await fetch(url, {
         method: "GET",
-        headers: SERVICE_HEADERS,
+        headers: serviceHeaders(),
         cache: "no-store"
       });
       if (!response.ok) {
@@ -1172,7 +1173,7 @@ function createDepositService(baseUrl, options) {
       );
       const response = await fetch(url, {
         method: "GET",
-        headers: SERVICE_HEADERS,
+        headers: serviceHeaders(),
         cache: "no-store"
       });
       if (!response.ok) {
@@ -1194,7 +1195,7 @@ function createDepositService(baseUrl, options) {
     async getPositions(address) {
       const url = apiUrl(`/positions/${address}`);
       debugLog(debug, scope, "getPositions:request", { url, address });
-      const response = await fetch(url, { headers: SERVICE_HEADERS });
+      const response = await fetch(url, { headers: serviceHeaders() });
       if (!response.ok) {
         const error = await response.json().catch(() => ({ error: "Unknown error" }));
         debugError(debug, scope, "getPositions:failed", error, {
@@ -1228,7 +1229,7 @@ function createDepositService(baseUrl, options) {
       });
       const response = await fetch(url, {
         method: "POST",
-        headers: SERVICE_HEADERS,
+        headers: serviceHeaders(),
         body: JSON.stringify({ account, market, chainId, asset, amount })
       });
       if (!response.ok) {
@@ -1264,7 +1265,7 @@ function createDepositService(baseUrl, options) {
       });
       const response = await fetch(url, {
         method: "POST",
-        headers: SERVICE_HEADERS,
+        headers: serviceHeaders(),
         body: JSON.stringify({
           depositWallet,
           owner,
@@ -1306,18 +1307,15 @@ function createDepositService(baseUrl, options) {
       });
       const response = await fetch(url, {
         method: "GET",
-        headers: SERVICE_HEADERS,
+        headers: serviceHeaders(),
         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) }
-        );
+        debugError(debug, scope, "fetchDepositHistory:failed", error, {
+          status: response.status,
+          recipient: shortRef(params.recipient)
+        });
         throw new Error(
           error.error || `Deposit history fetch failed: ${response.status}`
         );
@@ -1359,7 +1357,7 @@ function createDepositService(baseUrl, options) {
       });
       const response = await fetch(url, {
         method: "GET",
-        headers: SERVICE_HEADERS,
+        headers: serviceHeaders(),
         cache: "no-store"
       });
       if (!response.ok) {
@@ -1391,7 +1389,10 @@ function createDepositService(baseUrl, options) {
       const body = {
         account: params.account,
         // HyperCore has its own CAIP-2 namespace — never the eip155 placeholder.
-        sourceChainId: params.sourceChainId === "hypercore" ? HYPERCORE_MAINNET_CAIP2 : `eip155:${params.sourceChainId}`,
+        // The branch is unreachable against today's processor whatever venue it
+        // names: `sourceToken` is validated as a 20-byte 0x address on every
+        // chain, and a HyperCore source token is a 16-byte Core spot tokenId.
+        sourceChainId: params.sourceChainId === "hypercore" ? HYPERCORE_SPOT_CAIP2 : `eip155:${params.sourceChainId}`,
         sourceToken: params.sourceToken,
         amount: params.amount
       };
@@ -1404,7 +1405,7 @@ function createDepositService(baseUrl, options) {
       try {
         const response = await fetch(url, {
           method: "POST",
-          headers: SERVICE_HEADERS,
+          headers: serviceHeaders(),
           body: JSON.stringify(body),
           cache: "no-store"
         });
@@ -1432,6 +1433,154 @@ function createDepositService(baseUrl, options) {
         return null;
       }
     },
+    async preparePermitDeposit(params) {
+      const url = apiUrl("/deposits/permit/prepare");
+      debugLog(debug, scope, "preparePermitDeposit:request", {
+        url,
+        account: shortRef(params.account),
+        sourceChain: params.sourceChain,
+        token: params.token,
+        amount: params.amount
+      });
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: serviceHeaders(),
+          body: JSON.stringify({ ...params, kind: "auto" }),
+          cache: "no-store"
+        });
+        if (!response.ok) {
+          debugLog(debug, scope, "preparePermitDeposit:unavailable", {
+            status: response.status
+          });
+          return null;
+        }
+        const data = await response.json();
+        if (!data || typeof data.available !== "boolean") {
+          debugLog(debug, scope, "preparePermitDeposit:unavailable", {
+            status: response.status,
+            reason: "malformed"
+          });
+          return null;
+        }
+        if (data.available === false) {
+          const reason = data.reason;
+          if (reason !== "permit2-approval-required" && reason !== "unsupported-token" && reason !== "unsupported-owner") {
+            return null;
+          }
+          debugLog(debug, scope, "preparePermitDeposit:unavailable", {
+            status: response.status,
+            reason
+          });
+          const approval = data.approval;
+          const parsedApproval = approval && typeof approval.token === "string" && typeof approval.spender === "string" && typeof approval.minimumAmount === "string" ? {
+            token: approval.token,
+            spender: approval.spender,
+            minimumAmount: approval.minimumAmount
+          } : void 0;
+          return {
+            available: false,
+            reason,
+            ...parsedApproval && { approval: parsedApproval }
+          };
+        }
+        const authorization = data.authorization;
+        if (!authorization || typeof authorization.typedData !== "object" || authorization.typedData === null || typeof authorization.nonce !== "string") {
+          return null;
+        }
+        if (authorization.kind === "erc3009" && typeof authorization.validAfter === "string" && typeof authorization.validBefore === "string") {
+          debugLog(debug, scope, "preparePermitDeposit:success", {
+            kind: authorization.kind,
+            nonce: authorization.nonce
+          });
+          return {
+            available: true,
+            authorization: {
+              kind: "erc3009",
+              typedData: authorization.typedData,
+              nonce: authorization.nonce,
+              validAfter: authorization.validAfter,
+              validBefore: authorization.validBefore
+            }
+          };
+        }
+        if ((authorization.kind === "erc2612" || authorization.kind === "permit2") && typeof authorization.deadline === "string") {
+          debugLog(debug, scope, "preparePermitDeposit:success", {
+            kind: authorization.kind,
+            nonce: authorization.nonce
+          });
+          return {
+            available: true,
+            authorization: {
+              kind: authorization.kind,
+              typedData: authorization.typedData,
+              nonce: authorization.nonce,
+              deadline: authorization.deadline
+            }
+          };
+        }
+        return null;
+      } catch (error) {
+        debugError(debug, scope, "preparePermitDeposit:error", error);
+        return null;
+      }
+    },
+    async submitPermitDeposit(params) {
+      const url = apiUrl("/deposits/permit");
+      debugLog(debug, scope, "submitPermitDeposit:request", {
+        url,
+        account: shortRef(params.account),
+        sourceChain: params.sourceChain,
+        token: params.token,
+        amount: params.amount,
+        nonce: params.nonce
+      });
+      let response;
+      try {
+        response = await fetch(url, {
+          method: "POST",
+          headers: serviceHeaders(),
+          body: JSON.stringify(params)
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Network error";
+        throw new PermitDepositSubmitError(message, false);
+      }
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: "Unknown error" }));
+        debugError(debug, scope, "submitPermitDeposit:failed", error, {
+          status: response.status,
+          account: shortRef(params.account)
+        });
+        const safeToTransfer = [400, 401, 403, 404, 422].includes(
+          response.status
+        );
+        throw new PermitDepositSubmitError(
+          error.error || `Permit deposit failed: ${response.status}`,
+          safeToTransfer
+        );
+      }
+      const result = await response.json();
+      if (typeof result?.txHash !== "string" || result.txHash.length === 0) {
+        debugError(debug, scope, "submitPermitDeposit:failed", result, {
+          reason: "missing txHash"
+        });
+        throw new PermitDepositSubmitError(
+          "Permit deposit response missing txHash",
+          false
+        );
+      }
+      debugLog(debug, scope, "submitPermitDeposit:success", {
+        depositId: result.depositId,
+        txHash: shortRef(result.txHash),
+        status: result.status
+      });
+      return {
+        depositId: result.depositId ?? "",
+        txHash: result.txHash,
+        status: result.status ?? "processing"
+      };
+    },
     async fetchPrices(symbols) {
       const list = symbols.filter((s) => s.length > 0);
       if (list.length === 0) return {};
@@ -1441,7 +1590,7 @@ function createDepositService(baseUrl, options) {
       try {
         const response = await fetch(url, {
           method: "GET",
-          headers: SERVICE_HEADERS,
+          headers: serviceHeaders(),
           cache: "no-store"
         });
         if (!response.ok) {
@@ -1466,12 +1615,14 @@ function createDepositService(baseUrl, options) {
       const list = caip2Ids.filter((id) => id.length > 0);
       if (list.length === 0) return {};
       const url = apiUrl(
-        `/prices?${new URLSearchParams({ addresses: list.join(",") }).toString()}`
+        `/prices?${new URLSearchParams({
+          addresses: list.join(",")
+        }).toString()}`
       );
       try {
         const response = await fetch(url, {
           method: "GET",
-          headers: SERVICE_HEADERS,
+          headers: serviceHeaders(),
           cache: "no-store"
         });
         if (!response.ok) {
@@ -1496,7 +1647,7 @@ function createDepositService(baseUrl, options) {
       });
       const response = await fetch(url, {
         method: "POST",
-        headers: SERVICE_HEADERS,
+        headers: serviceHeaders(),
         body: JSON.stringify(params)
       });
       if (!response.ok) {
@@ -1528,7 +1679,7 @@ function createDepositService(baseUrl, options) {
       });
       const response = await fetch(url, {
         method: "POST",
-        headers: SERVICE_HEADERS,
+        headers: serviceHeaders(),
         body: JSON.stringify(params)
       });
       if (!response.ok) {
@@ -1565,7 +1716,7 @@ function createDepositService(baseUrl, options) {
       debugLog(debug, scope, "getSwappedConnectExchanges:request");
       const response = await fetch(url, {
         method: "GET",
-        headers: SERVICE_HEADERS,
+        headers: serviceHeaders(),
         cache: "no-store"
       });
       if (!response.ok) {
@@ -1618,7 +1769,7 @@ function createDepositService(baseUrl, options) {
       try {
         const response = await fetch(url, {
           method: "GET",
-          headers: SERVICE_HEADERS,
+          headers: serviceHeaders(),
           cache: "no-store"
         });
         if (!response.ok) {
@@ -1704,7 +1855,7 @@ function createDepositService(baseUrl, options) {
       try {
         const response = await fetch(url, {
           method: "GET",
-          headers: SERVICE_HEADERS,
+          headers: serviceHeaders(),
           cache: "no-store"
         });
         if (!response.ok) {
@@ -1731,7 +1882,7 @@ function createDepositService(baseUrl, options) {
       );
       const response = await fetch(url, {
         method: "GET",
-        headers: SERVICE_HEADERS,
+        headers: serviceHeaders(),
         cache: "no-store"
       });
       if (!response.ok) return null;
@@ -1800,9 +1951,15 @@ function normalizeOrchestratorPortfolio(data) {
       if (!resolvedTokenAddress) {
         continue;
       }
-      const registrySymbol = getTokenSymbol(resolvedTokenAddress, chainBalance.chainId);
+      const registrySymbol = getTokenSymbol(
+        resolvedTokenAddress,
+        chainBalance.chainId
+      );
       const symbol = registrySymbol !== "Token" ? registrySymbol : normalizedName || "Token";
-      const decimals = registrySymbol !== "Token" ? getTokenDecimalsByAddress(resolvedTokenAddress, chainBalance.chainId) : tokenData.tokenDecimals ?? 18;
+      const decimals = registrySymbol !== "Token" ? getTokenDecimalsByAddress(
+        resolvedTokenAddress,
+        chainBalance.chainId
+      ) : tokenData.tokenDecimals ?? 18;
       tokens.push({
         chainId: chainBalance.chainId,
         address: resolvedTokenAddress,
@@ -1823,8 +1980,8 @@ 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" : (
-    // HyperCore (`hypercore:mainnet`) is a non-EVM source; keep its USDC
-    // instead of dropping it as an unparseable chain string.
+    // HyperCore is a non-EVM source under its own namespace; keep its
+    // USDC instead of dropping it as an unparseable chain string.
     isHyperCoreCaip2(rawChainString) || rawChainString.toLowerCase() === "hypercore" ? "hypercore" : parseEvmChainId(rawChainString)
   ) : null);
   if (chainId === null) return null;
@@ -1909,32 +2066,65 @@ import {
   useContext as useContext2,
   useEffect as useEffect2,
   useMemo as useMemo2,
-  useState as useState2
+  useState as useState2,
+  useSyncExternalStore
 } from "react";
 
 // src/core/public-client.ts
 import { createPublicClient, http } from "viem";
 var clientCache = /* @__PURE__ */ new Map();
 var runtimeChainById = /* @__PURE__ */ new Map();
+var BOOTSTRAP_RPC_URL = {
+  1: "https://eth.merkle.io",
+  10: "https://mainnet.optimism.io",
+  56: "https://56.rpc.thirdweb.com",
+  100: "https://rpc.gnosischain.com",
+  130: "https://mainnet.unichain.org",
+  137: "https://polygon.drpc.org",
+  143: "https://rpc.monad.xyz",
+  146: "https://rpc.soniclabs.com",
+  999: "https://rpc.hyperliquid.xyz/evm",
+  1868: "https://rpc.soneium.org",
+  8453: "https://mainnet.base.org",
+  9745: "https://rpc.plasma.to",
+  42161: "https://arb1.arbitrum.io/rpc",
+  747474: "https://rpc.katana.network"
+};
+var runtimeChainsVersion = 0;
+var runtimeChainListeners = /* @__PURE__ */ new Set();
+function subscribeToRuntimeChains(listener) {
+  runtimeChainListeners.add(listener);
+  return () => {
+    runtimeChainListeners.delete(listener);
+  };
+}
+function getRuntimeChainsVersion() {
+  return runtimeChainsVersion;
+}
 function setRuntimeChains(chains) {
+  let changed = false;
   for (const chain of chains) {
     const known = runtimeChainById.get(chain.id);
     if (known === chain) continue;
     runtimeChainById.set(chain.id, chain);
+    changed = true;
     for (const key of clientCache.keys()) {
       if (key.startsWith(`${chain.id}|`)) clientCache.delete(key);
     }
   }
+  if (!changed) return;
+  runtimeChainsVersion += 1;
+  for (const listener of runtimeChainListeners) listener();
 }
 function getPublicClient(chainId, rpcUrls) {
   const url = rpcUrlFor(rpcUrls, chainId);
   const cacheKey = `${chainId}|${url ?? ""}`;
   let client = clientCache.get(cacheKey);
   if (!client) {
-    const chain = CHAIN_BY_ID[chainId] ?? runtimeChainById.get(chainId);
+    const chain = runtimeChainById.get(chainId);
     client = createPublicClient({
       chain,
-      transport: http(url)
+      transport: http(url ?? (chain ? void 0 : BOOTSTRAP_RPC_URL[chainId]))
     });
     clientCache.set(cacheKey, client);
   }
@@ -2095,7 +2285,8 @@ function publishRuntimeChainMeta(catalog) {
         chainId,
         name: chain.name,
         iconUrl: chain.iconUrl ?? void 0,
-        nativeSymbol: chain.nativeToken.symbol
+        nativeSymbol: chain.nativeToken.symbol,
+        explorerUrl: chain.explorer?.url
       }));
     })
   );
@@ -2204,6 +2395,20 @@ function useChainName() {
     };
   }, [catalog]);
 }
+function useRuntimeChainsVersion() {
+  return useSyncExternalStore(
+    subscribeToRuntimeChains,
+    getRuntimeChainsVersion,
+    getRuntimeChainsVersion
+  );
+}
+function useReadClient(chainId, rpcUrls) {
+  const version = useRuntimeChainsVersion();
+  return useMemo2(
+    () => getPublicClient(chainId, rpcUrls),
+    [chainId, rpcUrls, version]
+  );
+}
 function useExplorerTxUrl() {
   const { catalog } = useChainCatalog();
   return useMemo2(() => {
@@ -2671,6 +2876,524 @@ function formatReceiveEstimate(params) {
   return sameSymbol ? `${formatted} ${params.targetSymbol}` : `~${formatted} ${params.targetSymbol}`;
 }
 
+// src/core/analytics.tsx
+import {
+  createContext as createContext3,
+  useCallback as useCallback2,
+  useContext as useContext3,
+  useEffect as useEffect4,
+  useMemo as useMemo3,
+  useRef as useRef3
+} from "react";
+
+// src/core/analytics-ingest.ts
+var DEFAULT_ANALYTICS_INGEST_URL = "https://v1.orchestrator.rhinestone.dev/deposit-processor/analytics/events";
+var MAX_BATCH = 20;
+var MAX_QUEUE = 200;
+var FLUSH_DELAY_MS = 5e3;
+var MAX_BODY_BYTES = 48 * 1024;
+var TOKEN_REFRESH_MARGIN_MS = 6e4;
+var TOKEN_TIMEOUT_MS = 3e3;
+var MAX_ATTEMPTS = 3;
+var MAX_BACKOFF_MS = 3e4;
+var ENVELOPE_FIELDS = /* @__PURE__ */ new Set([
+  "type",
+  "timestamp",
+  "session_id",
+  "modal",
+  "widget_version",
+  "session_properties",
+  "funding_method"
+]);
+function createIngestTransport(options) {
+  const {
+    ingestUrl,
+    backendUrl,
+    proxyOrigin,
+    sessionId,
+    modal,
+    widgetVersion,
+    sessionProperties,
+    onFailure
+  } = options;
+  const fetchImpl = options.fetchImpl ?? (typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : void 0);
+  const now = options.now ?? (() => Date.now());
+  const createEventId = options.createEventId ?? randomUuid;
+  const mintUrl = `${backendUrl.replace(/\/$/, "")}/analytics/ingest-token`;
+  const queue = [];
+  let sequence = 0;
+  let dropped = 0;
+  let token = null;
+  let mintUnavailable = false;
+  let mintFailures = 0;
+  let mintBackoffUntil = 0;
+  let timer = null;
+  let sending = false;
+  let disposed = false;
+  let pendingTerminal = false;
+  let terminalRequested = false;
+  let mintAbort = null;
+  const sleepers = /* @__PURE__ */ new Set();
+  function report(reason, status) {
+    try {
+      onFailure({ reason, status, droppedEvents: dropped });
+    } catch {
+    }
+  }
+  function drop(batch, reason, status) {
+    dropped += batch.length;
+    report(reason, status);
+  }
+  function toWireEvent(event) {
+    const payload = {};
+    for (const [key, value] of Object.entries(event)) {
+      if (!ENVELOPE_FIELDS.has(key)) payload[key] = value;
+    }
+    const wire = {
+      event_id: createEventId(),
+      session_id: sessionId,
+      sequence: sequence++,
+      type: String(event.type),
+      timestamp: String(event.timestamp),
+      widget_version: widgetVersion,
+      proxy_origin: proxyOrigin,
+      modal,
+      session_properties: sessionProperties,
+      payload
+    };
+    if (modal === "deposit") wire.funding_method = event.funding_method ?? null;
+    return wire;
+  }
+  function takeBatch() {
+    const batch = queue.slice(0, MAX_BATCH);
+    while (batch.length > 1 && bodyOf(batch).length > MAX_BODY_BYTES) {
+      batch.pop();
+    }
+    queue.splice(0, batch.length);
+    return batch;
+  }
+  function bodyOf(batch) {
+    return JSON.stringify({ events: batch });
+  }
+  function backoff(attempt) {
+    return Math.min(1e3 * 2 ** (attempt - 1), MAX_BACKOFF_MS);
+  }
+  function sleep(ms) {
+    return new Promise((resolve) => {
+      const timeout = setTimeout(finish, ms);
+      function finish() {
+        clearTimeout(timeout);
+        sleepers.delete(finish);
+        resolve();
+      }
+      sleepers.add(finish);
+    });
+  }
+  function interruptForUnload() {
+    for (const wake of [...sleepers]) wake();
+    mintAbort?.abort();
+  }
+  function retryDelay(response, attempt) {
+    const seconds = Number(response.headers?.get?.("Retry-After"));
+    if (Number.isFinite(seconds) && seconds > 0) {
+      return Math.min(seconds * 1e3, MAX_BACKOFF_MS);
+    }
+    return backoff(attempt);
+  }
+  async function mintToken() {
+    if (mintUnavailable || !fetchImpl) return;
+    const controller = typeof AbortController === "function" ? new AbortController() : null;
+    mintAbort = controller;
+    const timeout = controller ? setTimeout(() => controller.abort(), TOKEN_TIMEOUT_MS) : null;
+    let response;
+    try {
+      response = await fetchImpl(mintUrl, {
+        method: "POST",
+        headers: serviceHeaders(),
+        signal: controller?.signal
+      });
+    } catch {
+      if (!terminalRequested) {
+        mintFailures += 1;
+        mintBackoffUntil = now() + backoff(mintFailures);
+      }
+      return;
+    } finally {
+      if (timeout !== null) clearTimeout(timeout);
+      mintAbort = null;
+    }
+    if (response.status === 404 || response.status === 401 || response.status === 403) {
+      mintUnavailable = true;
+      report("token_unavailable", response.status);
+      return;
+    }
+    if (!response.ok) {
+      mintFailures += 1;
+      mintBackoffUntil = now() + backoff(mintFailures);
+      return;
+    }
+    try {
+      const data = await response.json();
+      const value = typeof data.token === "string" ? data.token : "";
+      const expiresAt = Date.parse(String(data.expiresAt));
+      if (!value || Number.isNaN(expiresAt)) throw new Error("malformed");
+      token = { value, expiresAt };
+      mintFailures = 0;
+      mintBackoffUntil = 0;
+    } catch {
+      mintUnavailable = true;
+      report("token_unavailable", response.status);
+    }
+  }
+  async function ensureToken() {
+    if (mintUnavailable) return;
+    if (token && token.expiresAt - now() > TOKEN_REFRESH_MARGIN_MS) return;
+    if (now() < mintBackoffUntil) return;
+    await mintToken();
+  }
+  async function deliver(batch, isTerminal) {
+    if (!fetchImpl) return drop(batch, "unsupported");
+    let attempt = 0;
+    let refreshed = false;
+    let unattributed = false;
+    for (; ; ) {
+      const terminal = isTerminal || terminalRequested;
+      attempt += 1;
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (token && !unattributed) headers.Authorization = `Bearer ${token.value}`;
+      let response;
+      try {
+        response = await fetchImpl(ingestUrl, {
+          method: "POST",
+          headers,
+          body: bodyOf(batch),
+          keepalive: true
+        });
+      } catch {
+        if (terminal || attempt >= MAX_ATTEMPTS) {
+          return drop(batch, "network");
+        }
+        await sleep(backoff(attempt));
+        continue;
+      }
+      if (response.ok) return;
+      const status = response.status;
+      if (status === 401) {
+        token = null;
+        if (!refreshed && !terminal) {
+          refreshed = true;
+          await mintToken();
+          if (token) continue;
+        }
+        if (!unattributed) {
+          unattributed = true;
+          continue;
+        }
+        return drop(batch, "unauthorized", status);
+      }
+      if (status === 409) return drop(batch, "conflict", status);
+      if (status === 429 || status >= 500) {
+        if (terminal || attempt >= MAX_ATTEMPTS) {
+          return drop(batch, status === 429 ? "throttled" : "unavailable", status);
+        }
+        await sleep(retryDelay(response, attempt));
+        continue;
+      }
+      return drop(batch, "rejected", status);
+    }
+  }
+  async function run(requestedTerminal) {
+    if (requestedTerminal) terminalRequested = true;
+    if (sending) {
+      if (requestedTerminal) {
+        pendingTerminal = true;
+        interruptForUnload();
+      }
+      return;
+    }
+    sending = true;
+    try {
+      while (queue.length > 0) {
+        const terminal = requestedTerminal || terminalRequested;
+        const batch = takeBatch();
+        if (!terminal) await ensureToken();
+        await deliver(batch, terminal);
+        if (!terminal && disposed) break;
+      }
+    } finally {
+      sending = false;
+    }
+    if (pendingTerminal) {
+      pendingTerminal = false;
+      await run(true);
+      return;
+    }
+    if (!disposed && queue.length === 0) terminalRequested = false;
+  }
+  function clearFlushTimer() {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  }
+  function scheduleFlush() {
+    if (timer !== null || disposed) return;
+    timer = setTimeout(() => {
+      timer = null;
+      void run(false);
+    }, FLUSH_DELAY_MS);
+  }
+  return {
+    enqueue(event) {
+      if (disposed) return;
+      queue.push(toWireEvent(event));
+      if (queue.length > MAX_QUEUE) {
+        dropped += queue.length - MAX_QUEUE;
+        queue.splice(0, queue.length - MAX_QUEUE);
+      }
+      if (queue.length >= MAX_BATCH) {
+        clearFlushTimer();
+        void run(false);
+      } else {
+        scheduleFlush();
+      }
+    },
+    flush(flushOptions) {
+      const terminal = flushOptions?.terminal ?? false;
+      if (disposed && !terminal) return;
+      clearFlushTimer();
+      void run(terminal);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      clearFlushTimer();
+      void run(true);
+    }
+  };
+}
+function randomUuid() {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  const bytes = new Uint8Array(16);
+  globalThis.crypto?.getRandomValues?.(bytes);
+  if (!bytes.some(Boolean)) {
+    for (let index = 0; index < bytes.length; index += 1) {
+      bytes[index] = Math.floor(Math.random() * 256);
+    }
+  }
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0"));
+  return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10).join("")}`;
+}
+function resolveProxyOrigin(backendUrl) {
+  if (!backendUrl.trim()) return null;
+  try {
+    const { origin } = new URL(backendUrl, globalThis.location?.href);
+    return origin.startsWith("http") ? origin : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/core/analytics.tsx
+import { jsx as jsx11 } from "react/jsx-runtime";
+var AnalyticsContext = createContext3(null);
+var noopDepositEmitter = () => {
+};
+var noopWithdrawEmitter = () => {
+};
+var noopClaimEmitter = () => {
+};
+function cloneAndFreeze(value) {
+  if (Array.isArray(value)) {
+    return Object.freeze(value.map(cloneAndFreeze));
+  }
+  if (value && typeof value === "object") {
+    const clone = Object.fromEntries(
+      Object.entries(value).map(([key, child]) => [key, cloneAndFreeze(child)])
+    );
+    return Object.freeze(clone);
+  }
+  return value;
+}
+function AnalyticsSession(props) {
+  const sessionIdRef = useRef3(void 0);
+  if (sessionIdRef.current === void 0) {
+    sessionIdRef.current = (props.createSessionId ?? randomUuid)();
+  }
+  const sessionPropertiesRef = useRef3(void 0);
+  if (sessionPropertiesRef.current === void 0) {
+    sessionPropertiesRef.current = cloneAndFreeze(props.sessionProperties);
+  }
+  const onEventRef = useRef3(props.onEvent);
+  onEventRef.current = props.onEvent;
+  const nowRef = useRef3(props.now ?? (() => /* @__PURE__ */ new Date()));
+  nowRef.current = props.now ?? (() => /* @__PURE__ */ new Date());
+  const modal = props.modal;
+  const reportedFailuresRef = useRef3(/* @__PURE__ */ new Set());
+  const emitFailure = useCallback2(
+    ({ reason, status, droppedEvents }) => {
+      if (reportedFailuresRef.current.has(reason)) return;
+      reportedFailuresRef.current.add(reason);
+      const event = {
+        type: "analytics_ingest_failure",
+        session_id: sessionIdRef.current,
+        modal,
+        widget_version: MODAL_VERSION,
+        timestamp: nowRef.current().toISOString(),
+        reason,
+        ...status === void 0 ? {} : { status },
+        dropped_events: droppedEvents
+      };
+      onEventRef.current?.(event);
+    },
+    [modal]
+  );
+  function createIngest() {
+    if (props.enableIngest === false) {
+      return { transport: null, initialFailure: null };
+    }
+    const proxyOrigin = resolveProxyOrigin(props.backendUrl ?? "");
+    if (!proxyOrigin || typeof globalThis.fetch !== "function") {
+      return {
+        transport: null,
+        initialFailure: { reason: "unsupported", droppedEvents: 0 }
+      };
+    }
+    return {
+      transport: createIngestTransport({
+        ingestUrl: props.ingestUrl ?? DEFAULT_ANALYTICS_INGEST_URL,
+        backendUrl: props.backendUrl,
+        proxyOrigin,
+        sessionId: sessionIdRef.current,
+        modal,
+        widgetVersion: MODAL_VERSION,
+        sessionProperties: sessionPropertiesRef.current,
+        onFailure: (failure) => emitFailure(failure),
+        fetchImpl: props.fetchImpl,
+        createEventId: props.createEventId
+      }),
+      initialFailure: null
+    };
+  }
+  const ingestRef = useRef3(void 0);
+  if (ingestRef.current === void 0) {
+    ingestRef.current = createIngest();
+  }
+  const pendingDisposalRef = useRef3(null);
+  const enqueue = useCallback2(
+    (event) => {
+      try {
+        ingestRef.current?.transport?.enqueue(
+          event
+        );
+      } catch {
+      }
+    },
+    []
+  );
+  useEffect4(() => {
+    if (pendingDisposalRef.current !== null) {
+      clearTimeout(pendingDisposalRef.current);
+      pendingDisposalRef.current = null;
+    }
+    const setup = ingestRef.current;
+    if (setup.initialFailure) emitFailure(setup.initialFailure);
+    const transport = setup.transport;
+    if (!transport) return;
+    const flush = () => transport.flush({ terminal: true });
+    const onVisibilityChange = () => {
+      if (document.visibilityState === "hidden") flush();
+    };
+    window.addEventListener("pagehide", flush);
+    document.addEventListener("visibilitychange", onVisibilityChange);
+    return () => {
+      window.removeEventListener("pagehide", flush);
+      document.removeEventListener("visibilitychange", onVisibilityChange);
+      pendingDisposalRef.current = setTimeout(() => {
+        pendingDisposalRef.current = null;
+        transport.dispose();
+      }, 0);
+    };
+  }, [emitFailure]);
+  const emitDeposit = useCallback2(
+    (...[payload, fundingMethod]) => {
+      if (modal !== "deposit") return;
+      const event = {
+        ...payload,
+        session_id: sessionIdRef.current,
+        modal,
+        widget_version: MODAL_VERSION,
+        timestamp: nowRef.current().toISOString(),
+        session_properties: sessionPropertiesRef.current,
+        funding_method: fundingMethod
+      };
+      onEventRef.current?.(
+        event
+      );
+      enqueue(event);
+    },
+    [enqueue, modal, nowRef, onEventRef]
+  );
+  const emitWithdraw = useCallback2(
+    (payload) => {
+      if (modal !== "withdraw") return;
+      const event = {
+        ...payload,
+        session_id: sessionIdRef.current,
+        modal,
+        widget_version: MODAL_VERSION,
+        timestamp: nowRef.current().toISOString(),
+        session_properties: sessionPropertiesRef.current
+      };
+      onEventRef.current?.(event);
+      enqueue(event);
+    },
+    [enqueue, modal, nowRef, onEventRef]
+  );
+  const emitClaim = useCallback2(
+    (payload) => {
+      if (modal !== "claim") return;
+      const event = {
+        ...payload,
+        session_id: sessionIdRef.current,
+        modal,
+        widget_version: MODAL_VERSION,
+        timestamp: nowRef.current().toISOString(),
+        session_properties: sessionPropertiesRef.current
+      };
+      onEventRef.current?.(event);
+      enqueue(event);
+    },
+    [enqueue, modal, nowRef, onEventRef]
+  );
+  const context = useMemo3(
+    () => modal === "deposit" ? { modal, emit: emitDeposit } : modal === "withdraw" ? { modal, emit: emitWithdraw } : { modal, emit: emitClaim },
+    [modal, emitDeposit, emitWithdraw, emitClaim]
+  );
+  return /* @__PURE__ */ jsx11(AnalyticsContext.Provider, { value: context, children: props.children });
+}
+function useDepositAnalyticsEmitter() {
+  const context = useContext3(AnalyticsContext);
+  if (!context || context.modal !== "deposit") return noopDepositEmitter;
+  return context.emit;
+}
+function useWithdrawAnalyticsEmitter() {
+  const context = useContext3(AnalyticsContext);
+  if (!context || context.modal !== "withdraw") return noopWithdrawEmitter;
+  return context.emit;
+}
+function useClaimAnalyticsEmitter() {
+  const context = useContext3(AnalyticsContext);
+  if (!context || context.modal !== "claim") return noopClaimEmitter;
+  return context.emit;
+}
+
 // src/core/theme.ts
 var RADIUS_SCALE = {
   none: { sm: "0", md: "0", lg: "0" },
@@ -2770,15 +3493,32 @@ var CUSTOM_PRIMARY_VARS = [
   "--rs-primary-foreground",
   "--rs-border-accent"
 ];
+var DARK_SCHEME_QUERY = "(prefers-color-scheme: dark)";
+var NOTHING_TO_STOP = () => {
+};
+function resolveThemeMode(mode) {
+  if (mode !== "system") return mode;
+  return globalThis.matchMedia?.(DARK_SCHEME_QUERY).matches ? "dark" : "light";
+}
+function followSystemAppearance(mode, onChange) {
+  if (mode !== "system") return NOTHING_TO_STOP;
+  const query = globalThis.matchMedia?.(DARK_SCHEME_QUERY);
+  if (!query) return NOTHING_TO_STOP;
+  query.addEventListener("change", onChange);
+  return () => query.removeEventListener("change", onChange);
+}
 function applyTheme(element, theme) {
-  if (!element) return;
+  if (!element) return NOTHING_TO_STOP;
   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");
-  }
+  const paintMode = () => {
+    const resolved = resolveThemeMode(theme?.mode);
+    for (const t of targets) {
+      if (resolved) t.setAttribute("data-theme", resolved);
+      else t.removeAttribute("data-theme");
+    }
+  };
+  paintMode();
   if (theme?.fontColor) {
     setVar(targets, "--rs-foreground", theme.fontColor);
   }
@@ -2828,6 +3568,7 @@ function applyTheme(element, theme) {
     setVar(targets, "--rs-radius-lg", scale.lg);
     setVar(targets, "--rs-radius", scale.md);
   }
+  return followSystemAppearance(theme?.mode, paintMode);
 }
 
 // src/core/backend-url.ts
@@ -2858,9 +3599,6 @@ export {
   CopyIcon,
   ArrowUpRightIcon,
   AlertTriangleIcon,
-  PercentIcon,
-  ClockIcon,
-  PlusCircleIcon,
   CircleArrowOutUpLeftIcon,
   CardIcon,
   BankIcon,
@@ -2884,6 +3622,7 @@ export {
   SwappedConnectFeeChangedError,
   SUPPORTED_CONNECT_EXCHANGE_COUNT,
   resolveAppFeeBps,
+  PermitDepositSubmitError,
   createDepositService,
   rpcUrlFor,
   RpcUrlsProvider,
@@ -2899,6 +3638,7 @@ export {
   useTargetTokens,
   useIsDepositChain,
   useChainName,
+  useReadClient,
   useExplorerTxUrl,
   ChainCatalogProvider,
   useLatestRef,
@@ -2918,6 +3658,12 @@ export {
   estimateReceiveAmount,
   formatQuotedReceive,
   formatReceiveEstimate,
+  AnalyticsSession,
+  useDepositAnalyticsEmitter,
+  useWithdrawAnalyticsEmitter,
+  useClaimAnalyticsEmitter,
+  resolveThemeMode,
+  followSystemAppearance,
   applyTheme,
   checkBackendUrl
 };