@ab-org/predicate-market-sdk 1.0.0 → 1.0.1

package/dist/index.js

@@ -1,23 +1,4700 @@
-export * from "./types.js";
-export * from "./auth/config.js";
-export * from "./auth/autoReconnect.js";
-export * from "./auth/google.js";
-export * from "./auth/twitter.js";
-export * from "./modules/deposit.js";
-export * from "./modules/withdraw.js";
-export * from "./modules/marketData.js";
-export * from "./modules/balanceQuery.js";
-export * from "./modules/withdrawExecutor.js";
-export * from "./modules/api.js";
-export * from "./modules/withdrawDirect.js";
-export * from "./policyAdapter.js";
-export * from "./ui/SignInModal.js";
-export * from "./ui/signInTypes.js";
-export * from "./ui/WalletSelectionModal.js";
-export * from "./ui/DepositModal.js";
-export * from "./ui/WithdrawModal.js";
-export * from "./ui/components/DropdownField.js";
-export * from "./ui/components/DepositDetailsPanel.js";
-export * from "./walletUtils.js";
-// Re-export funding chain helpers so apps can import from package root
-export * from "./constants/chains.js";
+import { sessionStore, createDefaultInjectedWalletRegistry, CubistSocialProvider, WalletConnector, createSessionCapabilityPolicy, CubeSignerAuth, createChainContext } from '@ab-org/sdk-core';
+import { toHex, fromHex, parseGwei, formatUnits } from 'viem';
+import axios from 'axios';
+import { useState, useRef, useEffect, useMemo, useCallback } from 'react';
+import { EvmSigner } from '@cubist-labs/cubesigner-sdk';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import qrcode from 'qrcode-generator';
+
+// src/utils/env.ts
+function pick(...candidates) {
+  for (const candidate of candidates) {
+    if (candidate != null && candidate !== "") return candidate;
+  }
+  return void 0;
+}
+function nextPublicProcessEnvKey(logicalKey) {
+  return `NEXT_PUBLIC_${logicalKey}`;
+}
+function readProcessEnvStatic(key) {
+  if (typeof process === "undefined" || !process.env) return void 0;
+  switch (key) {
+    case "STAGE":
+      return pick(process.env.NEXT_PUBLIC_STAGE, process.env.STAGE);
+    case "GOOGLE_CLIENT_ID":
+      return pick(process.env.NEXT_PUBLIC_GOOGLE_CLIENT_ID, process.env.GOOGLE_CLIENT_ID);
+    case "X_CLIENT_ID":
+      return pick(process.env.NEXT_PUBLIC_X_CLIENT_ID, process.env.X_CLIENT_ID);
+    case "MERCHANT_BASE_URL":
+      return pick(process.env.NEXT_PUBLIC_MERCHANT_BASE_URL, process.env.MERCHANT_BASE_URL);
+    case "CUBE_SIGNER_ENV":
+      return pick(process.env.NEXT_PUBLIC_CUBE_SIGNER_ENV, process.env.CUBE_SIGNER_ENV);
+    case "CUBE_SIGNER_ORG_ID":
+      return pick(process.env.NEXT_PUBLIC_CUBE_SIGNER_ORG_ID, process.env.CUBE_SIGNER_ORG_ID);
+    case "CUBE_REG":
+      return pick(process.env.NEXT_PUBLIC_CUBE_REG, process.env.CUBE_REG);
+    case "RELAY_ORIGIN":
+      return pick(process.env.NEXT_PUBLIC_RELAY_ORIGIN, process.env.RELAY_ORIGIN);
+    case "FUNDING_TOKEN_SYMBOL":
+      return pick(process.env.NEXT_PUBLIC_FUNDING_TOKEN_SYMBOL, process.env.FUNDING_TOKEN_SYMBOL) || "USDT";
+    default:
+      return void 0;
+  }
+}
+function getEnv(key) {
+  const staticVal = readProcessEnvStatic(key);
+  if (staticVal != null && staticVal !== "") return staticVal;
+  const globalEnv = globalThis.process?.env;
+  if (globalEnv) {
+    const pub = nextPublicProcessEnvKey(key);
+    const val = globalEnv[key] ?? globalEnv[pub];
+    if (val != null && val !== "") return val;
+  }
+  try {
+    const metaEnv = import.meta.env;
+    if (metaEnv) {
+      const pub = nextPublicProcessEnvKey(key);
+      const val = metaEnv[key] ?? metaEnv[pub];
+      if (val != null && val !== "") return val;
+    }
+  } catch {
+  }
+  console.error(`${key} is not set`);
+  return "";
+}
+
+// src/auth/bundledConfig.ts
+function readOptionalEnv(key) {
+  const value = getEnv(key);
+  return value === "" ? void 0 : value;
+}
+var relayOrigin = readOptionalEnv("RELAY_ORIGIN");
+var cubeEnv = readOptionalEnv("CUBE_SIGNER_ENV");
+var cubeOrgId = readOptionalEnv("CUBE_SIGNER_ORG_ID");
+var BUNDLED_AUTH_CONFIG = {
+  googleClientId: readOptionalEnv("GOOGLE_CLIENT_ID"),
+  twitterClientId: readOptionalEnv("X_CLIENT_ID"),
+  twitterRedirectUri: relayOrigin ? `${relayOrigin}/auth/twitter-callback` : void 0,
+  cubeSigner: cubeEnv && cubeOrgId ? {
+    env: cubeEnv,
+    orgId: cubeOrgId
+  } : void 0
+};
+var pending = null;
+function tryAutoReconnect() {
+  const session = sessionStore.getState().session;
+  if (!session) return Promise.resolve(null);
+  if (pending) return pending;
+  pending = doAutoReconnect().finally(() => {
+    pending = null;
+  });
+  return pending;
+}
+async function doAutoReconnect() {
+  const config = getSDKConfig();
+  const registry = createDefaultInjectedWalletRegistry();
+  const adapters = [...registry.map((r) => r.provider)];
+  if (config.cubeSigner) {
+    adapters.push(
+      new CubistSocialProvider({
+        ...config.cubeSigner,
+        defaultSessionPolicy: config.signIn?.sessionPolicy ?? config.cubeSigner.defaultSessionPolicy
+      })
+    );
+  }
+  const connector = new WalletConnector(adapters);
+  return connector.tryAutoReconnect();
+}
+
+// src/auth/config.ts
+var sdkConfig = {};
+function readOptionalEnv2(key) {
+  const value = getEnv(key);
+  return value === "" ? void 0 : value;
+}
+function getFixedAuthConfig() {
+  const envGoogle = readOptionalEnv2("GOOGLE_CLIENT_ID");
+  const envTwitter = readOptionalEnv2("X_CLIENT_ID");
+  const relayOrigin2 = readOptionalEnv2("RELAY_ORIGIN");
+  const envRedirect = relayOrigin2 ? `${relayOrigin2}/auth/twitter-callback` : void 0;
+  const cubeEnv2 = readOptionalEnv2("CUBE_SIGNER_ENV");
+  const cubeOrgId2 = readOptionalEnv2("CUBE_SIGNER_ORG_ID");
+  const cubeSignerFromEnv = cubeEnv2 && cubeOrgId2 ? { env: cubeEnv2, orgId: cubeOrgId2 } : void 0;
+  return {
+    googleClientId: envGoogle || BUNDLED_AUTH_CONFIG.googleClientId,
+    twitterClientId: envTwitter || BUNDLED_AUTH_CONFIG.twitterClientId,
+    twitterRedirectUri: envRedirect || BUNDLED_AUTH_CONFIG.twitterRedirectUri,
+    cubeSigner: cubeSignerFromEnv ?? BUNDLED_AUTH_CONFIG.cubeSigner
+  };
+}
+function initSDK(config = {}) {
+  const { registerUser, ...rest } = config;
+  const fixed = getFixedAuthConfig();
+  const merged = {
+    ...sdkConfig,
+    ...fixed,
+    ...rest,
+    cubeSigner: rest.cubeSigner ?? fixed.cubeSigner
+  };
+  if (registerUser != null && merged.cubeSigner) {
+    merged.cubeSigner = {
+      ...merged.cubeSigner,
+      oidcLoginHooks: {
+        ...merged.cubeSigner.oidcLoginHooks,
+        registerUser
+      }
+    };
+  }
+  sdkConfig = merged;
+  tryAutoReconnect().catch(() => {
+  });
+}
+function getSDKConfig() {
+  return sdkConfig;
+}
+
+// src/auth/google.ts
+var GIS_URL = "https://accounts.google.com/gsi/client";
+var loadPromise = null;
+var currentCredentialHandler = null;
+var initializedKey = null;
+function loadGIS() {
+  if (loadPromise) return loadPromise;
+  if (window.google?.accounts?.id) {
+    loadPromise = Promise.resolve();
+    return loadPromise;
+  }
+  loadPromise = new Promise((resolve, reject) => {
+    const script = document.createElement("script");
+    script.src = GIS_URL;
+    script.async = true;
+    script.defer = true;
+    script.onload = () => resolve();
+    script.onerror = () => reject(new Error("Failed to load Google Identity Services"));
+    document.head.appendChild(script);
+  });
+  return loadPromise;
+}
+function decodeJwtPayload(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3) throw new Error("Invalid JWT");
+  const payload = parts[1];
+  if (!payload) throw new Error("Invalid JWT payload");
+  let padded = payload.replace(/-/g, "+").replace(/_/g, "/");
+  while (padded.length % 4 !== 0) padded += "=";
+  return JSON.parse(atob(padded));
+}
+function isFedCMSupported() {
+  if (typeof window === "undefined" || typeof navigator === "undefined") return false;
+  if (!window.isSecureContext) return false;
+  return typeof navigator.credentials?.get === "function";
+}
+async function signInWithGoogle(clientId) {
+  await loadGIS();
+  const gid = window.google?.accounts?.id;
+  if (!gid) throw new Error("Google Identity Services not available");
+  const SIGN_IN_TIMEOUT_MS = 9e4;
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let fallbackContainer = null;
+    const cleanupFallback = () => {
+      if (!fallbackContainer) return;
+      fallbackContainer.remove();
+      fallbackContainer = null;
+    };
+    const finish = (fn) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeoutId);
+      cleanupFallback();
+      fn();
+    };
+    const timeoutId = setTimeout(() => {
+      finish(() => reject(new Error("Google sign-in timed out")));
+    }, SIGN_IN_TIMEOUT_MS);
+    const handleCredential = (response) => {
+      finish(() => {
+        try {
+          const payload = decodeJwtPayload(response.credential);
+          resolve({
+            idToken: response.credential,
+            email: payload.email,
+            name: payload.name,
+            picture: payload.picture
+          });
+        } catch {
+          resolve({ idToken: response.credential });
+        }
+      });
+    };
+    const useFedcmForPrompt = isFedCMSupported();
+    const initKey = `${clientId}\0${useFedcmForPrompt ? "1" : "0"}`;
+    currentCredentialHandler = handleCredential;
+    if (initializedKey !== initKey) {
+      initializedKey = initKey;
+      gid.initialize({
+        client_id: clientId,
+        callback: (response) => currentCredentialHandler?.(response),
+        auto_select: false,
+        cancel_on_tap_outside: true,
+        use_fedcm_for_prompt: useFedcmForPrompt
+      });
+    }
+    const triggerFallback = () => {
+      if (settled) return;
+      fallbackContainer = document.createElement("div");
+      Object.assign(fallbackContainer.style, {
+        position: "fixed",
+        top: "-9999px",
+        left: "-9999px",
+        opacity: "0",
+        pointerEvents: "none"
+      });
+      document.body.appendChild(fallbackContainer);
+      gid.renderButton(fallbackContainer, { type: "standard", size: "large" });
+      const tryClickButton = (attemptsLeft) => {
+        requestAnimationFrame(() => {
+          const btn = fallbackContainer?.querySelector('[role="button"]') ?? fallbackContainer?.querySelector("div[style]");
+          if (btn) {
+            Object.assign(fallbackContainer.style, { pointerEvents: "auto" });
+            btn.click();
+            return;
+          }
+          if (attemptsLeft > 0) {
+            tryClickButton(attemptsLeft - 1);
+            return;
+          }
+          finish(() => reject(new Error("Google sign-in unavailable")));
+        });
+      };
+      tryClickButton(8);
+    };
+    gid.prompt((moment) => {
+      if (settled) return;
+      if (moment.isDismissedMoment()) {
+        const reason = moment.getDismissedReason();
+        if (reason === "credential_returned") return;
+        finish(() => reject(new Error(`Google sign-in dismissed: ${reason}`)));
+        return;
+      }
+      if (moment.isSkippedMoment()) {
+        triggerFallback();
+        return;
+      }
+      if (moment.isNotDisplayed()) {
+        triggerFallback();
+      }
+    });
+  });
+}
+
+// src/auth/twitter.ts
+function generateRandom(length) {
+  const array = new Uint8Array(length);
+  crypto.getRandomValues(array);
+  return Array.from(array, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function base64url(buffer) {
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  for (const b of bytes) binary += String.fromCharCode(b);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+async function createCodeChallenge(verifier) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(verifier);
+  const digest = await crypto.subtle.digest("SHA-256", data);
+  return base64url(digest);
+}
+var POPUP_WIDTH = 600;
+var POPUP_HEIGHT = 700;
+var MESSAGE_TYPE = "twitter-oauth-callback";
+var TWITTER_AUTH_URL = "https://twitter.com/i/oauth2/authorize";
+function notifyTwitterCallback() {
+  const params = new URLSearchParams(window.location.search);
+  const code = params.get("code");
+  const state = params.get("state");
+  const error = params.get("error");
+  if (window.opener) {
+    window.opener.postMessage(
+      { type: MESSAGE_TYPE, code, state, error },
+      window.location.origin
+    );
+    window.close();
+  }
+}
+async function signInWithTwitter(clientId, redirectUri) {
+  const codeVerifier = generateRandom(64);
+  const codeChallenge = await createCodeChallenge(codeVerifier);
+  const state = generateRandom(16);
+  const authUrl = new URL(TWITTER_AUTH_URL);
+  authUrl.searchParams.set("response_type", "code");
+  authUrl.searchParams.set("client_id", clientId);
+  authUrl.searchParams.set("redirect_uri", redirectUri);
+  authUrl.searchParams.set("scope", "tweet.read users.read offline.access");
+  authUrl.searchParams.set("state", state);
+  authUrl.searchParams.set("code_challenge", codeChallenge);
+  authUrl.searchParams.set("code_challenge_method", "S256");
+  const left = Math.round(screen.width / 2 - POPUP_WIDTH / 2);
+  const top = Math.round(screen.height / 2 - POPUP_HEIGHT / 2);
+  const popup = window.open(
+    authUrl.toString(),
+    "twitter-auth",
+    `width=${POPUP_WIDTH},height=${POPUP_HEIGHT},left=${left},top=${top},toolbar=no,menubar=no`
+  );
+  if (!popup) {
+    throw new Error("Failed to open Twitter login popup. Check your popup blocker.");
+  }
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = () => {
+      window.removeEventListener("message", onMessage);
+      clearInterval(pollTimer);
+    };
+    const onMessage = (event) => {
+      if (event.origin !== window.location.origin) return;
+      const data = event.data;
+      if (!data || data.type !== MESSAGE_TYPE) return;
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (data.error) {
+        reject(new Error(`Twitter auth error: ${data.error}`));
+        return;
+      }
+      if (!data.code) {
+        reject(new Error("No authorization code received from Twitter"));
+        return;
+      }
+      if (data.state !== state) {
+        reject(new Error("State mismatch - possible CSRF attack"));
+        return;
+      }
+      resolve({
+        code: data.code,
+        codeVerifier,
+        state
+      });
+    };
+    const pollTimer = setInterval(() => {
+      if (popup.closed && !settled) {
+        settled = true;
+        cleanup();
+        reject(new Error("Twitter login popup was closed"));
+      }
+    }, 500);
+    window.addEventListener("message", onMessage);
+  });
+}
+function requireSession() {
+  const session = sessionStore.getState().session;
+  if (!session) throw new Error("Login required");
+  return session;
+}
+var createDepositController = (custody, marketData) => {
+  let status = { phase: "idle" };
+  const notify = (next, cb) => {
+    status = next;
+    cb?.(status);
+  };
+  const open = async (config) => {
+    const session = requireSession();
+    const chain = config?.preferredChain ?? session.chainContext?.settlementChain ?? session.chain ?? "AB_CORE";
+    const token = config?.preferredToken || getEnv("FUNDING_TOKEN_SYMBOL") || "USDT";
+    try {
+      const { address } = await marketData.getDepositAddress(token, chain);
+      const depositId = `${chain}:${token}:${Date.now()}`;
+      notify({ phase: "address-issued", depositId, address }, config?.onStatusChange);
+      notify({ phase: "confirming", depositId }, config?.onStatusChange);
+      const { status: finalStatus, txHash } = await custody.getDepositStatus(depositId);
+      notify(
+        finalStatus === "SETTLED" ? { phase: "settled", depositId, txHash } : { phase: "failed", reason: finalStatus },
+        config?.onStatusChange
+      );
+    } catch (error) {
+      notify({ phase: "failed", reason: error.message }, config?.onStatusChange);
+    }
+  };
+  return {
+    get status() {
+      return status;
+    },
+    open,
+    fetchTokens() {
+      requireSession();
+      return marketData.getSupportedTokens("deposit");
+    },
+    fetchChains(token) {
+      requireSession();
+      return marketData.getSupportedChains(token, "deposit");
+    },
+    fetchQuote(token, chain, amount) {
+      requireSession();
+      return marketData.getQuote({ token, chain, amount, direction: "deposit" });
+    },
+    fetchDepositAddress(token, chain) {
+      requireSession();
+      return marketData.getDepositAddress(token, chain);
+    }
+  };
+};
+function requireSession2() {
+  const session = sessionStore.getState().session;
+  if (!session) throw new Error("Login required");
+  return session;
+}
+var createWithdrawController = (custody, marketData) => {
+  let status = { phase: "idle" };
+  const update = (next, cb) => {
+    status = next;
+    cb?.(status);
+  };
+  const open = async (config) => {
+    const session = requireSession2();
+    const token = config?.defaultToken || getEnv("FUNDING_TOKEN_SYMBOL") || "USDT";
+    const chain = config?.defaultChain ?? session.chainContext?.settlementChain ?? session.chain ?? "AB_CORE";
+    const targetAddress = config?.targetAddress;
+    if (!targetAddress) throw new Error("targetAddress required for withdraw");
+    try {
+      const { requestId } = await custody.requestWithdraw({
+        amount: config?.defaultAmount ?? "0",
+        token,
+        chain,
+        targetAddress
+      });
+      update({ phase: "requested", requestId }, config?.onStatusChange);
+      update({ phase: "processing", requestId }, config?.onStatusChange);
+      const { status: finalStatus, txHash } = await custody.getWithdrawStatus(requestId);
+      update(
+        finalStatus === "SETTLED" ? { phase: "settled", requestId, txHash } : { phase: "failed", reason: finalStatus },
+        config?.onStatusChange
+      );
+    } catch (error) {
+      update({ phase: "failed", reason: error.message }, config?.onStatusChange);
+    }
+  };
+  return {
+    get status() {
+      return status;
+    },
+    open,
+    fetchTokens() {
+      requireSession2();
+      return marketData.getSupportedTokens("withdraw");
+    },
+    fetchChains(token) {
+      requireSession2();
+      return marketData.getSupportedChains(token, "withdraw");
+    },
+    fetchQuote(token, chain, amount) {
+      requireSession2();
+      return marketData.getQuote({ token, chain, amount, direction: "withdraw" });
+    }
+  };
+};
+function createClient() {
+  const BASE_URL = getEnv("MERCHANT_BASE_URL");
+  if (!BASE_URL) {
+    throw new Error("MERCHANT_BASE_URL is not set");
+  }
+  return axios.create({
+    baseURL: BASE_URL,
+    timeout: 3e4,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function unwrap(res) {
+  if (res.code !== 0 || res.data === null) {
+    throw new Error(res.msg || "API error");
+  }
+  return res.data;
+}
+var apiClient = createClient();
+function configureMerchantApi() {
+  apiClient = createClient();
+}
+function getMerchantApiClient() {
+  return apiClient;
+}
+async function getChains() {
+  try {
+    const { data } = await apiClient.get("/chains");
+    return unwrap(data);
+  } catch {
+    throw new Error("Failed to get chains");
+  }
+}
+async function registerPlatform(body) {
+  try {
+    const { data } = await apiClient.post(
+      "/api/v1/platform",
+      body
+    );
+    return unwrap(data);
+  } catch {
+    throw new Error("Failed to register platform");
+  }
+}
+async function quote(body) {
+  const { data } = await apiClient.post("/api/v1/quote", body);
+  return unwrap(data);
+}
+async function getDepositOrder(orderId) {
+  try {
+    const { data } = await apiClient.get(
+      `/api/v1/orders/deposit/${encodeURIComponent(orderId)}`
+    );
+    return unwrap(data);
+  } catch {
+    throw new Error("Failed to get deposit order");
+  }
+}
+async function getWithdrawOrder(orderId) {
+  try {
+    const { data } = await apiClient.get(
+      `/api/v1/orders/withdraw/${encodeURIComponent(orderId)}`
+    );
+    return unwrap(data);
+  } catch {
+    throw new Error("Failed to get withdraw order");
+  }
+}
+async function createOrder(body) {
+  try {
+    const { data } = await apiClient.post("/order", body);
+    return unwrap(data);
+  } catch {
+    throw new Error("Failed to create order");
+  }
+}
+
+// src/modules/marketData.ts
+var cachedChains = null;
+async function fetchChainsFromApi() {
+  if (cachedChains) return cachedChains;
+  try {
+    const { chains } = await getChains();
+    if (chains.length > 0) {
+      cachedChains = chains;
+      return chains;
+    }
+    return [];
+  } catch {
+    return [];
+  }
+}
+function chainToChainInfo(chain) {
+  return {
+    id: chain.chain_id,
+    name: chain.network
+  };
+}
+function findTokenInChains(chains, chainId, tokenSymbol) {
+  const chain = chains.find((c) => c.chain_id === chainId);
+  return chain?.tokens.find((t) => t.symbol === tokenSymbol);
+}
+function formatMinimumDepositDisplay(token, tokenSymbol) {
+  const raw = token.minimum_deposit?.trim();
+  if (raw == null || raw === "") return void 0;
+  try {
+    return `${formatUnits(BigInt(raw), token.decimals)} ${tokenSymbol}`;
+  } catch {
+    return `${raw} ${tokenSymbol}`;
+  }
+}
+function deriveTokensFromChains(chains) {
+  const bySymbol = /* @__PURE__ */ new Map();
+  for (const chain of chains) {
+    for (const t of chain.tokens) {
+      if (!bySymbol.has(t.symbol)) {
+        bySymbol.set(t.symbol, {
+          symbol: t.symbol,
+          name: t.symbol,
+          decimals: t.decimals
+        });
+      }
+    }
+  }
+  return Array.from(bySymbol.values());
+}
+function computeDefaultQuote(request) {
+  const isStable = ["USDT", "USDC", "USD1"].includes(request.token);
+  const slippage = isStable ? "0.3" : "1.0";
+  const feeRate = request.direction === "withdraw" ? 1e-3 : 0;
+  const amount = Number(request.amount) || 0;
+  const fee = (amount * feeRate).toFixed(2);
+  const estimatedAmount = (amount - Number(fee)).toFixed(6);
+  return {
+    quoteId: `quote-${Date.now()}`,
+    estimatedAmount: amount > 0 ? estimatedAmount : "0",
+    slippage,
+    fee,
+    feeToken: request.token,
+    exchangeRate: "1.0",
+    expiresAt: Date.now() + 3e4
+  };
+}
+function createMarketDataProvider() {
+  return {
+    async getSupportedTokens(_direction) {
+      const chains = await fetchChainsFromApi();
+      const tokens = deriveTokensFromChains(chains);
+      return tokens.length > 0 ? tokens : [];
+    },
+    async getSupportedChains(token, _direction) {
+      const chains = await fetchChainsFromApi();
+      const forToken = chains.filter((c) => c.tokens.some((t) => t.symbol === token));
+      const list = forToken.length > 0 ? forToken : chains;
+      return list.map(chainToChainInfo);
+    },
+    async getQuote(request) {
+      return computeDefaultQuote(request);
+    },
+    async getDepositAddress(token, chain) {
+      const session = sessionStore.getState().session;
+      const chains = await fetchChainsFromApi();
+      const meta = findTokenInChains(chains, chain, token);
+      const minimumDeposit = meta != null ? formatMinimumDepositDisplay(meta, token) : void 0;
+      return {
+        address: session?.address ?? "",
+        minimumDeposit
+      };
+    }
+  };
+}
+
+// ../wallet-utils/dist/index.js
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var cache_exports = {};
+__export(cache_exports, {
+  clear: () => clear,
+  get: () => get,
+  remove: () => remove,
+  set: () => set,
+  setKeyNS: () => setKeyNS
+});
+var keyNS = "tomo-";
+function get(key) {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  const tempKey = keyNS + key;
+  if (!isKeyExist(tempKey)) {
+    return null;
+  }
+  let val = null;
+  try {
+    const data = window.localStorage.getItem(tempKey) || window.sessionStorage.getItem(tempKey);
+    val = JSON.parse(data);
+  } catch (err) {
+    console.error(err);
+  }
+  if (val !== null && Object.prototype.hasOwnProperty.call(val, "type") && Object.prototype.hasOwnProperty.call(val, "data")) {
+    return val["data"];
+  }
+  return null;
+}
+function set(key, val, isTemp) {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  let store;
+  if (isTemp) {
+    store = window.sessionStorage;
+  } else {
+    store = window.localStorage;
+  }
+  const data = JSON.stringify({
+    data: val,
+    time: (/* @__PURE__ */ new Date()).getTime(),
+    //for manage by time limit
+    type: typeof val
+  });
+  try {
+    store.setItem(keyNS + key, data);
+    return true;
+  } catch (err) {
+    if (err?.name?.toUpperCase().indexOf("QUOTA") >= 0) {
+      window.localStorage.clear();
+      store.setItem(keyNS + key, data);
+    }
+  }
+  return false;
+}
+function remove(key) {
+  if (typeof window === "undefined") {
+    return;
+  }
+  const tempKey = keyNS + key;
+  window.localStorage.removeItem(tempKey);
+  window.sessionStorage.removeItem(tempKey);
+}
+function clear() {
+  if (typeof window === "undefined") {
+    return;
+  }
+  window?.localStorage?.clear();
+  window?.sessionStorage?.clear();
+}
+function isKeyExist(key) {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  return Object.prototype.hasOwnProperty.call(window.localStorage, key) || Object.prototype.hasOwnProperty.call(window.sessionStorage, key);
+}
+function setKeyNS(NS) {
+  const isString = typeof NS === "string";
+  if (isString && NS !== "") {
+    keyNS = NS;
+  }
+}
+function pick2(...candidates) {
+  for (const c of candidates) {
+    if (c != null && c !== "") return c;
+  }
+  return void 0;
+}
+function nextPublicProcessEnvKey2(logicalKey) {
+  return `NEXT_PUBLIC_${logicalKey}`;
+}
+function readProcessEnvStatic2(key) {
+  if (typeof process === "undefined" || !process.env) return void 0;
+  switch (key) {
+    case "STAGE":
+      return pick2(
+        process.env.NEXT_PUBLIC_STAGE,
+        process.env.STAGE
+      );
+    case "FUNDING_CHAIN_ID":
+      return pick2(
+        process.env.NEXT_PUBLIC_FUNDING_CHAIN_ID,
+        process.env.FUNDING_CHAIN_ID
+      );
+    /** Next.js 仅内联「静态」`process.env.NEXT_PUBLIC_*`；动态键名在客户端会为 undefined，必须逐键写出。 */
+    case "GOOGLE_CLIENT_ID":
+      return pick2(
+        process.env.NEXT_PUBLIC_GOOGLE_CLIENT_ID,
+        process.env.GOOGLE_CLIENT_ID
+      );
+    case "X_CLIENT_ID":
+      return pick2(
+        process.env.NEXT_PUBLIC_X_CLIENT_ID,
+        process.env.X_CLIENT_ID
+      );
+    case "MERCHANT_BASE_URL":
+      return pick2(
+        process.env.NEXT_PUBLIC_MERCHANT_BASE_URL,
+        process.env.MERCHANT_BASE_URL
+      );
+    case "RELAY_ORIGIN":
+      return pick2(
+        process.env.NEXT_PUBLIC_RELAY_ORIGIN,
+        process.env.RELAY_ORIGIN
+      );
+    case "CUBE_SIGNER_ENV":
+      return pick2(
+        process.env.NEXT_PUBLIC_CUBE_SIGNER_ENV,
+        process.env.CUBE_SIGNER_ENV
+      );
+    case "CUBE_SIGNER_ORG_ID":
+      return pick2(
+        process.env.NEXT_PUBLIC_CUBE_SIGNER_ORG_ID,
+        process.env.CUBE_SIGNER_ORG_ID
+      );
+    case "CUBE_REG":
+      return pick2(
+        process.env.NEXT_PUBLIC_CUBE_REG,
+        process.env.CUBE_REG
+      );
+    case "FUNDING_TOKEN_SYMBOL":
+      return pick2(
+        process.env.NEXT_PUBLIC_FUNDING_TOKEN_SYMBOL,
+        process.env.FUNDING_TOKEN_SYMBOL
+      );
+    case "FUNDING_TOKEN_ADDRESS":
+      return pick2(
+        process.env.NEXT_PUBLIC_FUNDING_TOKEN_ADDRESS,
+        process.env.FUNDING_TOKEN_ADDRESS
+      );
+    default:
+      return pick2(
+        process.env[`NEXT_PUBLIC_${key}`],
+        process.env[key]
+      );
+  }
+}
+function getEnv2(key) {
+  const staticVal = readProcessEnvStatic2(key);
+  if (staticVal != null && staticVal !== "") return staticVal;
+  const g = globalThis;
+  const env = g.process?.env;
+  if (env) {
+    const pub = nextPublicProcessEnvKey2(key);
+    const v = env[key] ?? env[pub];
+    if (v != null && v !== "") return v;
+  }
+  try {
+    const m = import.meta.env;
+    if (m) {
+      const pub = nextPublicProcessEnvKey2(key);
+      const v = m[key] ?? m[pub];
+      if (v != null && v !== "") return v;
+    }
+  } catch {
+  }
+  console.error(`${key} is not set.`);
+  return "";
+}
+var TENDERLY_BSC_3131 = {
+  chainId: "3131",
+  name: "BSC_TENDERLY",
+  chainName: "BSC_TENDERLY",
+  nativeCurrencyName: "BSC",
+  nativeCurrencySymbol: "BSC",
+  nativeCurrencyDecimals: 18,
+  rpcUrls: [
+    "https://virtual.binance.eu.rpc.tenderly.co/e643ea28-32eb-4fb9-8116-90be24f7defa"
+  ],
+  blockExplorerUrl: "https://dashboard.tenderly.co/explorer/vnet/6593bc72-f548-497d-bff9-5be061436a48",
+  platformType: "EVM",
+  icon: "https://static.tomo.inc/token/bsc_new.svg",
+  // Tenderly 默认资金侧合约地址（测试环境镜像）：
+  defaultFundingTokenAddress: "0x55d398326f99059fF775485246999027B3197955"
+};
+var BSC_MAINNET_56 = {
+  chainId: "56",
+  name: "BSC",
+  chainName: "BNB Smart Chain",
+  nativeCurrencyName: "BNB",
+  nativeCurrencySymbol: "BNB",
+  nativeCurrencyDecimals: 18,
+  rpcUrls: ["https://bsc-dataseed.binance.org", "https://bsc-dataseed1.defibit.io"],
+  blockExplorerUrl: "https://bscscan.com",
+  platformType: "EVM",
+  icon: "https://static.tomo.inc/token/bsc_new.svg",
+  // 主网默认资金侧合约地址（USDT）；如需覆盖请使用 FUNDING_TOKEN_ADDRESS 环境变量
+  defaultFundingTokenAddress: "0x55d398326f99059fF775485246999027B3197955"
+};
+var CHAIN_REGISTRY = {
+  [TENDERLY_BSC_3131.chainId]: TENDERLY_BSC_3131,
+  [BSC_MAINNET_56.chainId]: BSC_MAINNET_56
+};
+var DEFAULT_FUNDING_CHAIN_ID = getEnv2("FUNDING_CHAIN_ID") || "3131";
+function normalizeFundingChainId(chainId) {
+  if (chainId === void 0 || chainId === null) return DEFAULT_FUNDING_CHAIN_ID;
+  const s = String(chainId).trim();
+  return s === "" ? DEFAULT_FUNDING_CHAIN_ID : s;
+}
+function getChainInfo(chainId) {
+  const id = normalizeFundingChainId(chainId);
+  const info = CHAIN_REGISTRY[id];
+  if (!info) {
+    throw new Error(
+      `Unsupported funding chainId "${id}". Supported: ${Object.keys(CHAIN_REGISTRY).sort().join(", ")}`
+    );
+  }
+  return info;
+}
+function pickEnvFundingTokenAddress() {
+  const tryPairs = [
+    ["NEXT_PUBLIC_FUNDING_TOKEN_ADDRESS", "FUNDING_TOKEN_ADDRESS"]
+  ];
+  if (typeof process !== "undefined" && process.env) {
+    for (const [pub, priv] of tryPairs) {
+      const a = process.env[pub];
+      const b = process.env[priv];
+      if (a != null && a !== "") return a;
+      if (b != null && b !== "") return b;
+    }
+  }
+  try {
+    const m = import.meta.env;
+    if (m) {
+      for (const [pub, priv] of tryPairs) {
+        const a = m[pub];
+        const b = m[priv];
+        if (a != null && a !== "") return a;
+        if (b != null && b !== "") return b;
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function getFundingTokenAddress(chainId) {
+  const v = pickEnvFundingTokenAddress();
+  if (v && /^0x[0-9a-fA-F]{40}$/.test(v)) return v;
+  return getChainInfo(chainId).defaultFundingTokenAddress;
+}
+var DEFAULT_FUNDING_TOKEN_ADDRESS = getFundingTokenAddress(DEFAULT_FUNDING_CHAIN_ID);
+var ClientIds = {
+  google: getEnv2("GOOGLE_CLIENT_ID"),
+  x: getEnv2("X_CLIENT_ID")
+};
+
+// src/modules/balanceQuery.ts
+var ERC20_BALANCE_OF_SELECTOR = "0x70a08231";
+function padAddress(address) {
+  return address.toLowerCase().replace("0x", "").padStart(64, "0");
+}
+function formatUnits2(value, decimals) {
+  const divisor = 10n ** BigInt(decimals);
+  const intPart = value / divisor;
+  const fracPart = value % divisor;
+  if (fracPart === 0n) return intPart.toString();
+  const fracStr = fracPart.toString().padStart(decimals, "0").replace(/0+$/, "");
+  return `${intPart}.${fracStr}`;
+}
+function formatBalanceDisplay(value, decimals) {
+  const full = formatUnits2(value, decimals);
+  const n = Number(full);
+  return Number.isNaN(n) ? full : n.toFixed(2);
+}
+async function fetchErc20Balance(rpcUrl, tokenAddress, walletAddress) {
+  const data = `${ERC20_BALANCE_OF_SELECTOR}${padAddress(walletAddress)}`;
+  const response = await fetch(rpcUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "eth_call",
+      params: [{ to: tokenAddress, data }, "latest"]
+    })
+  });
+  const json = await response.json();
+  if (json.error) throw new Error(json.error.message ?? "RPC error");
+  return BigInt(json.result ?? "0x0");
+}
+async function fetchFundingTokenBalance(walletAddress, options) {
+  const chain = getChainInfo(options?.chainId);
+  const rpcUrl = options?.rpcUrl ?? chain.rpcUrls[0];
+  const tokenAddress = options?.tokenAddress ?? getFundingTokenAddress(options?.chainId);
+  const decimals = options?.decimals ?? chain.nativeCurrencyDecimals;
+  const FUNDING_TOKEN_SYMBOL3 = getEnv("FUNDING_TOKEN_SYMBOL");
+  const displaySymbol = options?.displaySymbol ?? (FUNDING_TOKEN_SYMBOL3 || "Funding");
+  const raw = await fetchErc20Balance(rpcUrl, tokenAddress, walletAddress);
+  return {
+    raw,
+    formatted: formatBalanceDisplay(raw, decimals),
+    symbol: displaySymbol
+  };
+}
+var MAX_WITHDRAW_GAS_LIMIT = 500000n;
+var ERC20_TRANSFER_SELECTOR = "0xa9059cbb";
+function padHex256(value) {
+  return value.toString(16).padStart(64, "0");
+}
+function padAddress2(address) {
+  return address.toLowerCase().replace("0x", "").padStart(64, "0");
+}
+function parseUnits(value, decimals) {
+  if (!value || value === "0") return 0n;
+  const [intPart = "0", fracPart = ""] = value.split(".");
+  const padded = fracPart.padEnd(decimals, "0").slice(0, decimals);
+  return BigInt(intPart) * 10n ** BigInt(decimals) + BigInt(padded);
+}
+function encodeTransferData(to, amountWei) {
+  return `${ERC20_TRANSFER_SELECTOR}${padAddress2(to)}${padHex256(amountWei)}`;
+}
+function isUnsupportedMethodError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /unsupported rpc method|unsupported method|method not found|does not support/i.test(
+    message
+  );
+}
+function toHexQuantity(value) {
+  if (typeof value === "string") {
+    if (/^0x[0-9a-fA-F]+$/.test(value)) {
+      return value;
+    }
+    if (/^\d+$/.test(value)) {
+      return toHex(BigInt(value));
+    }
+  }
+  if (typeof value === "number") {
+    return toHex(BigInt(value));
+  }
+  if (typeof value === "bigint") {
+    return toHex(value);
+  }
+  throw new Error(`Invalid EVM quantity: ${String(value)}`);
+}
+async function callRpc(rpcUrl, method, params) {
+  const response = await fetch(rpcUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: Date.now(),
+      method,
+      params
+    })
+  });
+  const json = await response.json();
+  if (!response.ok || json.error) {
+    throw new Error(json.error?.message ?? `${method} failed`);
+  }
+  return json.result;
+}
+async function requestHexQuantity(provider, rpcUrl, method, params) {
+  try {
+    const result = await provider.request({ method, params });
+    return toHexQuantity(result);
+  } catch (error) {
+    if (!isUnsupportedMethodError(error)) {
+      throw error;
+    }
+    return toHexQuantity(await callRpc(rpcUrl, method, params));
+  }
+}
+async function ensureFundingEvmChain(provider, chainId) {
+  const hex = `0x${chainId.toString(16)}`;
+  try {
+    await provider.request({ method: "wallet_switchEthereumChain", params: [{ chainId: hex }] });
+  } catch {
+  }
+}
+function getDstTokenAddress(chains, chainId, tokenSymbol) {
+  const chain = chains.find((c) => c.chain_id === chainId);
+  return chain?.tokens.find((t) => t.symbol === tokenSymbol)?.address;
+}
+function createFundingWithdrawExecutor(options) {
+  const fundingChain = getChainInfo(options?.chainId);
+  const chainIdNum = Number(fundingChain.chainId);
+  const rpcUrl = options?.rpcUrl ?? fundingChain.rpcUrls[0];
+  const tokenAddress = options?.tokenAddress ?? getFundingTokenAddress(options?.chainId);
+  const decimals = options?.decimals ?? fundingChain.nativeCurrencyDecimals;
+  const maxAmountWei = options?.maxAmountWei;
+  const fundingLegTokenSymbol = options?.fundingLegTokenSymbol || getEnv("FUNDING_TOKEN_SYMBOL") || "USDT";
+  return async (request) => {
+    const amountWei = parseUnits(request.amount, decimals);
+    const amountWeiStr = amountWei.toString();
+    if (maxAmountWei != null && amountWei > BigInt(maxAmountWei)) {
+      throw new Error("Withdraw amount exceeds the single-transaction limit");
+    }
+    let session = sessionStore.getState().session;
+    if (!session) throw new Error("Login required");
+    let { provider } = session;
+    try {
+      await provider.request({ method: "eth_chainId", params: [] });
+    } catch (err) {
+      const msg = err.message ?? "";
+      if (msg.includes("restored from cache") || msg.includes("Reconnect your wallet")) {
+        const reconnected = await tryAutoReconnect();
+        if (reconnected) {
+          session = reconnected;
+          provider = reconnected.provider;
+        } else {
+          sessionStore.clearSession();
+          throw new Error("Session expired. Please sign in again.");
+        }
+      }
+    }
+    const chainsRes = await getChains();
+    const chains = chainsRes?.chains ?? [];
+    const dstTokenAddress = getDstTokenAddress(chains, request.chain, request.token);
+    if (!dstTokenAddress) {
+      throw new Error(`Unsupported token ${request.token} on chain ${request.chain}`);
+    }
+    const sourceTokenSymbol = fundingLegTokenSymbol;
+    const orderRes = await createOrder({
+      intent_id: `withdraw-${Date.now()}`,
+      order_type: "NATIVE_SWAP",
+      order_payload: {
+        chain_id: fundingChain.chainId,
+        token_address: tokenAddress,
+        token_amount: amountWeiStr,
+        dst_chain_id: request.chain,
+        dst_token_address: dstTokenAddress,
+        recipient: request.toAddress
+      },
+      payment_pairs: [
+        {
+          token_symbol: sourceTokenSymbol,
+          token_amount: amountWeiStr,
+          token_address: tokenAddress,
+          user_address: session.address,
+          chain_id: fundingChain.chainId
+        }
+      ]
+    });
+    const oneTimeAddress = orderRes.payment_sessions?.[0]?.one_time_wallet_address;
+    if (!oneTimeAddress) {
+      throw new Error("Order created but no one-time wallet address returned");
+    }
+    await ensureFundingEvmChain(provider, chainIdNum);
+    const data = encodeTransferData(oneTimeAddress, amountWei);
+    const nonce = await requestHexQuantity(
+      provider,
+      rpcUrl,
+      "eth_getTransactionCount",
+      [session.address, "latest"]
+    );
+    const tx = {
+      from: session.address,
+      to: tokenAddress,
+      value: "0x0",
+      nonce,
+      data,
+      chainId: toHex(chainIdNum)
+    };
+    const estimatedGasHex = await requestHexQuantity(
+      provider,
+      rpcUrl,
+      "eth_estimateGas",
+      [tx]
+    );
+    const estimatedGas = fromHex(estimatedGasHex, "bigint");
+    const gas = toHex(
+      estimatedGas > MAX_WITHDRAW_GAS_LIMIT ? MAX_WITHDRAW_GAS_LIMIT : estimatedGas
+    );
+    const transaction = {
+      ...tx,
+      gas,
+      maxFeePerGas: toHex(parseGwei("5")),
+      maxPriorityFeePerGas: toHex(parseGwei("1"))
+    };
+    let txHash;
+    try {
+      txHash = await provider.request({
+        method: "eth_sendTransaction",
+        params: [transaction]
+      });
+    } catch (error) {
+      if (!isUnsupportedMethodError(error)) {
+        throw error;
+      }
+      const signedTx = await provider.request({
+        method: "eth_signTransaction",
+        params: [transaction]
+      });
+      txHash = await callRpc(rpcUrl, "eth_sendRawTransaction", [signedTx]);
+    }
+    return { txHash, orderId: orderRes.order_id, fundingChainId: fundingChain.chainId };
+  };
+}
+
+// src/modules/withdrawDirect.ts
+function isUsdtWithdrawDirect(chainId, tokenAddress, chains) {
+  if (chainId !== String(DEFAULT_FUNDING_CHAIN_ID)) return false;
+  const addr = tokenAddress.trim();
+  if (!addr) return false;
+  const chain = chains.find((c) => c.chain_id === chainId);
+  const token = chain?.tokens.find((t) => t.address.toLowerCase() === addr.toLowerCase());
+  return token?.is_usd_stable === true;
+}
+function findTokenDataFromChains(chains, chainId, opts) {
+  const chain = chains.find((c) => c.chain_id === chainId);
+  if (!chain?.tokens.length) return void 0;
+  const sym = opts.symbol.trim();
+  const addr = opts.tokenAddress?.trim().toLowerCase();
+  return chain.tokens.find((t) => {
+    if (addr && t.address.toLowerCase() === addr) return true;
+    if (sym.length > 0 && t.symbol === sym) return true;
+    return false;
+  });
+}
+var createPolicy = (overrides, options) => createSessionCapabilityPolicy({
+  appId: options?.appId,
+  origin: options?.origin,
+  expiresAt: options?.expiresAt,
+  ...overrides
+});
+var withActionMetadata = (action, policy) => ({
+  ...policy,
+  metadata: {
+    ...policy.metadata ?? {},
+    action
+  }
+});
+var createPredicateMarketPolicyAdapter = (options) => ({
+  deposit(token, chain, maxAmount) {
+    return withActionMetadata(
+      "deposit",
+      createPolicy(
+        {
+          methods: ["eth_sendTransaction"],
+          chains: [chain],
+          tokens: [token],
+          maxAmount
+        },
+        options
+      )
+    );
+  },
+  withdraw(token, chain, maxAmount) {
+    return withActionMetadata(
+      "withdraw",
+      createPolicy(
+        {
+          methods: ["eth_sendTransaction"],
+          chains: [chain],
+          tokens: [token],
+          maxAmount
+        },
+        options
+      )
+    );
+  },
+  trade(chain, capabilities = ["eth_sendTransaction"]) {
+    return withActionMetadata(
+      "trade",
+      createPolicy(
+        {
+          methods: capabilities,
+          chains: [chain]
+        },
+        options
+      )
+    );
+  }
+});
+var cubistCapabilities = [
+  "eth_accounts",
+  "eth_requestAccounts",
+  "eth_chainId",
+  "eth_signTransaction",
+  "personal_sign",
+  "eth_signTypedData_v4",
+  "wallet_disconnect"
+];
+var evmChainIdMap = {
+  ETH: 1,
+  BSC: 56
+};
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var toBigIntQuantity = (value) => {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number") {
+    if (!Number.isInteger(value) || value < 0) {
+      throw new Error(`Invalid EVM quantity number: ${value}`);
+    }
+    return BigInt(value);
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new Error("EVM quantity cannot be empty");
+  }
+  if (/^0x[0-9a-fA-F]+$/.test(trimmed) || /^\d+$/.test(trimmed)) {
+    return BigInt(trimmed);
+  }
+  throw new Error(`Invalid EVM quantity string: ${value}`);
+};
+var toHexQuantity2 = (value) => {
+  if (value === void 0) return void 0;
+  return `0x${toBigIntQuantity(value).toString(16)}`;
+};
+var normalizeAccessList = (accessList) => {
+  if (!accessList) return void 0;
+  return accessList.map((item) => ({
+    address: item.address,
+    storageKeys: item.storageKeys
+  }));
+};
+var textEncoder = new TextEncoder();
+var resolveTransactionType = (transaction) => {
+  if (transaction.type !== void 0) {
+    const normalized = toHexQuantity2(transaction.type);
+    if (normalized === "0x0" || normalized === "0x1" || normalized === "0x2") {
+      return normalized;
+    }
+    throw new Error(`Unsupported EVM transaction type for Cubist: ${normalized}`);
+  }
+  if (transaction.maxFeePerGas !== void 0 || transaction.maxPriorityFeePerGas !== void 0) {
+    return "0x2";
+  }
+  if (transaction.accessList?.length) {
+    return "0x1";
+  }
+  return "0x0";
+};
+var toCubistSignRequest = (address, chain, transaction) => {
+  const resolvedChainId = (transaction.chainId !== void 0 ? Number(toBigIntQuantity(transaction.chainId)) : void 0) ?? evmChainIdMap[chain];
+  if (!resolvedChainId) {
+    throw new Error("Cubist signing requires an EVM chainId");
+  }
+  const type = resolveTransactionType(transaction);
+  const commonFields = {
+    from: transaction.from ?? address,
+    to: transaction.to,
+    data: transaction.data,
+    gas: toHexQuantity2(transaction.gas),
+    nonce: toHexQuantity2(transaction.nonce),
+    value: toHexQuantity2(transaction.value)
+  };
+  const accessList = normalizeAccessList(transaction.accessList);
+  const tx = type === "0x2" ? {
+    ...commonFields,
+    type,
+    ...accessList ? { accessList } : {},
+    maxFeePerGas: toHexQuantity2(transaction.maxFeePerGas),
+    maxPriorityFeePerGas: toHexQuantity2(transaction.maxPriorityFeePerGas)
+  } : type === "0x1" ? {
+    ...commonFields,
+    type,
+    ...accessList ? { accessList } : {},
+    gasPrice: toHexQuantity2(transaction.gasPrice)
+  } : {
+    ...commonFields,
+    type,
+    gasPrice: toHexQuantity2(transaction.gasPrice)
+  };
+  return {
+    chain_id: resolvedChainId,
+    tx
+  };
+};
+var getTransactionParam = (params) => {
+  const candidate = params?.[0];
+  if (!isRecord(candidate)) {
+    throw new Error("eth_signTransaction requires a transaction object");
+  }
+  return candidate;
+};
+var toHexBytes = (value) => {
+  if (/^0x[0-9a-fA-F]*$/.test(value)) return value;
+  return `0x${Array.from(textEncoder.encode(value)).map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+};
+var getMessageParam = (address, params) => {
+  const [first, second] = params ?? [];
+  if (typeof second === "string" && second.toLowerCase() === address.toLowerCase()) {
+    return String(first ?? "");
+  }
+  if (typeof first === "string" && first.toLowerCase() === address.toLowerCase()) {
+    return String(second ?? "");
+  }
+  return String(first ?? "");
+};
+var getTypedDataParam = (address, params) => {
+  const [first, second] = params ?? [];
+  if (typeof first === "string" && first.toLowerCase() === address.toLowerCase()) {
+    return typeof second === "string" ? JSON.parse(second) : second ?? {};
+  }
+  return typeof second === "string" ? JSON.parse(second) : second ?? first ?? {};
+};
+function createEmbeddedProvider({
+  session,
+  address,
+  chain
+}) {
+  const signer = new EvmSigner(address, session.client);
+  return {
+    async request(payload) {
+      switch (payload.method) {
+        case "eth_accounts":
+        case "eth_requestAccounts":
+          return [address];
+        case "eth_chainId": {
+          const chainId = evmChainIdMap[chain];
+          return `0x${chainId.toString(16)}`;
+        }
+        case "eth_signTransaction": {
+          const transaction = getTransactionParam(payload.params);
+          const signRequest = toCubistSignRequest(address, chain, transaction);
+          return await signer.signTransaction(signRequest);
+        }
+        case "personal_sign": {
+          const message = getMessageParam(address, payload.params);
+          return await signer.signEip191({ data: toHexBytes(message) });
+        }
+        case "eth_signTypedData_v4": {
+          const typedData = getTypedDataParam(address, payload.params);
+          const domain = typedData.domain;
+          const chainId = domain?.chainId !== void 0 ? Number(toBigIntQuantity(domain.chainId)) : evmChainIdMap[chain];
+          if (!chainId) {
+            throw new Error("CubistProvider: typed data signing requires an EVM chainId");
+          }
+          return await signer.signEip712({
+            chain_id: chainId,
+            typed_data: typedData
+          });
+        }
+        default:
+          throw new Error(`CubistProvider: unsupported RPC method "${payload.method}"`);
+      }
+    },
+    async disconnect() {
+      await session.client.revokeSession();
+    }
+  };
+}
+var EmbeddedWalletAccountProvider = class {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  async request(payload) {
+    return this.provider.request(payload);
+  }
+  async disconnect() {
+    await this.provider.disconnect();
+  }
+  async eth_accounts() {
+    return this.request({ method: "eth_accounts" });
+  }
+  async eth_chainId() {
+    return this.request({ method: "eth_chainId" });
+  }
+};
+var _WalletAccount = class _WalletAccount {
+  static clearInstance() {
+    _WalletAccount.instance = null;
+    _WalletAccount.instanceToken = null;
+    _WalletAccount.walletSession = null;
+    _WalletAccount.cubeSignerSession = null;
+  }
+  static getWalletSession() {
+    return _WalletAccount.walletSession;
+  }
+  static getCubeSignerSession() {
+    return _WalletAccount.cubeSignerSession;
+  }
+  static async getInstance(oidcToken, authSource, cubeSignerConfig) {
+    if (_WalletAccount.instance && _WalletAccount.instanceToken === oidcToken) {
+      return _WalletAccount.instance;
+    }
+    _WalletAccount.clearInstance();
+    const auth = new CubeSignerAuth(cubeSignerConfig);
+    const cubeSignerSession = await auth.loginWithGoogle(oidcToken);
+    const keys = await cubeSignerSession.client.sessionKeys();
+    const evmKey = keys.find((key) => key.cached.key_type === "SecpEthAddr");
+    if (!evmKey) {
+      throw new Error("No EVM key found in CubeSigner session");
+    }
+    const address = evmKey.materialId;
+    const chain = "BSC";
+    const provider = createEmbeddedProvider({
+      session: cubeSignerSession,
+      address,
+      chain
+    });
+    const wrappedProvider = new EmbeddedWalletAccountProvider(provider);
+    const capabilityPolicy = auth.defaultSessionPolicy ? createSessionCapabilityPolicy(auth.defaultSessionPolicy) : void 0;
+    _WalletAccount.instance = wrappedProvider;
+    _WalletAccount.instanceToken = oidcToken;
+    _WalletAccount.cubeSignerSession = cubeSignerSession;
+    _WalletAccount.walletSession = {
+      address,
+      chain,
+      provider: wrappedProvider,
+      walletType: "social",
+      authSource,
+      sessionId: `${authSource}:${address.toLowerCase()}`,
+      expiresAt: capabilityPolicy?.expiresAt,
+      capabilities: [...cubistCapabilities],
+      sessionData: cubeSignerSession.sessionData,
+      chainContext: createChainContext(chain),
+      capabilityPolicy
+    };
+    return wrappedProvider;
+  }
+};
+_WalletAccount.instance = null;
+_WalletAccount.instanceToken = null;
+_WalletAccount.walletSession = null;
+_WalletAccount.cubeSignerSession = null;
+var WalletAccount = _WalletAccount;
+function clearSocialAccountInstance() {
+  WalletAccount.clearInstance();
+}
+
+// src/ui/theme.ts
+var colors = {
+  background: "#050608",
+  card: "#121214",
+  cardRaised: "#151821",
+  border: "rgba(126,135,162,0.2)",
+  borderStrong: "rgba(255,255,255,0.16)",
+  borderFocused: "#FFFFFF",
+  textPrimary: "#FFFFFF",
+  textSecondary: "#737477",
+  accent: "#29FF9B",
+  accentStrong: "#4AD481",
+  warning: "#FFB547",
+  danger: "#FF6B6B",
+  stepActive: "#FFFFFF",
+  stepInactive: "#36383D",
+  buttonDisabledBg: "rgba(255,255,255,0.14)",
+  buttonDisabledBorder: "#444444"
+};
+var radii = {
+  xl: "28px",
+  lg: "20px",
+  pill: "99px",
+  full: "9999px",
+  card: "12px",
+  input: "8px"
+};
+var fonts = {
+  family: '"Switzer", "Inter", "SF Pro Display", system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif'
+};
+var GoogleIcon = () => /* @__PURE__ */ jsxs("svg", { width: "21", height: "21", viewBox: "0 0 21 21", fill: "none", children: [
+  /* @__PURE__ */ jsx("path", { d: "M20.3 10.73c0-.79-.07-1.54-.19-2.27H10.5v4.51h5.5a4.69 4.69 0 0 1-2.04 3.09v2.57h3.3c1.93-1.78 3.04-4.4 3.04-7.9Z", fill: "#4285F4" }),
+  /* @__PURE__ */ jsx("path", { d: "M10.5 21c2.76 0 5.07-.91 6.76-2.47l-3.3-2.57c-.92.61-2.09.97-3.46.97-2.66 0-4.91-1.8-5.71-4.22H1.39v2.65A10.5 10.5 0 0 0 10.5 21Z", fill: "#34A853" }),
+  /* @__PURE__ */ jsx("path", { d: "M4.79 12.71A6.3 6.3 0 0 1 4.46 10.5c0-.77.13-1.51.33-2.21V5.64H1.39A10.5 10.5 0 0 0 0 10.5c0 1.7.41 3.3 1.39 4.86l3.4-2.65Z", fill: "#FBBC05" }),
+  /* @__PURE__ */ jsx("path", { d: "M10.5 4.07c1.5 0 2.84.51 3.9 1.52l2.92-2.92C15.56 1.02 13.26 0 10.5 0A10.5 10.5 0 0 0 1.39 5.64l3.4 2.65C5.59 5.87 7.84 4.07 10.5 4.07Z", fill: "#EA4335" })
+] });
+var XIcon = () => /* @__PURE__ */ jsx("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", children: /* @__PURE__ */ jsx("path", { d: "M18.244 2.25h3.308l-7.227 8.26 8.502 11.24H16.17l-5.214-6.817L4.99 21.75H1.68l7.73-8.835L1.254 2.25H8.08l4.713 6.231 5.45-6.231Zm-1.161 17.52h1.833L7.084 4.126H5.117L17.083 19.77Z", fill: "white" }) });
+var ExpandIcon = ({ expanded }) => /* @__PURE__ */ jsxs(
+  "svg",
+  {
+    width: "24",
+    height: "24",
+    viewBox: "0 0 24 24",
+    fill: "none",
+    style: { transform: expanded ? "rotate(180deg)" : void 0, transition: "transform 0.2s" },
+    children: [
+      /* @__PURE__ */ jsx("path", { d: "M5 9L9 13L13 9", stroke: colors.textSecondary, strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round" }),
+      /* @__PURE__ */ jsx("path", { d: "M11 9L15 13L19 9", stroke: colors.textSecondary, strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round" })
+    ]
+  }
+);
+var SpinnerIcon = () => /* @__PURE__ */ jsxs("svg", { width: "20", height: "20", viewBox: "0 0 20 20", fill: "none", style: { animation: "spin 1s linear infinite" }, children: [
+  /* @__PURE__ */ jsx("circle", { cx: "10", cy: "10", r: "8", stroke: "rgba(255,255,255,0.2)", strokeWidth: "2.5" }),
+  /* @__PURE__ */ jsx("path", { d: "M10 2a8 8 0 0 1 8 8", stroke: colors.textPrimary, strokeWidth: "2.5", strokeLinecap: "round" }),
+  /* @__PURE__ */ jsx("style", { children: `@keyframes spin { to { transform: rotate(360deg); } }` })
+] });
+var defaultSocialProviders = [
+  { id: "google", label: "Continue with Google", icon: /* @__PURE__ */ jsx(GoogleIcon, {}) },
+  { id: "x", label: "Continue with X", icon: /* @__PURE__ */ jsx(XIcon, {}) }
+];
+function resolveWalletItems(wallets, defaultWalletRegistry) {
+  const walletMap = new Map(
+    defaultWalletRegistry.map((item) => [
+      item.id,
+      {
+        name: item.title,
+        installed: item.installed,
+        installUrl: item.installUrl
+      }
+    ])
+  );
+  if (wallets === void 0) {
+    return defaultWalletRegistry.map((item) => ({
+      id: item.id,
+      name: item.title,
+      icon: void 0,
+      installed: item.installed,
+      installUrl: item.installUrl
+    }));
+  }
+  if (wallets.length === 0) {
+    return [];
+  }
+  return wallets.map((wallet) => {
+    const fallback = walletMap.get(wallet.id);
+    return {
+      ...wallet,
+      name: wallet.name ?? fallback?.name ?? wallet.id,
+      installed: wallet.installed ?? fallback?.installed,
+      installUrl: wallet.installUrl ?? fallback?.installUrl
+    };
+  });
+}
+function resolveSocialProviders(socialProviders) {
+  if (socialProviders === void 0) {
+    return defaultSocialProviders;
+  }
+  if (socialProviders.length === 0) {
+    return [];
+  }
+  const defaultProviderMap = new Map(
+    defaultSocialProviders.map((provider) => [provider.id, provider])
+  );
+  return socialProviders.map((provider) => {
+    const fallback = defaultProviderMap.get(provider.id);
+    return {
+      ...provider,
+      label: provider.label ?? fallback?.label ?? provider.id,
+      icon: provider.icon ?? fallback?.icon
+    };
+  });
+}
+var IconFrame = ({
+  background,
+  children
+}) => /* @__PURE__ */ jsx(
+  "div",
+  {
+    style: {
+      width: 48,
+      height: 48,
+      borderRadius: 12,
+      background,
+      display: "flex",
+      alignItems: "center",
+      justifyContent: "center",
+      overflow: "hidden"
+    },
+    children
+  }
+);
+var MetaMaskWalletIcon = () => /* @__PURE__ */ jsx(IconFrame, { background: "#1A0F07", children: /* @__PURE__ */ jsxs("svg", { width: "32", height: "32", viewBox: "0 0 32 32", fill: "none", children: [
+  /* @__PURE__ */ jsx("path", { d: "M8 6L15 11L12 14L8 6Z", fill: "#E17726" }),
+  /* @__PURE__ */ jsx("path", { d: "M24 6L17 11L20 14L24 6Z", fill: "#E27625" }),
+  /* @__PURE__ */ jsx("path", { d: "M11 19L15 22V17L11 19Z", fill: "#F6851B" }),
+  /* @__PURE__ */ jsx("path", { d: "M21 19L17 22V17L21 19Z", fill: "#F6851B" }),
+  /* @__PURE__ */ jsx("path", { d: "M12 14L15 11V17L11 19L12 14Z", fill: "#763D16" }),
+  /* @__PURE__ */ jsx("path", { d: "M20 14L17 11V17L21 19L20 14Z", fill: "#763D16" })
+] }) });
+var OKXWalletIcon = () => /* @__PURE__ */ jsx(IconFrame, { background: "#FFFFFF", children: /* @__PURE__ */ jsxs("svg", { width: "30", height: "30", viewBox: "0 0 30 30", fill: "none", children: [
+  /* @__PURE__ */ jsx("rect", { x: "2", y: "2", width: "8", height: "8", rx: "2", fill: "#050608" }),
+  /* @__PURE__ */ jsx("rect", { x: "11", y: "2", width: "8", height: "8", rx: "2", fill: "#050608" }),
+  /* @__PURE__ */ jsx("rect", { x: "20", y: "2", width: "8", height: "8", rx: "2", fill: "#050608" }),
+  /* @__PURE__ */ jsx("rect", { x: "2", y: "11", width: "8", height: "8", rx: "2", fill: "#050608" }),
+  /* @__PURE__ */ jsx("rect", { x: "20", y: "11", width: "8", height: "8", rx: "2", fill: "#050608" }),
+  /* @__PURE__ */ jsx("rect", { x: "2", y: "20", width: "8", height: "8", rx: "2", fill: "#050608" }),
+  /* @__PURE__ */ jsx("rect", { x: "11", y: "20", width: "8", height: "8", rx: "2", fill: "#050608" }),
+  /* @__PURE__ */ jsx("rect", { x: "20", y: "20", width: "8", height: "8", rx: "2", fill: "#050608" })
+] }) });
+var CoinbaseWalletIcon = () => /* @__PURE__ */ jsx(IconFrame, { background: "#0052FF", children: /* @__PURE__ */ jsxs("svg", { width: "30", height: "30", viewBox: "0 0 30 30", fill: "none", children: [
+  /* @__PURE__ */ jsx("circle", { cx: "15", cy: "15", r: "10", stroke: "white", strokeWidth: "4" }),
+  /* @__PURE__ */ jsx("rect", { x: "9", y: "13", width: "12", height: "4", rx: "2", fill: "white" })
+] }) });
+var TrustWalletIcon = () => /* @__PURE__ */ jsx(IconFrame, { background: "#3375FF", children: /* @__PURE__ */ jsxs("svg", { width: "28", height: "28", viewBox: "0 0 28 28", fill: "none", children: [
+  /* @__PURE__ */ jsx("path", { d: "M14 4L21 6.6V12.8C21 17.1 18.1 20.9 14 22.4C9.9 20.9 7 17.1 7 12.8V6.6L14 4Z", fill: "white" }),
+  /* @__PURE__ */ jsx("path", { d: "M14 8L17 9.1V12.3C17 14.7 15.7 16.8 14 17.6C12.3 16.8 11 14.7 11 12.3V9.1L14 8Z", fill: "#3375FF" })
+] }) });
+var PhantomWalletIcon = () => /* @__PURE__ */ jsx(IconFrame, { background: "linear-gradient(135deg, #6C47FF 0%, #9B6BFF 100%)", children: /* @__PURE__ */ jsxs("svg", { width: "30", height: "30", viewBox: "0 0 30 30", fill: "none", children: [
+  /* @__PURE__ */ jsx("path", { d: "M8 18.5C8 14.4 11.2 11 15.3 11H20.4C21.8 11 23 12.2 23 13.6C23 15 21.8 16.2 20.4 16.2H14.7", stroke: "white", strokeWidth: "3", strokeLinecap: "round" }),
+  /* @__PURE__ */ jsx("path", { d: "M10.5 14H19.5", stroke: "white", strokeWidth: "3", strokeLinecap: "round" }),
+  /* @__PURE__ */ jsx("circle", { cx: "12", cy: "20", r: "1.4", fill: "white" }),
+  /* @__PURE__ */ jsx("circle", { cx: "18", cy: "20", r: "1.4", fill: "white" })
+] }) });
+var RabbyWalletIcon = () => /* @__PURE__ */ jsx(IconFrame, { background: "#EBF2FF", children: /* @__PURE__ */ jsxs("svg", { width: "30", height: "30", viewBox: "0 0 30 30", fill: "none", children: [
+  /* @__PURE__ */ jsx("path", { d: "M11 7L13.5 13", stroke: "#7084FF", strokeWidth: "3", strokeLinecap: "round" }),
+  /* @__PURE__ */ jsx("path", { d: "M19 7L16.5 13", stroke: "#7084FF", strokeWidth: "3", strokeLinecap: "round" }),
+  /* @__PURE__ */ jsx("rect", { x: "8", y: "12", width: "14", height: "11", rx: "6", fill: "#7084FF" }),
+  /* @__PURE__ */ jsx("circle", { cx: "13", cy: "17", r: "1.4", fill: "white" }),
+  /* @__PURE__ */ jsx("circle", { cx: "17", cy: "17", r: "1.4", fill: "white" }),
+  /* @__PURE__ */ jsx("path", { d: "M13 20C13.6 20.4 14.3 20.6 15 20.6C15.7 20.6 16.4 20.4 17 20", stroke: "white", strokeWidth: "1.8", strokeLinecap: "round" })
+] }) });
+var RainbowWalletIcon = () => /* @__PURE__ */ jsx(IconFrame, { background: "linear-gradient(180deg, #174299 0%, #001E59 100%)", children: /* @__PURE__ */ jsxs("svg", { width: "32", height: "32", viewBox: "0 0 120 120", fill: "none", style: { overflow: "hidden", borderRadius: 12 }, children: [
+  /* @__PURE__ */ jsxs("defs", { children: [
+    /* @__PURE__ */ jsxs("radialGradient", { id: "rainbow_r1", cx: "0", cy: "0", r: "1", gradientUnits: "userSpaceOnUse", gradientTransform: "translate(26 94) rotate(-90) scale(74)", children: [
+      /* @__PURE__ */ jsx("stop", { offset: "0.770277", stopColor: "#FF4000" }),
+      /* @__PURE__ */ jsx("stop", { offset: "1", stopColor: "#8754C9" })
+    ] }),
+    /* @__PURE__ */ jsxs("linearGradient", { id: "rainbow_l2", x1: "83", y1: "97", x2: "100", y2: "97", gradientUnits: "userSpaceOnUse", children: [
+      /* @__PURE__ */ jsx("stop", { stopColor: "#FF4000" }),
+      /* @__PURE__ */ jsx("stop", { offset: "1", stopColor: "#8754C9" })
+    ] }),
+    /* @__PURE__ */ jsxs("linearGradient", { id: "rainbow_l3", x1: "23", y1: "20", x2: "23", y2: "37", gradientUnits: "userSpaceOnUse", children: [
+      /* @__PURE__ */ jsx("stop", { stopColor: "#8754C9" }),
+      /* @__PURE__ */ jsx("stop", { offset: "1", stopColor: "#FF4000" })
+    ] }),
+    /* @__PURE__ */ jsxs("radialGradient", { id: "rainbow_r4", cx: "0", cy: "0", r: "1", gradientUnits: "userSpaceOnUse", gradientTransform: "translate(26 94) rotate(-90) scale(58)", children: [
+      /* @__PURE__ */ jsx("stop", { offset: "0.723929", stopColor: "#FFF700" }),
+      /* @__PURE__ */ jsx("stop", { offset: "1", stopColor: "#FF9901" })
+    ] }),
+    /* @__PURE__ */ jsxs("linearGradient", { id: "rainbow_l5", x1: "68", y1: "97", x2: "84", y2: "97", gradientUnits: "userSpaceOnUse", children: [
+      /* @__PURE__ */ jsx("stop", { stopColor: "#FFF700" }),
+      /* @__PURE__ */ jsx("stop", { offset: "1", stopColor: "#FF9901" })
+    ] }),
+    /* @__PURE__ */ jsxs("linearGradient", { id: "rainbow_l6", x1: "23", y1: "52", x2: "23", y2: "36", gradientUnits: "userSpaceOnUse", children: [
+      /* @__PURE__ */ jsx("stop", { stopColor: "#FFF700" }),
+      /* @__PURE__ */ jsx("stop", { offset: "1", stopColor: "#FF9901" })
+    ] }),
+    /* @__PURE__ */ jsxs("radialGradient", { id: "rainbow_r7", cx: "0", cy: "0", r: "1", gradientUnits: "userSpaceOnUse", gradientTransform: "translate(26 94) rotate(-90) scale(42)", children: [
+      /* @__PURE__ */ jsx("stop", { offset: "0.59513", stopColor: "#00AAFF" }),
+      /* @__PURE__ */ jsx("stop", { offset: "1", stopColor: "#01DA40" })
+    ] }),
+    /* @__PURE__ */ jsxs("radialGradient", { id: "rainbow_r8", cx: "0", cy: "0", r: "1", gradientUnits: "userSpaceOnUse", gradientTransform: "translate(51 97) scale(17 45.3333)", children: [
+      /* @__PURE__ */ jsx("stop", { stopColor: "#00AAFF" }),
+      /* @__PURE__ */ jsx("stop", { offset: "1", stopColor: "#01DA40" })
+    ] }),
+    /* @__PURE__ */ jsxs("radialGradient", { id: "rainbow_r9", cx: "0", cy: "0", r: "1", gradientUnits: "userSpaceOnUse", gradientTransform: "translate(23 69) rotate(-90) scale(17 322.37)", children: [
+      /* @__PURE__ */ jsx("stop", { stopColor: "#00AAFF" }),
+      /* @__PURE__ */ jsx("stop", { offset: "1", stopColor: "#01DA40" })
+    ] })
+  ] }),
+  /* @__PURE__ */ jsx("path", { d: "M20 38H26C56.9279 38 82 63.0721 82 94V100H94C97.3137 100 100 97.3137 100 94C100 53.1309 66.8691 20 26 20C22.6863 20 20 22.6863 20 26V38Z", fill: "url(#rainbow_r1)" }),
+  /* @__PURE__ */ jsx("path", { d: "M84 94H100C100 97.3137 97.3137 100 94 100H84V94Z", fill: "url(#rainbow_l2)" }),
+  /* @__PURE__ */ jsx("path", { d: "M26 20L26 36H20L20 26C20 22.6863 22.6863 20 26 20Z", fill: "url(#rainbow_l3)" }),
+  /* @__PURE__ */ jsx("path", { d: "M20 36H26C58.0325 36 84 61.9675 84 94V100H66V94C66 71.9086 48.0914 54 26 54H20V36Z", fill: "url(#rainbow_r4)" }),
+  /* @__PURE__ */ jsx("path", { d: "M68 94H84V100H68V94Z", fill: "url(#rainbow_l5)" }),
+  /* @__PURE__ */ jsx("path", { d: "M20 52L20 36L26 36L26 52H20Z", fill: "url(#rainbow_l6)" }),
+  /* @__PURE__ */ jsx("path", { d: "M20 62C20 65.3137 22.6863 68 26 68C40.3594 68 52 79.6406 52 94C52 97.3137 54.6863 100 58 100H68V94C68 70.804 49.196 52 26 52H20V62Z", fill: "url(#rainbow_r7)" }),
+  /* @__PURE__ */ jsx("path", { d: "M52 94H68V100H58C54.6863 100 52 97.3137 52 94Z", fill: "url(#rainbow_r8)" }),
+  /* @__PURE__ */ jsx("path", { d: "M26 68C22.6863 68 20 65.3137 20 62L20 52L26 52L26 68Z", fill: "url(#rainbow_r9)" })
+] }) });
+var ZerionWalletIcon = () => /* @__PURE__ */ jsx(IconFrame, { background: "#2962EF", children: /* @__PURE__ */ jsx("svg", { width: "28", height: "28", viewBox: "0 0 28 28", fill: "none", children: /* @__PURE__ */ jsx("path", { fill: "#fff", d: "M6.073 7c-.48 0-.665.593-.262.841l10.073 6.074a.577.577 0 0 0 .758-.139l4.43-5.814c.3-.404-.004-.962-.525-.962H6.073ZM21.904 21c.48 0 .67-.596.267-.844l-10.075-6.073a.569.569 0 0 0-.751.146l-4.437 5.813c-.301.404.012.958.534.958h14.462Z" }) }) });
+var BraveWalletIcon = () => /* @__PURE__ */ jsx(IconFrame, { background: "#FFF", children: /* @__PURE__ */ jsxs("svg", { width: "32", height: "32", viewBox: "-100 -100 2970 2970", fill: "none", style: { overflow: "hidden", borderRadius: 12 }, children: [
+  /* @__PURE__ */ jsxs("defs", { children: [
+    /* @__PURE__ */ jsxs("linearGradient", { id: "brave_a", y1: "51%", y2: "51%", children: [
+      /* @__PURE__ */ jsx("stop", { offset: "0.4", stopColor: "#f50" }),
+      /* @__PURE__ */ jsx("stop", { offset: "0.6", stopColor: "#ff2000" })
+    ] }),
+    /* @__PURE__ */ jsxs("linearGradient", { id: "brave_b", x1: "2%", y1: "51%", x2: "51%", y2: "51%", children: [
+      /* @__PURE__ */ jsx("stop", { offset: "0", stopColor: "#ff452a" }),
+      /* @__PURE__ */ jsx("stop", { offset: "1", stopColor: "#ff2000" })
+    ] })
+  ] }),
+  /* @__PURE__ */ jsx("path", { fill: "url(#brave_a)", d: "m2395 723 60-147-170-176c-92-92-288-38-288-38l-222-252H992L769 363s-196-53-288 37L311 575l60 147-75 218 250 953c52 204 87 283 234 387l457 310c44 27 98 74 147 74s103-47 147-74l457-310c147-104 182-183 234-387l250-953z" }),
+  /* @__PURE__ */ jsx("path", { fill: "#fff", d: "M1935 524s287 347 287 420c0 75-36 94-72 133l-215 230c-20 20-63 54-38 113 25 60 60 134 20 210-40 77-110 128-155 120a820 820 0 0 1-190-90c-38-25-160-126-160-165s126-110 150-124c23-16 130-78 132-102s2-30-30-90-88-140-80-192c10-52 100-80 167-105l207-78c16-8 12-15-36-20-48-4-183-22-244-5s-163 43-173 57c-8 14-16 14-7 62l58 315c4 40 12 67-30 77-44 10-117 27-142 27s-99-17-142-27-35-37-30-77c4-40 48-268 57-315 10-48 1-48-7-62-10-14-113-40-174-57-60-17-196 1-244 6-48 4-52 10-36 20l207 77c66 25 158 53 167 105 10 53-47 132-80 192s-32 66-30 90 110 86 132 102c24 15 150 85 150 124s-119 140-159 165a820 820 0 0 1-190 90c-45 8-115-43-156-120-40-76-4-150 20-210 25-60-17-92-38-113l-215-230c-35-37-71-57-71-131s287-420 287-420l273 44c32 0 103-27 168-50 65-20 110-22 110-22s44 0 110 22 136 50 168 50c33 0 275-47 275-47zm-215 1328c18 10 7 32-10 44l-254 198c-20 20-52 50-73 50s-52-30-73-50a13200 13200 0 0 0-255-198c-16-12-27-33-10-44l150-80a870 870 0 0 1 188-73c15 0 110 34 187 73l150 80z" }),
+  /* @__PURE__ */ jsx("path", { fill: "url(#brave_b)", d: "m1999 363-224-253H992L769 363s-196-53-288 37c0 0 260-23 350 123l276 47c32 0 103-27 168-50 65-20 110-22 110-22s44 0 110 22 136 50 168 50c33 0 275-47 275-47 90-146 350-123 350-123-92-92-288-38-288-38" })
+] }) });
+var BitgetWalletIcon = () => /* @__PURE__ */ jsx(IconFrame, { background: "#001F29", children: /* @__PURE__ */ jsx("svg", { width: "28", height: "28", viewBox: "0 0 512 512", fill: "none", children: /* @__PURE__ */ jsx("path", { d: "M219.948 95.7022C201.623 95.6929 183.33 95.6835 164.941 95.7116C153.822 95.7116 149.651 109.671 157.921 117.939L283.098 243.117C287.004 246.69 289.441 250.574 289.53 255.693C289.441 260.812 287.004 264.696 283.098 268.269L157.921 393.446C149.651 401.715 153.822 415.674 164.941 415.674C183.33 415.702 201.623 415.693 219.948 415.683C229.122 415.679 238.305 415.674 247.511 415.674C259.555 415.674 266.72 409.24 273.154 402.805L386.047 289.912C395.057 280.902 403.119 268.939 403.009 255.693C403.119 242.447 395.057 230.484 386.047 221.474L273.154 108.58C266.72 102.146 259.555 95.7116 247.511 95.7116C238.305 95.7116 229.122 95.7069 219.948 95.7022Z", fill: "#00F0FF" }) }) });
+var walletIconTheme = {
+  metamask: "#F6851B",
+  okx: "#050608",
+  coinbase: "#0052FF",
+  trust: "#3375FF",
+  phantom: "#6C47FF",
+  rabby: "#7084FF",
+  rainbow: "#123F99",
+  zerion: "#2962EF",
+  brave: "#FF452A",
+  bitget: "#00F0FF"
+};
+var WalletPlaceholder = ({ walletId, name }) => /* @__PURE__ */ jsx(IconFrame, { background: walletIconTheme[walletId] ?? colors.cardRaised, children: /* @__PURE__ */ jsx(
+  "span",
+  {
+    style: {
+      fontSize: 14,
+      fontWeight: 700,
+      color: walletIconTheme[walletId] ? "#FFFFFF" : colors.textSecondary,
+      fontFamily: fonts.family
+    },
+    children: name.slice(0, 2).toUpperCase()
+  }
+) });
+var DefaultWalletIcon = ({
+  walletId,
+  name
+}) => {
+  switch (walletId) {
+    case "metamask":
+      return /* @__PURE__ */ jsx(MetaMaskWalletIcon, {});
+    case "okx":
+      return /* @__PURE__ */ jsx(OKXWalletIcon, {});
+    case "coinbase":
+      return /* @__PURE__ */ jsx(CoinbaseWalletIcon, {});
+    case "trust":
+      return /* @__PURE__ */ jsx(TrustWalletIcon, {});
+    case "phantom":
+      return /* @__PURE__ */ jsx(PhantomWalletIcon, {});
+    case "rabby":
+      return /* @__PURE__ */ jsx(RabbyWalletIcon, {});
+    case "rainbow":
+      return /* @__PURE__ */ jsx(RainbowWalletIcon, {});
+    case "zerion":
+      return /* @__PURE__ */ jsx(ZerionWalletIcon, {});
+    case "brave":
+      return /* @__PURE__ */ jsx(BraveWalletIcon, {});
+    case "bitget":
+      return /* @__PURE__ */ jsx(BitgetWalletIcon, {});
+    default:
+      return /* @__PURE__ */ jsx(WalletPlaceholder, { walletId, name });
+  }
+};
+var CloseButton = ({ onClick }) => /* @__PURE__ */ jsx(
+  "button",
+  {
+    type: "button",
+    onClick,
+    "aria-label": "Close",
+    style: {
+      width: 30,
+      height: 30,
+      borderRadius: "50%",
+      background: colors.card,
+      border: "none",
+      cursor: "pointer",
+      display: "flex",
+      alignItems: "center",
+      justifyContent: "center",
+      padding: 0,
+      flexShrink: 0
+    },
+    children: /* @__PURE__ */ jsx("svg", { width: "17", height: "17", viewBox: "0 0 17 17", fill: "none", children: /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: "M4.25 4.25L12.75 12.75M12.75 4.25L4.25 12.75",
+        stroke: colors.textPrimary,
+        strokeWidth: "1.5",
+        strokeLinecap: "round"
+      }
+    ) })
+  }
+);
+var ModalFrame = ({
+  onClose,
+  width = 500,
+  cardStyle,
+  contentStyle,
+  children
+}) => /* @__PURE__ */ jsx("div", { style: { display: "flex", flexDirection: "column", alignItems: "center", justifyContent: "center" }, children: /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: 14, alignItems: "flex-start" }, children: [
+  /* @__PURE__ */ jsx(
+    "div",
+    {
+      style: {
+        width,
+        background: colors.card,
+        borderRadius: radii.card,
+        overflow: "hidden",
+        ...cardStyle
+      },
+      children: /* @__PURE__ */ jsx(
+        "div",
+        {
+          style: {
+            display: "flex",
+            flexDirection: "column",
+            minHeight: 0,
+            fontFamily: fonts.family,
+            color: colors.textPrimary,
+            boxSizing: "border-box",
+            ...contentStyle
+          },
+          children
+        }
+      )
+    }
+  ),
+  /* @__PURE__ */ jsx(CloseButton, { onClick: onClose })
+] }) });
+var SignInModalFrame = ({
+  id,
+  title,
+  onClose,
+  footer,
+  children
+}) => /* @__PURE__ */ jsx(
+  ModalFrame,
+  {
+    onClose,
+    cardStyle: { padding: "32px 24px" },
+    contentStyle: { alignItems: "center" },
+    children: /* @__PURE__ */ jsxs("div", { style: { width: "100%", display: "flex", flexDirection: "column", gap: 24, alignItems: "center" }, id, children: [
+      /* @__PURE__ */ jsx("h2", { style: { margin: 0, fontSize: 24, fontWeight: 600, lineHeight: 1.4, textAlign: "center" }, children: title }),
+      /* @__PURE__ */ jsx("div", { style: { width: "100%", display: "flex", flexDirection: "column", gap: 12, alignItems: "center" }, children }),
+      footer
+    ] })
+  }
+);
+var SignInModalSocialSection = ({
+  id,
+  socialProviders,
+  isBusy,
+  loadingProvider,
+  onSocialClick
+}) => /* @__PURE__ */ jsxs("div", { style: { width: "100%", display: "flex", flexDirection: "column", gap: 24 }, id, children: [
+  /* @__PURE__ */ jsx("div", { style: { display: "flex", flexDirection: "column", gap: 16 }, children: socialProviders.map((provider) => {
+    const isLoading = loadingProvider === provider.id;
+    return /* @__PURE__ */ jsxs(
+      "button",
+      {
+        type: "button",
+        disabled: isBusy,
+        onClick: () => onSocialClick(provider.id),
+        style: {
+          width: "100%",
+          height: 48,
+          borderRadius: radii.pill,
+          border: `1px solid ${colors.border}`,
+          background: "transparent",
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          gap: 12,
+          cursor: isBusy ? "wait" : "pointer",
+          padding: 12,
+          boxSizing: "border-box",
+          opacity: isLoading ? 0.6 : isBusy ? 0.8 : 1,
+          transition: "opacity .15s"
+        },
+        children: [
+          isLoading ? /* @__PURE__ */ jsx(SpinnerIcon, {}) : provider.icon,
+          /* @__PURE__ */ jsx("span", { style: { fontSize: 16, fontWeight: 500, lineHeight: 1.4, color: colors.textPrimary, fontFamily: fonts.family }, children: isLoading ? "Signing in..." : provider.label })
+        ]
+      },
+      provider.id
+    );
+  }) }),
+  /* @__PURE__ */ jsxs("div", { style: { display: "flex", alignItems: "center", gap: 20, width: "100%" }, children: [
+    /* @__PURE__ */ jsx("div", { style: { flex: 1, height: 1, background: colors.border } }),
+    /* @__PURE__ */ jsx("span", { style: { fontSize: 14, lineHeight: 1.4, color: colors.textPrimary, opacity: 0.4, whiteSpace: "nowrap" }, children: "Or connect a wallet" }),
+    /* @__PURE__ */ jsx("div", { style: { flex: 1, height: 1, background: colors.border } })
+  ] })
+] });
+var SignInModalWalletGrid = ({
+  wallets,
+  isBusy,
+  loadingWalletId,
+  expanded,
+  showExpandToggle,
+  onWalletClick,
+  onToggleExpanded
+}) => /* @__PURE__ */ jsxs("div", { style: { width: "100%", display: "flex", flexDirection: "column", gap: 8, alignItems: "center", paddingTop: 12 }, children: [
+  /* @__PURE__ */ jsx("div", { style: { width: "100%", display: "flex", flexWrap: "wrap", gap: "14px 0" }, children: wallets.map((wallet) => /* @__PURE__ */ jsxs(
+    "button",
+    {
+      type: "button",
+      disabled: isBusy,
+      onClick: () => onWalletClick(wallet.id),
+      style: {
+        width: "25%",
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        gap: 4,
+        background: "transparent",
+        border: "none",
+        cursor: isBusy ? "wait" : "pointer",
+        padding: 0,
+        opacity: loadingWalletId === wallet.id ? 0.7 : isBusy ? 0.85 : 1
+      },
+      children: [
+        /* @__PURE__ */ jsx("div", { style: { width: 56, height: 56, display: "flex", alignItems: "center", justifyContent: "center" }, children: loadingWalletId === wallet.id ? /* @__PURE__ */ jsx(SpinnerIcon, {}) : wallet.icon ?? /* @__PURE__ */ jsx(DefaultWalletIcon, { walletId: wallet.id, name: wallet.name }) }),
+        /* @__PURE__ */ jsxs("div", { style: { display: "flex", flexDirection: "column", alignItems: "center", width: "100%" }, children: [
+          /* @__PURE__ */ jsx("span", { style: { fontSize: 12, fontWeight: 500, lineHeight: 1.4, color: colors.textPrimary, fontFamily: fonts.family, textAlign: "center", whiteSpace: "nowrap" }, children: wallet.name }),
+          loadingWalletId === wallet.id ? /* @__PURE__ */ jsx("span", { style: { fontSize: 10, lineHeight: 1.4, color: colors.textSecondary, fontFamily: fonts.family }, children: "Connecting..." }) : wallet.installed ? /* @__PURE__ */ jsx("span", { style: { fontSize: 10, lineHeight: 1.4, color: colors.accent, fontFamily: fonts.family }, children: "Installed" }) : wallet.installUrl ? /* @__PURE__ */ jsx(
+            "a",
+            {
+              href: wallet.installUrl,
+              target: "_blank",
+              rel: "noopener noreferrer",
+              onClick: (event) => event.stopPropagation(),
+              style: { fontSize: 10, lineHeight: 1.4, color: colors.textSecondary, fontFamily: fonts.family, textDecoration: "underline" },
+              children: "Install"
+            }
+          ) : null
+        ] })
+      ]
+    },
+    wallet.id
+  )) }),
+  showExpandToggle && /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      onClick: onToggleExpanded,
+      style: {
+        background: "transparent",
+        border: "none",
+        cursor: "pointer",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        padding: 4
+      },
+      children: /* @__PURE__ */ jsx(ExpandIcon, { expanded })
+    }
+  )
+] });
+var SignInModalFooter = ({
+  privacyPolicyUrl,
+  termsOfUseUrl
+}) => /* @__PURE__ */ jsx("div", { style: { padding: "12px 0", display: "flex", justifyContent: "center", width: "100%" }, children: /* @__PURE__ */ jsxs("p", { style: { margin: 0, fontSize: 14, lineHeight: 1.4, color: colors.textSecondary, fontFamily: fonts.family, textAlign: "center" }, children: [
+  "By continuing, I agree to the",
+  " ",
+  /* @__PURE__ */ jsx("a", { href: privacyPolicyUrl, style: { color: colors.textPrimary, textDecoration: "underline" }, target: "_blank", rel: "noopener noreferrer", children: "Privacy Policy" }),
+  " ",
+  "and",
+  " ",
+  /* @__PURE__ */ jsx("a", { href: termsOfUseUrl, style: { color: colors.textPrimary, textDecoration: "underline" }, target: "_blank", rel: "noopener noreferrer", children: "Terms of Use" })
+] }) });
+
+// src/auth/oidcRelay.ts
+function getRelayOrigin() {
+  if (typeof window === "undefined") {
+    throw new Error("OIDC relay requires a browser environment");
+  }
+  if (window.location.hostname === "localhost") {
+    return window.location.origin;
+  }
+  const relayOrigin2 = getEnv("RELAY_ORIGIN");
+  if (!relayOrigin2) {
+    throw new Error("RELAY_ORIGIN is not configured");
+  }
+  return relayOrigin2;
+}
+function openRelayWindow(url, name) {
+  const width = 420;
+  const height = 640;
+  const top = (window.innerHeight - height) / 2 + window.screenY;
+  const left = (window.innerWidth - width) / 2 + window.screenX;
+  return window.open(
+    url,
+    name,
+    `dialog=yes,top=${top}px,left=${left}px,width=${width}px,height=${height}px`
+  );
+}
+function waitForOidcToken(popup, relayOrigin2, timeoutMs = 12e4) {
+  return new Promise((resolve, reject) => {
+    if (!popup) {
+      reject(new Error("Failed to open login popup"));
+      return;
+    }
+    let settled = false;
+    const cleanup = () => {
+      clearTimeout(timeout);
+      clearInterval(closedCheck);
+      window.removeEventListener("message", onMessage);
+    };
+    const finish = (fn) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      fn();
+    };
+    const timeout = window.setTimeout(() => {
+      try {
+        popup.close();
+      } catch {
+      }
+      finish(() => reject(new Error("Login timeout")));
+    }, timeoutMs);
+    const onMessage = (event) => {
+      if (event.origin !== relayOrigin2) return;
+      if (event.data?.action !== "login") return;
+      const payload = event.data?.data ?? {};
+      if (payload.error) {
+        try {
+          popup.close();
+        } catch {
+        }
+        finish(() => reject(new Error(String(payload.error))));
+        return;
+      }
+      if (payload.oidcToken) {
+        try {
+          popup.close();
+        } catch {
+        }
+        finish(() => resolve(payload.oidcToken));
+      }
+    };
+    const closedCheck = window.setInterval(() => {
+      if (popup.closed) {
+        finish(() => reject(new Error("Login cancelled by user")));
+      }
+    }, 400);
+    window.addEventListener("message", onMessage);
+  });
+}
+function createOidcRelayAuth({
+  stage,
+  googleClientId,
+  xClientId
+}) {
+  const relayOrigin2 = getRelayOrigin();
+  const buildUrl = (provider, clientId) => {
+    const target = window.location.origin;
+    const params = new URLSearchParams({
+      target,
+      stage,
+      eventId: Date.now().toString(),
+      action: "login",
+      clientId
+    });
+    return `${relayOrigin2}/relay/${provider}?${params.toString()}`;
+  };
+  return {
+    async loginByGoogle() {
+      const popup = openRelayWindow(buildUrl("google", googleClientId), "Google login");
+      return waitForOidcToken(popup, relayOrigin2);
+    },
+    async loginByX() {
+      const popup = openRelayWindow(buildUrl("x", xClientId), "X login");
+      return waitForOidcToken(popup, relayOrigin2);
+    }
+  };
+}
+function resolveOidcStage() {
+  return getEnv("STAGE").toLowerCase() === "prod" ? "prod" : "dev";
+}
+var useSignInModalController = ({
+  wallets,
+  initialVisibleCount,
+  onGoogleLogin,
+  onTwitterLogin,
+  onCubeSignerSession,
+  onWalletConnected,
+  onSocialLogin,
+  onWalletSelect
+}) => {
+  const [expanded, setExpanded] = useState(false);
+  const [loadingProvider, setLoadingProvider] = useState(null);
+  const [loadingWalletId, setLoadingWalletId] = useState(null);
+  const defaultWalletRegistry = useMemo(() => createDefaultInjectedWalletRegistry(), []);
+  const defaultWalletConnector = useMemo(
+    () => new WalletConnector([
+      ...defaultWalletRegistry.map((item) => item.provider)
+    ]),
+    [defaultWalletRegistry]
+  );
+  const resolvedWallets = useMemo(
+    () => resolveWalletItems(wallets, defaultWalletRegistry),
+    [defaultWalletRegistry, wallets]
+  );
+  const showExpandToggle = resolvedWallets.length > initialVisibleCount;
+  const visibleWallets = expanded ? resolvedWallets : resolvedWallets.slice(0, initialVisibleCount);
+  const isBusy = !!loadingProvider || !!loadingWalletId;
+  const handleSocialClick = async (providerId) => {
+    setLoadingProvider(providerId);
+    try {
+      const config = getSDKConfig();
+      if (!config.cubeSigner) {
+        throw new Error("cubeSigner config is required for social login");
+      }
+      const auth = createOidcRelayAuth({
+        stage: resolveOidcStage(),
+        googleClientId: config.googleClientId ?? "",
+        xClientId: config.twitterClientId ?? ""
+      });
+      if (providerId === "google") {
+        if (!config.googleClientId) {
+          throw new Error("googleClientId is required for Google sign-in");
+        }
+        const oidcToken = await auth.loginByGoogle();
+        const authSource = "google";
+        WalletAccount.clearInstance();
+        await WalletAccount.getInstance(oidcToken, authSource, config.cubeSigner);
+        const session = WalletAccount.getWalletSession();
+        const cubeSignerSession = WalletAccount.getCubeSignerSession();
+        onGoogleLogin?.({ idToken: oidcToken });
+        if (cubeSignerSession) onCubeSignerSession?.(cubeSignerSession);
+        onSocialLogin?.(providerId);
+        if (!session) {
+          throw new Error("Failed to build wallet session from Google login");
+        }
+        return session;
+      }
+      if (providerId === "x") {
+        if (!config.twitterClientId) {
+          throw new Error("twitterClientId is required for X sign-in");
+        }
+        const oidcToken = await auth.loginByX();
+        const authSource = "twitter";
+        WalletAccount.clearInstance();
+        await WalletAccount.getInstance(oidcToken, authSource, config.cubeSigner);
+        const session = WalletAccount.getWalletSession();
+        const cubeSignerSession = WalletAccount.getCubeSignerSession();
+        onTwitterLogin?.({ code: "", codeVerifier: "", state: "" });
+        if (cubeSignerSession) onCubeSignerSession?.(cubeSignerSession);
+        onSocialLogin?.(providerId);
+        if (!session) {
+          throw new Error("Failed to build wallet session from X login");
+        }
+        return session;
+      }
+      throw new Error(`Unsupported social provider: ${providerId}`);
+    } finally {
+      setLoadingProvider(null);
+    }
+  };
+  const handleWalletClick = async (walletId) => {
+    if (isBusy) return null;
+    const targetWallet = resolvedWallets.find((wallet) => wallet.id === walletId);
+    if (!targetWallet) return null;
+    if (targetWallet.installed === false && targetWallet.installUrl) return null;
+    setLoadingWalletId(walletId);
+    try {
+      if (onWalletSelect) {
+        await onWalletSelect(walletId);
+        return null;
+      }
+      const builtInWallet = defaultWalletRegistry.find((item) => item.id === walletId);
+      if (!builtInWallet || !builtInWallet.installed) return null;
+      const session = await defaultWalletConnector.connect(walletId);
+      onWalletConnected?.(session, walletId);
+      return session;
+    } catch (error) {
+      console.error(`[predicate-market-sdk] Wallet connect failed for ${walletId}:`, error);
+      throw error;
+    } finally {
+      setLoadingWalletId(null);
+    }
+  };
+  return {
+    expanded,
+    loadingProvider,
+    loadingWalletId,
+    visibleWallets,
+    showExpandToggle,
+    isBusy,
+    handleSocialClick,
+    handleWalletClick,
+    toggleExpanded: () => setExpanded((value) => !value)
+  };
+};
+var variantStyles = {
+  success: { bg: "rgba(41, 255, 155, 0.82)", border: "rgba(41, 255, 155, 0.53)" },
+  error: { bg: "rgba(255, 107, 107, 0.82)", border: "rgba(255, 107, 107, 0.53)" },
+  info: { bg: "rgba(126, 135, 162, 0.82)", border: "rgba(126, 135, 162, 0.55)" }
+};
+var Toast = ({ message, variant = "info", duration, onClose }) => {
+  const style = variantStyles[variant];
+  useEffect(() => {
+    if (duration != null && duration > 0 && onClose) {
+      const timer = setTimeout(onClose, duration);
+      return () => clearTimeout(timer);
+    }
+  }, [duration, onClose]);
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      style: {
+        position: "fixed",
+        top: 0,
+        left: 0,
+        right: 0,
+        display: "flex",
+        justifyContent: "center",
+        paddingTop: 16,
+        zIndex: 1e4,
+        pointerEvents: "none"
+      },
+      children: /* @__PURE__ */ jsxs(
+        "div",
+        {
+          role: "alert",
+          style: {
+            pointerEvents: "auto",
+            display: "flex",
+            alignItems: "center",
+            gap: 10,
+            padding: "12px 16px",
+            borderRadius: radii.card,
+            background: style.bg,
+            border: `1px solid ${style.border}`,
+            color: colors.textPrimary,
+            fontSize: 14,
+            lineHeight: 1.4,
+            maxWidth: 360,
+            boxSizing: "border-box"
+          },
+          children: [
+            /* @__PURE__ */ jsx("span", { style: { flex: 1 }, children: message }),
+            onClose ? /* @__PURE__ */ jsx(
+              "button",
+              {
+                type: "button",
+                "aria-label": "Dismiss",
+                onClick: onClose,
+                style: {
+                  padding: 4,
+                  margin: -4,
+                  border: "none",
+                  background: "transparent",
+                  color: colors.textSecondary,
+                  cursor: "pointer",
+                  borderRadius: 4,
+                  lineHeight: 1
+                },
+                children: /* @__PURE__ */ jsx("svg", { width: "14", height: "14", viewBox: "0 0 14 14", fill: "none", children: /* @__PURE__ */ jsx(
+                  "path",
+                  {
+                    d: "M3.5 3.5L10.5 10.5M10.5 3.5L3.5 10.5",
+                    stroke: "currentColor",
+                    strokeWidth: "1.5",
+                    strokeLinecap: "round"
+                  }
+                ) })
+              }
+            ) : null
+          ]
+        }
+      )
+    }
+  );
+};
+function clearSocialAccountInstance2() {
+  try {
+    clearSocialAccountInstance();
+    const storage = typeof localStorage !== "undefined" ? localStorage : null;
+    const adapterId = storage?.getItem("ab:wallet:adapterId");
+    const session = sessionStore.getState().session;
+    const isSocialSession = session?.walletType === "social" || session?.authSource === "google" || session?.authSource === "twitter" || adapterId === "cubist";
+    if (!isSocialSession) return;
+    sessionStore.clearSession();
+    storage?.removeItem("ab:wallet:session");
+    storage?.removeItem("ab:wallet:adapterId");
+  } catch {
+    clearSocialAccountInstance();
+    sessionStore.clearSession();
+  }
+}
+var SignInModal = ({
+  title = "Welcome to PredicateMarket",
+  socialProviders,
+  wallets,
+  initialVisibleCount,
+  privacyPolicyUrl = "#",
+  termsOfUseUrl = "#",
+  onGoogleLogin,
+  onTwitterLogin,
+  onCubeSignerSession,
+  onWalletConnected,
+  onSocialLogin,
+  onWalletSelect,
+  onDismiss,
+  onSuccess
+}) => {
+  const sdkConfig2 = getSDKConfig();
+  const effectiveSocialProviders = resolveSocialProviders(
+    socialProviders ?? sdkConfig2.signIn?.socialProviders
+  );
+  const effectiveWallets = wallets ?? sdkConfig2.signIn?.wallets;
+  const effectiveInitialVisibleCount = initialVisibleCount ?? sdkConfig2.signIn?.initialVisibleCount ?? 5;
+  const [toastError, setToastError] = useState(null);
+  const {
+    expanded,
+    loadingProvider,
+    loadingWalletId,
+    visibleWallets,
+    showExpandToggle,
+    isBusy,
+    handleSocialClick,
+    handleWalletClick,
+    toggleExpanded
+  } = useSignInModalController({
+    wallets: effectiveWallets,
+    initialVisibleCount: effectiveInitialVisibleCount,
+    onGoogleLogin,
+    onTwitterLogin,
+    onCubeSignerSession,
+    onWalletConnected,
+    onSocialLogin,
+    onWalletSelect
+  });
+  return /* @__PURE__ */ jsxs(
+    SignInModalFrame,
+    {
+      id: "SignInModalFrame",
+      title,
+      onClose: onDismiss,
+      footer: /* @__PURE__ */ jsx(
+        SignInModalFooter,
+        {
+          privacyPolicyUrl,
+          termsOfUseUrl
+        }
+      ),
+      children: [
+        toastError ? /* @__PURE__ */ jsx(
+          Toast,
+          {
+            message: toastError,
+            variant: "error",
+            duration: 5e3,
+            onClose: () => setToastError(null)
+          }
+        ) : null,
+        /* @__PURE__ */ jsx(
+          SignInModalSocialSection,
+          {
+            id: "SignInModalSocialSection",
+            socialProviders: effectiveSocialProviders,
+            isBusy,
+            loadingProvider,
+            onSocialClick: async (providerId) => {
+              try {
+                const session = await handleSocialClick(providerId);
+                if (!session) return;
+                const normalizedAuthSource = providerId === "x" ? "twitter" : providerId;
+                onSuccess?.({
+                  ...session,
+                  walletType: session.walletType ?? "social",
+                  authSource: session.authSource ?? normalizedAuthSource
+                });
+              } catch (error) {
+                const msg = error instanceof Error ? error.message : "Social login failed";
+                setToastError(msg);
+              }
+            }
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          SignInModalWalletGrid,
+          {
+            wallets: visibleWallets,
+            isBusy,
+            loadingWalletId,
+            expanded,
+            showExpandToggle,
+            onWalletClick: async (walletId) => {
+              try {
+                const session = await handleWalletClick(walletId);
+                if (session) {
+                  onSuccess?.(session);
+                }
+              } catch (error) {
+                const msg = error instanceof Error ? error.message : "Wallet connect failed";
+                setToastError(msg);
+              }
+            },
+            onToggleExpanded: toggleExpanded
+          }
+        )
+      ]
+    }
+  );
+};
+var placeholderIcon = (label) => /* @__PURE__ */ jsx(
+  "div",
+  {
+    style: {
+      width: 40,
+      height: 40,
+      borderRadius: "12px",
+      background: colors.cardRaised,
+      display: "flex",
+      alignItems: "center",
+      justifyContent: "center",
+      color: colors.textSecondary,
+      fontWeight: 600
+    },
+    children: label.slice(0, 2).toUpperCase()
+  }
+);
+var WalletSelectionModal = ({
+  title = "Connect Wallet",
+  options,
+  onSelect
+}) => {
+  const sections = [
+    {
+      id: "social",
+      label: "Social Wallets",
+      items: options.filter((item) => item.category === "social")
+    },
+    {
+      id: "plugin",
+      label: "Plugin Wallets",
+      items: options.filter((item) => item.category === "plugin")
+    }
+  ].filter((section) => section.items.length > 0);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      style: {
+        width: "min(720px, 90vw)",
+        background: colors.card,
+        borderRadius: radii.xl,
+        border: `1px solid ${colors.border}`,
+        padding: "40px",
+        display: "flex",
+        flexDirection: "column",
+        gap: 32,
+        color: colors.textPrimary,
+        fontFamily: fonts.family
+      },
+      children: [
+        /* @__PURE__ */ jsxs("div", { children: [
+          /* @__PURE__ */ jsx("div", { style: { fontSize: 26, fontWeight: 600 }, children: title }),
+          /* @__PURE__ */ jsx("p", { style: { color: colors.textSecondary, marginTop: 8 }, children: "Choose social or plugin wallets" })
+        ] }),
+        sections.map((section) => /* @__PURE__ */ jsxs("section", { style: { display: "flex", flexDirection: "column", gap: 16 }, children: [
+          /* @__PURE__ */ jsx("div", { style: { fontSize: 14, textTransform: "uppercase", letterSpacing: 1.5, color: colors.textSecondary }, children: section.label }),
+          /* @__PURE__ */ jsx(
+            "div",
+            {
+              style: {
+                display: "grid",
+                gap: 16,
+                gridTemplateColumns: "repeat(auto-fit, minmax(220px, 1fr))"
+              },
+              children: section.items.map((option) => /* @__PURE__ */ jsxs(
+                "button",
+                {
+                  onClick: () => onSelect?.(option.id),
+                  style: {
+                    borderRadius: radii.lg,
+                    border: `1px solid ${colors.border}`,
+                    background: colors.cardRaised,
+                    padding: "20px",
+                    display: "flex",
+                    gap: 14,
+                    alignItems: "center",
+                    textAlign: "left",
+                    cursor: "pointer",
+                    color: colors.textPrimary
+                  },
+                  children: [
+                    option.icon ?? placeholderIcon(option.label),
+                    /* @__PURE__ */ jsxs("div", { children: [
+                      /* @__PURE__ */ jsx("div", { style: { fontWeight: 600 }, children: option.label }),
+                      /* @__PURE__ */ jsx("div", { style: { color: colors.textSecondary, fontSize: 14 }, children: option.description })
+                    ] })
+                  ]
+                },
+                option.id
+              ))
+            }
+          )
+        ] }, section.id))
+      ]
+    }
+  );
+};
+var StepIndicator = ({ steps, stepActive, activeStep = 0 }) => {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        width: 20,
+        paddingTop: 4,
+        flexShrink: 0
+      },
+      children: Array.from({ length: steps }, (_, i) => {
+        const isActive = stepActive && stepActive.length > i ? stepActive[i] : i <= activeStep;
+        const isLast = i === steps - 1;
+        return /* @__PURE__ */ jsxs("div", { style: { display: "flex", flexDirection: "column", alignItems: "center" }, children: [
+          /* @__PURE__ */ jsx(
+            "div",
+            {
+              style: {
+                width: 20,
+                height: 20,
+                borderRadius: "50%",
+                border: `2px solid ${isActive ? colors.stepActive : colors.stepInactive}`,
+                display: "flex",
+                alignItems: "center",
+                justifyContent: "center",
+                boxSizing: "border-box"
+              },
+              children: /* @__PURE__ */ jsx(
+                "div",
+                {
+                  style: {
+                    width: 7.5,
+                    height: 7.5,
+                    borderRadius: "50%",
+                    background: isActive ? colors.stepActive : colors.stepInactive
+                  }
+                }
+              )
+            }
+          ),
+          !isLast && /* @__PURE__ */ jsx(
+            "div",
+            {
+              style: {
+                width: 1,
+                height: 87,
+                background: isActive ? colors.stepActive : colors.stepInactive,
+                opacity: 0.3
+              }
+            }
+          )
+        ] }, i);
+      })
+    }
+  );
+};
+var Chevron = ({ up }) => /* @__PURE__ */ jsx(
+  "svg",
+  {
+    width: "16",
+    height: "16",
+    viewBox: "0 0 16 16",
+    fill: "none",
+    style: { transition: "transform .2s", transform: up ? "rotate(180deg)" : "none" },
+    children: /* @__PURE__ */ jsx("path", { d: "M4 6L8 10L12 6", stroke: colors.textSecondary, strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round" })
+  }
+);
+var DropdownField = ({
+  label,
+  placeholder,
+  value,
+  icon,
+  focused,
+  options,
+  onSelect,
+  onClick
+}) => {
+  const [open, setOpen] = useState(false);
+  const [triggerFocused, setTriggerFocused] = useState(false);
+  const ref = useRef(null);
+  useEffect(() => {
+    if (!open) return;
+    const handler = (e) => {
+      if (ref.current && !ref.current.contains(e.target)) setOpen(false);
+    };
+    document.addEventListener("mousedown", handler);
+    return () => document.removeEventListener("mousedown", handler);
+  }, [open]);
+  const hasOptions = options && options.length > 0;
+  const handleClick = () => {
+    if (hasOptions) {
+      setOpen((p) => !p);
+    } else {
+      onClick?.();
+    }
+  };
+  const handleSelect = (id) => {
+    onSelect?.(id);
+    setOpen(false);
+  };
+  const selected = hasOptions ? options.find((o) => o.id === value) : void 0;
+  return /* @__PURE__ */ jsxs("div", { ref, style: { display: "flex", flexDirection: "column", gap: 8, width: "100%", position: "relative" }, children: [
+    /* @__PURE__ */ jsx(
+      "span",
+      {
+        style: {
+          fontSize: 14,
+          fontWeight: 400,
+          lineHeight: 1.4,
+          color: colors.textPrimary,
+          fontFamily: fonts.family
+        },
+        children: label
+      }
+    ),
+    /* @__PURE__ */ jsxs(
+      "button",
+      {
+        type: "button",
+        onClick: handleClick,
+        onFocus: () => setTriggerFocused(true),
+        onBlur: () => setTriggerFocused(false),
+        style: {
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "space-between",
+          height: 44,
+          padding: "0 16px",
+          borderRadius: radii.input,
+          border: `1px solid ${open || triggerFocused ? colors.borderFocused : colors.border}`,
+          background: "transparent",
+          cursor: "pointer",
+          fontFamily: fonts.family,
+          width: "100%",
+          boxSizing: "border-box"
+        },
+        children: [
+          /* @__PURE__ */ jsxs("div", { style: { display: "flex", alignItems: "center", gap: 8 }, children: [
+            selected?.icon ?? icon,
+            /* @__PURE__ */ jsx(
+              "span",
+              {
+                style: {
+                  fontSize: 14,
+                  lineHeight: 1.4,
+                  color: value ? colors.textPrimary : colors.textSecondary,
+                  fontFamily: fonts.family
+                },
+                children: selected?.label ?? value ?? placeholder
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx(Chevron, { up: open })
+        ]
+      }
+    ),
+    open && hasOptions && /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: "dropdown-list-item",
+        style: {
+          position: "absolute",
+          top: "calc(100% + 4px)",
+          left: 0,
+          right: 0,
+          zIndex: 10,
+          borderRadius: radii.input,
+          border: `1px solid ${colors.border}`,
+          background: colors.card,
+          overflow: "hidden",
+          boxShadow: "0 8px 24px rgba(0,0,0,0.4)"
+        },
+        children: options.map((opt) => /* @__PURE__ */ jsxs(
+          "button",
+          {
+            type: "button",
+            onClick: () => handleSelect(opt.id),
+            style: {
+              display: "flex",
+              alignItems: "center",
+              gap: 10,
+              width: "100%",
+              padding: "10px 16px",
+              border: "none",
+              background: opt.id === value ? "rgba(255,255,255,0.06)" : "transparent",
+              cursor: "pointer",
+              fontFamily: fonts.family,
+              textAlign: "left",
+              transition: "background .12s"
+            },
+            onMouseEnter: (e) => {
+              e.currentTarget.style.background = "rgba(255,255,255,0.08)";
+            },
+            onMouseLeave: (e) => {
+              e.currentTarget.style.background = opt.id === value ? "rgba(255,255,255,0.06)" : "transparent";
+            },
+            children: [
+              opt.icon && /* @__PURE__ */ jsx("div", { style: { width: 28, height: 28, flexShrink: 0, display: "flex", alignItems: "center", justifyContent: "center" }, children: opt.icon }),
+              /* @__PURE__ */ jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 1 }, children: [
+                /* @__PURE__ */ jsx("span", { style: { fontSize: 14, fontWeight: 500, color: colors.textPrimary }, children: opt.label }),
+                opt.subtitle && /* @__PURE__ */ jsx("span", { style: { fontSize: 12, color: colors.textSecondary }, children: opt.subtitle })
+              ] })
+            ]
+          },
+          opt.id
+        ))
+      }
+    )
+  ] });
+};
+function getRemaining(expiresAt) {
+  const end = typeof expiresAt === "string" ? new Date(expiresAt).getTime() : expiresAt;
+  return Math.max(0, Math.floor((end - Date.now()) / 1e3));
+}
+function formatRemaining(seconds) {
+  const m = Math.floor(seconds / 60);
+  const s = seconds % 60;
+  return `${m}:${s.toString().padStart(2, "0")}`;
+}
+function Countdown({
+  expiresAt,
+  expiredLabel = "Expired",
+  style,
+  isExpired = false,
+  onExpired
+}) {
+  const [remaining, setRemaining] = useState(() => getRemaining(expiresAt));
+  const hasFiredExpired = useRef(false);
+  useEffect(() => {
+    hasFiredExpired.current = false;
+  }, [expiresAt]);
+  useEffect(() => {
+    if (isExpired) {
+      setRemaining(0);
+      return;
+    }
+    const tick = () => {
+      const r = getRemaining(expiresAt);
+      setRemaining(r);
+      if (r <= 0 && onExpired && !hasFiredExpired.current) {
+        hasFiredExpired.current = true;
+        onExpired();
+      }
+    };
+    tick();
+    const id = setInterval(tick, 1e3);
+    return () => clearInterval(id);
+  }, [expiresAt, isExpired, onExpired]);
+  const text = remaining <= 0 ? expiredLabel : formatRemaining(remaining);
+  const color = remaining <= 0 ? colors.warning : colors.textSecondary;
+  return /* @__PURE__ */ jsxs("span", { style: { fontSize: 12, color, fontFamily: fonts.family, ...style }, children: [
+    "Expires in ",
+    /* @__PURE__ */ jsx("span", { style: { fontWeight: 600, color: "#fff" }, children: text })
+  ] });
+}
+function generateMatrix(data) {
+  const qr = qrcode(0, "H");
+  qr.addData(data);
+  qr.make();
+  const count = qr.getModuleCount();
+  const matrix = [];
+  for (let r = 0; r < count; r++) {
+    const row = [];
+    for (let c = 0; c < count; c++) {
+      row.push(qr.isDark(r, c));
+    }
+    matrix.push(row);
+  }
+  return matrix;
+}
+function isFinderZone(row, col, size) {
+  return row < 7 && col < 7 || row < 7 && col >= size - 7 || row >= size - 7 && col < 7;
+}
+var FinderEye = ({ ox, oy, s }) => /* @__PURE__ */ jsxs(Fragment, { children: [
+  /* @__PURE__ */ jsx("rect", { x: ox, y: oy, width: 7 * s, height: 7 * s, rx: s * 1.4, ry: s * 1.4, fill: "#fff" }),
+  /* @__PURE__ */ jsx(
+    "rect",
+    {
+      x: ox + s,
+      y: oy + s,
+      width: 5 * s,
+      height: 5 * s,
+      rx: s * 0.9,
+      ry: s * 0.9,
+      fill: colors.background
+    }
+  ),
+  /* @__PURE__ */ jsx(
+    "rect",
+    {
+      x: ox + 2 * s,
+      y: oy + 2 * s,
+      width: 3 * s,
+      height: 3 * s,
+      rx: s * 0.7,
+      ry: s * 0.7,
+      fill: "#fff"
+    }
+  )
+] });
+var SVG_SIZE = 220;
+var QUIET_ZONE = 2;
+var StyledQR = ({ data }) => {
+  const matrix = useMemo(() => generateMatrix(data), [data]);
+  const n = matrix.length;
+  const total = n + QUIET_ZONE * 2;
+  const cell = SVG_SIZE / total;
+  const off = QUIET_ZONE * cell;
+  const dotR = cell * 0.42;
+  const centerClearR = 3;
+  const cx = n / 2;
+  const cy = n / 2;
+  const dots = [];
+  for (let r = 0; r < n; r++) {
+    for (let c = 0; c < n; c++) {
+      if (!matrix[r][c]) continue;
+      if (isFinderZone(r, c, n)) continue;
+      if (Math.abs(c - cx) < centerClearR && Math.abs(r - cy) < centerClearR) continue;
+      dots.push(
+        /* @__PURE__ */ jsx(
+          "circle",
+          {
+            cx: off + c * cell + cell / 2,
+            cy: off + r * cell + cell / 2,
+            r: dotR,
+            fill: "#fff"
+          },
+          `${r}-${c}`
+        )
+      );
+    }
+  }
+  return /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      width: SVG_SIZE,
+      height: SVG_SIZE,
+      viewBox: `0 0 ${SVG_SIZE} ${SVG_SIZE}`,
+      style: { borderRadius: 12 },
+      children: [
+        /* @__PURE__ */ jsx("rect", { width: SVG_SIZE, height: SVG_SIZE, fill: colors.background }),
+        /* @__PURE__ */ jsx(FinderEye, { ox: off, oy: off, s: cell }),
+        /* @__PURE__ */ jsx(FinderEye, { ox: off + (n - 7) * cell, oy: off, s: cell }),
+        /* @__PURE__ */ jsx(FinderEye, { ox: off, oy: off + (n - 7) * cell, s: cell }),
+        dots
+      ]
+    }
+  );
+};
+var CopyIcon = () => /* @__PURE__ */ jsxs("svg", { width: "14", height: "14", viewBox: "0 0 14 14", fill: "none", children: [
+  /* @__PURE__ */ jsx("rect", { x: "4.5", y: "4.5", width: "7", height: "7", rx: "1.5", stroke: colors.textPrimary, strokeWidth: "1.2" }),
+  /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M9.5 4.5V3.5C9.5 2.67 8.83 2 8 2H3.5C2.67 2 2 2.67 2 3.5V8C2 8.83 2.67 9.5 3.5 9.5H4.5",
+      stroke: colors.textPrimary,
+      strokeWidth: "1.2"
+    }
+  )
+] });
+var DepositDetailsPanel = ({
+  address,
+  tokenIcon,
+  minimumDeposit,
+  onCopyAddress
+}) => {
+  const canCopy = typeof address === "string" && address.trim().length > 0;
+  const handleCopy = async () => {
+    if (!canCopy) return;
+    try {
+      if (navigator.clipboard && typeof navigator.clipboard.writeText === "function") {
+        await navigator.clipboard.writeText(address);
+      } else {
+        const el = document.createElement("textarea");
+        el.value = address;
+        el.setAttribute("readonly", "");
+        el.style.position = "absolute";
+        el.style.left = "-9999px";
+        document.body.appendChild(el);
+        el.select();
+        try {
+          document.execCommand("copy");
+        } catch {
+        }
+        document.body.removeChild(el);
+      }
+    } finally {
+      onCopyAddress?.(address);
+    }
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        gap: 16,
+        padding: "20px",
+        borderRadius: radii.card,
+        border: `1px solid ${colors.border}`,
+        fontFamily: fonts.family
+      },
+      children: [
+        /* @__PURE__ */ jsxs("div", { style: { position: "relative", display: "inline-flex" }, children: [
+          /* @__PURE__ */ jsx(StyledQR, { data: address }),
+          tokenIcon && /* @__PURE__ */ jsx(
+            "div",
+            {
+              style: {
+                position: "absolute",
+                top: "50%",
+                left: "50%",
+                transform: "translate(-50%, -50%)",
+                width: 36,
+                height: 36,
+                borderRadius: "50%",
+                background: "#3B5998",
+                display: "flex",
+                alignItems: "center",
+                justifyContent: "center",
+                boxShadow: `0 0 0 3px ${colors.background}`
+              },
+              children: tokenIcon
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx("div", { style: { width: "100%", display: "flex", flexDirection: "column", gap: 8 }, children: /* @__PURE__ */ jsx(
+          "div",
+          {
+            style: {
+              padding: "10px 14px",
+              borderRadius: radii.input,
+              background: "rgba(255,255,255,0.05)",
+              fontSize: 13,
+              color: colors.textPrimary,
+              wordBreak: "break-all",
+              lineHeight: 1.5
+            },
+            children: address
+          }
+        ) }),
+        minimumDeposit && /* @__PURE__ */ jsxs(
+          "div",
+          {
+            style: {
+              width: "100%",
+              display: "flex",
+              justifyContent: "space-between",
+              fontSize: 13
+            },
+            children: [
+              /* @__PURE__ */ jsx("span", { style: { color: colors.textSecondary }, children: "Minimum deposit" }),
+              /* @__PURE__ */ jsx("span", { style: { color: colors.textPrimary, fontWeight: 500 }, children: minimumDeposit })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          "button",
+          {
+            type: "button",
+            onClick: handleCopy,
+            disabled: !canCopy,
+            style: {
+              display: "flex",
+              alignItems: "center",
+              gap: 6,
+              padding: "10px 28px",
+              borderRadius: radii.pill,
+              border: `1px solid ${colors.borderStrong}`,
+              background: "transparent",
+              color: colors.textPrimary,
+              fontSize: 14,
+              fontWeight: 500,
+              cursor: canCopy ? "pointer" : "not-allowed",
+              opacity: canCopy ? 1 : 0.6,
+              fontFamily: fonts.family,
+              transition: "background .15s"
+            },
+            onMouseEnter: (e) => {
+              if (!canCopy) return;
+              e.currentTarget.style.background = "rgba(255,255,255,0.06)";
+            },
+            onMouseLeave: (e) => {
+              e.currentTarget.style.background = "transparent";
+            },
+            children: [
+              /* @__PURE__ */ jsx(CopyIcon, {}),
+              "Copy address"
+            ]
+          }
+        )
+      ]
+    }
+  );
+};
+var LockIcon = () => /* @__PURE__ */ jsxs("svg", { width: "48", height: "48", viewBox: "0 0 48 48", fill: "none", children: [
+  /* @__PURE__ */ jsx("rect", { x: "10", y: "22", width: "28", height: "20", rx: "4", stroke: colors.textSecondary, strokeWidth: "2" }),
+  /* @__PURE__ */ jsx("path", { d: "M16 22V16C16 11.5817 19.5817 8 24 8C28.4183 8 32 11.5817 32 16V22", stroke: colors.textSecondary, strokeWidth: "2", strokeLinecap: "round" }),
+  /* @__PURE__ */ jsx("circle", { cx: "24", cy: "33", r: "3", fill: colors.textSecondary })
+] });
+var LoginRequiredOverlay = ({
+  title,
+  onSignIn,
+  onClose
+}) => /* @__PURE__ */ jsx(ModalFrame, { onClose, contentStyle: { padding: "48px 24px" }, children: /* @__PURE__ */ jsxs(
+  "div",
+  {
+    style: {
+      display: "flex",
+      flexDirection: "column",
+      alignItems: "center",
+      gap: 24,
+      textAlign: "center"
+    },
+    children: [
+      /* @__PURE__ */ jsx(LockIcon, {}),
+      /* @__PURE__ */ jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 8 }, children: [
+        /* @__PURE__ */ jsx(
+          "h2",
+          {
+            style: {
+              margin: 0,
+              fontSize: 20,
+              fontWeight: 600,
+              color: colors.textPrimary
+            },
+            children: title
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "p",
+          {
+            style: {
+              margin: 0,
+              fontSize: 14,
+              color: colors.textSecondary,
+              lineHeight: 1.5
+            },
+            children: "Please sign in to continue"
+          }
+        )
+      ] }),
+      onSignIn && /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          onClick: onSignIn,
+          style: {
+            padding: "12px 48px",
+            borderRadius: radii.full,
+            border: "none",
+            background: colors.textPrimary,
+            color: "#15181D",
+            fontSize: 16,
+            fontWeight: 500,
+            fontFamily: fonts.family,
+            cursor: "pointer"
+          },
+          children: "Sign In"
+        }
+      )
+    ]
+  }
+) });
+function useSession() {
+  const [session, setSession] = useState(
+    () => sessionStore.getState().session
+  );
+  useEffect(() => {
+    const unsub = sessionStore.on("session:changed", setSession);
+    return () => {
+      unsub();
+    };
+  }, []);
+  return session;
+}
+var BackArrow = () => /* @__PURE__ */ jsx("svg", { width: "24", height: "24", viewBox: "0 0 24 24", fill: "none", children: /* @__PURE__ */ jsx("path", { d: "M15 6L9 12L15 18", stroke: colors.textPrimary, strokeWidth: "1.5", strokeLinecap: "round", strokeLinejoin: "round" }) });
+var TransferIcon = () => /* @__PURE__ */ jsxs("svg", { width: "36", height: "36", viewBox: "0 0 36 36", fill: "none", children: [
+  /* @__PURE__ */ jsx("circle", { cx: "18", cy: "18", r: "18", fill: "rgba(255,255,255,0.08)" }),
+  /* @__PURE__ */ jsx("circle", { cx: "18", cy: "18", r: "7", stroke: colors.textPrimary, strokeWidth: "1.5" }),
+  /* @__PURE__ */ jsx("circle", { cx: "18", cy: "18", r: "2.5", fill: colors.textPrimary }),
+  /* @__PURE__ */ jsx("path", { d: "M18 7V11", stroke: colors.textPrimary, strokeWidth: "1.5", strokeLinecap: "round" }),
+  /* @__PURE__ */ jsx("path", { d: "M18 25V29", stroke: colors.textPrimary, strokeWidth: "1.5", strokeLinecap: "round" }),
+  /* @__PURE__ */ jsx("path", { d: "M7 18H11", stroke: colors.textPrimary, strokeWidth: "1.5", strokeLinecap: "round" }),
+  /* @__PURE__ */ jsx("path", { d: "M25 18H29", stroke: colors.textPrimary, strokeWidth: "1.5", strokeLinecap: "round" })
+] });
+var FiatIcon = () => /* @__PURE__ */ jsxs("svg", { width: "36", height: "36", viewBox: "0 0 36 36", fill: "none", children: [
+  /* @__PURE__ */ jsx("circle", { cx: "18", cy: "18", r: "18", fill: "rgba(255,255,255,0.06)" }),
+  /* @__PURE__ */ jsx("circle", { cx: "18", cy: "18", r: "10", stroke: colors.textSecondary, strokeWidth: "1.5" }),
+  /* @__PURE__ */ jsx("path", { d: "M18 12V24", stroke: colors.textSecondary, strokeWidth: "1.5", strokeLinecap: "round" }),
+  /* @__PURE__ */ jsx("path", { d: "M15 15.5C15 14.12 16.34 13 18 13C19.66 13 21 14.12 21 15.5C21 16.88 19.66 18 18 18C16.34 18 15 19.12 15 20.5C15 21.88 16.34 23 18 23C19.66 23 21 21.88 21 20.5", stroke: colors.textSecondary, strokeWidth: "1.5", strokeLinecap: "round" })
+] });
+var DefaultCryptoIcons = () => {
+  const tokens = [
+    { label: "B", bg: "#F7931A" },
+    { label: "E", bg: "#627EEA" },
+    { label: "\u2261", bg: "#26A17B" },
+    { label: "$", bg: "#2775CA" },
+    { label: "S", bg: "#9945FF" },
+    { label: "A", bg: "#E84142" }
+  ];
+  return /* @__PURE__ */ jsx("div", { style: { display: "flex", gap: 0 }, children: tokens.map((t, i) => /* @__PURE__ */ jsx(
+    "div",
+    {
+      style: {
+        width: 24,
+        height: 24,
+        borderRadius: "50%",
+        background: t.bg,
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        fontSize: 11,
+        fontWeight: 700,
+        color: "#fff",
+        marginLeft: i > 0 ? -4 : 0,
+        border: `2px solid ${colors.card}`,
+        boxSizing: "content-box"
+      },
+      children: t.label
+    },
+    i
+  )) });
+};
+function chainsToTokenOptions(chains) {
+  const bySymbol = /* @__PURE__ */ new Map();
+  for (const c of chains) {
+    for (const t of c.tokens) {
+      if (!bySymbol.has(t.symbol)) bySymbol.set(t.symbol, { symbol: t.symbol, decimals: t.decimals });
+    }
+  }
+  return Array.from(bySymbol.entries()).map(([id, { symbol }]) => ({
+    id,
+    label: symbol,
+    subtitle: symbol
+  }));
+}
+function chainsToChainOptionsForToken(chains, tokenSymbol) {
+  return chains.filter((c) => c.tokens.some((t) => t.symbol === tokenSymbol)).map((c) => ({
+    id: c.chain_id,
+    label: c.network,
+    subtitle: `chainId: ${c.chain_id}`,
+    icon: /* @__PURE__ */ jsx(
+      "span",
+      {
+        style: {
+          display: "inline-flex",
+          alignItems: "center",
+          justifyContent: "center",
+          minWidth: 28,
+          height: 28,
+          padding: "0 6px",
+          borderRadius: radii.card,
+          background: "rgba(255,255,255,0.08)",
+          fontSize: 12,
+          fontWeight: 600,
+          color: colors.textPrimary,
+          fontFamily: fonts.family
+        },
+        children: c.network
+      }
+    )
+  }));
+}
+function getTokenAddressForChain(chains, chainId, tokenSymbol) {
+  const chain = chains.find((c) => c.chain_id === chainId);
+  return chain?.tokens.find((t) => t.symbol === tokenSymbol)?.address;
+}
+var FUNDING_TOKEN_SYMBOL = getEnv("FUNDING_TOKEN_SYMBOL");
+var DepositModal = ({
+  token,
+  chain,
+  tokenOptions: tokenOptionsProp,
+  chainOptions: chainOptionsProp,
+  depositAddress,
+  minimumDeposit,
+  qrCenterIcon,
+  cryptoIcons,
+  depositAmount,
+  onShowToast,
+  txHash,
+  explorerTxUrl,
+  onTokenSelect,
+  onChainSelect,
+  onCopyAddress,
+  onBuyCrypto,
+  onSignIn,
+  onBack,
+  onClose
+}) => {
+  const session = useSession();
+  const [view, setView] = useState("entry");
+  const [copySuccessMessage, setCopySuccessMessage] = useState(null);
+  const [apiChains, setApiChains] = useState(null);
+  const [apiQuote, setApiQuote] = useState(null);
+  const [loadingChains, setLoadingChains] = useState(false);
+  const [loadingQuote, setLoadingQuote] = useState(false);
+  const [quoteRefreshKey, setQuoteRefreshKey] = useState(0);
+  const [internalDepositAddress, setInternalDepositAddress] = useState(void 0);
+  const lastEmittedAddressRef = useRef(void 0);
+  const lastEmittedChainRef = useRef(void 0);
+  const tokenOptions = useMemo(() => {
+    if (tokenOptionsProp?.length) return tokenOptionsProp;
+    if (!apiChains?.length) return void 0;
+    return chainsToTokenOptions(apiChains);
+  }, [tokenOptionsProp, apiChains]);
+  const chainOptions = useMemo(() => {
+    if (chainOptionsProp?.length) return chainOptionsProp;
+    if (!apiChains?.length || !token) return void 0;
+    return chainsToChainOptionsForToken(apiChains, token);
+  }, [chainOptionsProp, apiChains, token]);
+  useEffect(() => {
+    if (chainOptions?.length !== 1 || !onChainSelect) return;
+    const onlyId = chainOptions[0].id;
+    if (chain === onlyId) return;
+    onChainSelect(onlyId);
+  }, [chainOptions, chain, onChainSelect]);
+  useEffect(() => {
+    if (view !== "transfer") return;
+    setLoadingChains(true);
+    getChains().then((res) => setApiChains(res?.chains ?? {})).finally(() => setLoadingChains(false));
+  }, [view]);
+  useEffect(() => {
+    if (view !== "transfer") return;
+    if (!session?.address || !chain) return;
+    registerPlatform({
+      platform_contract_address: session.address,
+      chain_id: chain
+    }).then((res) => {
+      if (res?.deposit_address) {
+        setInternalDepositAddress(res.deposit_address);
+      }
+    }).catch(() => {
+    });
+  }, [view, chain, session?.address]);
+  useEffect(() => {
+    if (!apiChains?.length || !token || !chain) {
+      setApiQuote(null);
+      return;
+    }
+    const tokenAddress = getTokenAddressForChain(apiChains, chain, token);
+    if (!tokenAddress) {
+      setApiQuote(null);
+      return;
+    }
+    setLoadingQuote(true);
+    console.log("setLoadingQuote", tokenAddress, depositAmount);
+    quote({
+      direction: "deposit",
+      chain_id: chain,
+      token_address: tokenAddress,
+      token_amount: depositAmount || void 0
+    }).then((q) => setApiQuote(q ?? null)).catch((err) => {
+      const message = err?.message ?? String(err);
+      console.error("setLoadingQuote", message);
+      if (onShowToast) onShowToast(message);
+      setApiQuote({
+        token_address: tokenAddress,
+        token_symbol: token,
+        token_decimals: 18,
+        rate: "1",
+        chain_id: Number(chain) || 56,
+        deposit_address: "0x" + "0".repeat(39) + "1",
+        dst_token_amount: depositAmount ?? "0",
+        expires_at: new Date(Date.now() + 6e4).toISOString()
+      });
+    }).finally(() => setLoadingQuote(false));
+  }, [apiChains, token, chain, depositAmount, quoteRefreshKey, onShowToast]);
+  useEffect(() => {
+    if (!chain) return;
+    if (!depositAddress) return;
+    if (lastEmittedAddressRef.current === depositAddress && lastEmittedChainRef.current === chain) {
+      return;
+    }
+    lastEmittedAddressRef.current = depositAddress;
+    lastEmittedChainRef.current = chain;
+  }, [depositAddress, chain]);
+  const handleQuoteExpired = useCallback(() => {
+    setQuoteRefreshKey((k) => k + 1);
+  }, []);
+  useEffect(() => {
+    if (txHash && chain && onShowToast) {
+      onShowToast("Transfer confirmed");
+    }
+  }, [txHash, chain, onShowToast]);
+  if (!session) {
+    return /* @__PURE__ */ jsx(LoginRequiredOverlay, { title: "Deposit", onSignIn, onClose });
+  }
+  const goToEntry = () => {
+    setView("entry");
+    onBack?.();
+  };
+  const handleCopyAddress = useCallback((address) => {
+    onCopyAddress?.(address);
+    onShowToast?.("Address copied");
+    setCopySuccessMessage("Address copied");
+  }, [onCopyAddress, onShowToast]);
+  useEffect(() => {
+    if (!copySuccessMessage) return;
+    const t = setTimeout(() => setCopySuccessMessage(null), 2e3);
+    return () => clearTimeout(t);
+  }, [copySuccessMessage]);
+  return /* @__PURE__ */ jsxs(ModalFrame, { onClose, contentStyle: { padding: "24px", position: "relative" }, children: [
+    copySuccessMessage && /* @__PURE__ */ jsx(
+      "div",
+      {
+        style: {
+          position: "absolute",
+          bottom: 24,
+          left: "50%",
+          transform: "translateX(-50%)",
+          padding: "10px 20px",
+          borderRadius: 8,
+          background: "var(--pm-colors-card, #1a1a2e)",
+          color: "var(--pm-colors-textPrimary, #fff)",
+          fontSize: 13,
+          fontWeight: 500,
+          boxShadow: "0 4px 12px rgba(0,0,0,.25)",
+          zIndex: 10
+        },
+        children: copySuccessMessage
+      }
+    ),
+    view === "entry" ? /* @__PURE__ */ jsx(
+      EntryView,
+      {
+        cryptoIcons,
+        onTransferCrypto: () => setView("transfer"),
+        onBuyCrypto
+      }
+    ) : /* @__PURE__ */ jsx(
+      TransferView,
+      {
+        token,
+        chain,
+        tokenOptions,
+        chainOptions,
+        depositAddress: depositAddress ?? internalDepositAddress,
+        minimumDeposit,
+        qrCenterIcon,
+        quote: apiQuote,
+        quoteLoading: loadingQuote,
+        txHash,
+        chainIdForExplorer: chain,
+        explorerTxUrl,
+        loadingChains,
+        onTokenSelect,
+        onChainSelect,
+        onCopyAddress: handleCopyAddress,
+        onQuoteExpired: handleQuoteExpired,
+        onRefreshQuote: () => {
+          if (!apiChains?.length || !token || !chain) return;
+          const tokenAddress = getTokenAddressForChain(apiChains, chain, token);
+          if (tokenAddress) {
+            setLoadingQuote(true);
+            quote({ direction: "deposit", chain_id: chain, token_address: tokenAddress, token_amount: depositAmount }).then((q) => setApiQuote(q ?? null)).catch(() => {
+              setApiQuote({
+                token_address: tokenAddress,
+                token_symbol: token,
+                token_decimals: 18,
+                rate: "1",
+                chain_id: Number(chain) || 56,
+                deposit_address: "0x" + "0".repeat(39) + "1",
+                dst_token_amount: depositAmount ?? "0",
+                expires_at: new Date(Date.now() + 6e4).toISOString()
+              });
+            }).finally(() => setLoadingQuote(false));
+          }
+        },
+        onShowToast,
+        onBack: goToEntry
+      }
+    )
+  ] });
+};
+var EntryView = ({
+  cryptoIcons,
+  onTransferCrypto,
+  onBuyCrypto: _onBuyCrypto
+}) => /* @__PURE__ */ jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 24 }, children: [
+  /* @__PURE__ */ jsx("h2", { style: { margin: 0, fontSize: 24, fontWeight: 600, lineHeight: 1.4 }, children: "Deposit" }),
+  /* @__PURE__ */ jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 12 }, children: [
+    /* @__PURE__ */ jsxs(
+      "button",
+      {
+        type: "button",
+        onClick: onTransferCrypto,
+        style: {
+          display: "flex",
+          alignItems: "center",
+          gap: 14,
+          padding: "18px 20px",
+          borderRadius: radii.card,
+          border: `1px solid ${colors.border}`,
+          background: "transparent",
+          cursor: "pointer",
+          textAlign: "left",
+          fontFamily: fonts.family,
+          width: "100%",
+          transition: "border-color .15s"
+        },
+        onMouseEnter: (e) => {
+          e.target.closest("button").style.borderColor = colors.borderStrong;
+        },
+        onMouseLeave: (e) => {
+          e.target.closest("button").style.borderColor = colors.border;
+        },
+        children: [
+          /* @__PURE__ */ jsx(TransferIcon, {}),
+          /* @__PURE__ */ jsxs("div", { style: { flex: 1, display: "flex", flexDirection: "column", gap: 2 }, children: [
+            /* @__PURE__ */ jsx("span", { style: { color: colors.textPrimary, fontSize: 16, fontWeight: 600 }, children: "Transfer Crypto" }),
+            /* @__PURE__ */ jsx("span", { style: { color: colors.textSecondary, fontSize: 13 }, children: "No limit \xB7 Instant" })
+          ] }),
+          cryptoIcons ?? /* @__PURE__ */ jsx(DefaultCryptoIcons, {})
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs(
+      "div",
+      {
+        style: {
+          display: "flex",
+          alignItems: "center",
+          gap: 14,
+          padding: "18px 20px",
+          borderRadius: radii.card,
+          border: `1px solid ${colors.border}`,
+          opacity: 0.55
+        },
+        children: [
+          /* @__PURE__ */ jsx(FiatIcon, {}),
+          /* @__PURE__ */ jsxs("div", { style: { flex: 1, display: "flex", flexDirection: "column", gap: 2 }, children: [
+            /* @__PURE__ */ jsx("span", { style: { color: colors.textSecondary, fontSize: 16, fontWeight: 600 }, children: "Buy Crypto" }),
+            /* @__PURE__ */ jsx("span", { style: { color: colors.textSecondary, fontSize: 13 }, children: "Debit card, credit card, ACH" })
+          ] }),
+          /* @__PURE__ */ jsx(
+            "span",
+            {
+              style: {
+                padding: "5px 12px",
+                borderRadius: radii.pill,
+                border: `1px solid ${colors.border}`,
+                fontSize: 12,
+                fontWeight: 500,
+                color: colors.textSecondary,
+                whiteSpace: "nowrap"
+              },
+              children: "Coming Soon"
+            }
+          )
+        ]
+      }
+    )
+  ] })
+] });
+var TransferView = ({
+  token,
+  chain,
+  tokenOptions,
+  chainOptions,
+  depositAddress,
+  minimumDeposit,
+  qrCenterIcon,
+  quote: quoteData,
+  quoteLoading,
+  txHash,
+  chainIdForExplorer,
+  explorerTxUrl,
+  loadingChains,
+  onTokenSelect,
+  onChainSelect,
+  onCopyAddress,
+  onQuoteExpired,
+  onRefreshQuote,
+  onShowToast,
+  onBack
+}) => {
+  const activeStep = chain ? 2 : token ? 1 : 0;
+  const stepActive = [!!token, !!chain, !!quoteData];
+  const quoteExpired = useMemo(() => {
+    if (!quoteData?.expires_at) return false;
+    try {
+      return new Date(quoteData.expires_at).getTime() < Date.now();
+    } catch {
+      return false;
+    }
+  }, [quoteData?.expires_at]);
+  const didToastWait = useRef(false);
+  useEffect(() => {
+    if (!depositAddress || !onShowToast || didToastWait.current) return;
+    didToastWait.current = true;
+    onShowToast("Please wait for deposit-address balance to update");
+  }, [depositAddress, onShowToast]);
+  return /* @__PURE__ */ jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 24 }, children: [
+    /* @__PURE__ */ jsx("div", { style: { display: "flex", alignItems: "center", justifyContent: "space-between" }, children: /* @__PURE__ */ jsxs("div", { style: { display: "flex", alignItems: "center", gap: 12 }, children: [
+      onBack && /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          onClick: onBack,
+          style: {
+            background: "transparent",
+            border: "none",
+            cursor: "pointer",
+            padding: 0,
+            display: "flex",
+            alignItems: "center"
+          },
+          children: /* @__PURE__ */ jsx(BackArrow, {})
+        }
+      ),
+      /* @__PURE__ */ jsx("h2", { style: { margin: 0, fontSize: 24, fontWeight: 600, lineHeight: 1.4 }, children: "Transfer Crypto" })
+    ] }) }),
+    /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: 16, position: "relative" }, children: [
+      /* @__PURE__ */ jsx(StepIndicator, { steps: 3, stepActive, activeStep }),
+      /* @__PURE__ */ jsxs("div", { style: { flex: 1, display: "flex", flexDirection: "column", gap: 40 }, children: [
+        /* @__PURE__ */ jsx(
+          DropdownField,
+          {
+            label: "Select token",
+            placeholder: loadingChains ? "Loading\u2026" : "Token",
+            value: token,
+            options: tokenOptions,
+            onSelect: onTokenSelect
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          DropdownField,
+          {
+            label: "Select chain",
+            placeholder: loadingChains ? "Loading\u2026" : "Chain",
+            value: chain,
+            options: chainOptions,
+            onSelect: onChainSelect
+          }
+        ),
+        quoteData && token && chain && /* @__PURE__ */ jsx(
+          "div",
+          {
+            id: "quote-panel",
+            style: {
+              padding: "12px 16px",
+              borderRadius: radii.card,
+              margin: "-10px 0",
+              border: `1px solid ${colors.border}`,
+              display: "flex",
+              flexDirection: "column",
+              gap: 8
+            },
+            children: quoteLoading ? /* @__PURE__ */ jsx("span", { style: { fontSize: 13, color: colors.textSecondary }, children: "Loading\u2026" }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+              /* @__PURE__ */ jsxs("span", { style: { fontSize: 13, color: colors.textSecondary }, children: [
+                "1 ",
+                quoteData.token_symbol,
+                " = ",
+                quoteData.rate,
+                " ",
+                FUNDING_TOKEN_SYMBOL
+              ] }),
+              quoteData.expires_at && /* @__PURE__ */ jsx(
+                Countdown,
+                {
+                  expiresAt: quoteData.expires_at,
+                  isExpired: quoteExpired,
+                  onExpired: onQuoteExpired
+                }
+              ),
+              quoteExpired && /* @__PURE__ */ jsxs("div", { style: { display: "flex", alignItems: "center", gap: 8 }, children: [
+                /* @__PURE__ */ jsx("span", { style: { fontSize: 13, color: "#f59e0b" }, children: "Quote expired, please refresh" }),
+                onRefreshQuote && /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    type: "button",
+                    onClick: onRefreshQuote,
+                    style: {
+                      padding: "4px 12px",
+                      fontSize: 12,
+                      borderRadius: radii.pill,
+                      border: `1px solid ${colors.border}`,
+                      background: "transparent",
+                      color: colors.textPrimary,
+                      cursor: "pointer",
+                      fontFamily: fonts.family
+                    },
+                    children: "Refresh"
+                  }
+                )
+              ] })
+            ] })
+          }
+        ),
+        /* @__PURE__ */ jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 8, marginTop: "-5px" }, id: "deposit-details", children: [
+          /* @__PURE__ */ jsx("span", { style: { fontSize: 14, lineHeight: 1.4, color: colors.textPrimary }, children: "Deposit details" }),
+          depositAddress ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(
+              DepositDetailsPanel,
+              {
+                address: depositAddress,
+                tokenIcon: qrCenterIcon,
+                minimumDeposit,
+                onCopyAddress
+              }
+            ),
+            txHash && chainIdForExplorer && explorerTxUrl && /* @__PURE__ */ jsx(
+              "a",
+              {
+                href: explorerTxUrl(chainIdForExplorer, txHash),
+                target: "_blank",
+                rel: "noopener noreferrer",
+                style: {
+                  fontSize: 13,
+                  color: colors.textPrimary,
+                  textDecoration: "underline"
+                },
+                children: "View on explorer"
+              }
+            )
+          ] }) : /* @__PURE__ */ jsx(
+            "div",
+            {
+              style: {
+                padding: "20px",
+                borderRadius: radii.card,
+                border: `1px solid ${colors.border}`,
+                color: colors.textSecondary,
+                fontSize: 13,
+                textAlign: "center"
+              },
+              children: "Select token and chain to view deposit details"
+            }
+          )
+        ] })
+      ] })
+    ] })
+  ] });
+};
+
+// src/utils/explorer.ts
+var explorerTemplates = {
+  "0": "",
+  "1": "https://etherscan.io/tx/{txId}",
+  "3": "https://dogechain.info/tx/{txId}",
+  "10": "https://optimistic.etherscan.io/tx/{txId}",
+  "56": "https://bscscan.com/tx/{txId}",
+  "110": "",
+  "126": "https://explorer.movementnetwork.xyz/txn/{txId}?network=mainnet",
+  "137": "https://polygonscan.com/tx/{txId}",
+  "204": "https://opbnb.bscscan.com/tx/{txId}",
+  "223": "https://explorer.bsquared.network/tx/{txId}",
+  "227": "https://promscan.io/tx/{txId}",
+  "324": "https://mainnet.era.zksync.io/tx/{txId}",
+  "400": "",
+  "420": "https://scan.merlinchain.io/tx/{txId}",
+  "480": "https://worldchain-mainnet.explorer.alchemy.com/tx/{txId}",
+  "501": "https://solscan.io/tx/{txId}",
+  "784": "",
+  "1329": "https://seitrace.com/tx/{txId}",
+  "1514": "https://mainnet.storyscan.xyz/tx/{txId}",
+  "1625": "https://explorer.gravity.xyz/tx/{txId}",
+  "2649": "https://mainnet-explorer.ailayer.xyz/tx/{txId}",
+  "3030": "https://dashboard.tenderly.co/explorer/vnet/bd8df763-9888-4be3-9a78-26f1d5ab8d3d/tx/{txId}",
+  "3131": "https://dashboard.tenderly.co/explorer/vnet/6593bc72-f548-497d-bff9-5be061436a48/tx/{txId}",
+  "5545": "https://scan.duckchain.io/tx/{txId}",
+  "8333": "https://mainnet-rpc.b3.fun/http/tx/{txId}",
+  "8453": "https://base.blockscout.com/tx/{txId}",
+  "19484": "https://tronscan.org/#/transaction/{txId}",
+  "21000": "https://maizenet-explorer.usecorn.com/tx/{txId}",
+  "42161": "https://arbiscan.io/tx/{txId}",
+  "43114": "https://snowtrace.io/tx/{txId}",
+  "47763": "https://neotube.io/transaction/{txId}",
+  "59144": "https://lineascan.build/tx/{txId}",
+  "60808": "https://rpc.gobob.xyz/tx/{txId}",
+  "80094": "https://berascan.com/tx/{txId}",
+  "81457": "https://blastscan.io/tx/{txId}",
+  "200901": "https://rpc.bitlayer.org/tx/{txId}",
+  "221122420": "https://blockscout.devnet.doge.xyz/tx/{txId}",
+  "534352": "https://scrollscan.com/tx/{txId}"
+};
+function getExplorerUrl(chainId, data) {
+  const template = explorerTemplates[chainId] ?? "";
+  if (template === "") {
+    throw new Error(`chainId ${chainId} tpl not found`);
+  }
+  return template.replace("{txId}", data.txId);
+}
+var SuccessIcon = () => {
+  return /* @__PURE__ */ jsxs("svg", { width: "80", height: "81", viewBox: "0 0 80 81", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: [
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: "M40 80.5C62.0914 80.5 80 62.5914 80 40.5C80 18.4086 62.0914 0.5 40 0.5C17.9086 0.5 0 18.4086 0 40.5C0 62.5914 17.9086 80.5 40 80.5Z",
+        fill: "#627EEA"
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: "M38.999 16.5V34.2437L53.9962 40.9451L38.999 16.5Z",
+        fill: "white",
+        fillOpacity: "0.602"
+      }
+    ),
+    /* @__PURE__ */ jsx("path", { d: "M38.9991 16.5L24 40.9451L38.9991 34.2437V16.5Z", fill: "white" }),
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: "M38.999 52.4434V64.4999L54.0061 43.7376L38.999 52.4434Z",
+        fill: "white",
+        fillOpacity: "0.602"
+      }
+    ),
+    /* @__PURE__ */ jsx("path", { d: "M38.9991 64.4999V52.4414L24 43.7376L38.9991 64.4999Z", fill: "white" }),
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: "M38.999 49.653L53.9962 40.9451L38.999 34.2477V49.653Z",
+        fill: "white",
+        fillOpacity: "0.2"
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: "M24 40.9451L38.9991 49.653V34.2477L24 40.9451Z",
+        fill: "white",
+        fillOpacity: "0.602"
+      }
+    ),
+    /* @__PURE__ */ jsx("g", { filter: "url(#filter0_ii_34_1690)", children: /* @__PURE__ */ jsx("circle", { cx: "40", cy: "40", r: "40", fill: "url(#paint0_linear_34_1690)" }) }),
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: "M25.8057 35.9858L38.7921 49.0324L56.7734 30.9678",
+        stroke: "#58AE36",
+        strokeWidth: "5.16129",
+        fill: "none"
+      }
+    ),
+    /* @__PURE__ */ jsxs("defs", { children: [
+      /* @__PURE__ */ jsxs(
+        "filter",
+        {
+          id: "filter0_ii_34_1690",
+          x: "0",
+          y: "0",
+          width: "80",
+          height: "80",
+          filterUnits: "userSpaceOnUse",
+          colorInterpolationFilters: "sRGB",
+          children: [
+            /* @__PURE__ */ jsx("feFlood", { floodOpacity: "0", result: "BackgroundImageFix" }),
+            /* @__PURE__ */ jsx("feBlend", { mode: "normal", in: "SourceGraphic", in2: "BackgroundImageFix", result: "shape" }),
+            /* @__PURE__ */ jsx(
+              "feColorMatrix",
+              {
+                in: "SourceAlpha",
+                type: "matrix",
+                values: "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0",
+                result: "hardAlpha"
+              }
+            ),
+            /* @__PURE__ */ jsx("feOffset", { dx: "-1.29032", dy: "-1.29032" }),
+            /* @__PURE__ */ jsx("feComposite", { in2: "hardAlpha", operator: "arithmetic", k2: "-1", k3: "1" }),
+            /* @__PURE__ */ jsx(
+              "feColorMatrix",
+              {
+                type: "matrix",
+                values: "0 0 0 0 0.584745 0 0 0 0 1 0 0 0 0 0.420982 0 0 0 1 0"
+              }
+            ),
+            /* @__PURE__ */ jsx("feBlend", { mode: "multiply", in2: "shape", result: "effect1_innerShadow_34_1690" }),
+            /* @__PURE__ */ jsx(
+              "feColorMatrix",
+              {
+                in: "SourceAlpha",
+                type: "matrix",
+                values: "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0",
+                result: "hardAlpha"
+              }
+            ),
+            /* @__PURE__ */ jsx("feOffset", { dx: "1.29032", dy: "1.29032" }),
+            /* @__PURE__ */ jsx("feComposite", { in2: "hardAlpha", operator: "arithmetic", k2: "-1", k3: "1" }),
+            /* @__PURE__ */ jsx("feColorMatrix", { type: "matrix", values: "0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0" }),
+            /* @__PURE__ */ jsx("feBlend", { mode: "normal", in2: "effect1_innerShadow_34_1690", result: "effect2_innerShadow_34_1690" })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxs(
+        "linearGradient",
+        {
+          id: "paint0_linear_34_1690",
+          x1: "27.4722",
+          y1: "7.62951",
+          x2: "70.4313",
+          y2: "26.563",
+          gradientUnits: "userSpaceOnUse",
+          children: [
+            /* @__PURE__ */ jsx("stop", { stopColor: "#BBFFA1" }),
+            /* @__PURE__ */ jsx("stop", { offset: "1", stopColor: "#ACFE8B" })
+          ]
+        }
+      )
+    ] })
+  ] });
+};
+function CopyIcon2() {
+  return /* @__PURE__ */ jsxs("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": true, children: [
+    /* @__PURE__ */ jsx("rect", { x: "5", y: "5", width: "9", height: "9", rx: "1", stroke: "currentColor", strokeWidth: "1.2", fill: "none" }),
+    /* @__PURE__ */ jsx("path", { d: "M3 11V3a1 1 0 0 1 1-1h8", stroke: "currentColor", strokeWidth: "1.2", fill: "none" })
+  ] });
+}
+var FUNDING_TOKEN_SYMBOL2 = getEnv("FUNDING_TOKEN_SYMBOL");
+function chainsToTokenOptions2(chains) {
+  const bySymbol = /* @__PURE__ */ new Map();
+  for (const c of chains) {
+    for (const t of c.tokens) {
+      if (!bySymbol.has(t.symbol)) bySymbol.set(t.symbol, t.symbol);
+    }
+  }
+  return Array.from(bySymbol.entries()).map(([id, symbol]) => ({
+    id,
+    label: symbol,
+    subtitle: symbol
+  }));
+}
+function chainsToChainOptionsForToken2(chains, tokenSymbol) {
+  return chains.filter((c) => c.tokens.some((t) => t.symbol === tokenSymbol)).map((c) => ({ id: c.chain_id, label: c.network, subtitle: c.chain_id }));
+}
+function getTokenAddressForChain2(chains, chainId, tokenSymbol) {
+  const chain = chains.find((c) => c.chain_id === chainId);
+  return chain?.tokens.find((t) => t.symbol === tokenSymbol)?.address;
+}
+function parseBalanceNumber(balance) {
+  const match = balance.trim().match(/^(\d*\.?\d*)/);
+  if (!match) return null;
+  const n = Number(match[1]);
+  return Number.isNaN(n) ? null : n;
+}
+function formatBalanceTo2Decimals(balance) {
+  const match = balance.trim().match(/^(\d*\.?\d*)(.*)$/);
+  if (!match) return balance;
+  const numPart = match[1];
+  const suffix = match[2].trim() ? " " + match[2].trim() : "";
+  const n = Number(numPart);
+  if (Number.isNaN(n)) return balance;
+  const formatted = n.toFixed(2);
+  return formatted + suffix;
+}
+function weiToEtherDisplay(wei) {
+  const s = (wei || "0").trim().replace(/^0+/, "") || "0";
+  if (s === "0") return "0";
+  const padded = s.padStart(19, "0");
+  const intPart = padded.slice(0, Math.max(0, padded.length - 18));
+  const decPart = padded.slice(-18).replace(/0+$/, "");
+  const combined = decPart ? `${intPart}.${decPart}` : intPart;
+  const num = Number(combined);
+  if (Number.isNaN(num)) return wei;
+  const fixed = num.toFixed(6).replace(/\.?0+$/, "");
+  return fixed;
+}
+var POLL_INTERVAL_MS = 4e3;
+var WithdrawModal = ({
+  address = "",
+  token,
+  tokenSymbol,
+  chain,
+  amount = "",
+  balance,
+  status = "idle",
+  receiveAmount: receiveAmountProp,
+  txHash,
+  tokenOptions: tokenOptionsProp,
+  chainOptions: chainOptionsProp,
+  useMerchantApi = false,
+  orderId,
+  withdrawMode,
+  withdrawDirectResult,
+  feeDisplay,
+  fundingChainId,
+  onShowToast,
+  onAddressChange,
+  onTokenSelect,
+  onChainSelect,
+  onAmountChange,
+  onMaxClick,
+  onSubmit,
+  onWithdrawCompleted,
+  onStartAnotherWithdrawal,
+  onSignIn,
+  onClose
+}) => {
+  const session = useSession();
+  const addressInputRef = useRef(null);
+  const [addressInputFocused, setAddressInputFocused] = useState(false);
+  const [amountInputFocused, setAmountInputFocused] = useState(false);
+  const [apiChains, setApiChains] = useState(null);
+  const [apiQuote, setApiQuote] = useState(null);
+  const [withdrawOrder, setWithdrawOrder] = useState(null);
+  const [loadingChains, setLoadingChains] = useState(false);
+  const [loadingQuote, setLoadingQuote] = useState(false);
+  const tokenOptions = useMemo(() => {
+    const raw = tokenOptionsProp?.length ? tokenOptionsProp : apiChains?.length ? chainsToTokenOptions2(apiChains) : void 0;
+    if (!raw?.length) return void 0;
+    return raw;
+  }, [tokenOptionsProp, apiChains]);
+  const chainOptions = useMemo(() => {
+    if (chainOptionsProp?.length) return chainOptionsProp;
+    if (!apiChains?.length || !token) return void 0;
+    return chainsToChainOptionsForToken2(apiChains, token);
+  }, [chainOptionsProp, apiChains, token]);
+  const resolvedTokenAddress = useMemo(() => {
+    if (!apiChains?.length || !token || !chain) return void 0;
+    return getTokenAddressForChain2(apiChains, chain, token);
+  }, [apiChains, token, chain]);
+  const [directActive, setDirectActive] = useState(false);
+  useEffect(() => {
+    setDirectActive(withdrawMode === "direct" && Boolean(withdrawDirectResult));
+  }, [withdrawMode, withdrawDirectResult]);
+  const trackingWithdraw = useMemo(
+    () => Boolean(orderId) || directActive,
+    [orderId, directActive]
+  );
+  useEffect(() => {
+    if (trackingWithdraw) return;
+    const t = requestAnimationFrame(() => {
+      addressInputRef.current?.focus();
+    });
+    return () => cancelAnimationFrame(t);
+  }, [trackingWithdraw]);
+  const shouldLoadChains = useMerchantApi || Boolean(token && chain);
+  useEffect(() => {
+    if (!shouldLoadChains) return;
+    setLoadingChains(true);
+    getChains().then((res) => setApiChains(res?.chains ?? [])).finally(() => setLoadingChains(false));
+  }, [shouldLoadChains]);
+  useEffect(() => {
+    if (!apiChains?.length || !token || !chain) {
+      setApiQuote(null);
+      return;
+    }
+    const tokenAddress = getTokenAddressForChain2(apiChains, chain, token);
+    if (!tokenAddress) {
+      setApiQuote(null);
+      return;
+    }
+    const amountNum = amount && Number(amount) > 0 ? Number(amount) : 1;
+    const amountWei = String(BigInt(Math.floor(amountNum * 1e18)));
+    setLoadingQuote(true);
+    quote({
+      direction: "withdraw",
+      chain_id: chain,
+      token_address: tokenAddress,
+      dst_token_amount: amountWei
+    }).then((q) => setApiQuote(q ?? null)).catch(() => {
+      setApiQuote({
+        token_address: tokenAddress,
+        token_symbol: token,
+        token_decimals: 18,
+        rate: "1",
+        chain_id: Number(chain) || 56,
+        token_amount: amountWei,
+        expires_at: new Date(Date.now() + 6e4).toISOString()
+      });
+    }).finally(() => setLoadingQuote(false));
+  }, [apiChains, token, chain, amount]);
+  useEffect(() => {
+    if (tokenOptions?.length !== 1 || !onTokenSelect) return;
+    const onlyId = tokenOptions[0].id;
+    if (token === onlyId) return;
+    onTokenSelect(onlyId);
+  }, [tokenOptions, token, onTokenSelect]);
+  useEffect(() => {
+    if (chainOptions?.length !== 1 || !onChainSelect) return;
+    const onlyId = chainOptions[0].id;
+    if (chain === onlyId) return;
+    onChainSelect(onlyId);
+  }, [chainOptions, chain, onChainSelect]);
+  const mockWithdrawOrderState = useMemo(
+    () => ({
+      order_id: orderId ?? "",
+      status: "pending",
+      chain_id: "56",
+      dst_token_amount: "0",
+      target_chain_id: chain ?? "1",
+      target_address: address ?? "0x",
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    }),
+    [orderId, chain, address]
+  );
+  useEffect(() => {
+    if (orderId) {
+      const t = setInterval(() => {
+        getWithdrawOrder(orderId).then((order) => {
+          setWithdrawOrder(order);
+          if (order.status === "completed" && onShowToast) {
+            onShowToast("Withdrawal completed");
+          }
+        }).catch(() => setWithdrawOrder(mockWithdrawOrderState));
+      }, POLL_INTERVAL_MS);
+      getWithdrawOrder(orderId).then(setWithdrawOrder).catch(() => setWithdrawOrder(mockWithdrawOrderState));
+      return () => clearInterval(t);
+    }
+    if (!orderId && directActive) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const inferredAmountWei = (() => {
+        if (withdrawDirectResult?.dst_token_amount) return withdrawDirectResult.dst_token_amount;
+        const n = Number(amount || "0");
+        return String(n > 0 ? BigInt(Math.floor(n * 1e18)) : 0n);
+      })();
+      const synthetic = {
+        order_id: withdrawDirectResult?.order_id ?? `direct-${Date.now()}`,
+        status: withdrawDirectResult?.status ?? "pending",
+        chain_id: withdrawDirectResult?.chain_id ?? String(fundingChainId ?? "3131"),
+        dst_token_amount: inferredAmountWei,
+        fee: withdrawDirectResult?.fee ?? feeDisplay,
+        target_chain_id: withdrawDirectResult?.target_chain_id ?? (chain ?? ""),
+        target_address: withdrawDirectResult?.target_address ?? (address ?? ""),
+        funding_tx_hash: withdrawDirectResult?.funding_tx_hash ?? txHash,
+        dst_tx_hash: withdrawDirectResult?.dst_tx_hash,
+        out_tx_hash: withdrawDirectResult?.out_tx_hash,
+        created_at: withdrawDirectResult?.created_at ?? now,
+        updated_at: withdrawDirectResult?.updated_at ?? now,
+        one_time_address: withdrawDirectResult?.one_time_address
+      };
+      setWithdrawOrder(synthetic);
+      return;
+    }
+    setWithdrawOrder(null);
+  }, [orderId, directActive, withdrawDirectResult, amount, feeDisplay, chain, address, txHash, fundingChainId, onShowToast, mockWithdrawOrderState]);
+  const completedKeyRef = useRef(null);
+  useEffect(() => {
+    if (withdrawOrder?.status !== "completed") return;
+    const key = orderId ?? withdrawOrder.order_id;
+    if (key && completedKeyRef.current !== key) {
+      completedKeyRef.current = key;
+      onWithdrawCompleted?.();
+    }
+    if (!trackingWithdraw) completedKeyRef.current = null;
+  }, [withdrawOrder?.status, orderId, trackingWithdraw, onWithdrawCompleted]);
+  const receiveAmount = useMemo(() => {
+    if (receiveAmountProp) {
+      const n = Number(receiveAmountProp);
+      if (!Number.isNaN(n)) return n.toFixed(2);
+      return receiveAmountProp;
+    }
+    if (!apiQuote?.token_amount || !apiQuote?.token_symbol) return void 0;
+    const amount2 = Number(apiQuote.token_amount);
+    const formatted = Number.isNaN(amount2) ? apiQuote.token_amount : amount2.toFixed(2);
+    return `\u2248 ${formatted} (wei) ${apiQuote.token_symbol}`;
+  }, [receiveAmountProp, apiQuote]);
+  const quoteExpired = useMemo(() => {
+    if (!apiQuote?.expires_at) return false;
+    try {
+      return new Date(apiQuote.expires_at).getTime() < Date.now();
+    } catch {
+      return false;
+    }
+  }, [apiQuote?.expires_at]);
+  const handleRefreshQuote = useCallback(() => {
+    if (!apiChains?.length || !token || !chain) return;
+    const tokenAddress = getTokenAddressForChain2(apiChains, chain, token);
+    if (!tokenAddress) return;
+    const amountNum = amount && Number(amount) > 0 ? Number(amount) : 1;
+    const amountWei = String(BigInt(Math.floor(amountNum * 1e18)));
+    setLoadingQuote(true);
+    quote({
+      direction: "withdraw",
+      chain_id: chain,
+      token_address: tokenAddress,
+      dst_token_amount: amountWei
+    }).then((q) => setApiQuote(q ?? null)).catch(() => {
+      setApiQuote({
+        token_address: tokenAddress,
+        token_symbol: token,
+        token_decimals: 18,
+        rate: "1",
+        chain_id: Number(chain) || 56,
+        token_amount: amountWei,
+        expires_at: new Date(Date.now() + 6e4).toISOString()
+      });
+    }).finally(() => setLoadingQuote(false));
+  }, [apiChains, token, chain, amount]);
+  const handleAmountChange = useCallback(
+    (e) => {
+      const raw = e.target.value;
+      const maxNum = balance ? parseBalanceNumber(balance) : null;
+      if (maxNum != null && raw !== "" && raw !== ".") {
+        const num = Number(raw);
+        if (!Number.isNaN(num) && num > maxNum) {
+          onAmountChange?.({
+            ...e,
+            target: { ...e.target, value: String(maxNum) }
+          });
+          return;
+        }
+      }
+      onAmountChange?.(e);
+    },
+    [balance, onAmountChange]
+  );
+  if (!session) {
+    return /* @__PURE__ */ jsx(LoginRequiredOverlay, { title: "Withdraw", onSignIn, onClose });
+  }
+  const activeStep = amount ? 3 : chain ? 2 : token ? 1 : address ? 0 : 0;
+  const canSubmit = address && token && chain && amount;
+  const isSubmitting = status !== "idle";
+  const orderInProgress = trackingWithdraw && (!withdrawOrder || withdrawOrder.status !== "completed");
+  const orderSucceeded = trackingWithdraw && withdrawOrder?.status === "completed";
+  return /* @__PURE__ */ jsxs(
+    ModalFrame,
+    {
+      onClose,
+      contentStyle: {
+        justifyContent: "space-between",
+        padding: "24px"
+      },
+      children: [
+        /* @__PURE__ */ jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 32 }, children: [
+          /* @__PURE__ */ jsx("div", { style: { display: "flex", alignItems: "center", justifyContent: "space-between" }, children: /* @__PURE__ */ jsx("h2", { style: { margin: 0, fontSize: 24, fontWeight: 600, lineHeight: 1.4 }, children: "Withdraw" }) }),
+          /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: 16 }, children: [
+            /* @__PURE__ */ jsx(
+              "div",
+              {
+                style: {
+                  opacity: trackingWithdraw ? 0 : 1,
+                  maxWidth: trackingWithdraw ? 0 : 48,
+                  overflow: "hidden",
+                  transition: "opacity 0.3s ease, max-width 0.35s ease"
+                },
+                children: /* @__PURE__ */ jsx(
+                  StepIndicator,
+                  {
+                    steps: 4,
+                    stepActive: [!!address, !!token, !!chain, !!apiQuote],
+                    activeStep
+                  }
+                )
+              }
+            ),
+            /* @__PURE__ */ jsxs("div", { style: { flex: 1, position: "relative", minHeight: 400 }, children: [
+              /* @__PURE__ */ jsxs(
+                "div",
+                {
+                  style: {
+                    position: "absolute",
+                    inset: 0,
+                    display: "flex",
+                    flexDirection: "column",
+                    alignItems: "center",
+                    justifyContent: "center",
+                    gap: 12,
+                    padding: "0 16px",
+                    opacity: trackingWithdraw ? 1 : 0,
+                    maxHeight: trackingWithdraw ? 400 : 0,
+                    overflow: "hidden",
+                    pointerEvents: trackingWithdraw ? "auto" : "none",
+                    transition: "opacity 0.3s ease, max-height 0.35s ease"
+                  },
+                  children: [
+                    orderInProgress && /* @__PURE__ */ jsxs(
+                      "div",
+                      {
+                        style: {
+                          display: "flex",
+                          flexDirection: "column",
+                          alignItems: "center",
+                          justifyContent: "center",
+                          gap: 32
+                        },
+                        children: [
+                          /* @__PURE__ */ jsx(
+                            "span",
+                            {
+                              style: {
+                                display: "inline-block",
+                                width: 60,
+                                height: 60,
+                                border: `3px solid ${colors.border}`,
+                                borderTopColor: colors.textPrimary,
+                                borderRadius: "50%",
+                                animation: "withdraw-modal-spin 0.8s linear infinite"
+                              },
+                              "aria-hidden": true
+                            }
+                          ),
+                          /* @__PURE__ */ jsx(
+                            "span",
+                            {
+                              style: {
+                                fontSize: 20,
+                                fontWeight: 600,
+                                color: colors.textPrimary,
+                                textAlign: "center",
+                                fontFamily: fonts.family,
+                                lineHeight: 1.4
+                              },
+                              children: "Processing withdrawal..."
+                            }
+                          )
+                        ]
+                      }
+                    ),
+                    orderSucceeded && (() => {
+                      const destTxHash = withdrawOrder.dst_tx_hash ?? withdrawOrder.out_tx_hash;
+                      const targetChainName = apiChains?.find((c) => c.chain_id === withdrawOrder.target_chain_id)?.network ?? withdrawOrder.target_chain_id ?? "\u2014";
+                      const explorerUrl = destTxHash && withdrawOrder.target_chain_id ? getExplorerUrl(withdrawOrder.target_chain_id, { txId: destTxHash }) : null;
+                      const copyHash = () => {
+                        if (destTxHash && typeof navigator?.clipboard?.writeText === "function") {
+                          navigator.clipboard.writeText(destTxHash);
+                          onShowToast?.("Copied");
+                        }
+                      };
+                      return /* @__PURE__ */ jsxs(
+                        "div",
+                        {
+                          style: {
+                            display: "flex",
+                            flexDirection: "column",
+                            alignItems: "center",
+                            gap: 20,
+                            width: "100%",
+                            maxWidth: 412
+                          },
+                          children: [
+                            /* @__PURE__ */ jsxs("div", { style: { display: "flex", flexDirection: "column", alignItems: "center", gap: 24 }, children: [
+                              /* @__PURE__ */ jsx(
+                                "span",
+                                {
+                                  style: {
+                                    display: "flex",
+                                    alignItems: "center",
+                                    justifyContent: "center",
+                                    width: 60,
+                                    height: 60,
+                                    borderRadius: "50%",
+                                    color: "#22c55e",
+                                    fontSize: 40,
+                                    lineHeight: 1,
+                                    fontWeight: 700
+                                  },
+                                  "aria-hidden": true,
+                                  children: /* @__PURE__ */ jsx(SuccessIcon, {})
+                                }
+                              ),
+                              /* @__PURE__ */ jsx(
+                                "span",
+                                {
+                                  style: {
+                                    fontSize: 20,
+                                    fontWeight: 600,
+                                    color: colors.textPrimary,
+                                    textAlign: "center",
+                                    fontFamily: fonts.family,
+                                    lineHeight: 1.4
+                                  },
+                                  children: "Withdrawal successful"
+                                }
+                              )
+                            ] }),
+                            /* @__PURE__ */ jsxs(
+                              "div",
+                              {
+                                style: {
+                                  display: "flex",
+                                  flexDirection: "column",
+                                  gap: 4,
+                                  width: "100%"
+                                },
+                                children: [
+                                  /* @__PURE__ */ jsxs("div", { style: { display: "flex", justifyContent: "space-between", alignItems: "center", padding: "8px 0", height: 36 }, children: [
+                                    /* @__PURE__ */ jsx("span", { style: { fontSize: 14, lineHeight: 1.4, color: colors.textSecondary }, children: "Amount" }),
+                                    /* @__PURE__ */ jsxs("span", { style: { fontSize: 14, lineHeight: 1.4, color: colors.textPrimary }, children: [
+                                      weiToEtherDisplay(withdrawOrder.dst_token_amount),
+                                      " ",
+                                      tokenSymbol
+                                    ] })
+                                  ] }),
+                                  /* @__PURE__ */ jsxs("div", { style: { display: "flex", justifyContent: "space-between", alignItems: "center", padding: "8px 0", height: 36 }, children: [
+                                    /* @__PURE__ */ jsx("span", { style: { fontSize: 14, lineHeight: 1.4, color: colors.textSecondary }, children: "Fee" }),
+                                    /* @__PURE__ */ jsx("span", { style: { fontSize: 14, lineHeight: 1.4, color: colors.textPrimary }, children: withdrawOrder.fee ?? feeDisplay ?? "\u2014" })
+                                  ] }),
+                                  /* @__PURE__ */ jsxs("div", { style: { display: "flex", justifyContent: "space-between", alignItems: "center", padding: "8px 0", height: 36 }, children: [
+                                    /* @__PURE__ */ jsx("span", { style: { fontSize: 14, lineHeight: 1.4, color: colors.textSecondary }, children: "Network" }),
+                                    /* @__PURE__ */ jsx("span", { style: { fontSize: 14, lineHeight: 1.4, color: colors.textPrimary }, children: targetChainName })
+                                  ] }),
+                                  destTxHash && /* @__PURE__ */ jsxs("div", { style: { display: "flex", justifyContent: "space-between", alignItems: "center", padding: "8px 0", minHeight: 38 }, children: [
+                                    /* @__PURE__ */ jsx("span", { style: { fontSize: 14, lineHeight: 1.4, color: colors.textSecondary }, children: "Transaction Hash" }),
+                                    /* @__PURE__ */ jsxs("div", { style: { display: "flex", alignItems: "center", gap: 8 }, children: [
+                                      explorerUrl ? /* @__PURE__ */ jsxs(
+                                        "a",
+                                        {
+                                          href: explorerUrl,
+                                          target: "_blank",
+                                          rel: "noopener noreferrer",
+                                          style: { fontSize: 14, color: colors.textPrimary, textDecoration: "underline" },
+                                          children: [
+                                            destTxHash.slice(0, 10),
+                                            "...",
+                                            destTxHash.slice(-8)
+                                          ]
+                                        }
+                                      ) : /* @__PURE__ */ jsxs("span", { style: { fontSize: 14, color: colors.textPrimary }, children: [
+                                        destTxHash.slice(0, 10),
+                                        "...",
+                                        destTxHash.slice(-8)
+                                      ] }),
+                                      /* @__PURE__ */ jsx(
+                                        "button",
+                                        {
+                                          type: "button",
+                                          onClick: copyHash,
+                                          "aria-label": "Copy hash",
+                                          style: {
+                                            padding: 0,
+                                            border: "none",
+                                            background: "transparent",
+                                            color: colors.textPrimary,
+                                            cursor: "pointer",
+                                            display: "flex",
+                                            alignItems: "center",
+                                            justifyContent: "center",
+                                            width: 16,
+                                            height: 16
+                                          },
+                                          children: /* @__PURE__ */ jsx(CopyIcon2, {})
+                                        }
+                                      )
+                                    ] })
+                                  ] })
+                                ]
+                              }
+                            ),
+                            /* @__PURE__ */ jsx("div", { style: { paddingTop: 24, width: "100%", display: "flex", justifyContent: "center" }, children: /* @__PURE__ */ jsx(
+                              "button",
+                              {
+                                type: "button",
+                                onClick: () => {
+                                  setDirectActive(false);
+                                  setWithdrawOrder(null);
+                                  (onStartAnotherWithdrawal ?? onClose)?.();
+                                },
+                                style: {
+                                  width: 274,
+                                  padding: "12px 0",
+                                  borderRadius: radii.full,
+                                  border: `1px solid ${colors.buttonDisabledBorder}`,
+                                  background: colors.textPrimary,
+                                  color: "#121214",
+                                  fontSize: 16,
+                                  fontWeight: 500,
+                                  lineHeight: 1.4,
+                                  fontFamily: fonts.family,
+                                  cursor: "pointer",
+                                  textAlign: "center"
+                                },
+                                children: "Start another withdrawal"
+                              }
+                            ) })
+                          ]
+                        }
+                      );
+                    })()
+                  ]
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                "div",
+                {
+                  style: {
+                    opacity: trackingWithdraw ? 0 : 1,
+                    maxHeight: trackingWithdraw ? 0 : 1200,
+                    overflow: "hidden",
+                    pointerEvents: trackingWithdraw ? "none" : "auto",
+                    transition: "opacity 0.3s ease, max-height 0.35s ease"
+                  },
+                  children: /* @__PURE__ */ jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 40 }, children: [
+                    /* @__PURE__ */ jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 8, width: "100%" }, children: [
+                      /* @__PURE__ */ jsx("span", { style: { fontSize: 14, lineHeight: 1.4, color: colors.textPrimary }, children: "Recipient address" }),
+                      /* @__PURE__ */ jsx(
+                        "div",
+                        {
+                          style: {
+                            display: "flex",
+                            alignItems: "center",
+                            height: 44,
+                            padding: "0 16px",
+                            borderRadius: radii.input,
+                            border: `1px solid ${addressInputFocused ? colors.borderFocused : colors.border}`,
+                            boxSizing: "border-box"
+                          },
+                          children: /* @__PURE__ */ jsx(
+                            "input",
+                            {
+                              ref: addressInputRef,
+                              value: address,
+                              onChange: onAddressChange,
+                              onFocus: () => setAddressInputFocused(true),
+                              onBlur: () => setAddressInputFocused(false),
+                              spellCheck: false,
+                              placeholder: "0x",
+                              style: {
+                                flex: 1,
+                                border: "none",
+                                outline: "none",
+                                background: "transparent",
+                                color: colors.textPrimary,
+                                fontSize: 14,
+                                fontFamily: fonts.family,
+                                lineHeight: 1.4,
+                                padding: 0
+                              }
+                            }
+                          )
+                        }
+                      )
+                    ] }),
+                    /* @__PURE__ */ jsx(
+                      DropdownField,
+                      {
+                        label: "Select token",
+                        placeholder: loadingChains ? "Loading\u2026" : "Token",
+                        value: token,
+                        options: tokenOptions,
+                        onSelect: onTokenSelect
+                      }
+                    ),
+                    /* @__PURE__ */ jsx(
+                      DropdownField,
+                      {
+                        label: "Select chain",
+                        placeholder: loadingChains ? "Loading\u2026" : "Chain",
+                        value: chain,
+                        options: chainOptions,
+                        onSelect: onChainSelect
+                      }
+                    ),
+                    apiQuote && token && chain && /* @__PURE__ */ jsx(
+                      "div",
+                      {
+                        style: {
+                          padding: "12px 16px",
+                          borderRadius: radii.card,
+                          border: `1px solid ${colors.border}`,
+                          display: "flex",
+                          flexDirection: "column",
+                          gap: 8
+                        },
+                        children: loadingQuote ? /* @__PURE__ */ jsx("span", { style: { fontSize: 13, color: colors.textSecondary }, children: "Loading\u2026" }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+                          /* @__PURE__ */ jsxs("span", { style: { fontSize: 13, color: colors.textSecondary }, children: [
+                            "Rate: 1 ",
+                            FUNDING_TOKEN_SYMBOL2,
+                            " = ",
+                            apiQuote.rate,
+                            " ",
+                            apiQuote.token_symbol
+                          ] }),
+                          apiQuote.expires_at && /* @__PURE__ */ jsx(
+                            Countdown,
+                            {
+                              expiresAt: apiQuote.expires_at,
+                              isExpired: quoteExpired,
+                              onExpired: handleRefreshQuote
+                            }
+                          ),
+                          quoteExpired && /* @__PURE__ */ jsxs("div", { style: { display: "flex", alignItems: "center", gap: 8 }, children: [
+                            /* @__PURE__ */ jsx("span", { style: { fontSize: 13, color: "#f59e0b" }, children: "Quote expired, please refresh" }),
+                            /* @__PURE__ */ jsx(
+                              "button",
+                              {
+                                type: "button",
+                                onClick: handleRefreshQuote,
+                                style: {
+                                  padding: "4px 12px",
+                                  fontSize: 12,
+                                  borderRadius: radii.pill,
+                                  border: `1px solid ${colors.border}`,
+                                  background: "transparent",
+                                  color: colors.textPrimary,
+                                  cursor: "pointer",
+                                  fontFamily: fonts.family
+                                },
+                                children: "Refresh"
+                              }
+                            )
+                          ] })
+                        ] })
+                      }
+                    ),
+                    /* @__PURE__ */ jsx("div", { style: { display: "flex", flexDirection: "column", gap: 16 }, children: /* @__PURE__ */ jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 8 }, children: [
+                      /* @__PURE__ */ jsxs("div", { style: { display: "flex", justifyContent: "space-between", alignItems: "center" }, children: [
+                        /* @__PURE__ */ jsx("span", { style: { fontSize: 14, lineHeight: 1.4, color: colors.textPrimary }, children: "Amount" }),
+                        balance && /* @__PURE__ */ jsxs("span", { style: { fontSize: 13, lineHeight: 1.2, color: colors.textSecondary }, children: [
+                          "Balance: \xA0",
+                          formatBalanceTo2Decimals(balance),
+                          " ",
+                          FUNDING_TOKEN_SYMBOL2
+                        ] })
+                      ] }),
+                      /* @__PURE__ */ jsxs(
+                        "div",
+                        {
+                          style: {
+                            display: "flex",
+                            alignItems: "center",
+                            justifyContent: "space-between",
+                            height: 48,
+                            padding: "0 16px",
+                            borderRadius: radii.input,
+                            border: `1px solid ${amountInputFocused ? colors.borderFocused : colors.border}`,
+                            boxSizing: "border-box"
+                          },
+                          children: [
+                            /* @__PURE__ */ jsx(
+                              "input",
+                              {
+                                value: amount,
+                                onChange: handleAmountChange,
+                                onFocus: () => setAmountInputFocused(true),
+                                onBlur: () => setAmountInputFocused(false),
+                                placeholder: "0.00",
+                                type: "text",
+                                inputMode: "decimal",
+                                style: {
+                                  flex: 1,
+                                  border: "none",
+                                  outline: "none",
+                                  background: "transparent",
+                                  color: amount ? colors.textPrimary : colors.textSecondary,
+                                  fontSize: 14,
+                                  fontFamily: fonts.family,
+                                  lineHeight: 1.4,
+                                  padding: 0
+                                }
+                              }
+                            ),
+                            /* @__PURE__ */ jsx("div", { style: { display: "flex", alignItems: "center", gap: 8 }, children: /* @__PURE__ */ jsx(
+                              "button",
+                              {
+                                type: "button",
+                                onClick: onMaxClick,
+                                style: {
+                                  background: colors.textPrimary,
+                                  border: "none",
+                                  borderRadius: radii.pill,
+                                  padding: "2px 8px",
+                                  fontSize: 12,
+                                  lineHeight: 1.4,
+                                  fontWeight: 400,
+                                  color: "#15181D",
+                                  fontFamily: fonts.family,
+                                  cursor: "pointer"
+                                },
+                                children: "Max"
+                              }
+                            ) })
+                          ]
+                        }
+                      )
+                    ] }) })
+                  ] })
+                }
+              )
+            ] })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { style: { padding: "20px 20px 0", display: "flex", flexDirection: "column", gap: 10, alignItems: "center" }, id: "WithdrawModalReceiveAmount", children: [
+          !trackingWithdraw && amount && Number(amount) > 0 && /* @__PURE__ */ jsxs("span", { style: { fontSize: 14, lineHeight: 1.4, color: colors.textPrimary }, children: [
+            "You will receive : ",
+            receiveAmount
+          ] }),
+          orderInProgress && withdrawOrder && (() => {
+            const fundingHash = txHash ?? withdrawOrder?.funding_tx_hash;
+            const showFundingLink = fundingHash && fundingChainId;
+            try {
+              return /* @__PURE__ */ jsx("div", { style: { display: "none", flexDirection: "column", gap: 6, alignItems: "center" }, children: showFundingLink && /* @__PURE__ */ jsx(
+                "a",
+                {
+                  href: getExplorerUrl(fundingChainId, { txId: fundingHash }),
+                  target: "_blank",
+                  rel: "noopener noreferrer",
+                  style: { fontSize: 13, color: colors.textPrimary, textDecoration: "underline" },
+                  children: "Withdraw request transaction on explorer"
+                }
+              ) });
+            } catch {
+              return /* @__PURE__ */ jsx("span", { style: { fontSize: 13, color: colors.textPrimary }, children: "Withdraw in progress." });
+            }
+          })(),
+          orderInProgress && withdrawOrder && /* @__PURE__ */ jsxs("span", { style: { fontSize: 13, color: colors.textSecondary, display: "none", alignItems: "center", gap: 6 }, children: [
+            "Order status: ",
+            withdrawOrder.status,
+            /* @__PURE__ */ jsx(
+              "span",
+              {
+                style: {
+                  display: "inline-block",
+                  width: 10,
+                  height: 10,
+                  border: `2px solid ${colors.textSecondary}`,
+                  borderTopColor: "transparent",
+                  borderRadius: "50%",
+                  animation: "withdraw-modal-spin 0.7s linear infinite"
+                },
+                "aria-hidden": true
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx("style", { children: `@keyframes withdraw-modal-spin { to { transform: rotate(360deg); } }` }),
+          orderSucceeded || trackingWithdraw ? null : /* @__PURE__ */ jsx(
+            SubmitButton,
+            {
+              disabled: !canSubmit || isSubmitting,
+              status,
+              onClick: () => onSubmit?.({
+                toAddress: address,
+                amount: amount ?? "",
+                token: token ?? "",
+                tokenAddress: resolvedTokenAddress ?? apiQuote?.token_address ?? "",
+                chain: chain ?? ""
+              })
+            }
+          )
+        ] })
+      ]
+    }
+  );
+};
+var SubmitButton = ({ disabled, status, onClick }) => {
+  const labels = {
+    idle: disabled ? "Please fill in withdrawal information" : "Submit",
+    pending: "Processing...",
+    success: "Withdrawal successful",
+    manual_review: "Under manual review"
+  };
+  const isDisabled = disabled || status !== "idle";
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      disabled: isDisabled,
+      onClick,
+      style: {
+        width: 364,
+        padding: "12px 0",
+        borderRadius: radii.full,
+        border: isDisabled ? `1px solid ${colors.buttonDisabledBorder}` : "none",
+        background: isDisabled ? colors.buttonDisabledBg : colors.textPrimary,
+        color: isDisabled ? colors.textSecondary : "#15181D",
+        fontSize: 16,
+        fontWeight: 500,
+        lineHeight: 1.4,
+        fontFamily: fonts.family,
+        cursor: isDisabled ? "not-allowed" : "pointer",
+        textAlign: "center"
+      },
+      children: labels[status]
+    }
+  );
+};
+
+export { ClientIds, DEFAULT_FUNDING_CHAIN_ID, DEFAULT_FUNDING_TOKEN_ADDRESS, DepositDetailsPanel, DepositModal, DropdownField, SignInModal, WalletSelectionModal, WithdrawModal, clearSocialAccountInstance2 as clearSocialAccountInstance, configureMerchantApi, createDepositController, createFundingWithdrawExecutor, createMarketDataProvider, createOrder, createPredicateMarketPolicyAdapter, createWithdrawController, fetchErc20Balance, fetchFundingTokenBalance, findTokenDataFromChains, getChainInfo, getChains, getDepositOrder, getEnv, getExplorerUrl, getFixedAuthConfig, getFundingTokenAddress, getMerchantApiClient, getSDKConfig, getWithdrawOrder, initSDK, isFedCMSupported, isUsdtWithdrawDirect, notifyTwitterCallback, parseUnits, quote, registerPlatform, signInWithGoogle, signInWithTwitter, tryAutoReconnect };