@moon-x/core 0.2.0

package/dist/react/index.mjs

@@ -0,0 +1,328 @@
+import {
+  formatPasskeyLabel,
+  resolvePasskeyMetadata
+} from "../chunk-CDT4MC7S.mjs";
+import "../chunk-GQKIA37O.mjs";
+import {
+  SDKProvider,
+  useMoonKeySDK
+} from "../chunk-MOREUKOG.mjs";
+
+// src/react/use-login-with-email.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+var useLoginWithEmail = (callbacks) => {
+  const sdk = useMoonKeySDK();
+  const [state, setState] = useState({ status: "idle" });
+  const callbacksRef = useRef(callbacks);
+  useEffect(() => {
+    callbacksRef.current = callbacks;
+  });
+  const sendCode = 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 = 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 = useCallback(() => setState({ status: "idle" }), []);
+  return { state, sendCode, loginWithCode, reset };
+};
+
+// src/react/use-register-passkey.ts
+import { useCallback as useCallback2, useState as useState2 } from "react";
+var useRegisterPasskey = () => {
+  const sdk = useMoonKeySDK();
+  const [isRegistering, setIsRegistering] = useState2(false);
+  const [error, setError] = useState2(null);
+  const registerPasskey = useCallback2(
+    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
+import { useCallback as useCallback3, useState as useState3 } from "react";
+var useUser = () => {
+  const sdk = useMoonKeySDK();
+  const [loading, setLoading] = useState3(false);
+  const refresh = useCallback3(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
+import { useCallback as useCallback4, useEffect as useEffect2, useRef as useRef2, useState as useState4 } from "react";
+var useWallets = (walletType) => {
+  const sdk = useMoonKeySDK();
+  const sdkRef = useRef2(sdk);
+  sdkRef.current = sdk;
+  const [wallets, setWallets] = useState4([]);
+  const [loading, setLoading] = useState4(false);
+  const [error, setError] = useState4(null);
+  const isAuthenticated = !!sdk.isAuthenticated;
+  const refresh = useCallback4(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]);
+  useEffect2(() => {
+    if (!isAuthenticated) {
+      setWallets([]);
+      return;
+    }
+    refresh();
+  }, [isAuthenticated, refresh]);
+  return { wallets, loading, error, refresh, refetch: refresh };
+};
+
+// src/react/use-logout.ts
+import { useCallback as useCallback5 } from "react";
+var useLogout = () => {
+  const sdk = useMoonKeySDK();
+  const logout = useCallback5(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/react/use-passkey-status.ts
+import { useCallback as useCallback6, useEffect as useEffect3, useReducer } from "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] = useReducer((x) => x + 1, 0);
+  useEffect3(() => {
+    const cb = () => forceUpdate();
+    subscribers.add(cb);
+    return () => {
+      subscribers.delete(cb);
+    };
+  }, []);
+  const refresh = useCallback6(async () => {
+    return sharedRefresh(sdk);
+  }, [sdk]);
+  useEffect3(() => {
+    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
+import { useCallback as useCallback7, useState as useState5 } from "react";
+var useAddPasskey = () => {
+  const sdk = useMoonKeySDK();
+  const [isAdding, setIsAdding] = useState5(false);
+  const [error, setError] = useState5(null);
+  const addPasskey = useCallback7(
+    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] = useState5(false);
+  const [error, setError] = useState5(null);
+  const removePasskey = useCallback7(
+    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 };
+};
+export {
+  SDKProvider,
+  useAddPasskey,
+  useCreateWallet,
+  useImportKey,
+  useLoginWithEmail,
+  useLogout,
+  useMoonKeySDK,
+  usePasskeyStatus,
+  useRegisterPasskey,
+  useRemovePasskey,
+  useUser,
+  useWallets
+};

package/dist/react/solana.d.mts

@@ -0,0 +1,17 @@
+import { SolanaGetBalanceParams, SolanaGetBalanceResult, SolanaSendTransactionParams, SolanaSendTransactionResult, SolanaSignMessageParams, SolanaSignMessageResult, SolanaSignTransactionParams, SolanaSignTransactionResult } from '../types/index.mjs';
+import '../chain-C9dvKXUY.mjs';
+
+declare const useSignMessage: () => {
+    signMessage: (params: SolanaSignMessageParams) => Promise<SolanaSignMessageResult>;
+};
+declare const useSignTransaction: () => {
+    signTransaction: (params: SolanaSignTransactionParams) => Promise<SolanaSignTransactionResult>;
+};
+declare const useSendTransaction: () => {
+    sendTransaction: (params: SolanaSendTransactionParams) => Promise<SolanaSendTransactionResult>;
+};
+declare const useGetBalance: () => {
+    getBalance: (params: SolanaGetBalanceParams) => Promise<SolanaGetBalanceResult>;
+};
+
+export { useGetBalance, useSendTransaction, useSignMessage, useSignTransaction };

package/dist/react/solana.d.ts

@@ -0,0 +1,17 @@
+import { SolanaGetBalanceParams, SolanaGetBalanceResult, SolanaSendTransactionParams, SolanaSendTransactionResult, SolanaSignMessageParams, SolanaSignMessageResult, SolanaSignTransactionParams, SolanaSignTransactionResult } from '../types/index.js';
+import '../chain-C9dvKXUY.js';
+
+declare const useSignMessage: () => {
+    signMessage: (params: SolanaSignMessageParams) => Promise<SolanaSignMessageResult>;
+};
+declare const useSignTransaction: () => {
+    signTransaction: (params: SolanaSignTransactionParams) => Promise<SolanaSignTransactionResult>;
+};
+declare const useSendTransaction: () => {
+    sendTransaction: (params: SolanaSendTransactionParams) => Promise<SolanaSendTransactionResult>;
+};
+declare const useGetBalance: () => {
+    getBalance: (params: SolanaGetBalanceParams) => Promise<SolanaGetBalanceResult>;
+};
+
+export { useGetBalance, useSendTransaction, useSignMessage, useSignTransaction };

package/dist/react/solana.js

@@ -0,0 +1,75 @@
+"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/react/solana.ts
+var solana_exports = {};
+__export(solana_exports, {
+  useGetBalance: () => useGetBalance,
+  useSendTransaction: () => useSendTransaction,
+  useSignMessage: () => useSignMessage,
+  useSignTransaction: () => useSignTransaction
+});
+module.exports = __toCommonJS(solana_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/solana.ts
+var useSignMessage = () => {
+  const sdk = useMoonKeySDK();
+  return {
+    signMessage: (params) => sdk.signSolanaMessageHeadless(params)
+  };
+};
+var useSignTransaction = () => {
+  const sdk = useMoonKeySDK();
+  return {
+    signTransaction: (params) => sdk.signSolanaTransactionHeadless(params)
+  };
+};
+var useSendTransaction = () => {
+  const sdk = useMoonKeySDK();
+  return {
+    sendTransaction: (params) => sdk.sendSolanaTransactionHeadless(params)
+  };
+};
+var useGetBalance = () => {
+  const sdk = useMoonKeySDK();
+  return {
+    getBalance: (params) => sdk.getSolanaBalance(params)
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useGetBalance,
+  useSendTransaction,
+  useSignMessage,
+  useSignTransaction
+});

package/dist/react/solana.mjs

@@ -0,0 +1,35 @@
+import {
+  useMoonKeySDK
+} from "../chunk-MOREUKOG.mjs";
+
+// src/react/solana.ts
+var useSignMessage = () => {
+  const sdk = useMoonKeySDK();
+  return {
+    signMessage: (params) => sdk.signSolanaMessageHeadless(params)
+  };
+};
+var useSignTransaction = () => {
+  const sdk = useMoonKeySDK();
+  return {
+    signTransaction: (params) => sdk.signSolanaTransactionHeadless(params)
+  };
+};
+var useSendTransaction = () => {
+  const sdk = useMoonKeySDK();
+  return {
+    sendTransaction: (params) => sdk.sendSolanaTransactionHeadless(params)
+  };
+};
+var useGetBalance = () => {
+  const sdk = useMoonKeySDK();
+  return {
+    getBalance: (params) => sdk.getSolanaBalance(params)
+  };
+};
+export {
+  useGetBalance,
+  useSendTransaction,
+  useSignMessage,
+  useSignTransaction
+};

package/dist/sdk/index.d.mts

@@ -0,0 +1,126 @@
+import { T as Transport, P as PasskeyAssertor, K as KvStorage } from '../interfaces-fNhwnCeY.mjs';
+export { O as OAuthOpener, a as PlatformImpls } from '../interfaces-fNhwnCeY.mjs';
+import { C as CachedAssertion } from '../passkey-cache-B9PT3AWX.mjs';
+import { EthereumSignMessageParams, EthereumSignMessageResult, EthereumSignTransactionParams, EthereumSignTransactionResult, EthereumSignTypedDataParams, EthereumSignTypedDataResult, EthereumSignHashParams, EthereumSignHashResult, EthereumSign7702AuthorizationParams, EthereumSign7702AuthorizationResult, EthereumSendTransactionParams, EthereumSendTransactionResult, EthereumGetBalanceParams, EthereumGetBalanceResult, EthereumGetTokenAccountsByOwnerParams, EthereumGetTokenAccountsByOwnerResult, SolanaSignMessageParams, SolanaSignMessageResult, SolanaSignTransactionParams, SolanaSignTransactionResult, SolanaSendTransactionParams, SolanaSendTransactionResult, SolanaGetBalanceParams, SolanaGetBalanceResult, SolanaGetTokenAccountsByOwnerParams, SolanaGetTokenAccountsByOwnerResult, PublicWallet } from '../types/index.mjs';
+import '../post-message-C_99BCBh.mjs';
+import '../chain-C9dvKXUY.mjs';
+
+type AssertPasskeyInParentResult = CachedAssertion;
+declare const assertPasskeyInParent: ({ transport, passkey, publishableKey, requireFreshAssertion, }: {
+    transport: Transport;
+    passkey: PasskeyAssertor;
+    publishableKey: string;
+    requireFreshAssertion?: boolean;
+}) => Promise<AssertPasskeyInParentResult>;
+
+declare const getHeadlessEthereumMethods: ({ transport, passkey, publishableKey, }: {
+    transport: Transport;
+    passkey: PasskeyAssertor;
+    publishableKey: string;
+}) => {
+    signEthereumMessageHeadless: (params: EthereumSignMessageParams) => Promise<EthereumSignMessageResult>;
+    signEthereumTransactionHeadless: (params: EthereumSignTransactionParams) => Promise<EthereumSignTransactionResult>;
+    signEthereumTypedDataHeadless: (params: EthereumSignTypedDataParams) => Promise<EthereumSignTypedDataResult>;
+    signEthereumHashHeadless: (params: EthereumSignHashParams) => Promise<EthereumSignHashResult>;
+    signEthereum7702AuthorizationHeadless: (params: EthereumSign7702AuthorizationParams) => Promise<EthereumSign7702AuthorizationResult>;
+    sendEthereumTransactionHeadless: (params: EthereumSendTransactionParams) => Promise<EthereumSendTransactionResult>;
+    getEthereumBalance: (params: EthereumGetBalanceParams) => Promise<EthereumGetBalanceResult>;
+    getEthereumTokenAccountsByOwner: (params: EthereumGetTokenAccountsByOwnerParams) => Promise<EthereumGetTokenAccountsByOwnerResult>;
+    getEthereumConfirmTransaction: (params: {
+        transaction: string | object;
+        walletAddress: string;
+        rpcUrl: string;
+        network?: string;
+    }) => Promise<unknown>;
+};
+
+declare const getHeadlessSolanaMethods: ({ transport, passkey, publishableKey, }: {
+    transport: Transport;
+    passkey: PasskeyAssertor;
+    publishableKey: string;
+}) => {
+    signSolanaMessageHeadless: (params: SolanaSignMessageParams) => Promise<SolanaSignMessageResult>;
+    signSolanaTransactionHeadless: (params: SolanaSignTransactionParams) => Promise<SolanaSignTransactionResult>;
+    sendSolanaTransactionHeadless: (params: SolanaSendTransactionParams) => Promise<SolanaSendTransactionResult>;
+    getSolanaBalance: (params: SolanaGetBalanceParams) => Promise<SolanaGetBalanceResult>;
+    getSolanaTokenAccountsByOwner: (params: SolanaGetTokenAccountsByOwnerParams) => Promise<SolanaGetTokenAccountsByOwnerResult>;
+};
+
+interface SendCodeParams {
+    email: string;
+    disableSignup?: boolean;
+}
+interface LoginWithCodeParams {
+    code: string;
+}
+interface VerifyOAuthParams {
+    provider: "google" | "apple";
+    code?: string;
+    token?: string;
+    state?: string;
+}
+declare const getHeadlessAuthenticationMethods: ({ transport, publishableKey, emailConfig, setIsAuthenticated, setUser, }: {
+    transport: Transport;
+    publishableKey: string;
+    emailConfig?: {
+        expiresIn?: number;
+    };
+    setIsAuthenticated?: (isAuth: boolean) => void;
+    setUser?: (user: unknown | null) => void;
+}) => {
+    /** Send a one-time passcode to the user's email address. */
+    sendCode: (params: SendCodeParams) => Promise<void>;
+    /**
+     * Verify the OTP and complete the login. The iframe-app handles
+     * session persistence; on success the SDK flips isAuthenticated and
+     * fetches the real user object to populate provider state.
+     */
+    loginWithCode: (params: LoginWithCodeParams) => Promise<unknown>;
+    /**
+     * Commit an OAuth code/token for a session. The deep-link / popup
+     * round-trip lives in the platform-specific OAuth hook; this method
+     * is the tail-end commit step the hook calls.
+     */
+    verifyOAuth: (params: VerifyOAuthParams) => Promise<unknown>;
+};
+
+declare const getHeadlessGeneralMethods: ({ transport, passkey, storage, publishableKey, setIsAuthenticated, setUser, }: {
+    transport: Transport;
+    passkey: PasskeyAssertor;
+    storage: KvStorage;
+    publishableKey: string;
+    setIsAuthenticated?: (isAuth: boolean) => void;
+    setUser?: (user: unknown | null) => void;
+}) => {
+    getPasskeyStatus: () => Promise<unknown>;
+    removePasskey: (credentialIdB64url: string) => Promise<void>;
+    createWallet: (walletType: "solana" | "ethereum", options?: {
+        createAdditional?: boolean;
+        walletIndex?: number;
+        requireFreshAssertion?: boolean;
+    }) => Promise<{
+        wallet: PublicWallet;
+    }>;
+    importKey: (walletType: "solana" | "ethereum", key: string, options?: {
+        requireFreshAssertion?: boolean;
+    }) => Promise<{
+        wallet: PublicWallet;
+    }>;
+    getWallets: (walletType: "solana" | "ethereum") => Promise<{
+        wallets: unknown[];
+        walletType: string;
+    }>;
+    getSessionTokens: () => Promise<{
+        accessToken: string;
+        identityToken: string;
+        expiresAt: number;
+    } | null>;
+    logout: () => Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    getCurrentSession: () => Promise<unknown>;
+    getUser: () => Promise<unknown>;
+};
+
+export { type AssertPasskeyInParentResult, KvStorage, type LoginWithCodeParams, PasskeyAssertor, type SendCodeParams, Transport, type VerifyOAuthParams, assertPasskeyInParent, getHeadlessAuthenticationMethods, getHeadlessEthereumMethods, getHeadlessGeneralMethods, getHeadlessSolanaMethods };