@moon-x/core 0.2.0

package/dist/react/index.js

@@ -0,0 +1,586 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react/index.ts
+var react_exports = {};
+__export(react_exports, {
+  SDKProvider: () => SDKProvider,
+  useAddPasskey: () => useAddPasskey,
+  useCreateWallet: () => useCreateWallet,
+  useImportKey: () => useImportKey,
+  useLoginWithEmail: () => useLoginWithEmail,
+  useLogout: () => useLogout,
+  useMoonKeySDK: () => useMoonKeySDK,
+  usePasskeyStatus: () => usePasskeyStatus,
+  useRegisterPasskey: () => useRegisterPasskey,
+  useRemovePasskey: () => useRemovePasskey,
+  useUser: () => useUser,
+  useWallets: () => useWallets
+});
+module.exports = __toCommonJS(react_exports);
+
+// src/react/sdk-context.ts
+var import_react = require("react");
+var SDKContext = (0, import_react.createContext)(null);
+var SDKProvider = SDKContext.Provider;
+var useMoonKeySDK = () => {
+  const sdk = (0, import_react.useContext)(SDKContext);
+  if (!sdk) {
+    throw new Error(
+      "MoonKey hook called outside a <MoonKeyProvider> \u2014 wrap your app in the provider from @moon-x/react-sdk (web) or @moon-x/react-native-sdk (RN)."
+    );
+  }
+  return sdk;
+};
+
+// src/react/use-login-with-email.ts
+var import_react2 = require("react");
+var useLoginWithEmail = (callbacks) => {
+  const sdk = useMoonKeySDK();
+  const [state, setState] = (0, import_react2.useState)({ status: "idle" });
+  const callbacksRef = (0, import_react2.useRef)(callbacks);
+  (0, import_react2.useEffect)(() => {
+    callbacksRef.current = callbacks;
+  });
+  const sendCode = (0, import_react2.useCallback)(
+    async (params) => {
+      setState({ status: "sending" });
+      try {
+        await sdk.sendCode(params);
+        setState({ status: "awaiting-code", email: params.email });
+      } catch (e) {
+        const err = e instanceof Error ? e : new Error(String(e));
+        setState({ status: "error", error: err });
+        callbacksRef.current?.onError?.(err);
+        throw err;
+      }
+    },
+    [sdk]
+  );
+  const loginWithCode = (0, import_react2.useCallback)(
+    async (params) => {
+      setState({ status: "verifying" });
+      try {
+        await sdk.loginWithCode(params);
+        const user = await sdk.getCurrentSession?.();
+        setState({ status: "complete" });
+        callbacksRef.current?.onComplete?.(user);
+      } catch (e) {
+        const err = e instanceof Error ? e : new Error(String(e));
+        setState({ status: "error", error: err });
+        callbacksRef.current?.onError?.(err);
+        throw err;
+      }
+    },
+    [sdk]
+  );
+  const reset = (0, import_react2.useCallback)(() => setState({ status: "idle" }), []);
+  return { state, sendCode, loginWithCode, reset };
+};
+
+// src/react/use-register-passkey.ts
+var import_react3 = require("react");
+var useRegisterPasskey = () => {
+  const sdk = useMoonKeySDK();
+  const [isRegistering, setIsRegistering] = (0, import_react3.useState)(false);
+  const [error, setError] = (0, import_react3.useState)(null);
+  const registerPasskey = (0, import_react3.useCallback)(
+    async (params) => {
+      if (!sdk.registerPasskey) {
+        const msg = "registerPasskey not available on this SDK";
+        setError(msg);
+        throw new Error(msg);
+      }
+      setIsRegistering(true);
+      setError(null);
+      try {
+        const result = await sdk.registerPasskey(params);
+        return result;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        setError(msg);
+        throw err;
+      } finally {
+        setIsRegistering(false);
+      }
+    },
+    [sdk]
+  );
+  return { registerPasskey, isRegistering, error };
+};
+
+// src/react/use-user.ts
+var import_react4 = require("react");
+var useUser = () => {
+  const sdk = useMoonKeySDK();
+  const [loading, setLoading] = (0, import_react4.useState)(false);
+  const refresh = (0, import_react4.useCallback)(async () => {
+    setLoading(true);
+    try {
+      if (sdk.refreshUser) {
+        await sdk.refreshUser();
+      } else {
+        await sdk.getUser();
+      }
+    } finally {
+      setLoading(false);
+    }
+  }, [sdk]);
+  return {
+    // `user` returned as `any` to preserve the loose typing both demos
+    // already rely on (`.email`, `.user_id`, `.first_name`, etc.). The
+    // concrete shape lives in the iframe-app — apps that want stricter
+    // types should narrow at the call site.
+    user: sdk.user ?? null,
+    loading,
+    refresh,
+    refreshUser: refresh
+  };
+};
+
+// src/react/use-wallets.ts
+var import_react5 = require("react");
+var useWallets = (walletType) => {
+  const sdk = useMoonKeySDK();
+  const sdkRef = (0, import_react5.useRef)(sdk);
+  sdkRef.current = sdk;
+  const [wallets, setWallets] = (0, import_react5.useState)([]);
+  const [loading, setLoading] = (0, import_react5.useState)(false);
+  const [error, setError] = (0, import_react5.useState)(null);
+  const isAuthenticated = !!sdk.isAuthenticated;
+  const refresh = (0, import_react5.useCallback)(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await sdkRef.current.getWallets(walletType);
+      setWallets(result.wallets || []);
+    } catch (e) {
+      setError(e instanceof Error ? e : new Error(String(e)));
+    } finally {
+      setLoading(false);
+    }
+  }, [walletType]);
+  (0, import_react5.useEffect)(() => {
+    if (!isAuthenticated) {
+      setWallets([]);
+      return;
+    }
+    refresh();
+  }, [isAuthenticated, refresh]);
+  return { wallets, loading, error, refresh, refetch: refresh };
+};
+
+// src/react/use-logout.ts
+var import_react6 = require("react");
+var useLogout = () => {
+  const sdk = useMoonKeySDK();
+  const logout = (0, import_react6.useCallback)(async () => sdk.logout(), [sdk]);
+  return { logout };
+};
+
+// src/react/use-create-wallet.ts
+var useCreateWallet = () => {
+  const sdk = useMoonKeySDK();
+  return {
+    createWallet: (walletType, options) => sdk.createWallet(walletType, options)
+  };
+};
+
+// src/react/use-import-key.ts
+var useImportKey = () => {
+  const sdk = useMoonKeySDK();
+  return {
+    importKey: (walletType, key) => sdk.importKey(walletType, key)
+  };
+};
+
+// src/lib/auth/authentication-state.ts
+var AuthenticationState = class {
+  constructor() {
+    this.email = null;
+  }
+  setEmail(email) {
+    this.email = email;
+  }
+  getEmail() {
+    return this.email;
+  }
+  clearEmail() {
+    this.email = null;
+  }
+  clear() {
+    this.clearEmail();
+  }
+};
+var authState = new AuthenticationState();
+
+// src/lib/passkey/passkey-aaguid-registry.json
+var passkey_aaguid_registry_default = {
+  "a11a5faa-9f32-4b8c-8c5d-2f7d13e8c942": {
+    name: "AliasVault"
+  },
+  "ea9b8d66-4d01-1d21-3ce4-b6b48cb575d4": {
+    name: "Google Password Manager"
+  },
+  "adce0002-35bc-c60a-648b-0b25f1f05503": {
+    name: "Chrome on Mac"
+  },
+  "08987058-cadc-4b81-b6e1-30de50dcbe96": {
+    name: "Windows Hello"
+  },
+  "9ddd1817-af5a-4672-a2b9-3e3dd95000a9": {
+    name: "Windows Hello"
+  },
+  "6028b017-b1d4-4c02-b4b3-afcdafc96bb2": {
+    name: "Windows Hello"
+  },
+  "dd4ec289-e01d-41c9-bb89-70fa845d4bf2": {
+    name: "iCloud Keychain (Managed)"
+  },
+  "531126d6-e717-415c-9320-3d9aa6981239": {
+    name: "Dashlane"
+  },
+  "bada5566-a7aa-401f-bd96-45619a55120d": {
+    name: "1Password"
+  },
+  "b84e4048-15dc-4dd0-8640-f4f60813c8af": {
+    name: "NordPass"
+  },
+  "0ea242b4-43c4-4a1b-8b17-dd6d0b6baec6": {
+    name: "Keeper"
+  },
+  "891494da-2c90-4d31-a9cd-4eab0aed1309": {
+    name: "S\xE9same"
+  },
+  "f3809540-7f14-49c1-a8b3-8f813b225541": {
+    name: "Enpass"
+  },
+  "b5397666-4885-aa6b-cebf-e52262a439a2": {
+    name: "Chromium Browser"
+  },
+  "771b48fd-d3d4-4f74-9232-fc157ab0507a": {
+    name: "Edge on Mac"
+  },
+  "39a5647e-1853-446c-a1f6-a79bae9f5bc7": {
+    name: "IDmelon"
+  },
+  "d548826e-79b4-db40-a3d8-11116f7e8349": {
+    name: "Bitwarden"
+  },
+  "fbfc3007-154e-4ecc-8c0b-6e020557d7bd": {
+    name: "Apple Passwords"
+  },
+  "53414d53-554e-4700-0000-000000000000": {
+    name: "Samsung Pass"
+  },
+  "66a0ccb3-bd6a-191f-ee06-e375c50b9846": {
+    name: "Thales Bio iOS SDK"
+  },
+  "8836336a-f590-0921-301d-46427531eee6": {
+    name: "Thales Bio Android SDK"
+  },
+  "cd69adb5-3c7a-deb9-3177-6800ea6cb72a": {
+    name: "Thales PIN Android SDK"
+  },
+  "17290f1e-c212-34d0-1423-365d729f09d9": {
+    name: "Thales PIN iOS SDK"
+  },
+  "50726f74-6f6e-5061-7373-50726f746f6e": {
+    name: "Proton Pass"
+  },
+  "fdb141b2-5d84-443e-8a35-4698c205a502": {
+    name: "KeePassXC"
+  },
+  "eaecdef2-1c31-5634-8639-f1cbd9c00a08": {
+    name: "KeePassDX"
+  },
+  "cc45f64e-52a2-451b-831a-4edd8022a202": {
+    name: "ToothPic Passkey Provider"
+  },
+  "bfc748bb-3429-4faa-b9f9-7cfa9f3b76d0": {
+    name: "iPasswords"
+  },
+  "b35a26b2-8f6e-4697-ab1d-d44db4da28c6": {
+    name: "Zoho Vault"
+  },
+  "b78a0a55-6ef8-d246-a042-ba0f6d55050c": {
+    name: "LastPass"
+  },
+  "de503f9c-21a4-4f76-b4b7-558eb55c6f89": {
+    name: "Devolutions"
+  },
+  "22248c4c-7a12-46e2-9a41-44291b373a4d": {
+    name: "LogMeOnce"
+  },
+  "a10c6dd9-465e-4226-8198-c7c44b91c555": {
+    name: "Kaspersky Password Manager"
+  },
+  "d350af52-0351-4ba2-acd3-dfeeadc3f764": {
+    name: "pwSafe"
+  },
+  "d3452668-01fd-4c12-926c-83a4204853aa": {
+    name: "Microsoft Password Manager"
+  },
+  "6d212b28-a2c1-4638-b375-5932070f62e9": {
+    name: "initial"
+  },
+  "d49b2120-b865-4191-8cea-be84a52b0485": {
+    name: "Heimlane Vault"
+  },
+  "e8b7f4a2-c3d5-e6f7-890a-b1c2d3e4f567": {
+    name: "Sherlocked"
+  },
+  "d9be9d39-e6a6-4c28-a581-32b044d986e4": {
+    name: "Sticky Password Manager"
+  },
+  "70617373-7761-6c6c-6669-646f32303236": {
+    name: "Passwall"
+  },
+  "c9cadfc9-89a9-489e-a25a-c7e86a4d5f15": {
+    name: "Burp Suite Navigation Recorder"
+  }
+};
+
+// src/lib/passkey/passkey-metadata.ts
+var aaguidRegistry = passkey_aaguid_registry_default;
+var ZERO_AAGUID = "00000000-0000-0000-0000-000000000000";
+function resolveProvider(aaguid, transports) {
+  if (!aaguid) return "Unknown authenticator";
+  const entry = aaguidRegistry[aaguid];
+  if (entry?.name) return entry.name;
+  if (aaguid === ZERO_AAGUID) {
+    if (transports.includes("internal")) return "iCloud Keychain";
+    return "Unknown authenticator";
+  }
+  return "Unknown authenticator";
+}
+function resolveFormFactor(transports) {
+  if (transports.includes("hybrid")) return "hybrid";
+  if (transports.includes("internal")) return "platform";
+  if (transports.includes("usb") || transports.includes("nfc") || transports.includes("ble")) {
+    return "roaming";
+  }
+  return "unknown";
+}
+function formatPasskeyLabel(input) {
+  if (input.nickname && input.nickname.trim()) return input.nickname.trim();
+  const transports = input.transports ?? [];
+  const providerName = resolveProvider(input.aaguid, transports);
+  if (providerName.includes(" on ")) return providerName;
+  if (input.registeredBrowser) {
+    return `${providerName} on ${input.registeredBrowser}`;
+  }
+  return providerName;
+}
+function resolvePasskeyMetadata(input) {
+  const transports = input.transports ?? [];
+  const providerName = resolveProvider(input.aaguid, transports);
+  return {
+    providerName,
+    formFactor: resolveFormFactor(transports),
+    isCloudSynced: !!input.backupState,
+    label: formatPasskeyLabel(input)
+  };
+}
+
+// src/lib/ethereum/chains.ts
+var import_viem = require("viem");
+
+// src/lib/ethereum/siwe.ts
+var import_siwe = require("siwe");
+var import_viem2 = require("viem");
+
+// src/lib/ethereum/tx-prep.ts
+var import_viem3 = require("viem");
+
+// src/lib/solana/siws.ts
+var nacl = __toESM(require("tweetnacl"));
+
+// src/lib/solana/transaction-log-parser.ts
+var import_web3 = require("@solana/web3.js");
+var import_bn = __toESM(require("bn.js"));
+
+// src/react/use-passkey-status.ts
+var import_react7 = require("react");
+var sharedHasPasskey = null;
+var sharedPasskeys = [];
+var sharedLoading = false;
+var sharedError = null;
+var sharedInflight = null;
+var subscribers = /* @__PURE__ */ new Set();
+function notifyAll() {
+  subscribers.forEach((cb) => {
+    try {
+      cb();
+    } catch {
+    }
+  });
+}
+function resetShared() {
+  sharedHasPasskey = null;
+  sharedPasskeys = [];
+  sharedLoading = false;
+  sharedError = null;
+  sharedInflight = null;
+  notifyAll();
+}
+async function sharedRefresh(sdk) {
+  if (!sdk?.getPasskeyStatus) return;
+  if (sharedInflight) return sharedInflight;
+  const run = (async () => {
+    sharedLoading = true;
+    sharedError = null;
+    notifyAll();
+    try {
+      const status = await sdk.getPasskeyStatus();
+      sharedHasPasskey = !!status.has_passkey;
+      sharedPasskeys = (status.passkeys || []).map((p) => {
+        const metadata = resolvePasskeyMetadata({
+          aaguid: p.aaguid,
+          transports: p.transports,
+          backupState: p.backup_state,
+          registeredBrowser: p.registered_browser,
+          registeredOS: p.registered_os
+        });
+        return {
+          ...p,
+          label: formatPasskeyLabel({
+            aaguid: p.aaguid,
+            transports: p.transports,
+            registeredBrowser: p.registered_browser,
+            registeredOS: p.registered_os
+          }),
+          metadata
+        };
+      });
+    } catch (e) {
+      sharedError = e instanceof Error ? e.message : "Failed to load status";
+    } finally {
+      sharedLoading = false;
+      sharedInflight = null;
+      notifyAll();
+    }
+  })();
+  sharedInflight = run;
+  return run;
+}
+var usePasskeyStatus = () => {
+  const sdk = useMoonKeySDK();
+  const [, forceUpdate] = (0, import_react7.useReducer)((x) => x + 1, 0);
+  (0, import_react7.useEffect)(() => {
+    const cb = () => forceUpdate();
+    subscribers.add(cb);
+    return () => {
+      subscribers.delete(cb);
+    };
+  }, []);
+  const refresh = (0, import_react7.useCallback)(async () => {
+    return sharedRefresh(sdk);
+  }, [sdk]);
+  (0, import_react7.useEffect)(() => {
+    if (!sdk?.getPasskeyStatus) return;
+    if (sdk.ready && !sdk.isAuthenticated) {
+      resetShared();
+      return;
+    }
+    if (!sdk.ready || !sdk.isAuthenticated) return;
+    sharedRefresh(sdk);
+  }, [sdk, sdk?.ready, sdk?.isAuthenticated]);
+  return {
+    hasPasskey: sharedHasPasskey,
+    passkeys: sharedPasskeys,
+    loading: sharedLoading,
+    error: sharedError,
+    refresh
+  };
+};
+
+// src/react/use-manage-passkeys.ts
+var import_react8 = require("react");
+var useAddPasskey = () => {
+  const sdk = useMoonKeySDK();
+  const [isAdding, setIsAdding] = (0, import_react8.useState)(false);
+  const [error, setError] = (0, import_react8.useState)(null);
+  const addPasskey = (0, import_react8.useCallback)(
+    async (params) => {
+      if (!sdk?.addPasskey) throw new Error("SDK not ready");
+      setIsAdding(true);
+      setError(null);
+      try {
+        return await sdk.addPasskey(params);
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : "Failed to add passkey";
+        setError(msg);
+        throw e;
+      } finally {
+        setIsAdding(false);
+      }
+    },
+    [sdk]
+  );
+  return { addPasskey, isAdding, error };
+};
+var useRemovePasskey = () => {
+  const sdk = useMoonKeySDK();
+  const [isRemoving, setIsRemoving] = (0, import_react8.useState)(false);
+  const [error, setError] = (0, import_react8.useState)(null);
+  const removePasskey = (0, import_react8.useCallback)(
+    async (credentialIdB64url) => {
+      if (!sdk?.removePasskey) throw new Error("SDK not ready");
+      setIsRemoving(true);
+      setError(null);
+      try {
+        await sdk.removePasskey(credentialIdB64url);
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : "Failed to remove passkey";
+        setError(msg);
+        throw e;
+      } finally {
+        setIsRemoving(false);
+      }
+    },
+    [sdk]
+  );
+  return { removePasskey, isRemoving, error };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SDKProvider,
+  useAddPasskey,
+  useCreateWallet,
+  useImportKey,
+  useLoginWithEmail,
+  useLogout,
+  useMoonKeySDK,
+  usePasskeyStatus,
+  useRegisterPasskey,
+  useRemovePasskey,
+  useUser,
+  useWallets
+});