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

package/dist/index.cjs

@@ -0,0 +1,682 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  HorusHttpError: () => HorusHttpError,
+  HorusLoginButton: () => HorusLoginButton,
+  HorusProvider: () => HorusProvider,
+  useHorusAuth: () => useHorusAuth,
+  useSignMessage: () => useSignMessage,
+  useTransfer: () => useTransfer,
+  useUser: () => useUser,
+  useWallets: () => useWallets
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/HorusProvider.tsx
+var import_react2 = require("react");
+
+// src/HorusContext.ts
+var import_react = require("react");
+var HorusContext = (0, import_react.createContext)(null);
+function useHorusContext() {
+  const ctx = (0, import_react.useContext)(HorusContext);
+  if (!ctx) {
+    throw new Error(
+      '@horus-wallet/sdk-react: hook used outside <HorusProvider>. Wrap your app with <HorusProvider appId="\u2026"> at the root.'
+    );
+  }
+  return ctx;
+}
+
+// src/tokenStore.ts
+var STORAGE_KEY = "horus.auth.tokens";
+var WebStorageStore = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  read() {
+    try {
+      const raw = this.storage.getItem(STORAGE_KEY);
+      if (!raw) return null;
+      const parsed = JSON.parse(raw);
+      if (typeof parsed?.idToken !== "string") return null;
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  write(tokens) {
+    try {
+      this.storage.setItem(STORAGE_KEY, JSON.stringify(tokens));
+    } catch {
+    }
+  }
+  clear() {
+    try {
+      this.storage.removeItem(STORAGE_KEY);
+    } catch {
+    }
+  }
+};
+var MemoryStore = class {
+  constructor() {
+    this.value = null;
+  }
+  read() {
+    return this.value;
+  }
+  write(t) {
+    this.value = t;
+  }
+  clear() {
+    this.value = null;
+  }
+};
+function createTokenStore(kind = "localStorage") {
+  if (kind === "memory" || typeof window === "undefined") {
+    return new MemoryStore();
+  }
+  if (kind === "sessionStorage") return new WebStorageStore(window.sessionStorage);
+  return new WebStorageStore(window.localStorage);
+}
+function stampExpiry(raw) {
+  const seconds = typeof raw.expiresIn === "string" ? Number(raw.expiresIn) : raw.expiresIn;
+  return {
+    ...raw,
+    localExpiresAt: Math.floor(Date.now() / 1e3) + (Number.isFinite(seconds) ? seconds : 3600)
+  };
+}
+
+// src/http.ts
+var HorusHttpError = class extends Error {
+  constructor(status, message, body, code) {
+    super(message);
+    this.name = "HorusHttpError";
+    this.status = status;
+    this.code = code;
+    this.body = body;
+  }
+};
+function makeHttp(deps) {
+  const url = (path) => {
+    const base = deps.apiBase.endsWith("/") ? deps.apiBase.slice(0, -1) : deps.apiBase;
+    return path.startsWith("/") ? `${base}${path}` : `${base}/${path}`;
+  };
+  async function rawRequest(method, path, body, options = {}) {
+    const headers = { "Content-Type": "application/json" };
+    if (options.auth !== false) {
+      const tokens = deps.getTokens();
+      if (tokens?.idToken) {
+        headers["x-horus-id-token"] = 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"
+    });
+    const text = await res.text();
+    let parsed = void 0;
+    if (text.length > 0) {
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = text;
+      }
+    }
+    if (res.ok) return parsed;
+    const code = parsed?.code;
+    const message = parsed?.message ?? `HTTP ${res.status}`;
+    throw new HorusHttpError(res.status, message, parsed, code);
+  }
+  async function request(method, path, body, options = {}) {
+    try {
+      return await rawRequest(method, path, body, options);
+    } catch (err) {
+      if (err instanceof HorusHttpError && err.status === 401 && options.auth !== false && deps.autoRefresh) {
+        try {
+          await deps.refreshTokens();
+        } catch {
+          throw err;
+        }
+        return await rawRequest(method, path, body, options);
+      }
+      throw err;
+    }
+  }
+  return {
+    get: (path, opts) => request("GET", path, void 0, opts),
+    post: (path, body, opts) => request("POST", path, body, opts),
+    put: (path, body, opts) => request("PUT", path, body, opts),
+    del: (path, opts) => request("DELETE", path, void 0, opts)
+  };
+}
+
+// src/HorusProvider.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var DEFAULT_API_BASE = "/api/horus";
+var DEFAULT_AUTH_PAGE = "https://auth.horuswallet.com";
+var REFRESH_LEAD_SECONDS = 60;
+function HorusProvider(props) {
+  const {
+    appId,
+    apiBase = DEFAULT_API_BASE,
+    authPageUrl = DEFAULT_AUTH_PAGE,
+    branding,
+    tokenStorage = "localStorage",
+    autoRefresh = true,
+    children
+  } = props;
+  const tokenStoreRef = (0, import_react2.useRef)(createTokenStore(tokenStorage));
+  const tokensRef = (0, import_react2.useRef)(null);
+  const [state, setState] = (0, import_react2.useState)({ status: "loading" });
+  const setTokens = (0, import_react2.useCallback)((tokens) => {
+    tokensRef.current = tokens;
+    if (tokens) {
+      tokenStoreRef.current.write(tokens);
+      setState({
+        status: "authenticated",
+        tokens,
+        user: userFromTokens(tokens)
+      });
+    } else {
+      tokenStoreRef.current.clear();
+      setState({ status: "unauthenticated" });
+    }
+  }, []);
+  const http = (0, import_react2.useMemo)(() => {
+    const refreshOnce = async () => {
+      const cur = tokensRef.current;
+      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"
+      });
+      if (!fresh.ok) throw new Error(`refresh failed: ${fresh.status}`);
+      const raw = await fresh.json();
+      const stamped = stampExpiry(raw);
+      setTokens(stamped);
+      return stamped;
+    };
+    return makeHttp({
+      apiBase,
+      getTokens: () => tokensRef.current,
+      refreshTokens: refreshOnce,
+      autoRefresh
+    });
+  }, [apiBase, autoRefresh, setTokens]);
+  (0, import_react2.useEffect)(() => {
+    const stored = tokenStoreRef.current.read();
+    if (stored) {
+      tokensRef.current = stored;
+      setState({
+        status: "authenticated",
+        tokens: stored,
+        user: userFromTokens(stored)
+      });
+    } else {
+      setState({ status: "unauthenticated" });
+    }
+  }, []);
+  (0, import_react2.useEffect)(() => {
+    if (typeof window === "undefined") return;
+    const onStorage = (ev) => {
+      if (ev.key !== "horus.auth.tokens") return;
+      const next = tokenStoreRef.current.read();
+      tokensRef.current = next;
+      if (next) {
+        setState({ status: "authenticated", tokens: next, user: userFromTokens(next) });
+      } else {
+        setState({ status: "unauthenticated" });
+      }
+    };
+    window.addEventListener("storage", onStorage);
+    return () => window.removeEventListener("storage", onStorage);
+  }, []);
+  (0, import_react2.useEffect)(() => {
+    if (state.status !== "authenticated" || !autoRefresh) return;
+    const secondsUntil = state.tokens.localExpiresAt - Math.floor(Date.now() / 1e3);
+    const refreshIn = Math.max(0, secondsUntil - REFRESH_LEAD_SECONDS) * 1e3;
+    const handle = setTimeout(() => {
+      http.post("/auth/refresh", { refreshToken: state.tokens.refreshToken }, { auth: false }).then((raw) => setTokens(stampExpiry(raw))).catch(() => {
+      });
+    }, refreshIn);
+    return () => clearTimeout(handle);
+  }, [state, autoRefresh, http, setTokens]);
+  const ctx = (0, import_react2.useMemo)(
+    () => ({
+      state,
+      http,
+      authPageUrl,
+      appId,
+      branding,
+      signIn: setTokens,
+      signOut: () => setTokens(null),
+      refreshTokens: async () => {
+        const cur = tokensRef.current;
+        if (!cur?.refreshToken) throw new Error("not authenticated");
+        const raw = await http.post(
+          "/auth/refresh",
+          { refreshToken: cur.refreshToken },
+          { auth: false }
+        );
+        const stamped = stampExpiry(raw);
+        setTokens(stamped);
+        return stamped;
+      }
+    }),
+    [state, http, authPageUrl, appId, branding, setTokens]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(HorusContext.Provider, { value: ctx, children });
+}
+function userFromTokens(t) {
+  return {
+    uid: t.localId,
+    email: t.email,
+    emailVerified: t.emailVerified,
+    displayName: t.displayName,
+    photoUrl: t.photoUrl,
+    providerId: t.providerId
+  };
+}
+function joinUrl(base, path) {
+  const b = base.endsWith("/") ? base.slice(0, -1) : base;
+  const p = path.startsWith("/") ? path : `/${path}`;
+  return `${b}${p}`;
+}
+
+// src/hooks/useHorusAuth.ts
+var import_react3 = require("react");
+function useHorusAuth() {
+  const ctx = useHorusContext();
+  const { state, http, signIn, signOut, refreshTokens, authPageUrl, appId, branding } = ctx;
+  const loginWithEmail = (0, import_react3.useCallback)(async (input) => {
+    const raw = await http.post(
+      "/auth/email/signin",
+      input,
+      { auth: false }
+    );
+    const stamped = stampExpiry(raw);
+    signIn(stamped);
+    return userFromTokens2(stamped);
+  }, [http, signIn]);
+  const signUpWithEmail = (0, import_react3.useCallback)(async (input) => {
+    const raw = await http.post(
+      "/auth/email/signup",
+      input,
+      { auth: false }
+    );
+    const stamped = stampExpiry(raw);
+    signIn(stamped);
+    return userFromTokens2(stamped);
+  }, [http, signIn]);
+  const sendEmailLink = (0, import_react3.useCallback)(async (input) => {
+    await http.post("/auth/email-link/send", input, { auth: false });
+  }, [http]);
+  const verifyEmailLink = (0, import_react3.useCallback)(async (input) => {
+    const raw = await http.post(
+      "/auth/email-link/verify",
+      input,
+      { auth: false }
+    );
+    const stamped = stampExpiry(raw);
+    signIn(stamped);
+    return userFromTokens2(stamped);
+  }, [http, signIn]);
+  const popupFlow = (0, import_react3.useCallback)(
+    async (flow, extras = {}) => {
+      const tokens = await openPopupFlow({
+        flow,
+        appId,
+        baseUrl: authPageUrl,
+        branding,
+        phone: extras.phone
+      });
+      const stamped = stampExpiry({
+        idToken: tokens.idToken,
+        refreshToken: "",
+        // popup path doesn't expose refresh — partner refreshes via backend on next 401
+        expiresIn: tokens.expiresAt ? Math.max(60, tokens.expiresAt - Math.floor(Date.now() / 1e3)) : 3600,
+        localId: tokens.user?.uid ?? "",
+        email: tokens.user?.email,
+        displayName: tokens.user?.displayName,
+        photoUrl: tokens.user?.photoURL,
+        providerId: tokens.user?.providerId
+      });
+      signIn(stamped);
+      return userFromTokens2(stamped);
+    },
+    [appId, authPageUrl, branding, signIn]
+  );
+  const loginWithGoogle = (0, import_react3.useCallback)(() => popupFlow("google"), [popupFlow]);
+  const loginWithEmailLinkPopup = (0, import_react3.useCallback)(() => popupFlow("email_link"), [popupFlow]);
+  const loginWithPhone = (0, import_react3.useCallback)(
+    (opts) => popupFlow("phone", { phone: opts?.phone }),
+    [popupFlow]
+  );
+  return {
+    ready: state.status !== "loading",
+    authenticated: state.status === "authenticated",
+    user: state.status === "authenticated" ? state.user : void 0,
+    loginWithEmail,
+    signUpWithEmail,
+    sendEmailLink,
+    verifyEmailLink,
+    loginWithGoogle,
+    loginWithEmailLink: loginWithEmailLinkPopup,
+    loginWithPhone,
+    logout: signOut,
+    refresh: refreshTokens
+  };
+}
+function userFromTokens2(t) {
+  return {
+    uid: t.localId,
+    email: t.email,
+    emailVerified: t.emailVerified,
+    displayName: t.displayName,
+    photoUrl: t.photoUrl,
+    providerId: t.providerId
+  };
+}
+function openPopupFlow(params) {
+  return new Promise((resolve, reject) => {
+    if (typeof window === "undefined") {
+      reject(new Error("useHorusAuth popup methods require a browser context."));
+      return;
+    }
+    const state = randomState();
+    const url = buildAuthUrl(params, 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."));
+      return;
+    }
+    const expectedOrigin = new URL(params.baseUrl).origin;
+    let settled = false;
+    const cleanup = () => {
+      window.removeEventListener("message", onMessage);
+      clearInterval(poll);
+    };
+    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 !== state) return;
+      const body = data.body;
+      if (!body) return;
+      switch (body.type) {
+        case "success":
+          if (settled) return;
+          settled = true;
+          cleanup();
+          try {
+            popup.close();
+          } catch {
+          }
+          resolve({ idToken: body.idToken, expiresAt: body.expiresAt, user: body.user });
+          return;
+        case "cancel":
+          if (settled) return;
+          settled = true;
+          cleanup();
+          try {
+            popup.close();
+          } catch {
+          }
+          reject(new Error("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."));
+          return;
+      }
+    };
+    window.addEventListener("message", onMessage);
+    const poll = setInterval(() => {
+      if (popup.closed && !settled) {
+        settled = true;
+        cleanup();
+        reject(new Error("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}`;
+  const left = Math.max(0, (window.innerWidth - w) / 2 + (window.screenX ?? 0));
+  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() {
+  const { state } = useHorusContext();
+  return state.status === "authenticated" ? state.user : void 0;
+}
+
+// src/hooks/useWallets.ts
+var import_react4 = require("react");
+function useWallets() {
+  const { http, state } = useHorusContext();
+  const [wallets, setWallets] = (0, import_react4.useState)([]);
+  const [ready, setReady] = (0, import_react4.useState)(false);
+  const [error, setError] = (0, import_react4.useState)(void 0);
+  const load = (0, import_react4.useCallback)(async () => {
+    if (state.status !== "authenticated") {
+      setWallets([]);
+      setReady(true);
+      return;
+    }
+    setReady(false);
+    setError(void 0);
+    try {
+      const response = await http.get(
+        "/wallets"
+      );
+      const flat = [];
+      for (const [network, group] of Object.entries(response.wallets ?? {})) {
+        for (const w of group?.wallets ?? []) {
+          flat.push({ ...w, network });
+        }
+      }
+      setWallets(flat);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setReady(true);
+    }
+  }, [http, state.status]);
+  (0, import_react4.useEffect)(() => {
+    void load();
+  }, [load]);
+  return { ready, wallets, refresh: load, error };
+}
+
+// src/hooks/useSignMessage.ts
+var import_react5 = require("react");
+function useSignMessage() {
+  const { http } = useHorusContext();
+  const [pending, setPending] = (0, import_react5.useState)(false);
+  const [error, setError] = (0, import_react5.useState)(void 0);
+  const signMessage = (0, import_react5.useCallback)(
+    async (input) => {
+      setPending(true);
+      setError(void 0);
+      try {
+        const response = await http.post("/sign-message", input);
+        return response.signature;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        throw e;
+      } finally {
+        setPending(false);
+      }
+    },
+    [http]
+  );
+  return { signMessage, pending, error };
+}
+
+// src/hooks/useTransfer.ts
+var import_react6 = require("react");
+function useTransfer() {
+  const { http } = useHorusContext();
+  const [pending, setPending] = (0, import_react6.useState)(false);
+  const [error, setError] = (0, import_react6.useState)(void 0);
+  const wrap = (0, import_react6.useCallback)(
+    async (fn) => {
+      setPending(true);
+      setError(void 0);
+      try {
+        return await fn();
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        throw e;
+      } finally {
+        setPending(false);
+      }
+    },
+    []
+  );
+  const native = (0, import_react6.useCallback)(
+    (input) => wrap(
+      () => http.post("/transfer/native", {
+        ...input,
+        amount: typeof input.amount === "bigint" ? input.amount.toString() : String(input.amount)
+      })
+    ),
+    [http, wrap]
+  );
+  const token = (0, import_react6.useCallback)(
+    (input) => wrap(
+      () => http.post("/transfer/token", {
+        ...input,
+        amount: typeof input.amount === "bigint" ? input.amount.toString() : String(input.amount)
+      })
+    ),
+    [http, wrap]
+  );
+  return { native, token, pending, error };
+}
+
+// src/components/HorusLoginButton.tsx
+var import_react7 = require("react");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function HorusLoginButton({
+  flow = "google",
+  phone,
+  onAuthenticated,
+  onError,
+  children,
+  disabled,
+  style,
+  ...rest
+}) {
+  const auth = useHorusAuth();
+  const [busy, setBusy] = (0, import_react7.useState)(false);
+  const onClick = async () => {
+    if (busy) return;
+    setBusy(true);
+    try {
+      let user;
+      if (flow === "google") user = await auth.loginWithGoogle();
+      else if (flow === "email_link") user = await auth.loginWithEmailLink();
+      else user = await auth.loginWithPhone({ phone });
+      onAuthenticated?.(user);
+    } catch (err) {
+      onError?.(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setBusy(false);
+    }
+  };
+  const defaultStyle = {
+    padding: "10px 16px",
+    fontSize: 15,
+    fontWeight: 500,
+    borderRadius: 8,
+    border: "1px solid #e2e8f0",
+    background: "#ffffff",
+    color: "#0f172a",
+    cursor: busy || disabled ? "progress" : "pointer",
+    opacity: busy || disabled ? 0.7 : 1
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+    "button",
+    {
+      ...rest,
+      onClick,
+      disabled: busy || disabled,
+      style: { ...defaultStyle, ...style },
+      children: children ?? (flow === "google" ? "Continue with Google" : flow === "email_link" ? "Continue with email" : "Continue with phone")
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HorusHttpError,
+  HorusLoginButton,
+  HorusProvider,
+  useHorusAuth,
+  useSignMessage,
+  useTransfer,
+  useUser,
+  useWallets
+});