@iamgame/wallet-sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2000 @@
+'use strict';
+
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var reactDom = require('react-dom');
+
+// ../../solven/sdk-client/src/errors.ts
+var SolvenSdkError = class _SolvenSdkError extends Error {
+  constructor(args) {
+    super(args.message);
+    this.name = "SolvenSdkError";
+    this.code = args.code;
+    this.httpStatus = args.httpStatus;
+    this.details = args.details;
+  }
+  static fromEnvelope(envelope, httpStatus) {
+    return new _SolvenSdkError({
+      code: envelope.code,
+      message: envelope.message,
+      httpStatus,
+      details: envelope.details
+    });
+  }
+};
+
+// ../../solven/sdk-client/src/session.ts
+var STORAGE_KEY = "solven.session.v1";
+var localStorageSession = {
+  get() {
+    try {
+      const raw = globalThis.localStorage?.getItem(STORAGE_KEY);
+      if (!raw) return null;
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  },
+  set(session) {
+    try {
+      if (session) {
+        globalThis.localStorage?.setItem(STORAGE_KEY, JSON.stringify(session));
+      } else {
+        globalThis.localStorage?.removeItem(STORAGE_KEY);
+      }
+    } catch {
+    }
+  }
+};
+var inMemorySession = () => {
+  let s = null;
+  return {
+    get: () => s,
+    set: (next) => {
+      s = next;
+    }
+  };
+};
+
+// ../../solven/sdk-client/src/client.ts
+var SolvenClient = class {
+  constructor(options) {
+    this.opts = {
+      publishableKey: options.publishableKey,
+      baseUrl: options.baseUrl.replace(/\/$/, ""),
+      storage: options.storage ?? localStorageSession,
+      fetchImpl: options.fetchImpl ?? globalThis.fetch.bind(globalThis)
+    };
+  }
+  // ─── Auth ──────────────────────────────────────────────────────────────────
+  async requestSiwsChallenge(publicKey) {
+    return this.publicCall("POST", "/auth/siws/challenge", { publicKey });
+  }
+  async verifySiws(req) {
+    const session = await this.publicCall("POST", "/auth/siws/verify", req);
+    this.opts.storage.set(session);
+    return session;
+  }
+  async verifyTelegram(req) {
+    const session = await this.publicCall("POST", "/auth/telegram/verify", req);
+    this.opts.storage.set(session);
+    return session;
+  }
+  async refreshSession() {
+    const current = this.opts.storage.get();
+    if (!current) return null;
+    try {
+      const next = await this.publicCall("POST", "/auth/refresh", {
+        refreshToken: current.refreshToken
+      });
+      this.opts.storage.set(next);
+      return next;
+    } catch (e) {
+      this.opts.storage.set(null);
+      throw e;
+    }
+  }
+  async logout() {
+    const current = this.opts.storage.get();
+    if (current) {
+      try {
+        await this.publicCall("POST", "/auth/logout", { refreshToken: current.refreshToken });
+      } catch {
+      }
+    }
+    this.opts.storage.set(null);
+  }
+  getSession() {
+    return this.opts.storage.get();
+  }
+  // ─── User / wallet ─────────────────────────────────────────────────────────
+  async getMe() {
+    return this.userCall("GET", "/me");
+  }
+  async getMyWallet() {
+    return this.userCall("GET", "/wallets/me");
+  }
+  async getBalance(walletId) {
+    return this.userCall("GET", `/wallets/${encodeURIComponent(walletId)}/balance`);
+  }
+  async signAction(req, idempotencyKey) {
+    return this.userCall(
+      "POST",
+      `/wallets/${encodeURIComponent(req.walletId)}/sign`,
+      { txBase64: req.txBase64, label: req.label },
+      idempotencyKey
+    );
+  }
+  async withdraw(req) {
+    return this.userCall(
+      "POST",
+      `/wallets/${encodeURIComponent(req.walletId)}/withdraw`,
+      {
+        toAddress: req.toAddress,
+        mint: req.mint,
+        amount: req.amount,
+        idempotencyKey: req.idempotencyKey
+      },
+      req.idempotencyKey
+    );
+  }
+  async exportPreflight(walletId) {
+    return this.userCall(
+      "GET",
+      `/wallets/${encodeURIComponent(walletId)}/export/preflight`
+    );
+  }
+  async exportWallet(walletId, idempotencyKey) {
+    return this.userCall(
+      "POST",
+      `/wallets/${encodeURIComponent(walletId)}/export`,
+      { idempotencyKey },
+      idempotencyKey
+    );
+  }
+  // ─── HTTP plumbing ─────────────────────────────────────────────────────────
+  async publicCall(method, path, body) {
+    return this.doFetch(method, path, body, {
+      Authorization: `Bearer ${this.opts.publishableKey}`
+    });
+  }
+  async userCall(method, path, body, idempotencyKey) {
+    const headers = {};
+    if (idempotencyKey) headers["Idempotency-Key"] = idempotencyKey;
+    const session = this.opts.storage.get();
+    if (!session) {
+      throw new SolvenSdkError({ code: "auth/missing_token", message: "not signed in" });
+    }
+    headers.Authorization = `Bearer ${session.accessToken}`;
+    try {
+      return await this.doFetch(method, path, body, headers);
+    } catch (e) {
+      if (e instanceof SolvenSdkError && e.code === "auth/expired_token") {
+        const refreshed = await this.refreshSession();
+        if (!refreshed) throw e;
+        headers.Authorization = `Bearer ${refreshed.accessToken}`;
+        return this.doFetch(method, path, body, headers);
+      }
+      throw e;
+    }
+  }
+  async doFetch(method, path, body, headers) {
+    const url = this.opts.baseUrl + path;
+    let resp;
+    try {
+      resp = await this.opts.fetchImpl(url, {
+        method,
+        headers: { "Content-Type": "application/json", ...headers },
+        body: body === void 0 ? void 0 : JSON.stringify(body)
+      });
+    } catch (e) {
+      throw new SolvenSdkError({
+        code: "client/network",
+        message: e instanceof Error ? e.message : "network error"
+      });
+    }
+    if (resp.status === 204) {
+      return void 0;
+    }
+    const text = await resp.text();
+    const parsed = text ? JSON.parse(text) : null;
+    if (!resp.ok) {
+      const envelope = parsed?.error;
+      if (envelope) {
+        throw SolvenSdkError.fromEnvelope(envelope, resp.status);
+      }
+      throw new SolvenSdkError({
+        code: "server/internal",
+        message: `unexpected status ${resp.status}`,
+        httpStatus: resp.status
+      });
+    }
+    return parsed;
+  }
+};
+
+// ../../solven/sdk-client/src/siws.ts
+function buildChallengeMessageOnClient(c) {
+  return [
+    `${c.domain} wants you to sign in with your Solana account.`,
+    "",
+    c.statement,
+    "",
+    `URI: ${c.uri}`,
+    `Nonce: ${c.nonce}`,
+    `Issued At: ${c.issuedAt}`,
+    `Expires At: ${c.expiresAt}`
+  ].join("\n");
+}
+
+// ../../solven/sdk-client/src/telegram.ts
+function getTelegram() {
+  if (typeof window === "undefined") return void 0;
+  return window.Telegram;
+}
+function getTelegramInitData() {
+  const data = getTelegram()?.WebApp?.initData;
+  if (!data || typeof data !== "string" || data.length === 0) return null;
+  return data;
+}
+function isTelegramMiniApp() {
+  return getTelegramInitData() !== null;
+}
+function notifyTelegramReady() {
+  try {
+    const wa = getTelegram()?.WebApp;
+    wa?.ready?.();
+    wa?.expand?.();
+  } catch {
+  }
+}
+var SolvenContext = react.createContext(null);
+function useSolvenContext() {
+  const ctx = react.useContext(SolvenContext);
+  if (!ctx) throw new Error("useSolvenContext must be inside a <SolvenProvider />");
+  return ctx;
+}
+function SolvenProvider({ children, ...opts }) {
+  const client = react.useMemo(() => new SolvenClient(opts), [
+    opts.publishableKey,
+    opts.baseUrl,
+    opts.storage,
+    opts.fetchImpl
+  ]);
+  const [session, setSession] = react.useState(client.getSession());
+  const [status, setStatus] = react.useState("loading");
+  react.useEffect(() => {
+    let cancelled = false;
+    (async () => {
+      const stored = client.getSession();
+      if (!stored) {
+        if (!cancelled) {
+          setSession(null);
+          setStatus("anonymous");
+        }
+        return;
+      }
+      const expired = new Date(stored.expiresAt).getTime() <= Date.now();
+      if (expired) {
+        try {
+          const next = await client.refreshSession();
+          if (cancelled) return;
+          setSession(next);
+          setStatus(next ? "authenticated" : "anonymous");
+        } catch {
+          if (cancelled) return;
+          setSession(null);
+          setStatus("anonymous");
+        }
+      } else if (!cancelled) {
+        setSession(stored);
+        setStatus("authenticated");
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [client]);
+  const value = {
+    client,
+    session,
+    status,
+    setSession: (s) => {
+      setSession(s);
+      setStatus(s ? "authenticated" : "anonymous");
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(SolvenContext.Provider, { value, children });
+}
+
+// ../../solven/sdk-client/src/hooks.ts
+function useSolvenAuth() {
+  const { client, session, status, setSession } = useSolvenContext();
+  const connectExternal = react.useCallback(
+    async (adapter) => {
+      const { publicKey } = await adapter.connect();
+      const challenge = await client.requestSiwsChallenge(publicKey);
+      const message = buildChallengeMessageOnClient(challenge);
+      const { signature } = await adapter.signMessage(message);
+      const session2 = await client.verifySiws({ challenge, publicKey, signature });
+      setSession(session2);
+    },
+    [client, setSession]
+  );
+  const connectTelegram = react.useCallback(async () => {
+    const initData = getTelegramInitData();
+    if (!initData) throw new Error("Not running inside a Telegram Mini App.");
+    const session2 = await client.verifyTelegram({ initData });
+    setSession(session2);
+  }, [client, setSession]);
+  const logout = react.useCallback(async () => {
+    await client.logout();
+    setSession(null);
+  }, [client, setSession]);
+  return {
+    user: session?.user ?? null,
+    status,
+    connectExternal,
+    connectTelegram,
+    logout
+  };
+}
+function useSolvenWallet() {
+  const { client, status } = useSolvenContext();
+  const [wallet, setWallet] = react.useState(null);
+  react.useEffect(() => {
+    if (status !== "authenticated") {
+      setWallet(null);
+      return;
+    }
+    let cancelled = false;
+    client.getMyWallet().then((w) => !cancelled && setWallet(w)).catch(() => !cancelled && setWallet(null));
+    return () => {
+      cancelled = true;
+    };
+  }, [client, status]);
+  return wallet;
+}
+function useSolvenBalance(walletId, pollMs = 15e3) {
+  const { client, status } = useSolvenContext();
+  const [balance, setBalance] = react.useState(null);
+  react.useEffect(() => {
+    if (status !== "authenticated" || !walletId) {
+      setBalance(null);
+      return;
+    }
+    let cancelled = false;
+    const tick = async () => {
+      try {
+        const b = await client.getBalance(walletId);
+        if (!cancelled) setBalance(b);
+      } catch {
+      }
+    };
+    void tick();
+    const t = setInterval(tick, pollMs);
+    return () => {
+      cancelled = true;
+      clearInterval(t);
+    };
+  }, [client, status, walletId, pollMs]);
+  return balance;
+}
+function useSolvenSign() {
+  const { client } = useSolvenContext();
+  const signAction = react.useCallback(
+    ({ walletId, txBase64, label, idempotencyKey }) => client.signAction({ walletId, txBase64, label }, idempotencyKey),
+    [client]
+  );
+  return { signAction };
+}
+function useSolvenExport(walletId) {
+  const { client } = useSolvenContext();
+  const [preflight, setPreflight] = react.useState(null);
+  const refreshPreflight = react.useCallback(async () => {
+    if (!walletId) return;
+    const p = await client.exportPreflight(walletId);
+    setPreflight(p);
+  }, [client, walletId]);
+  react.useEffect(() => {
+    if (walletId) void refreshPreflight();
+  }, [walletId, refreshPreflight]);
+  const exportKey = react.useCallback(
+    async (idempotencyKey) => {
+      if (!walletId) throw new Error("No wallet selected for export");
+      return client.exportWallet(walletId, idempotencyKey);
+    },
+    [client, walletId]
+  );
+  return { preflight, refreshPreflight, exportKey };
+}
+function useSolvenTransferIn() {
+  const wallet = useSolvenWallet();
+  return { destinationAddress: wallet?.address ?? null };
+}
+
+// ../../solven/sdk-client/src/wallet-adapter.ts
+function phantomAdapter() {
+  const w = typeof window !== "undefined" ? window : null;
+  const provider = w?.phantom?.solana ?? w?.solana;
+  if (!provider) {
+    throw new Error("No Solana provider detected on window (Phantom/Solflare not installed?).");
+  }
+  return {
+    async connect() {
+      const out = await provider.connect();
+      return { publicKey: out.publicKey.toString() };
+    },
+    async disconnect() {
+      if (typeof provider.disconnect === "function") {
+        await provider.disconnect();
+      }
+    },
+    async signMessage(message) {
+      const enc = new TextEncoder().encode(message);
+      const out = await provider.signMessage(enc, "utf8");
+      const sig = out.signature ?? out;
+      return {
+        signature: btoa(String.fromCharCode(...sig)),
+        publicKey: provider.publicKey.toString()
+      };
+    }
+  };
+}
+
+// ../../solven/sdk-client/src/wallet-adapters.ts
+function getWindow() {
+  return typeof window !== "undefined" ? window : null;
+}
+function phantomDetected() {
+  const w = getWindow();
+  return Boolean(w?.phantom?.solana?.isPhantom || w?.solana?.isPhantom);
+}
+function solflareDetected() {
+  const w = getWindow();
+  return Boolean(w?.solflare?.isSolflare);
+}
+function backpackDetected() {
+  const w = getWindow();
+  return Boolean(w?.backpack?.isBackpack);
+}
+function genericAdapter(provider) {
+  if (!provider) {
+    throw new Error("Wallet provider not detected on window");
+  }
+  return {
+    async connect() {
+      const out = await provider.connect();
+      return { publicKey: out.publicKey.toString() };
+    },
+    async disconnect() {
+      if (typeof provider.disconnect === "function") {
+        await provider.disconnect();
+      }
+    },
+    async signMessage(message) {
+      const enc = new TextEncoder().encode(message);
+      const out = await provider.signMessage(enc, "utf8");
+      const sig = out.signature ?? out;
+      return {
+        signature: btoa(String.fromCharCode(...sig)),
+        publicKey: provider.publicKey.toString()
+      };
+    }
+  };
+}
+var solflareAdapter = () => {
+  const w = getWindow();
+  return genericAdapter(w?.solflare);
+};
+var backpackAdapter = () => {
+  const w = getWindow();
+  return genericAdapter(w?.backpack);
+};
+function listSupportedWallets() {
+  return [
+    {
+      id: "phantom",
+      name: "Phantom",
+      detected: phantomDetected(),
+      downloadUrl: "https://phantom.app/download",
+      buildAdapter: phantomAdapter
+    },
+    {
+      id: "solflare",
+      name: "Solflare",
+      detected: solflareDetected(),
+      downloadUrl: "https://solflare.com/download",
+      buildAdapter: solflareAdapter
+    },
+    {
+      id: "backpack",
+      name: "Backpack",
+      detected: backpackDetected(),
+      downloadUrl: "https://backpack.app",
+      buildAdapter: backpackAdapter
+    }
+  ];
+}
+var defaultTheme = {
+  primary: "#0f766e",
+  background: "#ffffff",
+  foreground: "#1a1714",
+  muted: "#6b6359",
+  surface: "#f3ede2",
+  border: "#ece7dd",
+  radius: "1rem",
+  fontFamily: 'system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif'
+};
+function SolvenLoginContent(props) {
+  const { connectExternal, connectTelegram, status, user } = useSolvenAuth();
+  const [busy, setBusy] = react.useState(null);
+  const [error, setError] = react.useState(null);
+  const theme = react.useMemo(
+    () => ({ ...defaultTheme, ...props.theme ?? {} }),
+    [props.theme]
+  );
+  const inTma = react.useMemo(() => isTelegramMiniApp(), []);
+  const autoTelegram = props.autoTelegram ?? true;
+  const wallets = react.useMemo(listSupportedWallets, []);
+  react.useEffect(() => {
+    notifyTelegramReady();
+    if (!inTma || !autoTelegram) return;
+    if (status === "authenticated") return;
+    let cancelled = false;
+    (async () => {
+      setBusy("tg");
+      setError(null);
+      try {
+        await connectTelegram();
+        if (cancelled) return;
+        props.onSignIn?.();
+        props.onCloseAfterSignIn?.();
+      } catch (e) {
+        if (!cancelled) {
+          setError(e instanceof Error ? e.message : "Telegram sign-in failed");
+        }
+      } finally {
+        if (!cancelled) setBusy(null);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [inTma, autoTelegram, status, connectTelegram]);
+  if (status === "authenticated" && user) {
+    return null;
+  }
+  const handleWallet = async (descriptor) => {
+    setBusy(descriptor.id);
+    setError(null);
+    try {
+      if (!descriptor.detected) {
+        window.open(descriptor.downloadUrl, "_blank", "noopener,noreferrer");
+        return;
+      }
+      const adapter = props.adapterFactory ? props.adapterFactory() : descriptor.buildAdapter();
+      await connectExternal(adapter);
+      props.onSignIn?.();
+      props.onCloseAfterSignIn?.();
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Wallet sign-in failed");
+    } finally {
+      setBusy(null);
+    }
+  };
+  const handleTelegramButton = async () => {
+    setBusy("tg");
+    setError(null);
+    try {
+      await connectTelegram();
+      props.onSignIn?.();
+      props.onCloseAfterSignIn?.();
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "Telegram sign-in failed");
+    } finally {
+      setBusy(null);
+    }
+  };
+  const buttonBase = {
+    width: "100%",
+    padding: "0.75rem 0.875rem",
+    borderRadius: theme.radius,
+    border: `1px solid ${theme.border}`,
+    fontWeight: 600,
+    fontSize: "0.9375rem",
+    cursor: "pointer",
+    transition: "transform 100ms ease, opacity 100ms ease",
+    display: "flex",
+    alignItems: "center",
+    gap: "0.625rem",
+    background: theme.surface,
+    color: theme.foreground
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        style: {
+          marginBottom: "0.25rem",
+          fontWeight: 700,
+          fontSize: "1.25rem"
+        },
+        children: props.title ?? "Sign in"
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        style: {
+          marginBottom: "1.25rem",
+          color: theme.muted,
+          fontSize: "0.9375rem"
+        },
+        children: props.subtitle ?? (inTma ? "Continuing with your Telegram account\u2026" : "Choose a wallet to continue.")
+      }
+    ),
+    inTma ? /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        type: "button",
+        onClick: handleTelegramButton,
+        disabled: busy !== null,
+        style: {
+          ...buttonBase,
+          justifyContent: "center",
+          background: theme.primary,
+          color: "#ffffff",
+          border: "none",
+          opacity: busy === "tg" ? 0.7 : 1
+        },
+        children: busy === "tg" ? "Signing in with Telegram\u2026" : "Continue with Telegram"
+      }
+    ) : /* @__PURE__ */ jsxRuntime.jsx("div", { style: { display: "flex", flexDirection: "column", gap: "0.5rem" }, children: wallets.map((w) => {
+      const isBusy = busy === w.id;
+      return /* @__PURE__ */ jsxRuntime.jsxs(
+        "button",
+        {
+          type: "button",
+          onClick: () => handleWallet(w),
+          disabled: busy !== null,
+          style: {
+            ...buttonBase,
+            opacity: isBusy ? 0.7 : 1
+          },
+          "aria-label": w.detected ? `Connect with ${w.name}` : `Install ${w.name}`,
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { style: { flex: 1, textAlign: "left" }, children: w.name }),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "span",
+              {
+                style: {
+                  fontSize: "0.75rem",
+                  color: w.detected ? theme.primary : theme.muted,
+                  fontWeight: 500
+                },
+                children: isBusy ? "Connecting\u2026" : w.detected ? "Detected" : "Install"
+              }
+            )
+          ]
+        },
+        w.id
+      );
+    }) }),
+    error && /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        role: "alert",
+        style: {
+          marginTop: "0.875rem",
+          padding: "0.625rem 0.75rem",
+          borderRadius: "0.5rem",
+          background: "#fee2e2",
+          color: "#991b1b",
+          fontSize: "0.875rem"
+        },
+        children: error
+      }
+    )
+  ] });
+}
+function SolvenLogin(props) {
+  const theme = react.useMemo(
+    () => ({ ...defaultTheme, ...props.theme ?? {} }),
+    [props.theme]
+  );
+  const { status } = useSolvenAuth();
+  if (status === "authenticated") return null;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      role: "dialog",
+      "aria-label": "Wallet sign-in",
+      style: {
+        background: theme.background,
+        color: theme.foreground,
+        fontFamily: theme.fontFamily,
+        padding: "1.5rem",
+        borderRadius: theme.radius,
+        boxShadow: "0 10px 40px rgba(0,0,0,0.08)",
+        maxWidth: 380,
+        margin: "0 auto"
+      },
+      children: /* @__PURE__ */ jsxRuntime.jsx(SolvenLoginContent, { ...props })
+    }
+  );
+}
+function SolvenLoginModal(props) {
+  const {
+    isOpen,
+    onClose,
+    closeOnBackdrop = true,
+    closeOnEscape = true,
+    ...content
+  } = props;
+  const theme = react.useMemo(
+    () => ({ ...defaultTheme, ...props.theme ?? {} }),
+    [props.theme]
+  );
+  const dialogRef = react.useRef(null);
+  const previouslyFocused = react.useRef(null);
+  const [mounted, setMounted] = react.useState(false);
+  react.useEffect(() => {
+    setMounted(true);
+  }, []);
+  react.useEffect(() => {
+    if (!isOpen || !closeOnEscape) return;
+    const onKey = (e) => {
+      if (e.key === "Escape") {
+        e.stopPropagation();
+        onClose();
+      }
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [isOpen, closeOnEscape, onClose]);
+  react.useEffect(() => {
+    if (!isOpen) return;
+    previouslyFocused.current = document.activeElement ?? null;
+    queueMicrotask(() => {
+      const focusable = dialogRef.current?.querySelector(
+        'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])'
+      );
+      focusable?.focus();
+    });
+    const onKey = (e) => {
+      if (e.key !== "Tab" || !dialogRef.current) return;
+      const focusables = Array.from(
+        dialogRef.current.querySelectorAll(
+          'button:not([disabled]), [href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"])'
+        )
+      );
+      if (focusables.length === 0) return;
+      const first = focusables[0];
+      const last = focusables[focusables.length - 1];
+      if (e.shiftKey && document.activeElement === first) {
+        e.preventDefault();
+        last.focus();
+      } else if (!e.shiftKey && document.activeElement === last) {
+        e.preventDefault();
+        first.focus();
+      }
+    };
+    window.addEventListener("keydown", onKey);
+    const prevOverflow = document.body.style.overflow;
+    document.body.style.overflow = "hidden";
+    return () => {
+      window.removeEventListener("keydown", onKey);
+      document.body.style.overflow = prevOverflow;
+      previouslyFocused.current?.focus?.();
+    };
+  }, [isOpen]);
+  const handleBackdropClick = react.useCallback(
+    (e) => {
+      if (!closeOnBackdrop) return;
+      if (e.target === e.currentTarget) onClose();
+    },
+    [closeOnBackdrop, onClose]
+  );
+  if (!mounted || !isOpen) return null;
+  const node = /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      onClick: handleBackdropClick,
+      style: {
+        position: "fixed",
+        inset: 0,
+        background: "rgba(15, 12, 8, 0.55)",
+        backdropFilter: "blur(2px)",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        padding: "1rem",
+        zIndex: 2147483e3,
+        animation: "solven-fade-in 140ms ease-out"
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            ref: dialogRef,
+            role: "dialog",
+            "aria-modal": "true",
+            "aria-label": "Wallet sign-in",
+            style: {
+              background: theme.background,
+              color: theme.foreground,
+              fontFamily: theme.fontFamily,
+              padding: "1.5rem",
+              borderRadius: theme.radius,
+              boxShadow: "0 24px 80px rgba(0,0,0,0.22)",
+              maxWidth: 420,
+              width: "100%",
+              position: "relative",
+              animation: "solven-pop-in 160ms cubic-bezier(0.16, 1, 0.3, 1)"
+            },
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "button",
+                {
+                  type: "button",
+                  "aria-label": "Close",
+                  onClick: onClose,
+                  style: {
+                    position: "absolute",
+                    top: 12,
+                    right: 12,
+                    border: "none",
+                    background: "transparent",
+                    color: theme.muted,
+                    fontSize: "1.25rem",
+                    lineHeight: 1,
+                    cursor: "pointer",
+                    padding: "0.25rem 0.5rem",
+                    borderRadius: 8
+                  },
+                  children: "\xD7"
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsx(SolvenLoginContent, { ...content, onCloseAfterSignIn: onClose })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx("style", { children: `
+        @keyframes solven-fade-in {
+          from { opacity: 0; }
+          to   { opacity: 1; }
+        }
+        @keyframes solven-pop-in {
+          from { opacity: 0; transform: translateY(8px) scale(0.98); }
+          to   { opacity: 1; transform: translateY(0)   scale(1);    }
+        }
+      ` })
+      ]
+    }
+  );
+  return reactDom.createPortal(node, document.body);
+}
+var defaultTheme2 = {
+  background: "#ffffff",
+  foreground: "#1a1714",
+  muted: "#6b6359",
+  surface: "#f3ede2",
+  border: "#ece7dd",
+  primary: "#0f766e",
+  radius: "1rem",
+  fontFamily: 'system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif'
+};
+function truncateAddress(address, chars) {
+  if (address.length <= chars * 2 + 3) return address;
+  return `${address.slice(0, chars)}...${address.slice(-chars)}`;
+}
+function SolvenAddress(props) {
+  const wallet = useSolvenWallet();
+  const theme = react.useMemo(() => ({ ...defaultTheme2, ...props.theme ?? {} }), [props.theme]);
+  const truncateChars = props.truncateChars ?? 6;
+  const showCopy = props.showCopy ?? true;
+  const label = props.label ?? "Wallet Address";
+  const [copied, setCopied] = react.useState(false);
+  const handleCopy = react.useCallback(async () => {
+    if (!wallet?.address) return;
+    try {
+      await navigator.clipboard.writeText(wallet.address);
+      setCopied(true);
+      setTimeout(() => setCopied(false), 2e3);
+    } catch {
+      const ta = document.createElement("textarea");
+      ta.value = wallet.address;
+      ta.style.position = "fixed";
+      ta.style.left = "-9999px";
+      document.body.appendChild(ta);
+      ta.select();
+      document.execCommand("copy");
+      document.body.removeChild(ta);
+      setCopied(true);
+      setTimeout(() => setCopied(false), 2e3);
+    }
+  }, [wallet?.address]);
+  if (!wallet) return null;
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      style: {
+        background: theme.background,
+        color: theme.foreground,
+        fontFamily: theme.fontFamily,
+        borderRadius: theme.radius,
+        padding: "1.25rem"
+      },
+      children: [
+        label && /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            style: {
+              fontSize: "0.8125rem",
+              fontWeight: 600,
+              color: theme.muted,
+              marginBottom: "0.75rem",
+              textTransform: "uppercase",
+              letterSpacing: "0.04em"
+            },
+            children: label
+          }
+        ),
+        props.renderQr && /* @__PURE__ */ jsxRuntime.jsx("div", { style: { display: "flex", justifyContent: "center", marginBottom: "1rem" }, children: props.renderQr(wallet.address) }),
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            style: {
+              display: "flex",
+              alignItems: "center",
+              gap: "0.5rem",
+              background: theme.surface,
+              padding: "0.625rem 0.875rem",
+              borderRadius: "0.75rem",
+              border: `1px solid ${theme.border}`
+            },
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "span",
+                {
+                  style: {
+                    flex: 1,
+                    fontFamily: "monospace",
+                    fontSize: "0.875rem",
+                    color: theme.foreground,
+                    overflow: "hidden",
+                    textOverflow: "ellipsis",
+                    whiteSpace: "nowrap"
+                  },
+                  title: wallet.address,
+                  children: truncateAddress(wallet.address, truncateChars)
+                }
+              ),
+              showCopy && /* @__PURE__ */ jsxRuntime.jsx(
+                "button",
+                {
+                  type: "button",
+                  onClick: handleCopy,
+                  style: {
+                    border: "none",
+                    background: copied ? theme.primary : "transparent",
+                    color: copied ? "#ffffff" : theme.muted,
+                    fontSize: "0.75rem",
+                    fontWeight: 600,
+                    padding: "0.375rem 0.625rem",
+                    borderRadius: "0.5rem",
+                    cursor: "pointer",
+                    transition: "all 150ms ease",
+                    whiteSpace: "nowrap"
+                  },
+                  children: copied ? "Copied" : "Copy"
+                }
+              )
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+var defaultTheme3 = {
+  background: "#ffffff",
+  foreground: "#1a1714",
+  muted: "#6b6359",
+  surface: "#f3ede2",
+  border: "#ece7dd",
+  primary: "#0f766e",
+  radius: "1rem",
+  fontFamily: 'system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif'
+};
+function formatTokenAmount(token) {
+  const raw = BigInt(token.amount);
+  if (token.decimals === 0) return raw.toString();
+  const divisor = BigInt(10 ** token.decimals);
+  const whole = raw / divisor;
+  const fractional = raw % divisor;
+  const fracStr = fractional.toString().padStart(token.decimals, "0");
+  const trimmed = fracStr.slice(0, 4).replace(/0+$/, "");
+  return trimmed ? `${whole}.${trimmed}` : whole.toString();
+}
+function getTokenLabel(token) {
+  if (token.symbol) return token.symbol;
+  if (token.mint === "SOL") return "SOL";
+  return `${token.mint.slice(0, 4)}...${token.mint.slice(-4)}`;
+}
+function SolvenBalance(props) {
+  const wallet = useSolvenWallet();
+  const balance = useSolvenBalance(wallet?.id ?? null, props.pollMs);
+  const theme = react.useMemo(() => ({ ...defaultTheme3, ...props.theme ?? {} }), [props.theme]);
+  const showRefresh = props.showRefresh ?? true;
+  const label = props.label ?? "Balance";
+  const compact = props.compact ?? false;
+  const [refreshing, setRefreshing] = react.useState(false);
+  const tokens = react.useMemo(() => {
+    if (!balance?.tokens) return [];
+    if (!props.filterMints) return balance.tokens;
+    const set = new Set(props.filterMints);
+    return balance.tokens.filter((t) => set.has(t.mint));
+  }, [balance?.tokens, props.filterMints]);
+  const handleRefresh = react.useCallback(() => {
+    setRefreshing(true);
+    setTimeout(() => setRefreshing(false), 1500);
+  }, []);
+  if (!wallet) return null;
+  if (compact) {
+    const solToken = tokens.find((t) => t.mint === "SOL");
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "span",
+      {
+        style: {
+          fontFamily: theme.fontFamily,
+          fontSize: "0.9375rem",
+          fontWeight: 600,
+          color: theme.foreground
+        },
+        children: solToken ? `${formatTokenAmount(solToken)} SOL` : "\u2014"
+      }
+    );
+  }
+  const loading = !balance;
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      style: {
+        background: theme.background,
+        color: theme.foreground,
+        fontFamily: theme.fontFamily,
+        borderRadius: theme.radius,
+        padding: "1.25rem"
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            style: {
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "space-between",
+              marginBottom: "0.75rem"
+            },
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "span",
+                {
+                  style: {
+                    fontSize: "0.8125rem",
+                    fontWeight: 600,
+                    color: theme.muted,
+                    textTransform: "uppercase",
+                    letterSpacing: "0.04em"
+                  },
+                  children: label
+                }
+              ),
+              showRefresh && /* @__PURE__ */ jsxRuntime.jsx(
+                "button",
+                {
+                  type: "button",
+                  onClick: handleRefresh,
+                  disabled: refreshing,
+                  style: {
+                    border: "none",
+                    background: "transparent",
+                    color: theme.muted,
+                    fontSize: "0.75rem",
+                    fontWeight: 600,
+                    cursor: refreshing ? "default" : "pointer",
+                    opacity: refreshing ? 0.5 : 1,
+                    padding: "0.25rem 0.5rem",
+                    borderRadius: "0.375rem",
+                    transition: "opacity 150ms ease"
+                  },
+                  children: refreshing ? "Refreshing..." : "Refresh"
+                }
+              )
+            ]
+          }
+        ),
+        loading ? /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            style: {
+              padding: "1rem 0",
+              textAlign: "center",
+              color: theme.muted,
+              fontSize: "0.875rem"
+            },
+            children: "Loading balances..."
+          }
+        ) : tokens.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            style: {
+              padding: "1rem 0",
+              textAlign: "center",
+              color: theme.muted,
+              fontSize: "0.875rem"
+            },
+            children: "No tokens found"
+          }
+        ) : /* @__PURE__ */ jsxRuntime.jsx("div", { style: { display: "flex", flexDirection: "column", gap: "0.5rem" }, children: tokens.map((token) => /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            style: {
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "space-between",
+              padding: "0.625rem 0.875rem",
+              background: theme.surface,
+              borderRadius: "0.75rem",
+              border: `1px solid ${theme.border}`
+            },
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "span",
+                {
+                  style: {
+                    fontSize: "0.8125rem",
+                    fontWeight: 500,
+                    color: theme.muted
+                  },
+                  children: getTokenLabel(token)
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "span",
+                {
+                  style: {
+                    fontSize: "1rem",
+                    fontWeight: 700,
+                    color: theme.foreground,
+                    fontFamily: "monospace"
+                  },
+                  children: formatTokenAmount(token)
+                }
+              )
+            ]
+          },
+          token.mint
+        )) }),
+        balance?.asOf && /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            style: {
+              marginTop: "0.625rem",
+              fontSize: "0.6875rem",
+              color: theme.muted,
+              textAlign: "right"
+            },
+            children: [
+              "Updated ",
+              new Date(balance.asOf).toLocaleTimeString()
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+var defaultTheme4 = {
+  background: "#ffffff",
+  foreground: "#1a1714",
+  muted: "#6b6359",
+  surface: "#f3ede2",
+  border: "#ece7dd",
+  primary: "#0f766e",
+  danger: "#dc2626",
+  radius: "1rem",
+  fontFamily: 'system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif'
+};
+function formatTokenAmount2(token) {
+  const raw = BigInt(token.amount);
+  if (token.decimals === 0) return raw.toString();
+  const divisor = BigInt(10 ** token.decimals);
+  const whole = raw / divisor;
+  const fractional = raw % divisor;
+  const fracStr = fractional.toString().padStart(token.decimals, "0");
+  const trimmed = fracStr.slice(0, 4).replace(/0+$/, "");
+  return trimmed ? `${whole}.${trimmed}` : whole.toString();
+}
+function getTokenLabel2(token) {
+  if (token.symbol) return token.symbol;
+  if (token.mint === "SOL") return "SOL";
+  return `${token.mint.slice(0, 4)}...${token.mint.slice(-4)}`;
+}
+function parseAmountToBaseUnits(amount, decimals) {
+  const parts = amount.split(".");
+  const whole = parts[0] || "0";
+  let frac = parts[1] || "";
+  frac = frac.padEnd(decimals, "0").slice(0, decimals);
+  const raw = BigInt(whole) * BigInt(10 ** decimals) + BigInt(frac);
+  return raw.toString();
+}
+function isValidSolanaAddress(address) {
+  return /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(address);
+}
+function SolvenWithdraw(props) {
+  const wallet = useSolvenWallet();
+  const balance = useSolvenBalance(wallet?.id ?? null);
+  const { client } = useSolvenContext();
+  const theme = react.useMemo(() => ({ ...defaultTheme4, ...props.theme ?? {} }), [props.theme]);
+  const label = props.label ?? "Withdraw";
+  const [toAddress, setToAddress] = react.useState("");
+  const [amount, setAmount] = react.useState("");
+  const [selectedMint, setSelectedMint] = react.useState(props.mint ?? "SOL");
+  const [busy, setBusy] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [successSig, setSuccessSig] = react.useState(null);
+  const tokens = react.useMemo(() => {
+    if (!balance?.tokens) return [];
+    if (props.mint) return balance.tokens.filter((t) => t.mint === props.mint);
+    return balance.tokens;
+  }, [balance?.tokens, props.mint]);
+  const selectedToken = react.useMemo(
+    () => tokens.find((t) => t.mint === selectedMint) ?? null,
+    [tokens, selectedMint]
+  );
+  const availableFormatted = selectedToken ? formatTokenAmount2(selectedToken) : "0";
+  const handleMax = react.useCallback(() => {
+    if (!selectedToken) return;
+    if (selectedToken.mint === "SOL") {
+      const raw = BigInt(selectedToken.amount);
+      const reserve = BigInt(5e6);
+      const maxRaw = raw > reserve ? raw - reserve : 0n;
+      const divisor = BigInt(10 ** selectedToken.decimals);
+      const whole = maxRaw / divisor;
+      const fractional = maxRaw % divisor;
+      const fracStr = fractional.toString().padStart(selectedToken.decimals, "0");
+      const trimmed = fracStr.slice(0, selectedToken.decimals).replace(/0+$/, "");
+      setAmount(trimmed ? `${whole}.${trimmed}` : whole.toString());
+    } else {
+      setAmount(formatTokenAmount2(selectedToken));
+    }
+  }, [selectedToken]);
+  const handleSubmit = react.useCallback(async () => {
+    setError(null);
+    setSuccessSig(null);
+    if (!wallet) {
+      setError("No wallet connected");
+      return;
+    }
+    if (!toAddress.trim()) {
+      setError("Enter a destination address");
+      return;
+    }
+    if (!isValidSolanaAddress(toAddress.trim())) {
+      setError("Invalid Solana address");
+      return;
+    }
+    if (!amount.trim() || parseFloat(amount) <= 0) {
+      setError("Enter a valid amount");
+      return;
+    }
+    if (!selectedToken) {
+      setError("Token not found in wallet");
+      return;
+    }
+    const baseUnits = parseAmountToBaseUnits(amount, selectedToken.decimals);
+    if (BigInt(baseUnits) > BigInt(selectedToken.amount)) {
+      setError("Insufficient balance");
+      return;
+    }
+    setBusy(true);
+    try {
+      const result = await client.withdraw({
+        walletId: wallet.id,
+        toAddress: toAddress.trim(),
+        mint: selectedMint,
+        amount: baseUnits,
+        idempotencyKey: `w-${wallet.id}-${Date.now()}`
+      });
+      setSuccessSig(result.signature);
+      setAmount("");
+      setToAddress("");
+      props.onSuccess?.(result.signature);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : "Withdrawal failed";
+      setError(msg);
+      props.onError?.(e instanceof Error ? e : new Error(msg));
+    } finally {
+      setBusy(false);
+    }
+  }, [wallet, toAddress, amount, selectedMint, selectedToken, client, props]);
+  if (!wallet) return null;
+  const inputStyle = {
+    width: "100%",
+    padding: "0.625rem 0.875rem",
+    borderRadius: "0.75rem",
+    border: `1px solid ${theme.border}`,
+    background: theme.surface,
+    color: theme.foreground,
+    fontFamily: theme.fontFamily,
+    fontSize: "0.875rem",
+    outline: "none",
+    boxSizing: "border-box"
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      style: {
+        background: theme.background,
+        color: theme.foreground,
+        fontFamily: theme.fontFamily,
+        borderRadius: theme.radius,
+        padding: "1.25rem"
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            style: {
+              fontSize: "0.8125rem",
+              fontWeight: 600,
+              color: theme.muted,
+              marginBottom: "1rem",
+              textTransform: "uppercase",
+              letterSpacing: "0.04em"
+            },
+            children: label
+          }
+        ),
+        !props.mint && tokens.length > 1 && /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { marginBottom: "0.75rem" }, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "label",
+            {
+              style: { display: "block", fontSize: "0.75rem", color: theme.muted, marginBottom: "0.25rem" },
+              children: "Token"
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "select",
+            {
+              value: selectedMint,
+              onChange: (e) => {
+                setSelectedMint(e.target.value);
+                setAmount("");
+              },
+              style: {
+                ...inputStyle,
+                cursor: "pointer",
+                appearance: "auto"
+              },
+              children: tokens.map((t) => /* @__PURE__ */ jsxRuntime.jsxs("option", { value: t.mint, children: [
+                getTokenLabel2(t),
+                " \u2014 ",
+                formatTokenAmount2(t)
+              ] }, t.mint))
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { marginBottom: "0.75rem" }, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "label",
+            {
+              style: { display: "block", fontSize: "0.75rem", color: theme.muted, marginBottom: "0.25rem" },
+              children: "To Address"
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "input",
+            {
+              type: "text",
+              value: toAddress,
+              onChange: (e) => setToAddress(e.target.value),
+              placeholder: "Solana address (base58)",
+              disabled: busy,
+              style: inputStyle
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { marginBottom: "0.75rem" }, children: [
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            "div",
+            {
+              style: {
+                display: "flex",
+                alignItems: "center",
+                justifyContent: "space-between",
+                marginBottom: "0.25rem"
+              },
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx("label", { style: { fontSize: "0.75rem", color: theme.muted }, children: "Amount" }),
+                /* @__PURE__ */ jsxRuntime.jsxs("span", { style: { fontSize: "0.6875rem", color: theme.muted }, children: [
+                  "Available: ",
+                  availableFormatted,
+                  " ",
+                  selectedToken ? getTokenLabel2(selectedToken) : ""
+                ] })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { position: "relative" }, children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "input",
+              {
+                type: "text",
+                inputMode: "decimal",
+                value: amount,
+                onChange: (e) => {
+                  const v = e.target.value.replace(/[^0-9.]/g, "");
+                  if (v.split(".").length <= 2) setAmount(v);
+                },
+                placeholder: "0.00",
+                disabled: busy,
+                style: { ...inputStyle, paddingRight: "3.5rem" }
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "button",
+              {
+                type: "button",
+                onClick: handleMax,
+                disabled: busy,
+                style: {
+                  position: "absolute",
+                  right: 8,
+                  top: "50%",
+                  transform: "translateY(-50%)",
+                  border: "none",
+                  background: theme.primary,
+                  color: "#ffffff",
+                  fontSize: "0.6875rem",
+                  fontWeight: 700,
+                  padding: "0.25rem 0.5rem",
+                  borderRadius: "0.375rem",
+                  cursor: "pointer"
+                },
+                children: "MAX"
+              }
+            )
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            type: "button",
+            onClick: handleSubmit,
+            disabled: busy,
+            style: {
+              width: "100%",
+              padding: "0.75rem",
+              borderRadius: theme.radius,
+              border: "none",
+              background: theme.primary,
+              color: "#ffffff",
+              fontWeight: 700,
+              fontSize: "0.9375rem",
+              cursor: busy ? "default" : "pointer",
+              opacity: busy ? 0.6 : 1,
+              transition: "opacity 150ms ease",
+              fontFamily: theme.fontFamily
+            },
+            children: busy ? "Withdrawing..." : "Withdraw"
+          }
+        ),
+        error && /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            role: "alert",
+            style: {
+              marginTop: "0.75rem",
+              padding: "0.625rem 0.75rem",
+              borderRadius: "0.5rem",
+              background: "#fee2e2",
+              color: theme.danger,
+              fontSize: "0.8125rem"
+            },
+            children: error
+          }
+        ),
+        successSig && /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            style: {
+              marginTop: "0.75rem",
+              padding: "0.625rem 0.75rem",
+              borderRadius: "0.5rem",
+              background: "#d1fae5",
+              color: "#065f46",
+              fontSize: "0.8125rem",
+              wordBreak: "break-all"
+            },
+            children: [
+              "Sent! Tx: ",
+              successSig.slice(0, 20),
+              "...",
+              successSig.slice(-8)
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+var defaultTheme5 = {
+  background: "#ffffff",
+  foreground: "#1a1714",
+  muted: "#6b6359",
+  surface: "#f3ede2",
+  border: "#ece7dd",
+  primary: "#0f766e",
+  danger: "#dc2626",
+  radius: "1rem",
+  fontFamily: 'system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif'
+};
+function formatLamports(lamports) {
+  const raw = BigInt(lamports);
+  const whole = raw / 1000000000n;
+  const frac = raw % 1000000000n;
+  const fracStr = frac.toString().padStart(9, "0").slice(0, 4).replace(/0+$/, "");
+  return fracStr ? `${whole}.${fracStr}` : whole.toString();
+}
+function SolvenExport(props) {
+  const wallet = useSolvenWallet();
+  const { preflight, refreshPreflight, exportKey } = useSolvenExport(wallet?.id ?? null);
+  const theme = react.useMemo(() => ({ ...defaultTheme5, ...props.theme ?? {} }), [props.theme]);
+  const label = props.label ?? "Export Wallet";
+  const [step, setStep] = react.useState("preflight");
+  const [busy, setBusy] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [exportedKey, setExportedKey] = react.useState(null);
+  const [newAddress, setNewAddress] = react.useState(null);
+  const [bootstrapSig, setBootstrapSig] = react.useState(null);
+  const [keyCopied, setKeyCopied] = react.useState(false);
+  const handleExport = react.useCallback(async () => {
+    setError(null);
+    setBusy(true);
+    try {
+      const result = await exportKey(`export-${wallet.id}-${Date.now()}`);
+      setExportedKey(result.exportedPrivateKey);
+      setNewAddress(result.newWalletAddress);
+      setBootstrapSig(result.bootstrapTxSignature);
+      setStep("revealed");
+      props.onSuccess?.(result.newWalletAddress);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : "Export failed";
+      setError(msg);
+      props.onError?.(e instanceof Error ? e : new Error(msg));
+    } finally {
+      setBusy(false);
+    }
+  }, [wallet, exportKey, props]);
+  const handleCopyKey = react.useCallback(async () => {
+    if (!exportedKey) return;
+    try {
+      await navigator.clipboard.writeText(exportedKey);
+    } catch {
+      const ta = document.createElement("textarea");
+      ta.value = exportedKey;
+      ta.style.position = "fixed";
+      ta.style.left = "-9999px";
+      document.body.appendChild(ta);
+      ta.select();
+      document.execCommand("copy");
+      document.body.removeChild(ta);
+    }
+    setKeyCopied(true);
+    setTimeout(() => setKeyCopied(false), 3e3);
+  }, [exportedKey]);
+  if (!wallet) return null;
+  const cardStyle = {
+    background: theme.background,
+    color: theme.foreground,
+    fontFamily: theme.fontFamily,
+    borderRadius: theme.radius,
+    padding: "1.25rem"
+  };
+  const headerStyle = {
+    fontSize: "0.8125rem",
+    fontWeight: 600,
+    color: theme.muted,
+    marginBottom: "1rem",
+    textTransform: "uppercase",
+    letterSpacing: "0.04em"
+  };
+  if (step === "preflight") {
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: cardStyle, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { style: headerStyle, children: label }),
+      /* @__PURE__ */ jsxRuntime.jsxs(
+        "div",
+        {
+          style: {
+            padding: "0.875rem",
+            borderRadius: "0.75rem",
+            background: theme.surface,
+            border: `1px solid ${theme.border}`,
+            marginBottom: "1rem",
+            fontSize: "0.875rem",
+            lineHeight: 1.6
+          },
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx("p", { style: { margin: 0, marginBottom: "0.5rem" }, children: "Exporting reveals your wallet's private key and creates a new wallet. Your remaining balance transfers to the new wallet automatically." }),
+            /* @__PURE__ */ jsxRuntime.jsx("p", { style: { margin: 0, fontWeight: 600, color: theme.danger }, children: "This action cannot be undone. Store the private key securely." })
+          ]
+        }
+      ),
+      !preflight ? /* @__PURE__ */ jsxRuntime.jsx("div", { style: { color: theme.muted, fontSize: "0.875rem", textAlign: "center", padding: "0.5rem 0" }, children: "Checking eligibility..." }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            style: {
+              display: "flex",
+              flexDirection: "column",
+              gap: "0.375rem",
+              marginBottom: "1rem",
+              fontSize: "0.8125rem"
+            },
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { display: "flex", justifyContent: "space-between" }, children: [
+                /* @__PURE__ */ jsxRuntime.jsx("span", { style: { color: theme.muted }, children: "Current balance" }),
+                /* @__PURE__ */ jsxRuntime.jsxs("span", { style: { fontFamily: "monospace" }, children: [
+                  formatLamports(preflight.currentBalanceLamports),
+                  " SOL"
+                ] })
+              ] }),
+              /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { display: "flex", justifyContent: "space-between" }, children: [
+                /* @__PURE__ */ jsxRuntime.jsx("span", { style: { color: theme.muted }, children: "Minimum required" }),
+                /* @__PURE__ */ jsxRuntime.jsxs("span", { style: { fontFamily: "monospace" }, children: [
+                  formatLamports(preflight.minBalanceLamports),
+                  " SOL"
+                ] })
+              ] }),
+              /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { display: "flex", justifyContent: "space-between" }, children: [
+                /* @__PURE__ */ jsxRuntime.jsx("span", { style: { color: theme.muted }, children: "Bootstrap to new wallet" }),
+                /* @__PURE__ */ jsxRuntime.jsxs("span", { style: { fontFamily: "monospace" }, children: [
+                  formatLamports(preflight.bootstrapLamports),
+                  " SOL"
+                ] })
+              ] })
+            ]
+          }
+        ),
+        preflight.allowed ? /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            type: "button",
+            onClick: () => setStep("confirm"),
+            style: {
+              width: "100%",
+              padding: "0.75rem",
+              borderRadius: theme.radius,
+              border: "none",
+              background: theme.danger,
+              color: "#ffffff",
+              fontWeight: 700,
+              fontSize: "0.9375rem",
+              cursor: "pointer",
+              fontFamily: theme.fontFamily
+            },
+            children: "Continue to Export"
+          }
+        ) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "div",
+            {
+              style: {
+                padding: "0.625rem 0.75rem",
+                borderRadius: "0.5rem",
+                background: "#fef3c7",
+                color: "#92400e",
+                fontSize: "0.8125rem",
+                marginBottom: "0.75rem"
+              },
+              children: preflight.reason || "Balance is below the minimum required to export."
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              type: "button",
+              onClick: refreshPreflight,
+              style: {
+                width: "100%",
+                padding: "0.625rem",
+                borderRadius: theme.radius,
+                border: `1px solid ${theme.border}`,
+                background: "transparent",
+                color: theme.foreground,
+                fontWeight: 600,
+                fontSize: "0.875rem",
+                cursor: "pointer",
+                fontFamily: theme.fontFamily
+              },
+              children: "Re-check Balance"
+            }
+          )
+        ] })
+      ] })
+    ] });
+  }
+  if (step === "confirm") {
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: cardStyle, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { style: headerStyle, children: "Confirm Export" }),
+      /* @__PURE__ */ jsxRuntime.jsxs(
+        "div",
+        {
+          style: {
+            padding: "0.875rem",
+            borderRadius: "0.75rem",
+            background: "#fef2f2",
+            border: `1px solid #fecaca`,
+            marginBottom: "1rem",
+            fontSize: "0.875rem",
+            color: theme.danger,
+            lineHeight: 1.6
+          },
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx("p", { style: { margin: 0, fontWeight: 700, marginBottom: "0.375rem" }, children: "Are you sure?" }),
+            /* @__PURE__ */ jsxRuntime.jsx("p", { style: { margin: 0 }, children: "Your current wallet's private key will be revealed and then deleted from our servers. A new wallet will be created for future use." })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { display: "flex", gap: "0.625rem" }, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            type: "button",
+            onClick: () => setStep("preflight"),
+            disabled: busy,
+            style: {
+              flex: 1,
+              padding: "0.75rem",
+              borderRadius: theme.radius,
+              border: `1px solid ${theme.border}`,
+              background: "transparent",
+              color: theme.foreground,
+              fontWeight: 600,
+              fontSize: "0.875rem",
+              cursor: "pointer",
+              fontFamily: theme.fontFamily
+            },
+            children: "Cancel"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            type: "button",
+            onClick: handleExport,
+            disabled: busy,
+            style: {
+              flex: 1,
+              padding: "0.75rem",
+              borderRadius: theme.radius,
+              border: "none",
+              background: theme.danger,
+              color: "#ffffff",
+              fontWeight: 700,
+              fontSize: "0.875rem",
+              cursor: busy ? "default" : "pointer",
+              opacity: busy ? 0.6 : 1,
+              fontFamily: theme.fontFamily
+            },
+            children: busy ? "Exporting..." : "Export Now"
+          }
+        )
+      ] }),
+      error && /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          role: "alert",
+          style: {
+            marginTop: "0.75rem",
+            padding: "0.625rem 0.75rem",
+            borderRadius: "0.5rem",
+            background: "#fee2e2",
+            color: theme.danger,
+            fontSize: "0.8125rem"
+          },
+          children: error
+        }
+      )
+    ] });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: cardStyle, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { style: headerStyle, children: "Export Complete" }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        style: {
+          padding: "0.875rem",
+          borderRadius: "0.75rem",
+          background: "#d1fae5",
+          border: "1px solid #a7f3d0",
+          marginBottom: "1rem",
+          fontSize: "0.8125rem",
+          color: "#065f46",
+          lineHeight: 1.5
+        },
+        children: "Your wallet has been exported. A new wallet has been created and your remaining balance has been transferred."
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { marginBottom: "1rem" }, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "label",
+        {
+          style: { display: "block", fontSize: "0.75rem", color: theme.muted, marginBottom: "0.375rem", fontWeight: 600 },
+          children: "Private Key (save this securely)"
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsxs(
+        "div",
+        {
+          style: {
+            position: "relative",
+            background: "#1a1714",
+            borderRadius: "0.75rem",
+            padding: "0.75rem"
+          },
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "code",
+              {
+                style: {
+                  display: "block",
+                  fontFamily: "monospace",
+                  fontSize: "0.75rem",
+                  color: "#f5f5f4",
+                  wordBreak: "break-all",
+                  lineHeight: 1.5
+                },
+                children: exportedKey
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "button",
+              {
+                type: "button",
+                onClick: handleCopyKey,
+                style: {
+                  position: "absolute",
+                  top: 8,
+                  right: 8,
+                  border: "none",
+                  background: keyCopied ? "#065f46" : "rgba(255,255,255,0.15)",
+                  color: "#ffffff",
+                  fontSize: "0.6875rem",
+                  fontWeight: 600,
+                  padding: "0.25rem 0.5rem",
+                  borderRadius: "0.375rem",
+                  cursor: "pointer"
+                },
+                children: keyCopied ? "Copied!" : "Copy"
+              }
+            )
+          ]
+        }
+      )
+    ] }),
+    newAddress && /* @__PURE__ */ jsxRuntime.jsx("div", { style: { marginBottom: "0.75rem", fontSize: "0.8125rem" }, children: /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { display: "flex", justifyContent: "space-between", marginBottom: "0.25rem" }, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { style: { color: theme.muted }, children: "New wallet" }),
+      /* @__PURE__ */ jsxRuntime.jsxs("span", { style: { fontFamily: "monospace", fontSize: "0.75rem" }, children: [
+        newAddress.slice(0, 8),
+        "...",
+        newAddress.slice(-6)
+      ] })
+    ] }) }),
+    bootstrapSig && /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { fontSize: "0.75rem", color: theme.muted, wordBreak: "break-all" }, children: [
+      "Bootstrap tx: ",
+      bootstrapSig.slice(0, 16),
+      "...",
+      bootstrapSig.slice(-8)
+    ] })
+  ] });
+}
+
+// ../../solven/sdk-client/src/transfer-in.ts
+async function buildSolTransferIn(deps, opts) {
+  const { Connection, PublicKey, Transaction, SystemProgram } = deps;
+  const conn = new Connection(opts.rpcUrl, "confirmed");
+  const fromPk = new PublicKey(opts.fromAddress);
+  const toPk = new PublicKey(opts.toAddress);
+  const { blockhash } = await conn.getLatestBlockhash();
+  const tx = new Transaction({ recentBlockhash: blockhash, feePayer: fromPk });
+  tx.add(
+    SystemProgram.transfer({
+      fromPubkey: fromPk,
+      toPubkey: toPk,
+      lamports: Number(BigInt(opts.lamports))
+    })
+  );
+  return Buffer.from(
+    tx.serialize({ requireAllSignatures: false, verifySignatures: false })
+  ).toString("base64");
+}
+async function buildSplTransferIn(deps, opts) {
+  if (!deps.TOKEN_PROGRAM_ID || !deps.createTransferCheckedInstruction || !deps.getAssociatedTokenAddressSync || !deps.createAssociatedTokenAccountInstruction || !deps.getMint) {
+    throw new Error("buildSplTransferIn requires the SPL-token helpers in deps.");
+  }
+  const {
+    Connection,
+    PublicKey,
+    Transaction,
+    TOKEN_PROGRAM_ID,
+    createTransferCheckedInstruction,
+    getAssociatedTokenAddressSync,
+    createAssociatedTokenAccountInstruction,
+    getMint
+  } = deps;
+  const conn = new Connection(opts.rpcUrl, "confirmed");
+  const fromPk = new PublicKey(opts.fromAddress);
+  const toPk = new PublicKey(opts.toAddress);
+  const mintPk = new PublicKey(opts.mint);
+  const mintInfo = await getMint(conn, mintPk);
+  const fromAta = getAssociatedTokenAddressSync(mintPk, fromPk);
+  const toAta = getAssociatedTokenAddressSync(mintPk, toPk);
+  const destInfo = await conn.getAccountInfo(toAta).catch(() => null);
+  const { blockhash } = await conn.getLatestBlockhash();
+  const tx = new Transaction({ recentBlockhash: blockhash, feePayer: fromPk });
+  if (!destInfo) {
+    tx.add(
+      createAssociatedTokenAccountInstruction(fromPk, toAta, toPk, mintPk)
+    );
+  }
+  tx.add(
+    createTransferCheckedInstruction(
+      fromAta,
+      mintPk,
+      toAta,
+      fromPk,
+      BigInt(opts.amount),
+      mintInfo.decimals,
+      [],
+      TOKEN_PROGRAM_ID
+    )
+  );
+  return Buffer.from(
+    tx.serialize({ requireAllSignatures: false, verifySignatures: false })
+  ).toString("base64");
+}
+
+// src/provider.tsx
+var IAMGameWalletProvider = SolvenProvider;
+
+exports.IAMGameWalletClient = SolvenClient;
+exports.IAMGameWalletProvider = IAMGameWalletProvider;
+exports.WalletAddress = SolvenAddress;
+exports.WalletBalance = SolvenBalance;
+exports.WalletExport = SolvenExport;
+exports.WalletLogin = SolvenLogin;
+exports.WalletLoginModal = SolvenLoginModal;
+exports.WalletSdkError = SolvenSdkError;
+exports.WalletWithdraw = SolvenWithdraw;
+exports.backpackAdapter = backpackAdapter;
+exports.buildSolTransferIn = buildSolTransferIn;
+exports.buildSplTransferIn = buildSplTransferIn;
+exports.getTelegramInitData = getTelegramInitData;
+exports.inMemorySession = inMemorySession;
+exports.isTelegramMiniApp = isTelegramMiniApp;
+exports.listSupportedWallets = listSupportedWallets;
+exports.localStorageSession = localStorageSession;
+exports.notifyTelegramReady = notifyTelegramReady;
+exports.phantomAdapter = phantomAdapter;
+exports.solflareAdapter = solflareAdapter;
+exports.useWallet = useSolvenWallet;
+exports.useWalletAuth = useSolvenAuth;
+exports.useWalletBalance = useSolvenBalance;
+exports.useWalletExport = useSolvenExport;
+exports.useWalletSign = useSolvenSign;
+exports.useWalletTransferIn = useSolvenTransferIn;