@moon-x/react-sdk 0.1.0

package/dist/index.css

@@ -0,0 +1,169 @@
+/* src/styles.css */
+@font-face {
+  font-family: "Sons";
+  src: url("./assets/Sons-Thin.ttf") format("truetype");
+  font-weight: 100;
+  font-style: normal;
+  font-display: swap;
+}
+@font-face {
+  font-family: "Sons";
+  src: url("./assets/Sons-Light.ttf") format("truetype");
+  font-weight: 300;
+  font-style: normal;
+  font-display: swap;
+}
+@font-face {
+  font-family: "Sons";
+  src: url("./assets/Sons-Regular.ttf") format("truetype");
+  font-weight: 400;
+  font-style: normal;
+  font-display: swap;
+}
+@font-face {
+  font-family: "Sons";
+  src: url("./assets/Sons-Medium.ttf") format("truetype");
+  font-weight: 500;
+  font-style: normal;
+  font-display: swap;
+}
+@font-face {
+  font-family: "Sons";
+  src: url("./assets/Sons-Semibold.ttf") format("truetype");
+  font-weight: 600;
+  font-style: normal;
+  font-display: swap;
+}
+@font-face {
+  font-family: "Sons";
+  src: url("./assets/Sons-Bold.ttf") format("truetype");
+  font-weight: 700;
+  font-style: normal;
+  font-display: swap;
+}
+@font-face {
+  font-family: "Sons";
+  src: url("./assets/Sons-Extrabold.ttf") format("truetype");
+  font-weight: 800;
+  font-style: normal;
+  font-display: swap;
+}
+@font-face {
+  font-family: "Sons";
+  src: url("./assets/Sons-Black.ttf") format("truetype");
+  font-weight: 900;
+  font-style: normal;
+  font-display: swap;
+}
+:root {
+  --moonkey-font-family:
+    "Sons",
+    -apple-system,
+    BlinkMacSystemFont,
+    "Segoe UI",
+    "Roboto",
+    "Oxygen",
+    "Ubuntu",
+    "Cantarell",
+    "Fira Sans",
+    "Droid Sans",
+    "Helvetica Neue",
+    sans-serif;
+  --moonkey-border-radius-sm: 0.375rem;
+  --moonkey-border-radius-md: 0.5rem;
+  --moonkey-border-radius-lg: 0.75rem;
+  --moonkey-border-radius-full: 9999px;
+  --moonkey-color-background: #ffffff;
+  --moonkey-color-background-2: #f9fafb;
+  --moonkey-color-background-3: #f3f4f6;
+  --moonkey-color-foreground: #111827;
+  --moonkey-color-foreground-2: #374151;
+  --moonkey-color-foreground-3: #6b7280;
+  --moonkey-color-foreground-4: #9ca3af;
+  --moonkey-color-foreground-accent: #4f46e5;
+  --moonkey-color-accent: #6366f1;
+  --moonkey-color-accent-foreground: #ffffff;
+  --moonkey-color-accent-light: #818cf8;
+  --moonkey-color-accent-lightest: #c7d2fe;
+  --moonkey-color-accent-dark: #4338ca;
+  --moonkey-color-accent-darkest: #3730a3;
+  --moonkey-color-success: #10b981;
+  --moonkey-color-success-foreground: #ffffff;
+  --moonkey-color-error: #ef4444;
+  --moonkey-color-error-foreground: #ffffff;
+  --moonkey-color-error-light: #fca5a5;
+  --moonkey-color-border: #e5e7eb;
+}
+.moonkey-animate-in {
+  animation: moonkey-enter 0.2s ease-out;
+}
+.moonkey-fade-in-0 {
+  --tw-enter-opacity: initial;
+  --tw-enter-scale: initial;
+  --tw-enter-rotate: initial;
+  --tw-enter-translate-x: initial;
+  --tw-enter-translate-y: initial;
+}
+.moonkey-zoom-in-95 {
+  --tw-enter-scale: .95;
+}
+.moonkey-duration-200 {
+  animation-duration: 0.2s;
+}
+.moonkey-center-y {
+  top: 50%;
+  transform: translateY(-50%);
+}
+.moonkey-animate-spin {
+  animation: moonkey-spin 1s linear infinite;
+}
+.moonkey-modal-overlay {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  width: 100vw;
+  height: 100vh;
+  background-color: var(--moonkey-color-background-3);
+  backdrop-filter: blur(4px);
+  z-index: 50;
+}
+.moonkey-modal-container {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  width: 100vw;
+  height: 100vh;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 1rem;
+  z-index: 51;
+}
+.moonkey-input::placeholder {
+  opacity: 0.3;
+}
+.moonkey-scrollbar-none {
+  scrollbar-width: none;
+  -ms-overflow-style: none;
+}
+.moonkey-scrollbar-none::-webkit-scrollbar {
+  display: none;
+}
+@keyframes moonkey-enter {
+  from {
+    opacity: 0;
+    transform: translate3d(var(--tw-enter-translate-x, 0), var(--tw-enter-translate-y, 0), 0) scale3d(var(--tw-enter-scale, 1), var(--tw-enter-scale, 1), var(--tw-enter-scale, 1)) rotate(var(--tw-enter-rotate, 0));
+  }
+}
+@keyframes moonkey-spin {
+  from {
+    transform: rotate(0deg);
+  }
+  to {
+    transform: rotate(360deg);
+  }
+}

package/dist/index.d.mts

@@ -0,0 +1,298 @@
+export { LoginWithEmailState, PasskeyStatusEntry, RegisterPasskeyResult, UseAddPasskeyResult, UseLoginWithEmailCallbacks, UsePasskeyStatusResult, UseRemovePasskeyResult, useAddPasskey, useLoginWithEmail, usePasskeyStatus, useRegisterPasskey, useRemovePasskey, useUser } from '@moon-x/core/react';
+import { WalletListEntry, AuthAppearance, PrefillConfig, WalletChainType, MoonKeyThemeConfig, PasskeyEnrollConfig, SignMessageConfig, ExportKeyConfig, SignTransactionConfig, SendTransactionConfig, Chain, LogoutResponse, EmailOtpFlowState, Wallet } from '@moon-x/core/types';
+export { Chain, Factor, IdpProvider, Network, PublicEthereumWallet, PublicWallet, WalletConnectConfig, WalletListEntry } from '@moon-x/core/types';
+import React$1, { ReactNode } from 'react';
+export { e as ethereum } from './ethereum-DobH9IQl.mjs';
+export { s as solana } from './solana-CzXRbze_.mjs';
+export { estimateEvmGas, estimateEvmGasReserve, getChainById, getDefaultChain, getEvmGasPrice, getEvmMaxPriorityFeePerGas, getEvmNonce, getRpcUrl, isChainSupported, setChainRpcUrl, validateChainConfig } from '@moon-x/core/lib';
+export { arbitrum, arbitrumSepolia, avalanche, avalancheFuji, base, baseSepolia, bsc, bscTestnet, goerli, holesky, mainnet, optimism, optimismSepolia, polygon, polygonAmoy, sepolia } from 'viem/chains';
+import './base-wallet-CzJLpndu.mjs';
+import '@moon-x/core';
+
+type OAuthProvider$1 = "google" | "apple";
+interface OAuthAttachResult {
+    created_at: number;
+    expires_at: number;
+    last_active_at: number;
+    publishable_key: string;
+    access_token: string;
+    refresh_token: string;
+    user_id: string;
+}
+interface AttachOAuthState {
+    status: "initial" | "loading" | "done" | "error";
+    error: Error | null;
+    result: OAuthAttachResult | null;
+}
+interface UseAttachOAuthCallbacks {
+    onSuccess?: (result: OAuthAttachResult) => void;
+    onError?: (error: Error) => void;
+}
+interface UseAttachOAuth {
+    state: AttachOAuthState;
+    ready: boolean;
+    attachOAuth: (options: {
+        provider: OAuthProvider$1;
+    }) => Promise<void>;
+}
+declare function useAttachOAuth(options?: UseAttachOAuthCallbacks): UseAttachOAuth;
+
+interface BaseConnectedEthereumWallet {
+    public_address: string;
+    wallet_type: "ethereum";
+    chain_id?: string;
+    connector?: any;
+}
+interface BaseConnectedSolanaWallet {
+    public_address: string;
+    wallet_type: "solana";
+    chain_id?: string;
+}
+interface ConnectWalletParams {
+    description?: string;
+    walletList?: WalletListEntry[];
+    walletChainType?: "ethereum" | "solana" | "ethereum-and-solana";
+    mode?: "signIn" | "link";
+}
+
+interface ConnectWalletCallbacks {
+    onSuccess?: (params: {
+        wallet: BaseConnectedEthereumWallet | BaseConnectedSolanaWallet;
+    }) => void;
+    onError?: (error: Error) => void;
+    onClose?: () => void;
+}
+interface UseConnectWallet {
+    connectWallet: (params?: ConnectWalletParams) => Promise<void>;
+    isConnecting: boolean;
+}
+declare function useConnectWallet(callbacks?: ConnectWalletCallbacks): UseConnectWallet;
+
+interface DetachOAuthResult {
+    success: boolean;
+    message?: string;
+}
+interface DetachOAuthState {
+    status: "initial" | "loading" | "done" | "error";
+    error: Error | null;
+    result: DetachOAuthResult | null;
+}
+interface UseDetachOAuthCallbacks {
+    onSuccess?: (result: DetachOAuthResult) => void;
+    onError?: (error: Error) => void;
+}
+interface UseDetachOAuth {
+    state: DetachOAuthState;
+    loading: boolean;
+    detachOAuth: (idpUserId: string) => Promise<void>;
+}
+declare function useDetachOAuth(options?: UseDetachOAuthCallbacks): UseDetachOAuth;
+
+type OAuthProvider = "google" | "apple";
+interface OAuthUser {
+    created_at: number;
+    expires_at: number;
+    last_active_at: number;
+    publishable_key: string;
+    access_token: string;
+    refresh_token: string;
+    user_id: string;
+}
+interface OAuthState {
+    status: "initial" | "loading" | "done" | "error";
+    error: Error | null;
+    user: OAuthUser | null;
+}
+interface UseLoginWithOAuthCallbacks {
+    onSuccess?: (result: OAuthUser) => void;
+    onError?: (error: Error) => void;
+}
+interface UseLoginWithOAuth {
+    state: OAuthState;
+    ready: boolean;
+    initOAuth: (options: {
+        provider: OAuthProvider;
+    }) => Promise<void>;
+}
+declare function useLoginWithOAuth(options?: UseLoginWithOAuthCallbacks): UseLoginWithOAuth;
+
+interface MoonKeyConfig {
+    appearance?: AuthAppearance;
+    loginMethods?: ("email" | "google" | "apple" | "wallet")[];
+    /**
+     * Security-policy knobs. Safe defaults (the entire `security` object
+     * can be omitted for the strictest posture).
+     */
+    security?: {
+        /**
+         * TTL in milliseconds for the parent-side passkey assertion cache.
+         *
+         * Default: 0 (no cache — every sensitive op forces a fresh
+         * biometric prompt). This is the safe-by-default posture; the raw
+         * userHandle (the AES-GCM KEK that unwraps the user's DEK) never
+         * lingers in the parent JS heap past the moment of use.
+         *
+         * Set to a positive number (e.g. 5 * 60 * 1000) only if the
+         * integrating app has a UX that genuinely benefits from skipping
+         * the OS passkey prompt on routine ops within a window. The
+         * trade-off: during the warm window, parent-coresident JS that
+         * can reach the SDK can drive wallet ops without re-prompting.
+         *
+         * Sensitive operations (export, addPasskey, removePasskey, and
+         * any call passing `requireFreshAssertion: true`) bypass the
+         * cache regardless of this setting.
+         */
+        assertionCacheTtlMs?: number;
+    };
+    prefill?: PrefillConfig;
+    walletChainType?: WalletChainType;
+    isDark?: boolean;
+    theme?: MoonKeyThemeConfig;
+    emailConfig?: {
+        skipVerifiedSuccess?: boolean;
+        expiresIn?: number;
+        verifiedDisplayTime?: number;
+        verifyEmailTitle?: string;
+        verifyEmailResendTitle?: string;
+        resendCodeTime?: number;
+        verifiedNewUserMessage?: string;
+        verifiedExistingUserMessage?: string;
+        verifiedSuccessMessage?: string;
+    };
+    passkeyEnrollConfig?: PasskeyEnrollConfig;
+    signMessageConfig?: SignMessageConfig;
+    exportKeyConfig?: ExportKeyConfig;
+    signTransactionConfig?: SignTransactionConfig;
+    sendTransactionConfig?: SendTransactionConfig;
+    walletConnect?: {
+        projectId: string;
+    };
+    defaultChain?: Chain;
+    supportedChains?: Chain[];
+    solana?: {
+        rpcs: {
+            [key: string]: {
+                rpc: string;
+                rpcSubscriptions?: string;
+            };
+        };
+    };
+}
+interface MoonKeyProviderProps$1 {
+    publishableKey: string;
+    config?: MoonKeyConfig;
+    children: React.ReactNode;
+    onClose?: () => void;
+}
+interface MoonKeyInstance {
+    ready: boolean;
+    isAuthenticated: boolean;
+    user: any | null;
+    getCurrentSession: () => Promise<any>;
+    getUser: () => Promise<any>;
+    logout: () => Promise<LogoutResponse>;
+    flowState: EmailOtpFlowState;
+    /**
+     * Get the current user's three-token bundle from IndexedDB. The access
+     * token is short-lived (~1h, ES256-signed, JWKS-verifiable by your
+     * backend). The identity token carries linked-account metadata. The
+     * refresh token is opaque and rotates on every use.
+     * @returns Promise with the bundle, or null if not authenticated
+     * @example
+     * const tokens = await getSessionTokens();
+     * if (tokens) {
+     *   fetch('/api/protected', {
+     *     headers: { 'X-MoonX-Access-Token': tokens.accessToken }
+     *   });
+     * }
+     */
+    getSessionTokens: () => Promise<{
+        accessToken: string;
+        identityToken: string;
+        refreshToken: string;
+        expiresAt: number;
+    } | null>;
+    /**
+     * Start authentication flow (UI-based)
+     * @param params - Optional configuration to override provider-level config
+     * @param params.loginMethods - Login methods to show in UI
+     * @param params.prefill - Pre-fill email/phone in UI
+     * @param params.disableSignup - Disable signup for new users
+     * @param params.walletChainType - Which wallet type to create on login
+     */
+    start: (params?: {
+        loginMethods?: ("email" | "google" | "apple" | "wallet")[];
+        prefill?: {
+            type: "email" | "phone";
+            value: string;
+        };
+        disableSignup?: boolean;
+        walletChainType?: "ethereum" | "solana" | "ethereum-or-solana";
+    }) => Promise<any>;
+    onError: (callback: (error: Error) => void) => void;
+    onClose: (callback: () => void) => void;
+    /**
+     * Dynamically update the appearance configuration
+     * @param appearance - Appearance configuration including displayMode, backgroundColor, and accentColor
+     * @example
+     * const { setAppearance } = useMoonKey();
+     * const colorScheme = useColorScheme(); // React Native
+     * setAppearance({ displayMode: colorScheme === 'dark' ? 'dark' : 'light' });
+     */
+    setAppearance: (appearance: AuthAppearance) => void;
+    publishableKey: string;
+    sendCode: (params: {
+        email: string;
+        disableSignup?: boolean;
+    }) => Promise<void>;
+    loginWithCode: (params: {
+        code: string;
+    }) => Promise<void>;
+}
+interface WalletInstance {
+    wallets: () => Promise<Wallet[]>;
+    signMessage: (message: string) => Promise<any>;
+    getAddress: () => Promise<string>;
+    getBalance: () => Promise<string>;
+}
+interface WalletConfig {
+    network: "mainnet" | "testnet" | "devnet";
+    rpcUrl?: string;
+}
+type WalletType = "solana" | "ethereum";
+
+declare const useMoonKey: () => MoonKeyInstance;
+
+interface UseOAuthCompletionOptions {
+    onSuccess?: (data: any) => void;
+    onError?: (error: Error) => void;
+}
+declare function useOAuthCompletion(options?: UseOAuthCompletionOptions): void;
+
+interface MoonKeyProviderProps {
+    publishableKey: string;
+    embeddableId?: string;
+    config?: MoonKeyConfig;
+    children: ReactNode;
+}
+declare const MoonKeyProvider: React$1.FC<MoonKeyProviderProps>;
+
+declare class SessionExpiredError extends Error {
+    walletType: string;
+    walletAddress?: string;
+    requiresReconnection: boolean;
+    constructor(walletType: string, walletAddress?: string, message?: string);
+}
+declare class SessionNotFoundError extends Error {
+    walletType: string;
+    walletAddress?: string;
+    requiresReconnection: boolean;
+    constructor(walletType: string, walletAddress?: string, message?: string);
+}
+declare const requiresReconnection: (error: any) => boolean;
+declare const getReconnectionInfo: (error: any) => {
+    walletType?: string;
+    walletAddress?: string;
+} | null;
+
+export { type AttachOAuthState, type BaseConnectedEthereumWallet, type BaseConnectedSolanaWallet, type ConnectWalletCallbacks, type ConnectWalletParams, type DetachOAuthResult, type DetachOAuthState, type MoonKeyConfig, type MoonKeyInstance, MoonKeyProvider, type MoonKeyProviderProps$1 as MoonKeyProviderProps, type OAuthAttachResult, type OAuthProvider, type OAuthState, type OAuthUser, SessionExpiredError, SessionNotFoundError, type UseAttachOAuth, type UseAttachOAuthCallbacks, type UseConnectWallet, type UseDetachOAuth, type UseDetachOAuthCallbacks, type UseLoginWithOAuth, type UseLoginWithOAuthCallbacks, type WalletConfig, type WalletInstance, type WalletType, getReconnectionInfo, requiresReconnection, useAttachOAuth, useConnectWallet, useDetachOAuth, useLoginWithOAuth, useMoonKey, useOAuthCompletion };