@silentswap/react 0.0.41

package/dist/hooks/silent/useAuth.js

@@ -0,0 +1,269 @@
+import { useCallback, useState, useEffect, useRef } from 'react';
+import { createSignInMessage, createEip712DocForOrder, createEip712DocForWalletGeneration, loadCachedAuth, saveAuth, clearAuth, normalizeAddress, } from '@silentswap/sdk';
+/**
+ * React hook for SilentSwap authentication with full SIWE flow
+ *
+ * This hook provides:
+ * - SIWE authentication with nonce management
+ * - Automatic auth caching and restoration
+ * - Sign-in message creation and signing
+ * - Auth state management
+ * - Auto-authentication when dependencies are available
+ *
+ * @param options - Configuration options for authentication
+ * @returns Object with authentication state and methods
+ *
+ * @example
+ * ```typescript
+ * import { useAuth, useSilentClient } from '@silentswap/react';
+ * import { useWalletClient, useAccount } from 'wagmi';
+ *
+ * function MyComponent() {
+ *   const { address } = useAccount();
+ *   const { data: walletClient } = useWalletClient();
+ *   const client = useSilentClient({ config: { /* ... *\/ } }).client;
+ *
+ *   const {
+ *     auth,
+ *     isAuthenticated,
+ *     signIn,
+ *     signOut,
+ *     isLoading,
+ *     error
+ *   } = useAuth({
+ *     client,
+ *     address,
+ *     walletClient: walletClient as any,
+ *     autoAuthenticate: true,
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       {isLoading && <div>Authenticating...</div>}
+ *       {error && <div>Error: {error.message}</div>}
+ *
+ *       {isAuthenticated() ? (
+ *         <div>
+ *           <p>Authenticated as {auth?.address}</p>
+ *           <button onClick={signOut}>Sign Out</button>
+ *         </div>
+ *       ) : (
+ *         <button onClick={signIn} disabled={isLoading}>
+ *           Sign In with Ethereum
+ *         </button>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export function useAuth({ client, address, walletClient, domain = typeof window !== 'undefined' ? window.location.host : undefined, autoAuthenticate = false, } = {}) {
+    const [auth, setAuth] = useState(null);
+    const [nonce, setNonce] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [isAutoAuthenticating, setIsAutoAuthenticating] = useState(false);
+    const [error, setError] = useState(null);
+    // Track if auto-authentication has been attempted to prevent duplicate calls
+    const hasAutoAuthenticatedRef = useRef(false);
+    // Normalize address
+    const normalizedAddress = address ? normalizeAddress(address) : null;
+    /**
+     * Load cached authentication
+     */
+    const loadCachedAuthCallback = useCallback(() => {
+        if (!normalizedAddress)
+            return null;
+        return loadCachedAuth(normalizedAddress);
+    }, [normalizedAddress]);
+    /**
+     * Save authentication to cache
+     */
+    const saveAuthCallback = useCallback((authData) => {
+        if (!normalizedAddress)
+            return;
+        saveAuth(normalizedAddress, authData);
+    }, [normalizedAddress]);
+    /**
+     * Create SIWE sign-in message
+     */
+    const createSignInMessageCallback = useCallback((address, nonce, domain) => {
+        return createSignInMessage(address, nonce, domain);
+    }, []);
+    /**
+     * Create EIP-712 document for order
+     */
+    const createEip712DocForOrderCallback = useCallback((quoteResponse) => {
+        return createEip712DocForOrder(quoteResponse);
+    }, []);
+    /**
+     * Create EIP-712 document for wallet generation
+     */
+    const createEip712DocForWalletGenerationCallback = useCallback((scope, token) => {
+        return createEip712DocForWalletGeneration(scope, token);
+    }, []);
+    /**
+     * Get nonce from server
+     */
+    const getNonce = useCallback(async () => {
+        if (!client) {
+            throw new Error('Client required for nonce request');
+        }
+        if (!normalizedAddress) {
+            throw new Error('Address required for nonce request');
+        }
+        setError(null);
+        try {
+            const [error, response] = await client.nonce(normalizedAddress);
+            if (error) {
+                throw new Error(`Failed to get nonce: ${error.error}`);
+            }
+            const nonceValue = response.nonce;
+            setNonce(nonceValue);
+            return nonceValue;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to fetch nonce');
+            setError(error);
+            throw error;
+        }
+    }, [client, normalizedAddress]);
+    /**
+     * Perform SIWE authentication
+     */
+    const authenticate = useCallback(async () => {
+        if (!client) {
+            throw new Error('Client required for authentication');
+        }
+        if (!normalizedAddress) {
+            throw new Error('Address required for authentication');
+        }
+        if (!walletClient) {
+            throw new Error('Wallet client required for authentication');
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            // Get nonce if we don't have one
+            let nonceValue = nonce;
+            if (!nonceValue) {
+                nonceValue = await getNonce();
+            }
+            // Create SIWE message
+            const siweMessage = createSignInMessageCallback(normalizedAddress, nonceValue, domain);
+            // Sign the message
+            const signature = await walletClient.signMessage({
+                account: normalizedAddress,
+                message: siweMessage.message,
+            });
+            // Authenticate with server
+            const [authError, authResponse] = await client.authenticate({
+                siwe: {
+                    message: siweMessage.message,
+                    signature: signature,
+                },
+            });
+            if (authError || !authResponse) {
+                throw new Error(`Authentication failed: ${authError?.error}`);
+            }
+            // Cache the auth response
+            saveAuthCallback(authResponse);
+            // Update state
+            setAuth(authResponse);
+            return authResponse;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Authentication failed');
+            setError(error);
+            return null;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [client, normalizedAddress, walletClient, nonce, getNonce, createSignInMessageCallback, domain, saveAuthCallback]);
+    /**
+     * Sign in (alias for authenticate for convenience)
+     */
+    const signIn = useCallback(async () => {
+        return authenticate();
+    }, [authenticate]);
+    /**
+     * Sign out and clear auth
+     */
+    const signOut = useCallback(() => {
+        if (!normalizedAddress)
+            return;
+        clearAuth(normalizedAddress);
+        setAuth(null);
+        setNonce(null);
+        setError(null);
+        setIsAutoAuthenticating(false);
+        // Reset auto-authentication flag
+        hasAutoAuthenticatedRef.current = false;
+    }, [normalizedAddress]);
+    /**
+     * Check if user is authenticated
+     */
+    const isAuthenticated = useCallback(() => {
+        return auth !== null && auth.authExpires > Date.now();
+    }, [auth]);
+    // Load cached auth on mount
+    useEffect(() => {
+        if (normalizedAddress && !auth && !isLoading) {
+            const cachedAuth = loadCachedAuthCallback();
+            if (cachedAuth) {
+                setAuth(cachedAuth);
+            }
+        }
+    }, [normalizedAddress, auth, isLoading, loadCachedAuthCallback]);
+    // Auto-authenticate when dependencies are available
+    useEffect(() => {
+        // Skip if already authenticated, loading, has error, or already attempted
+        if (!autoAuthenticate ||
+            !normalizedAddress ||
+            !walletClient ||
+            auth ||
+            isLoading ||
+            isAutoAuthenticating ||
+            error ||
+            hasAutoAuthenticatedRef.current) {
+            return;
+        }
+        // Check if cached auth exists and is valid
+        const cachedAuth = loadCachedAuthCallback();
+        if (cachedAuth && cachedAuth.authExpires > Date.now()) {
+            setAuth(cachedAuth);
+            hasAutoAuthenticatedRef.current = true;
+            return;
+        }
+        // Mark as in progress and attempt authentication
+        setIsAutoAuthenticating(true);
+        authenticate()
+            .then(() => {
+            hasAutoAuthenticatedRef.current = true;
+        })
+            .catch((err) => {
+            console.error('Auto-authentication failed:', err);
+        })
+            .finally(() => {
+            setIsAutoAuthenticating(false);
+        });
+    }, [autoAuthenticate, normalizedAddress, walletClient, auth, isLoading, isAutoAuthenticating, error, authenticate, loadCachedAuthCallback]);
+    return {
+        // State
+        auth,
+        nonce,
+        isLoading: isLoading || isAutoAuthenticating,
+        error,
+        // Sign-in message creation
+        createSignInMessage: createSignInMessageCallback,
+        // EIP-712 document creation
+        createEip712DocForOrder: createEip712DocForOrderCallback,
+        createEip712DocForWalletGeneration: createEip712DocForWalletGenerationCallback,
+        // Authentication methods
+        getNonce,
+        authenticate,
+        signIn,
+        signOut,
+        isAuthenticated,
+    };
+}

package/dist/hooks/silent/useBridgeExecution.d.ts

@@ -0,0 +1,39 @@
+import type { Hex, WalletClient } from 'viem';
+import type { Connector } from 'wagmi';
+import type { DepositParams } from '@silentswap/sdk';
+import type { SolanaWalletConnector, SolanaConnection } from './solana-transaction.js';
+/**
+ * Result from executing a bridge transaction
+ */
+export interface BridgeExecutionResult {
+    /** Transaction hash of the deposit on Avalanche */
+    depositTxHash: Hex;
+    /** Selected bridge provider */
+    provider: 'relay' | 'debridge';
+}
+/**
+ * Hook for executing bridge transactions (Solana → Avalanche or EVM → Avalanche)
+ *
+ * This hook handles the complete bridge execution flow:
+ * - Solving for optimal USDC amount (if not provided)
+ * - Fetching quotes from both relay.link and deBridge
+ * - Selecting the best provider based on rates
+ * - Executing bridge transactions (Solana or EVM)
+ * - Monitoring bridge status until deposit arrives
+ *
+ * Supports both Solana and EVM source chains, automatically selecting
+ * the best bridge provider (relay.link or deBridge) based on rates.
+ *
+ * @param walletClient - Wallet client for EVM transactions
+ * @param connector - Wagmi connector for chain switching
+ * @param solanaConnector - Solana wallet connector (required for Solana swaps)
+ * @param solanaConnection - Solana RPC connection (required for Solana swaps)
+ * @param solanaRpcUrl - Optional Solana RPC URL
+ * @param setCurrentStep - Callback to set current step message
+ * @param onStatus - Optional status update callback
+ * @returns Functions for executing bridge transactions
+ */
+export declare function useBridgeExecution(walletClient: WalletClient | undefined, connector: Connector | undefined, solanaConnector: SolanaWalletConnector | undefined, solanaConnection: SolanaConnection | undefined, solanaRpcUrl: string | undefined, setCurrentStep: (step: string) => void, depositorAddress: Hex, onStatus?: (status: string) => void): {
+    executeSolanaBridge: (sourceAsset: string, sourceAmount: string, usdcAmount: string | undefined, solanaSenderAddress: string, evmSignerAddress: `0x${string}`, depositParams?: DepositParams<`${bigint}`>) => Promise<BridgeExecutionResult>;
+    executeEvmBridge: (sourceChainId: number, sourceTokenAddress: string, sourceAmount: string, usdcAmount: string | undefined, depositParams: DepositParams<`${bigint}`>, evmSignerAddress: `0x${string}`, evmSenderAddress?: `0x${string}`, provider?: "relay" | "debridge") => Promise<BridgeExecutionResult>;
+};