@horus-wallet/sdk-react 0.1.0-beta.2 → 0.3.0-beta.2

package/dist/index.js

@@ -89,19 +89,21 @@ function makeHttp(deps) {
     return path.startsWith("/") ? `${base}${path}` : `${base}/${path}`;
   };
   async function rawRequest(method, path, body, options = {}) {
-    const headers = { "Content-Type": "application/json" };
+    const headers = {
+      "Content-Type": "application/json",
+      "x-horus-key": deps.appId
+    };
     if (options.auth !== false) {
       const tokens = deps.getTokens();
       if (tokens?.idToken) {
-        headers["x-horus-id-token"] = tokens.idToken;
+        headers["Authorization"] = `Bearer ${tokens.idToken}`;
       }
     }
     const res = await fetch(url(path), {
       method,
       headers,
       body: body !== void 0 ? JSON.stringify(body) : void 0,
-      signal: options.signal,
-      credentials: "same-origin"
+      signal: options.signal
     });
     const text = await res.text();
     let parsed = void 0;
@@ -142,9 +144,15 @@ function makeHttp(deps) {
 
 // src/HorusProvider.tsx
 import { jsx } from "react/jsx-runtime";
-var DEFAULT_API_BASE = "/api/horus";
+var DEFAULT_API_BASE = "https://api.horuswallet.com";
 var DEFAULT_AUTH_PAGE = "https://auth.horuswallet.com";
 var REFRESH_LEAD_SECONDS = 60;
+var DEFAULT_AUTO_PROVISION = {
+  network: "ETHEREUM",
+  networkType: "MAINNET"
+};
+var DEFAULT_CHAIN = { network: "ETHEREUM", networkType: "MAINNET" };
+var AUTO_PROVISION_STORAGE_KEY = "horus.autoProvisioned.localIds";
 function HorusProvider(props) {
   const {
     appId,
@@ -153,11 +161,25 @@ function HorusProvider(props) {
     branding,
     tokenStorage = "localStorage",
     autoRefresh = true,
+    autoProvisionWallet = DEFAULT_AUTO_PROVISION,
+    defaultChain = DEFAULT_CHAIN,
     children
   } = props;
   const tokenStoreRef = useRef(createTokenStore(tokenStorage));
   const tokensRef = useRef(null);
   const [state, setState] = useState({ status: "loading" });
+  const [walletsVersion, setWalletsVersion] = useState(0);
+  const revalidateWallets = useCallback(() => {
+    setWalletsVersion((v) => v + 1);
+  }, []);
+  const [currentChain, setCurrentChain] = useState(defaultChain);
+  const setChain = useCallback((chain) => {
+    setCurrentChain(chain);
+  }, []);
+  const [mcpKeysVersion, setMcpKeysVersion] = useState(0);
+  const revalidateMcpKeys = useCallback(() => {
+    setMcpKeysVersion((v) => v + 1);
+  }, []);
   const setTokens = useCallback((tokens) => {
     tokensRef.current = tokens;
     if (tokens) {
@@ -178,9 +200,11 @@ function HorusProvider(props) {
       if (!cur?.refreshToken) throw new Error("no refresh token cached");
       const fresh = await fetch(joinUrl(apiBase, "/auth/refresh"), {
         method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ refreshToken: cur.refreshToken }),
-        credentials: "same-origin"
+        headers: {
+          "Content-Type": "application/json",
+          "x-horus-key": appId
+        },
+        body: JSON.stringify({ refreshToken: cur.refreshToken })
       });
       if (!fresh.ok) throw new Error(`refresh failed: ${fresh.status}`);
       const raw = await fresh.json();
@@ -190,11 +214,12 @@ function HorusProvider(props) {
     };
     return makeHttp({
       apiBase,
+      appId,
       getTokens: () => tokensRef.current,
       refreshTokens: refreshOnce,
       autoRefresh
     });
-  }, [apiBase, autoRefresh, setTokens]);
+  }, [apiBase, appId, autoRefresh, setTokens]);
   useEffect(() => {
     const stored = tokenStoreRef.current.read();
     if (stored) {
@@ -208,6 +233,58 @@ function HorusProvider(props) {
       setState({ status: "unauthenticated" });
     }
   }, []);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const params = new URLSearchParams(window.location.search);
+    const mode = params.get("mode");
+    const oobCode = params.get("oobCode");
+    if (mode !== "signIn" || !oobCode) return;
+    if (consumedMagicLinkCodes.has(oobCode)) return;
+    consumedMagicLinkCodes.add(oobCode);
+    const email = params.get("email") ?? (typeof window.localStorage !== "undefined" ? window.localStorage.getItem("horus.signinEmail") : null) ?? "";
+    if (!email) {
+      console.warn(
+        "@horus-wallet/sdk-react: detected a magic-link return but no email is available. Pass `email` in the continueUrl or set localStorage.horus.signinEmail at send time."
+      );
+      return;
+    }
+    void (async () => {
+      try {
+        const stripUrlParams = () => {
+          const u = new URL(window.location.href);
+          ["mode", "oobCode", "apiKey", "continueUrl", "lang", "email"].forEach(
+            (k) => u.searchParams.delete(k)
+          );
+          window.history.replaceState({}, "", u.toString());
+          if (window.localStorage) {
+            window.localStorage.removeItem("horus.signinEmail");
+          }
+        };
+        const raw = await fetch(joinUrl(apiBase, "/auth/email-link/verify"), {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "x-horus-key": appId
+          },
+          body: JSON.stringify({ email, oobCode })
+        });
+        if (!raw.ok) {
+          const body = await raw.text();
+          console.warn(
+            `@horus-wallet/sdk-react: magic-link verify failed (HTTP ${raw.status}): ${body}`
+          );
+          stripUrlParams();
+          return;
+        }
+        const json = await raw.json();
+        const stamped = stampExpiry(json);
+        setTokens(stamped);
+        stripUrlParams();
+      } catch (err) {
+        console.warn("@horus-wallet/sdk-react: magic-link verify threw", err);
+      }
+    })();
+  }, [apiBase, appId, setTokens]);
   useEffect(() => {
     if (typeof window === "undefined") return;
     const onStorage = (ev) => {
@@ -233,6 +310,27 @@ function HorusProvider(props) {
     }, refreshIn);
     return () => clearTimeout(handle);
   }, [state, autoRefresh, http, setTokens]);
+  useEffect(() => {
+    if (state.status !== "authenticated") return;
+    if (!autoProvisionWallet) return;
+    const localId = state.tokens.localId;
+    if (!localId) return;
+    if (alreadyAutoProvisioned(localId)) return;
+    let cancelled = false;
+    (async () => {
+      try {
+        await http.post("/createWallet", autoProvisionWallet);
+        if (cancelled) return;
+        markAutoProvisioned(localId);
+        revalidateWallets();
+      } catch (err) {
+        console.warn("@horus-wallet/sdk-react: auto-provision wallet failed", err);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [state, autoProvisionWallet, http, revalidateWallets]);
   const ctx = useMemo(
     () => ({
       state,
@@ -253,9 +351,28 @@ function HorusProvider(props) {
         const stamped = stampExpiry(raw);
         setTokens(stamped);
         return stamped;
-      }
+      },
+      walletsVersion,
+      revalidateWallets,
+      currentChain,
+      setChain,
+      mcpKeysVersion,
+      revalidateMcpKeys
     }),
-    [state, http, authPageUrl, appId, branding, setTokens]
+    [
+      state,
+      http,
+      authPageUrl,
+      appId,
+      branding,
+      setTokens,
+      walletsVersion,
+      revalidateWallets,
+      currentChain,
+      setChain,
+      mcpKeysVersion,
+      revalidateMcpKeys
+    ]
   );
   return /* @__PURE__ */ jsx(HorusContext.Provider, { value: ctx, children });
 }
@@ -269,6 +386,37 @@ function userFromTokens(t) {
     providerId: t.providerId
   };
 }
+var consumedMagicLinkCodes = /* @__PURE__ */ new Set();
+var memoryAutoProvisioned = /* @__PURE__ */ new Set();
+function readAutoProvisionedSet() {
+  if (typeof window === "undefined" || !window.localStorage) {
+    return memoryAutoProvisioned;
+  }
+  try {
+    const raw = window.localStorage.getItem(AUTO_PROVISION_STORAGE_KEY);
+    if (!raw) return /* @__PURE__ */ new Set();
+    const parsed = JSON.parse(raw);
+    return new Set(Array.isArray(parsed) ? parsed : []);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function alreadyAutoProvisioned(localId) {
+  return readAutoProvisionedSet().has(localId);
+}
+function markAutoProvisioned(localId) {
+  if (typeof window === "undefined" || !window.localStorage) {
+    memoryAutoProvisioned.add(localId);
+    return;
+  }
+  try {
+    const set = readAutoProvisionedSet();
+    set.add(localId);
+    window.localStorage.setItem(AUTO_PROVISION_STORAGE_KEY, JSON.stringify([...set]));
+  } catch {
+    memoryAutoProvisioned.add(localId);
+  }
+}
 function joinUrl(base, path) {
   const b = base.endsWith("/") ? base.slice(0, -1) : base;
   const p = path.startsWith("/") ? path : `/${path}`;
@@ -277,6 +425,39 @@ function joinUrl(base, path) {
 
 // src/hooks/useHorusAuth.ts
 import { useCallback as useCallback2 } from "react";
+
+// src/internal/authUrl.ts
+function buildAuthUrl(p, state) {
+  const url = new URL(p.baseUrl);
+  url.searchParams.set("flow", p.flow);
+  url.searchParams.set("origin", window.location.origin);
+  url.searchParams.set("state", state);
+  url.searchParams.set("appKey", p.appId);
+  url.searchParams.set("mode", p.mode);
+  if (p.phone) url.searchParams.set("phone", p.phone);
+  if (p.flow === "unified" && p.enabledMethods && p.enabledMethods.length > 0) {
+    url.searchParams.set("methods", p.enabledMethods.join(","));
+  }
+  const b = p.branding;
+  if (b) {
+    if (b.logoUrl) url.searchParams.set("b_logo", b.logoUrl);
+    if (b.brandName) url.searchParams.set("b_name", b.brandName);
+    if (b.primaryColor) url.searchParams.set("b_color", b.primaryColor);
+    if (b.backgroundColor) url.searchParams.set("b_bg", b.backgroundColor);
+    if (b.fontFamily) url.searchParams.set("b_font", b.fontFamily);
+    if (b.termsUrl) url.searchParams.set("b_terms", b.termsUrl);
+    if (b.privacyUrl) url.searchParams.set("b_privacy", b.privacyUrl);
+    if (b.showPoweredByHorus === false) url.searchParams.set("b_poweredby", "0");
+  }
+  return url.toString();
+}
+function randomState() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/hooks/useHorusAuth.ts
 function useHorusAuth() {
   const ctx = useHorusContext();
   const { state, http, signIn, signOut, refreshTokens, authPageUrl, appId, branding } = ctx;
@@ -376,7 +557,7 @@ function openPopupFlow(params) {
       return;
     }
     const state = randomState();
-    const url = buildAuthUrl(params, state);
+    const url = buildAuthUrl({ ...params, mode: "popup" }, state);
     const popup = window.open(url, "horus-auth", defaultPopupFeatures());
     if (!popup) {
       reject(new Error("Popup blocked \u2014 call from a click handler so the browser allows it."));
@@ -384,6 +565,7 @@ function openPopupFlow(params) {
     }
     const expectedOrigin = new URL(params.baseUrl).origin;
     let settled = false;
+    let lastError = null;
     const cleanup = () => {
       window.removeEventListener("message", onMessage);
       clearInterval(poll);
@@ -414,17 +596,11 @@ function openPopupFlow(params) {
             popup.close();
           } catch {
           }
-          reject(new Error("User cancelled sign-in."));
+          reject(new Error(lastError ?? "User cancelled sign-in."));
           return;
         case "error":
           if (settled) return;
-          settled = true;
-          cleanup();
-          try {
-            popup.close();
-          } catch {
-          }
-          reject(new Error(body.message || "Sign-in failed."));
+          lastError = body.message || "Sign-in failed.";
           return;
       }
     };
@@ -433,31 +609,11 @@ function openPopupFlow(params) {
       if (popup.closed && !settled) {
         settled = true;
         cleanup();
-        reject(new Error("Auth popup was closed before sign-in completed."));
+        reject(new Error(lastError ?? "Auth popup was closed before sign-in completed."));
       }
     }, 400);
   });
 }
-function buildAuthUrl(p, state) {
-  const url = new URL(p.baseUrl);
-  url.searchParams.set("flow", p.flow);
-  url.searchParams.set("origin", window.location.origin);
-  url.searchParams.set("state", state);
-  url.searchParams.set("appKey", p.appId);
-  if (p.phone) url.searchParams.set("phone", p.phone);
-  const b = p.branding;
-  if (b) {
-    if (b.logoUrl) url.searchParams.set("b_logo", b.logoUrl);
-    if (b.brandName) url.searchParams.set("b_name", b.brandName);
-    if (b.primaryColor) url.searchParams.set("b_color", b.primaryColor);
-    if (b.backgroundColor) url.searchParams.set("b_bg", b.backgroundColor);
-    if (b.fontFamily) url.searchParams.set("b_font", b.fontFamily);
-    if (b.termsUrl) url.searchParams.set("b_terms", b.termsUrl);
-    if (b.privacyUrl) url.searchParams.set("b_privacy", b.privacyUrl);
-    if (b.showPoweredByHorus === false) url.searchParams.set("b_poweredby", "0");
-  }
-  return url.toString();
-}
 function defaultPopupFeatures() {
   const w = 480, h = 640;
   if (typeof window === "undefined") return `width=${w},height=${h}`;
@@ -465,11 +621,6 @@ function defaultPopupFeatures() {
   const top = Math.max(0, (window.innerHeight - h) / 2 + (window.screenY ?? 0));
   return `width=${w},height=${h},left=${left},top=${top},popup=1`;
 }
-function randomState() {
-  const bytes = new Uint8Array(16);
-  crypto.getRandomValues(bytes);
-  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
-}
 
 // src/hooks/useUser.ts
 function useUser() {
@@ -480,7 +631,7 @@ function useUser() {
 // src/hooks/useWallets.ts
 import { useCallback as useCallback3, useEffect as useEffect2, useState as useState2 } from "react";
 function useWallets() {
-  const { http, state } = useHorusContext();
+  const { http, state, walletsVersion } = useHorusContext();
   const [wallets, setWallets] = useState2([]);
   const [ready, setReady] = useState2(false);
   const [error, setError] = useState2(void 0);
@@ -494,7 +645,7 @@ function useWallets() {
     setError(void 0);
     try {
       const response = await http.get(
-        "/wallets"
+        "/getWallet"
       );
       const flat = [];
       for (const [network, group] of Object.entries(response.wallets ?? {})) {
@@ -511,22 +662,94 @@ function useWallets() {
   }, [http, state.status]);
   useEffect2(() => {
     void load();
-  }, [load]);
+  }, [load, walletsVersion]);
   return { ready, wallets, refresh: load, error };
 }
 
-// src/hooks/useSignMessage.ts
+// src/hooks/useCreateWallet.ts
 import { useCallback as useCallback4, useState as useState3 } from "react";
-function useSignMessage() {
-  const { http } = useHorusContext();
+function useCreateWallet() {
+  const { http, revalidateWallets } = useHorusContext();
   const [pending, setPending] = useState3(false);
   const [error, setError] = useState3(void 0);
-  const signMessage = useCallback4(
+  const create = useCallback4(
+    async (input) => {
+      if (pending) {
+        const err = new Error(
+          "useCreateWallet: a previous create() call is still in flight"
+        );
+        setError(err);
+        throw err;
+      }
+      setPending(true);
+      setError(void 0);
+      try {
+        const response = await http.post("/createWallet", {
+          network: input.network,
+          networkType: input.networkType,
+          ...input.password ? { password: input.password } : {}
+        });
+        revalidateWallets();
+        return response;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        throw e;
+      } finally {
+        setPending(false);
+      }
+    },
+    [http, revalidateWallets, pending]
+  );
+  return { create, pending, error };
+}
+
+// src/hooks/useSwitchChain.ts
+import { useCallback as useCallback5 } from "react";
+var SUPPORTED_CHAINS = [
+  // EVM-family chains the backend accepts as `network` selectors.
+  // `EVM` itself is intentionally NOT here — it's a family label, not
+  // a chain, and the API rejects it on /createWallet, /signMessage, etc.
+  // Pick a specific chain when interacting with the API.
+  "ETHEREUM",
+  "BASE",
+  "POLYGON",
+  "BSC",
+  "ARBITRUM",
+  "OPTIMISM",
+  "TELOS",
+  "CHILIZ",
+  "FLARE",
+  // Non-EVM chains.
+  "BITCOIN",
+  "ICP",
+  "CASPER",
+  "AETERNITY"
+];
+function useSwitchChain() {
+  const { currentChain, setChain } = useHorusContext();
+  const switchChain = useCallback5(
+    (chain) => {
+      setChain(chain);
+    },
+    [setChain]
+  );
+  return { chain: currentChain, switchChain, supportedChains: SUPPORTED_CHAINS };
+}
+var useChain = useSwitchChain;
+
+// src/hooks/useSignMessage.ts
+import { useCallback as useCallback6, useState as useState4 } from "react";
+function useSignMessage() {
+  const { http } = useHorusContext();
+  const [pending, setPending] = useState4(false);
+  const [error, setError] = useState4(void 0);
+  const signMessage = useCallback6(
     async (input) => {
       setPending(true);
       setError(void 0);
       try {
-        const response = await http.post("/sign-message", input);
+        const response = await http.post("/signMessage", input);
         return response.signature;
       } catch (err) {
         const e = err instanceof Error ? err : new Error(String(err));
@@ -541,13 +764,79 @@ function useSignMessage() {
   return { signMessage, pending, error };
 }
 
+// src/hooks/useSignTypedData.ts
+import { useCallback as useCallback7, useState as useState5 } from "react";
+function useSignTypedData() {
+  const { http } = useHorusContext();
+  const [pending, setPending] = useState5(false);
+  const [error, setError] = useState5(void 0);
+  const signTypedData = useCallback7(
+    async (input) => {
+      setPending(true);
+      setError(void 0);
+      try {
+        const response = await http.post("/signTypedData", {
+          network: input.network,
+          networkType: input.networkType,
+          typedData: input.typedData,
+          ...typeof input.walletIndex === "number" ? { walletIndex: input.walletIndex } : {},
+          ...input.password ? { password: input.password } : {}
+        });
+        return response.signature;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        throw e;
+      } finally {
+        setPending(false);
+      }
+    },
+    [http]
+  );
+  return { signTypedData, pending, error };
+}
+
+// src/hooks/useSendTransaction.ts
+import { useCallback as useCallback8, useState as useState6 } from "react";
+function useSendTransaction() {
+  const { http } = useHorusContext();
+  const [pending, setPending] = useState6(false);
+  const [error, setError] = useState6(void 0);
+  const sendTransaction = useCallback8(
+    async (input) => {
+      setPending(true);
+      setError(void 0);
+      try {
+        return await http.post("/sendTransaction", {
+          network: input.network,
+          networkType: input.networkType,
+          to: input.to,
+          ...input.value !== void 0 ? { value: String(input.value) } : {},
+          ...input.data !== void 0 ? { data: input.data } : {},
+          ...input.gasLimit !== void 0 ? { gasLimit: String(input.gasLimit) } : {},
+          ...typeof input.walletIndex === "number" ? { walletIndex: input.walletIndex } : {},
+          ...input.password ? { password: input.password } : {}
+        });
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        throw e;
+      } finally {
+        setPending(false);
+      }
+    },
+    [http]
+  );
+  return { sendTransaction, pending, error };
+}
+
 // src/hooks/useTransfer.ts
-import { useCallback as useCallback5, useState as useState4 } from "react";
+import { useCallback as useCallback9, useState as useState7 } from "react";
 function useTransfer() {
   const { http } = useHorusContext();
-  const [pending, setPending] = useState4(false);
-  const [error, setError] = useState4(void 0);
-  const wrap = useCallback5(
+  const [pending, setPending] = useState7(false);
+  const [error, setError] = useState7(void 0);
+  const wrap = useCallback9(
     async (fn) => {
       setPending(true);
       setError(void 0);
@@ -563,18 +852,18 @@ function useTransfer() {
     },
     []
   );
-  const native = useCallback5(
+  const native = useCallback9(
     (input) => wrap(
-      () => http.post("/transfer/native", {
+      () => http.post("/nativeTransfer", {
         ...input,
         amount: typeof input.amount === "bigint" ? input.amount.toString() : String(input.amount)
       })
     ),
     [http, wrap]
   );
-  const token = useCallback5(
+  const token = useCallback9(
     (input) => wrap(
-      () => http.post("/transfer/token", {
+      () => http.post("/tokenTransfer", {
         ...input,
         amount: typeof input.amount === "bigint" ? input.amount.toString() : String(input.amount)
       })
@@ -585,7 +874,7 @@ function useTransfer() {
 }
 
 // src/components/HorusLoginButton.tsx
-import { useState as useState5 } from "react";
+import { useState as useState8 } from "react";
 import { jsx as jsx2 } from "react/jsx-runtime";
 function HorusLoginButton({
   flow = "google",
@@ -598,7 +887,7 @@ function HorusLoginButton({
   ...rest
 }) {
   const auth = useHorusAuth();
-  const [busy, setBusy] = useState5(false);
+  const [busy, setBusy] = useState8(false);
   const onClick = async () => {
     if (busy) return;
     setBusy(true);
@@ -636,13 +925,458 @@ function HorusLoginButton({
     }
   );
 }
+
+// src/components/HorusAuthModal.tsx
+import { useCallback as useCallback10, useEffect as useEffect3, useMemo as useMemo2, useRef as useRef2 } from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var defaultBackdropStyle = {
+  position: "fixed",
+  inset: 0,
+  background: "rgba(0, 0, 0, 0.5)",
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "center",
+  zIndex: 2147483600
+};
+var defaultDialogStyle = {
+  width: "480px",
+  maxWidth: "95vw",
+  height: "640px",
+  maxHeight: "95vh",
+  background: "#fff",
+  borderRadius: "16px",
+  boxShadow: "0 24px 56px rgba(0, 0, 0, 0.32)",
+  overflow: "hidden"
+};
+function HorusAuthModal(props) {
+  const {
+    flow,
+    enabledMethods,
+    phone,
+    open,
+    onClose,
+    onSuccess,
+    onError,
+    dialogStyle,
+    backdropStyle
+  } = props;
+  const { appId, authPageUrl, branding, signIn } = useHorusContext();
+  const stateRef = useRef2("");
+  if (stateRef.current === "" || !open) {
+    stateRef.current = randomState();
+  }
+  const iframeSrc = useMemo2(() => {
+    if (!open) return "";
+    return buildAuthUrl(
+      {
+        flow,
+        appId,
+        baseUrl: authPageUrl,
+        mode: "iframe",
+        branding,
+        phone,
+        enabledMethods
+      },
+      stateRef.current
+    );
+  }, [open, flow, appId, authPageUrl, branding, phone, enabledMethods]);
+  const expectedOrigin = useMemo2(() => {
+    try {
+      return new URL(authPageUrl).origin;
+    } catch {
+      return "";
+    }
+  }, [authPageUrl]);
+  useEffect3(() => {
+    if (!open) return;
+    const onMessage = (ev) => {
+      if (ev.origin !== expectedOrigin) return;
+      const data = ev.data;
+      if (!data || data.channel !== "horus.auth" || data.version !== 1) return;
+      if (data.state !== void 0 && data.state !== stateRef.current) return;
+      const body = data.body;
+      if (!body) return;
+      switch (body.type) {
+        case "success": {
+          const stamped = stampExpiry({
+            idToken: body.idToken,
+            refreshToken: "",
+            expiresIn: body.expiresAt ? Math.max(60, body.expiresAt - Math.floor(Date.now() / 1e3)) : 3600,
+            localId: body.user?.uid ?? "",
+            email: body.user?.email,
+            displayName: body.user?.displayName,
+            photoUrl: body.user?.photoURL,
+            providerId: body.user?.providerId
+          });
+          signIn(stamped);
+          onSuccess?.({
+            uid: stamped.localId,
+            email: stamped.email,
+            emailVerified: stamped.emailVerified,
+            displayName: stamped.displayName,
+            photoUrl: stamped.photoUrl,
+            providerId: stamped.providerId
+          });
+          onClose();
+          return;
+        }
+        case "cancel":
+          onClose();
+          return;
+        case "error":
+          onError?.(new Error(body.message ?? "Sign-in failed."));
+          return;
+      }
+    };
+    window.addEventListener("message", onMessage);
+    return () => window.removeEventListener("message", onMessage);
+  }, [open, expectedOrigin, signIn, onSuccess, onError, onClose]);
+  useEffect3(() => {
+    if (!open) return;
+    const onKey = (ev) => {
+      if (ev.key === "Escape") onClose();
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [open, onClose]);
+  useEffect3(() => {
+    if (!open) return;
+    if (typeof document === "undefined") return;
+    const prev = document.body.style.overflow;
+    document.body.style.overflow = "hidden";
+    return () => {
+      document.body.style.overflow = prev;
+    };
+  }, [open]);
+  const backdropClick = useCallback10(
+    (ev) => {
+      if (ev.target === ev.currentTarget) onClose();
+    },
+    [onClose]
+  );
+  if (!open || typeof window === "undefined") return null;
+  return /* @__PURE__ */ jsx3(
+    "div",
+    {
+      role: "dialog",
+      "aria-modal": "true",
+      "aria-label": "Sign in with Horus",
+      style: { ...defaultBackdropStyle, ...backdropStyle },
+      onClick: backdropClick,
+      children: /* @__PURE__ */ jsx3("div", { style: { ...defaultDialogStyle, ...dialogStyle }, children: /* @__PURE__ */ jsx3(
+        "iframe",
+        {
+          src: iframeSrc,
+          title: "Horus authentication",
+          allow: "publickey-credentials-get; publickey-credentials-create; clipboard-write",
+          style: { width: "100%", height: "100%", border: "none" }
+        }
+      ) })
+    }
+  );
+}
+
+// src/components/HorusRevealModal.tsx
+import { useCallback as useCallback11, useEffect as useEffect4, useMemo as useMemo3, useRef as useRef3 } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var defaultBackdropStyle2 = {
+  position: "fixed",
+  inset: 0,
+  background: "rgba(0, 0, 0, 0.5)",
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "center",
+  zIndex: 2147483600
+};
+var defaultDialogStyle2 = {
+  width: "480px",
+  maxWidth: "95vw",
+  height: "640px",
+  maxHeight: "95vh",
+  background: "#fff",
+  borderRadius: "16px",
+  boxShadow: "0 24px 56px rgba(0, 0, 0, 0.32)",
+  overflow: "hidden"
+};
+function HorusRevealModal(props) {
+  const { revealToken, open, onClose, onComplete, onError, dialogStyle, backdropStyle } = props;
+  const { appId, authPageUrl, branding } = useHorusContext();
+  const stateRef = useRef3("");
+  if (stateRef.current === "" || !open) {
+    stateRef.current = randomState();
+  }
+  const iframeSrc = useMemo3(() => {
+    if (!open || !revealToken) return "";
+    const baseUrl = buildAuthUrl(
+      {
+        flow: "reveal",
+        appId,
+        baseUrl: authPageUrl,
+        mode: "iframe",
+        branding
+      },
+      stateRef.current
+    );
+    const u = new URL(baseUrl);
+    u.searchParams.set("token", revealToken);
+    return u.toString();
+  }, [open, revealToken, appId, authPageUrl, branding]);
+  const expectedOrigin = useMemo3(() => {
+    try {
+      return new URL(authPageUrl).origin;
+    } catch {
+      return "";
+    }
+  }, [authPageUrl]);
+  useEffect4(() => {
+    if (!open) return;
+    const onMessage = (ev) => {
+      if (ev.origin !== expectedOrigin) return;
+      const data = ev.data;
+      if (!data || data.channel !== "horus.auth" || data.version !== 1) return;
+      if (data.state !== void 0 && data.state !== stateRef.current) return;
+      const body = data.body;
+      if (!body) return;
+      switch (body.type) {
+        case "reveal_complete":
+          onComplete?.(Boolean(body.viewed));
+          onClose();
+          return;
+        case "cancel":
+          onClose();
+          return;
+        case "error":
+          onError?.(new Error(body.message ?? "Reveal failed."));
+          onClose();
+          return;
+      }
+    };
+    window.addEventListener("message", onMessage);
+    return () => window.removeEventListener("message", onMessage);
+  }, [open, expectedOrigin, onComplete, onClose, onError]);
+  useEffect4(() => {
+    if (!open) return;
+    const onKey = (ev) => {
+      if (ev.key === "Escape") onClose();
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [open, onClose]);
+  useEffect4(() => {
+    if (!open) return;
+    if (typeof document === "undefined") return;
+    const prev = document.body.style.overflow;
+    document.body.style.overflow = "hidden";
+    return () => {
+      document.body.style.overflow = prev;
+    };
+  }, [open]);
+  const backdropClick = useCallback11(
+    (ev) => {
+      if (ev.target === ev.currentTarget) onClose();
+    },
+    [onClose]
+  );
+  if (!open || !revealToken || typeof window === "undefined") return null;
+  return /* @__PURE__ */ jsx4(
+    "div",
+    {
+      role: "dialog",
+      "aria-modal": "true",
+      "aria-label": "Reveal wallet private key",
+      style: { ...defaultBackdropStyle2, ...backdropStyle },
+      onClick: backdropClick,
+      children: /* @__PURE__ */ jsx4("div", { style: { ...defaultDialogStyle2, ...dialogStyle }, children: /* @__PURE__ */ jsx4(
+        "iframe",
+        {
+          src: iframeSrc,
+          title: "Horus wallet export",
+          allow: "clipboard-write",
+          style: { width: "100%", height: "100%", border: "none" }
+        }
+      ) })
+    }
+  );
+}
+
+// src/hooks/useExportWallet.ts
+import { useCallback as useCallback12, useState as useState9 } from "react";
+function useExportWallet() {
+  const { http } = useHorusContext();
+  const [pending, setPending] = useState9(false);
+  const [error, setError] = useState9(void 0);
+  const reveal = useCallback12(
+    async (input) => {
+      setPending(true);
+      setError(void 0);
+      try {
+        const response = await http.post(
+          "/exportWallet/grant",
+          {
+            network: input.network,
+            networkType: input.networkType,
+            password: input.password,
+            ...typeof input.walletIndex === "number" ? { walletIndex: input.walletIndex } : {}
+          }
+        );
+        return response;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        throw e;
+      } finally {
+        setPending(false);
+      }
+    },
+    [http]
+  );
+  return { reveal, pending, error };
+}
+
+// src/hooks/useMcp.ts
+import { useCallback as useCallback13, useEffect as useEffect5, useState as useState10 } from "react";
+function useGenerateMcpKey() {
+  const { http, walletsVersion } = useHorusContext();
+  void walletsVersion;
+  const [pending, setPending] = useState10(false);
+  const [error, setError] = useState10(void 0);
+  const [lastResult, setLastResult] = useState10(null);
+  const generate = useCallback13(
+    async (input) => {
+      setPending(true);
+      setError(void 0);
+      try {
+        const response = await http.post("/mcp/keys/generate", {
+          name: input.name,
+          network: input.network,
+          wallet_index: typeof input.walletIndex === "number" ? input.walletIndex : 0,
+          expires_at: input.expiresAt,
+          allowed_ips: input.allowedIps,
+          allowed_tools: input.allowedTools,
+          max_requests_per_minute: input.maxRequestsPerMinute,
+          mcp_password: input.mcpPassword
+        });
+        setLastResult(response);
+        return response;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        throw e;
+      } finally {
+        setPending(false);
+      }
+    },
+    [http]
+  );
+  return { generate, pending, error, lastResult, clearLastResult: () => setLastResult(null) };
+}
+function useMcpKeys() {
+  const { http, state, mcpKeysVersion } = useHorusContext();
+  const [keys, setKeys] = useState10([]);
+  const [ready, setReady] = useState10(false);
+  const [error, setError] = useState10(void 0);
+  const load = useCallback13(async () => {
+    if (state.status !== "authenticated") {
+      setKeys([]);
+      setReady(true);
+      return;
+    }
+    setReady(false);
+    setError(void 0);
+    try {
+      const response = await http.get("/mcp/keys");
+      setKeys(response?.keys ?? []);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setReady(true);
+    }
+  }, [http, state.status]);
+  useEffect5(() => {
+    void load();
+  }, [load, mcpKeysVersion]);
+  return { ready, keys, refresh: load, error };
+}
+function useRevokeMcpKey() {
+  const { http, revalidateMcpKeys } = useHorusContext();
+  const [pending, setPending] = useState10(false);
+  const [error, setError] = useState10(void 0);
+  const revoke = useCallback13(
+    async (prefix) => {
+      if (!prefix) throw new Error("useRevokeMcpKey: prefix is required");
+      setPending(true);
+      setError(void 0);
+      try {
+        const response = await http.del(
+          `/mcp/keys/${encodeURIComponent(prefix)}`
+        );
+        revalidateMcpKeys();
+        return response;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        throw e;
+      } finally {
+        setPending(false);
+      }
+    },
+    [http, revalidateMcpKeys]
+  );
+  return { revoke, pending, error };
+}
+function useUpdateMcpKey() {
+  const { http, revalidateMcpKeys } = useHorusContext();
+  const [pending, setPending] = useState10(false);
+  const [error, setError] = useState10(void 0);
+  const update = useCallback13(
+    async (prefix, updates) => {
+      if (!prefix) throw new Error("useUpdateMcpKey: prefix is required");
+      setPending(true);
+      setError(void 0);
+      try {
+        const response = await http.put(
+          `/mcp/keys/${encodeURIComponent(prefix)}`,
+          {
+            expires_at: updates.expiresAt,
+            allowed_ips: updates.allowedIps,
+            allowed_tools: updates.allowedTools,
+            max_requests_per_minute: updates.maxRequestsPerMinute
+          }
+        );
+        revalidateMcpKeys();
+        return response;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        throw e;
+      } finally {
+        setPending(false);
+      }
+    },
+    [http, revalidateMcpKeys]
+  );
+  return { update, pending, error };
+}
 export {
+  HorusAuthModal,
   HorusHttpError,
   HorusLoginButton,
   HorusProvider,
+  HorusRevealModal,
+  SUPPORTED_CHAINS,
+  useChain,
+  useCreateWallet,
+  useExportWallet,
+  useGenerateMcpKey,
   useHorusAuth,
+  useMcpKeys,
+  useRevokeMcpKey,
+  useSendTransaction,
   useSignMessage,
+  useSignTypedData,
+  useSwitchChain,
   useTransfer,
+  useUpdateMcpKey,
   useUser,
   useWallets
 };