@silentswap/react 0.0.41

package/dist/hooks/silent/useSilentQuote.js

@@ -0,0 +1,381 @@
+import { useCallback, useMemo, useState } from 'react';
+import { hexToBase58, isSolanaAsset, parseEvmCaip19, S_CAIP19_USDC_AVALANCHE, NI_CHAIN_ID_AVALANCHE, getAssetByCaip19, } from '@silentswap/sdk';
+import { getAddress } from 'viem';
+import { BigNumber } from 'bignumber.js';
+import { useQuoteFetching } from './useQuoteFetching.js';
+import { useOrderSigning } from './useOrderSigning.js';
+import { useBridgeExecution } from './useBridgeExecution.js';
+import { useTransaction } from '../useTransaction.js';
+import { useQuoteCalculation } from './useQuoteCalculation.js';
+export function useSilentQuote({ client, address, evmAddress, solAddress, walletClient, connector, wallet, walletLoading = false, onStatus, solanaConnector, solanaConnection, solanaRpcUrl, getPrice, setDestinations, }) {
+    const [isLoading, setIsLoading] = useState(false);
+    const [currentStep, setCurrentStep] = useState('');
+    const [quote, setQuote] = useState(null);
+    const [error, setError] = useState(null);
+    const [orderId, setOrderId] = useState(null);
+    const [viewingAuth, setViewingAuth] = useState(null);
+    const [isSwapping, setIsSwapping] = useState(false);
+    // Normalize address - only normalize EVM addresses
+    // Note: For Solana swaps, we still need an EVM address for facilitator operations
+    // The address parameter should be EVM for facilitator operations, but can be Solana for quote requests
+    const normalizedAddress = useMemo(() => {
+        if (!address)
+            return null;
+        // Check if it's an EVM address (starts with 0x)
+        if (typeof address === 'string' && address.startsWith('0x')) {
+            try {
+                return getAddress(address);
+            }
+            catch {
+                // If getAddress fails, it might be invalid, but we'll keep it as-is for now
+                return address;
+            }
+        }
+        // For Solana addresses, return null (they're handled separately for transactions)
+        // But facilitator operations still require EVM address
+        return null;
+    }, [address]);
+    // Keep raw address for quote requests (can be EVM or Solana)
+    const rawAddress = useMemo(() => address || null, [address]);
+    // Get environment-based depositor address from client
+    const depositorAddress = useMemo(() => client.s0xDepositorAddress, [client]);
+    // Initialize specialized hooks
+    const { getQuote: getQuoteInternal } = useQuoteFetching(client, rawAddress, setIsLoading, setCurrentStep, setError, onStatus);
+    const { signAuthorizations, createOrder } = useOrderSigning(walletClient, connector, client, setCurrentStep, onStatus);
+    const { executeSolanaBridge, executeEvmBridge } = useBridgeExecution(walletClient, connector, solanaConnector, solanaConnection, solanaRpcUrl, setCurrentStep, depositorAddress, onStatus);
+    const { executeSwapTransaction, approveTokenSpending } = useTransaction({
+        address: normalizedAddress || '0x0000000000000000000000000000000000000000',
+        walletClient,
+        connector,
+        solanaConnector,
+        solanaConnection,
+        solanaRpcUrl,
+        setCurrentStep,
+        onStatus,
+    });
+    /**
+     * Get a quote for a swap
+     *
+     * Wrapper around the quote fetching hook that also stores the quote in state.
+     */
+    const getQuote = useCallback(async (request) => {
+        const quoteResponse = await getQuoteInternal(request);
+        if (quoteResponse) {
+            setQuote(quoteResponse);
+        }
+        return quoteResponse;
+    }, [getQuoteInternal]);
+    // Use the quote calculation hook
+    const { calculateQuote, loadingAmounts, depositAmountUsdc } = useQuoteCalculation({
+        address: rawAddress || '0x0000000000000000000000000000000000000000',
+        evmAddress,
+        wallet,
+        depositorAddress,
+        getQuote,
+        getPrice,
+        setDestinations,
+    });
+    /**
+     * Execute the complete swap flow
+     *
+     * Orchestrates the entire swap process:
+     * 1. Fetches quote and calculates provider/allowance/usdcAmount
+     * 2. Determines swap type (Solana, EVM bridge, or direct deposit)
+     * 3. Creates and signs the order
+     * 4. Executes bridge transactions if needed
+     * 5. Executes deposit transaction
+     * 6. Returns swap result with order ID and transaction hashes
+     */
+    const executeSwap = useCallback(async ({ sourceAsset, sourceAmount, destinations, splits, senderContactId, }) => {
+        if (!rawAddress) {
+            throw new Error('Address required for swap execution');
+        }
+        if (!walletClient) {
+            throw new Error('Wallet client required for swap execution');
+        }
+        // Check if wallet is being generated - wait a bit and check again
+        if (walletLoading) {
+            throw new Error('Wallet is being generated. Please wait for wallet generation to complete before executing swap.');
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            setIsSwapping(true);
+            setCurrentStep('Fetching quote...');
+            onStatus?.('Fetching quote...');
+            const quoteResult = await calculateQuote(sourceAsset, sourceAmount, destinations, splits);
+            if (!quoteResult) {
+                // Ensure loadingAmounts is reset if handleGetQuote failed
+                throw new Error('Failed to get quote');
+            }
+            const { quote: quoteResponse, usdcAmount: effectiveUsdcAmount, facilitatorGroup: passedFacilitatorGroup, bridgeProvider: effectiveProvider, allowanceTarget: effectiveAllowanceTarget, } = quoteResult;
+            setCurrentStep('Executing swap...');
+            onStatus?.('Executing swap...');
+            // Convert source amount to units
+            const assetInfo = getAssetByCaip19(sourceAsset);
+            if (!assetInfo) {
+                throw new Error(`Asset not found: ${sourceAsset}`);
+            }
+            const sourceAmountBN = BigNumber(sourceAmount);
+            console.log('sourceAmountBN', sourceAmountBN);
+            const sourceAmountInUnits = sourceAmountBN.shiftedBy(assetInfo.decimals).toFixed(0);
+            console.log('sourceAmountInUnits', sourceAmountInUnits, assetInfo);
+            // Determine provider for bridge swap
+            const isDirectDeposit = sourceAsset === S_CAIP19_USDC_AVALANCHE;
+            let providerForSwap = undefined;
+            if (effectiveUsdcAmount && !isDirectDeposit) {
+                // When usdcAmount is provided and not direct deposit, we're doing a bridge swap and MUST have a provider
+                if (effectiveProvider === 'relay' || effectiveProvider === 'debridge') {
+                    providerForSwap = effectiveProvider;
+                }
+                else {
+                    throw new Error(`Provider is required for bridge swap. ` +
+                        `usdcAmount is set but provider is '${effectiveProvider}'. ` +
+                        `Please ensure a valid quote has been fetched.`);
+                }
+            }
+            const resolvedGroup = passedFacilitatorGroup;
+            if (!resolvedGroup) {
+                throw new Error('Facilitator group not available. Please ensure wallet is connected and authenticated.');
+            }
+            // Check swap type
+            const isSourceSolana = isSolanaAsset(sourceAsset);
+            const isDepositingDirectly = sourceAsset === S_CAIP19_USDC_AVALANCHE;
+            const isSourceEvm = !isSourceSolana && !isDepositingDirectly && sourceAsset.startsWith('eip155:');
+            // Generate viewing authorization
+            const viewer = await resolvedGroup.viewer();
+            const evmSigner = await viewer.evmSigner();
+            const viewingAuth = hexToBase58(evmSigner.address);
+            // CRITICAL: Use user's wallet address for deposit calldata (matches Svelte's s0x_signer)
+            // In Svelte: s0x_signer = await contact_from_id(UserState.senderAtNamespace('eip155')).address()
+            // This is the user's EVM wallet address, NOT the facilitator group's viewer EVM signer
+            // The signer address in quote request (already set above) and deposit calldata must match
+            if (!evmAddress) {
+                throw new Error('EVM address required for swap execution');
+            }
+            const evmSignerAddress = getAddress(evmAddress); // Use user's wallet address, not facilitator group's viewer EVM signer
+            // Handle Solana swaps
+            if (isSourceSolana) {
+                const result = await executeSolanaSwap(quoteResponse, sourceAsset, sourceAmountInUnits, effectiveUsdcAmount, senderContactId, solanaConnector, evmSignerAddress, // Use EVM signer address, not normalizedAddress
+                viewingAuth, createOrder, executeSolanaBridge, resolvedGroup);
+                setOrderId(result.orderId);
+                setViewingAuth(result.viewingAuth);
+                return result;
+            }
+            // Sign authorizations (for EVM swaps)
+            const signedAuths = await signAuthorizations(quoteResponse.authorizations, isDepositingDirectly);
+            // Create order with resolved facilitator group
+            // Pass the resolved group as override parameter (matches Svelte behavior where
+            // sender_resolve_group() is called right before swap)
+            const orderResponse = await createOrder(quoteResponse, signedAuths, {
+                sourceAsset: {
+                    caip19: sourceAsset,
+                    amount: `${BigInt(sourceAmountInUnits)}`,
+                },
+                sourceSender: {
+                    contactId: senderContactId,
+                },
+            }, resolvedGroup);
+            // Handle ERC-20 approvals if needed
+            if (effectiveAllowanceTarget && !isDepositingDirectly && evmSignerAddress) {
+                const sourceAssetMatch = sourceAsset.match(/eip155:(\d+):erc20:(0x[a-fA-F0-9]+)/);
+                if (sourceAssetMatch) {
+                    const sourceChainId = parseInt(sourceAssetMatch[1]);
+                    const tokenAddress = sourceAssetMatch[2];
+                    await approveTokenSpending(sourceChainId, tokenAddress, effectiveAllowanceTarget, sourceAmountInUnits, evmSignerAddress);
+                }
+            }
+            // Handle EVM bridge swaps
+            if (isSourceEvm) {
+                // Use the USDC amount from solveOptimalUsdcAmount (matches Svelte behavior)
+                // In Svelte: zg_amount_src_usdc is passed directly to bridge execution (line 1028)
+                const result = await executeEvmSwap(sourceAsset, sourceAmountInUnits, effectiveUsdcAmount, // Use amount from solveOptimalUsdcAmount (matches Svelte)
+                providerForSwap, orderResponse, evmSignerAddress, // Use EVM signer address, not normalizedAddress
+                viewingAuth, executeEvmBridge, senderContactId);
+                setOrderId(result.orderId);
+                setViewingAuth(result.viewingAuth);
+                return result;
+            }
+            // Execute direct deposit transaction (for direct USDC deposits)
+            const depositTx = await executeSwapTransaction(orderResponse);
+            const resultOrderId = orderResponse.response.orderId;
+            setOrderId(resultOrderId);
+            setViewingAuth(viewingAuth);
+            return {
+                orderId: resultOrderId,
+                viewingAuth,
+                depositTransaction: depositTx,
+            };
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Swap execution failed');
+            console.error('Swap execution failed:', {
+                sourceAsset,
+                sourceAmount,
+                destinationsCount: destinations.length,
+                error: error.message,
+                stack: error.stack,
+            });
+            setError(error);
+            // Ensure all loading states are reset on error
+            return null;
+        }
+        finally {
+            setIsSwapping(false);
+            setIsLoading(false);
+            setCurrentStep('');
+        }
+    }, [
+        rawAddress,
+        evmAddress,
+        walletClient,
+        walletLoading,
+        solanaConnector,
+        signAuthorizations,
+        createOrder,
+        approveTokenSpending,
+        executeSolanaBridge,
+        executeEvmBridge,
+        executeSwapTransaction,
+        calculateQuote,
+        onStatus,
+    ]);
+    /**
+     * Clear current quote
+     */
+    const clearQuote = useCallback(() => {
+        setQuote(null);
+        setError(null);
+        setOrderId(null);
+        setViewingAuth(null);
+    }, []);
+    return {
+        // State
+        isLoading,
+        isSwapping,
+        currentStep,
+        quote,
+        error,
+        orderId,
+        viewingAuth,
+        // Methods
+        executeSwap,
+        clearQuote,
+        depositAmountUsdc,
+        loadingAmounts,
+    };
+}
+/**
+ * Execute Solana swap flow
+ *
+ * Handles the complete flow for Solana-based swaps:
+ * 1. Validates Solana connection
+ * 2. Creates order (with empty authorizations for Solana)
+ * 3. Executes bridge transaction
+ * 4. Returns swap result
+ */
+async function executeSolanaSwap(quoteResponse, sourceAsset, sourceAmount, usdcAmount, senderContactId, solanaConnector, evmSignerAddress, // EVM signer address (matches Svelte's s0x_signer)
+viewingAuth, createOrder, executeSolanaBridge, facilitatorGroup) {
+    if (!solanaConnector) {
+        throw new Error('Solana connector required for Solana swaps');
+    }
+    if (!solanaConnector.publicKey) {
+        throw new Error('Solana wallet not connected');
+    }
+    // Get Solana sender address (base58)
+    const solanaSenderAddress = solanaConnector.publicKey.toString() || '';
+    if (!solanaSenderAddress) {
+        throw new Error('Failed to get Solana sender address');
+    }
+    // Create order with empty authorizations (Solana doesn't use EIP-3009)
+    // Pass resolved facilitator group (matches Svelte behavior)
+    const orderResponse = await createOrder(quoteResponse, quoteResponse.authorizations.map((auth) => ({
+        ...auth,
+        signature: '0x', // No EIP-3009 deposit for Solana
+    })), {
+        sourceAsset: {
+            caip19: sourceAsset,
+            amount: `${BigInt(sourceAmount)}`,
+        },
+        sourceSender: {
+            contactId: senderContactId,
+        },
+    }, facilitatorGroup);
+    // Get deposit parameters from order
+    const depositParams = orderResponse.transaction.metadata?.params;
+    if (!depositParams) {
+        throw new Error('Missing deposit parameters in order response');
+    }
+    // Execute bridge transaction
+    // Use EVM signer address for deposit calldata (matches Svelte's s0x_signer)
+    // Pass depositParams so executeSolanaBridge can encode the actual deposit calldata
+    // Use usdcAmount from solveOptimalUsdcAmount (matches Svelte: zg_amount_src_usdc is passed directly)
+    const bridgeResult = await executeSolanaBridge(sourceAsset, sourceAmount, usdcAmount, // Use amount from solveOptimalUsdcAmount (matches Svelte line 1028)
+    solanaSenderAddress, evmSignerAddress, // Use EVM signer address, not normalizedAddress
+    depositParams);
+    const resultOrderId = orderResponse.response.orderId;
+    // Note: setOrderId is not available in this function scope,
+    // but the orderId will be set by the calling executeSwap function
+    return {
+        orderId: resultOrderId,
+        viewingAuth,
+        depositTransaction: {
+            hash: bridgeResult.depositTxHash,
+            chainId: NI_CHAIN_ID_AVALANCHE,
+            status: 'confirmed',
+            confirmations: 1,
+        },
+    };
+}
+/**
+ * Execute EVM swap flow
+ *
+ * Handles the complete flow for EVM-based bridge swaps:
+ * 1. Parses source asset to get chain ID and token address
+ * 2. Gets deposit parameters from order
+ * 3. Executes bridge transaction
+ * 4. Returns swap result
+ */
+async function executeEvmSwap(sourceAsset, sourceAmount, usdcAmount, provider, orderResponse, evmSignerAddress, // EVM signer address (matches Svelte's s0x_signer)
+viewingAuth, executeEvmBridge, senderContactId) {
+    // Parse source asset to get chain ID and token address
+    const sourceEvmParsed = parseEvmCaip19(sourceAsset);
+    if (!sourceEvmParsed) {
+        throw new Error(`Failed to parse EVM source asset: ${sourceAsset}`);
+    }
+    const sourceChainId = sourceEvmParsed.chainId;
+    const sourceTokenAddress = sourceEvmParsed.tokenAddress || '0x0000000000000000000000000000000000000000';
+    // Get deposit parameters from order
+    const depositParams = orderResponse.transaction.metadata?.params;
+    if (!depositParams) {
+        throw new Error('Missing deposit parameters in order response');
+    }
+    // Extract sender address from senderContactId (matches Svelte's s0x_sender)
+    // Format: caip10:eip155:*:0x... or caip10:eip155:chainId:0x...
+    let evmSenderAddress = evmSignerAddress; // Default to signer address
+    const senderMatch = senderContactId.match(/caip10:eip155(?::\*|:\d+):(0x[a-fA-F0-9]+)/i);
+    if (senderMatch) {
+        evmSenderAddress = getAddress(senderMatch[1]);
+    }
+    // Execute bridge transaction
+    // Use EVM sender address for bridge quotes (matches Svelte's s0x_sender)
+    // Use EVM signer address for deposit calldata (matches Svelte's s0x_signer)
+    // Use usdcAmount from solveOptimalUsdcAmount (matches Svelte: zg_amount_src_usdc is passed directly at line 1028)
+    const bridgeResult = await executeEvmBridge(sourceChainId, sourceTokenAddress, sourceAmount, usdcAmount, // Use amount from solveOptimalUsdcAmount (matches Svelte)
+    depositParams, evmSignerAddress, // Use EVM signer address for deposit calldata
+    evmSenderAddress, // Use EVM sender address for bridge quotes
+    provider);
+    const resultOrderId = orderResponse.response.orderId;
+    // Note: setOrderId is not available in this function scope,
+    // but the orderId will be set by the calling executeSwap function
+    return {
+        orderId: resultOrderId,
+        viewingAuth,
+        depositTransaction: {
+            hash: bridgeResult.depositTxHash,
+            chainId: NI_CHAIN_ID_AVALANCHE,
+            status: 'confirmed',
+            confirmations: 1,
+        },
+    };
+}

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

@@ -0,0 +1,76 @@
+import { type HdFacilitatorGroup, type AuthResponse, SilentSwapClient } from '@silentswap/sdk';
+import type { WalletClient } from 'viem';
+import type { Connector } from 'wagmi';
+export interface FacilitatorAccount {
+    group: () => Promise<HdFacilitatorGroup>;
+    nonce: number;
+}
+export interface SilentSwapWallet {
+    entropy: Uint8Array;
+    accounts: FacilitatorAccount[];
+}
+export interface useWalletOptions {
+    /** SilentSwap client */
+    client: SilentSwapClient;
+    /** The user's EVM address */
+    address: `0x${string}`;
+    /** Authentication response from SIWE */
+    auth?: AuthResponse;
+    /** Wallet client for signing operations */
+    walletClient?: WalletClient;
+    /** Wagmi connector */
+    connector?: Connector;
+    /** Whether to generate all deposit accounts or just the latest */
+    allDeposits?: boolean;
+}
+export interface useWalletReturn {
+    wallet: SilentSwapWallet | null;
+    isLoading: boolean;
+    error: Error | null;
+    generateWallet: () => Promise<void>;
+    getCachedWallet: () => SilentSwapWallet | null;
+    clearWallet: () => void;
+    refreshWallet: () => Promise<void>;
+}
+/**
+ * React hook for managing SilentSwap facilitator wallets and entropy generation
+ *
+ * This hook handles:
+ * - Generating and caching wallet entropy from SIWE authentication
+ * - Creating facilitator groups for different deposit nonces
+ * - Session storage persistence for wallet data
+ * - Automatic wallet refresh when deposits change
+ *
+ * @param options - Configuration options for wallet generation
+ * @returns Object with wallet state and management methods
+ *
+ * @example
+ * ```typescript
+ * import { useWallet, useAuth } from '@silentswap/react';
+ * import { useWalletClient } from 'wagmi';
+ *
+ * function MyComponent() {
+ *   const { data: walletClient } = useWalletClient();
+ *   const { auth } = useAuth();
+ *   const { wallet, generateWallet, isLoading } = useWallet({
+ *     address: '0x123...',
+ *     auth,
+ *     walletClient: walletClient as any,
+ *   });
+ *
+ *   useEffect(() => {
+ *     if (auth && walletClient && !wallet) {
+ *       generateWallet();
+ *     }
+ *   }, [auth, walletClient, wallet, generateWallet]);
+ *
+ *   return (
+ *     <div>
+ *       {isLoading && <div>Generating wallet...</div>}
+ *       {wallet && <div>Wallet ready with {wallet.accounts.length} accounts</div>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useWallet({ client, address, auth, walletClient, connector, allDeposits, }: useWalletOptions): useWalletReturn;

package/dist/hooks/silent/useWallet.js

@@ -0,0 +1,203 @@
+import { useCallback, useState, useEffect } from 'react';
+import { createHdFacilitatorGroupFromEntropy, createEip712DocForWalletGeneration, queryDepositCount, loadWalletData, saveWalletData, clearWalletData, XT_TTL_SESSION_CACHE, ensureChain, base93ToBytes, bytesToBase93, } from '@silentswap/sdk';
+import { getAddress, hexToBytes } from 'viem';
+/**
+ * React hook for managing SilentSwap facilitator wallets and entropy generation
+ *
+ * This hook handles:
+ * - Generating and caching wallet entropy from SIWE authentication
+ * - Creating facilitator groups for different deposit nonces
+ * - Session storage persistence for wallet data
+ * - Automatic wallet refresh when deposits change
+ *
+ * @param options - Configuration options for wallet generation
+ * @returns Object with wallet state and management methods
+ *
+ * @example
+ * ```typescript
+ * import { useWallet, useAuth } from '@silentswap/react';
+ * import { useWalletClient } from 'wagmi';
+ *
+ * function MyComponent() {
+ *   const { data: walletClient } = useWalletClient();
+ *   const { auth } = useAuth();
+ *   const { wallet, generateWallet, isLoading } = useWallet({
+ *     address: '0x123...',
+ *     auth,
+ *     walletClient: walletClient as any,
+ *   });
+ *
+ *   useEffect(() => {
+ *     if (auth && walletClient && !wallet) {
+ *       generateWallet();
+ *     }
+ *   }, [auth, walletClient, wallet, generateWallet]);
+ *
+ *   return (
+ *     <div>
+ *       {isLoading && <div>Generating wallet...</div>}
+ *       {wallet && <div>Wallet ready with {wallet.accounts.length} accounts</div>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export function useWallet({ client, address, auth, walletClient, connector, allDeposits = false, }) {
+    const [wallet, setWallet] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    // Normalize address
+    const normalizedAddress = address ? getAddress(address) : null;
+    /**
+     * Get cached wallet from sessionStorage
+     */
+    const getCachedWallet = useCallback(() => {
+        if (!normalizedAddress)
+            return null;
+        const cached = loadWalletData(normalizedAddress);
+        if (!cached)
+            return null;
+        try {
+            // Decode entropy
+            const entropy = base93ToBytes(cached.entropy);
+            // Create accounts
+            const accounts = cached.accounts.map(({ nonce }) => ({
+                group: () => createHdFacilitatorGroupFromEntropy(entropy, nonce),
+                nonce,
+            }));
+            return {
+                entropy,
+                accounts,
+            };
+        }
+        catch (err) {
+            console.warn('Failed to load cached wallet:', err);
+            clearWalletData(normalizedAddress);
+            return null;
+        }
+    }, [normalizedAddress]);
+    /**
+     * Generate wallet entropy from authentication
+     */
+    const generateEntropy = useCallback(async () => {
+        if (!auth) {
+            throw new Error('Authentication required for wallet generation');
+        }
+        if (!walletClient) {
+            throw new Error('Wallet client required for entropy generation');
+        }
+        if (!connector) {
+            throw new Error('Connector required for chain switching');
+        }
+        // Ensure we're on Ethereum mainnet for entropy generation (asked core devs about this in tg)
+        await ensureChain(1, walletClient, connector);
+        // Create EIP-712 document for wallet generation
+        const eip712Doc = createEip712DocForWalletGeneration(`eip155:43114:${address}`, // Gateway contract scope (Avalanche)
+        auth.secretToken);
+        // Fix chainId to be bigint
+        if (eip712Doc.domain && typeof eip712Doc.domain.chainId === 'number') {
+            eip712Doc.domain.chainId = BigInt(eip712Doc.domain.chainId);
+        }
+        // Sign the document to generate entropy
+        const signature = await walletClient.signTypedData({
+            ...eip712Doc,
+            account: walletClient.account,
+        });
+        return hexToBytes(signature);
+    }, [auth, walletClient, connector, address]);
+    /**
+     * Generate new wallet with facilitator accounts
+     */
+    const generateWallet = useCallback(async () => {
+        if (!normalizedAddress) {
+            throw new Error('Address required for wallet generation');
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            // Try to get cached wallet first
+            const cachedWallet = getCachedWallet();
+            if (cachedWallet) {
+                setWallet(cachedWallet);
+                return;
+            }
+            // Query the actual deposit count from the blockchain
+            const depositCount = await queryDepositCount(normalizedAddress, client.s0xGatewayAddress);
+            console.log('[useWallet] depositCount', depositCount);
+            // Generate new entropy
+            const entropy = await generateEntropy();
+            // Create accounts based on deposit count
+            const accounts = [];
+            // Match the Svelte implementation: if not allDeposits, start from depositCount (not depositCount-1)
+            // and use <= comparison to include the last account
+            const startNonce = allDeposits ? 0 : Number(depositCount);
+            const endNonce = Number(depositCount);
+            for (let nonce = startNonce; nonce <= endNonce; nonce++) {
+                accounts.push({
+                    group: () => createHdFacilitatorGroupFromEntropy(entropy, nonce),
+                    nonce,
+                });
+            }
+            // Ensure we always have at least one account (for new users with depositCount = 0)
+            // This guarantees wallet.accounts[0] exists
+            if (accounts.length === 0) {
+                accounts.push({
+                    group: () => createHdFacilitatorGroupFromEntropy(entropy, 0),
+                    nonce: 0,
+                });
+            }
+            const newWallet = {
+                entropy,
+                accounts,
+            };
+            // Cache wallet data
+            saveWalletData(normalizedAddress, {
+                entropy: bytesToBase93(entropy),
+                accounts: accounts.map(({ nonce }) => ({ nonce })),
+            }, XT_TTL_SESSION_CACHE);
+            setWallet(newWallet);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to generate wallet');
+            setError(error);
+            throw error;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [normalizedAddress, getCachedWallet, queryDepositCount, generateEntropy, allDeposits, connector, client.s0xGatewayAddress]);
+    /**
+     * Clear cached wallet
+     */
+    const clearWallet = useCallback(() => {
+        if (!normalizedAddress)
+            return;
+        clearWalletData(normalizedAddress);
+        setWallet(null);
+    }, [normalizedAddress]);
+    /**
+     * Refresh wallet (regenerate if needed)
+     */
+    const refreshWallet = useCallback(async () => {
+        clearWallet();
+        await generateWallet();
+    }, [clearWallet, generateWallet]);
+    // Auto-load cached wallet on mount
+    useEffect(() => {
+        if (normalizedAddress && !wallet && !isLoading) {
+            const cached = getCachedWallet();
+            if (cached) {
+                setWallet(cached);
+            }
+        }
+    }, [normalizedAddress, wallet, isLoading, getCachedWallet]);
+    return {
+        wallet,
+        isLoading,
+        error,
+        generateWallet,
+        getCachedWallet,
+        clearWallet,
+        refreshWallet,
+    };
+}

package/dist/hooks/useAssetPrice.d.ts

@@ -0,0 +1,8 @@
+import type { AssetInfo } from '@silentswap/sdk';
+/**
+ * Hook to fetch and manage asset price from the global context.
+ * Handles price fetching with optional override.
+ * This hook now uses the PricesContext to prevent duplicate API calls.
+ * Automatically updates when prices are refreshed (after 10 seconds).
+ */
+export declare function useAssetPrice(asset: AssetInfo | null, priceOverride?: number): number | undefined;