@silentswap/react 0.0.41

package/dist/hooks/silent/useQuoteCalculation.js

@@ -0,0 +1,331 @@
+import { useCallback, useState } from 'react';
+import { isSolanaAsset, parseEvmCaip19, S_CAIP19_USDC_AVALANCHE, getAssetByCaip19, solveOptimalUsdcAmount, N_RELAY_CHAIN_ID_SOLANA, SB58_ADDR_SOL_PROGRAM_SYSTEM, isSolanaNativeToken, parseSolanaCaip19, EVM_PHONY_ADDRESS, isValidSolanaAddress, getAddressFromCaip10, S0X_ADDR_USDC_AVALANCHE, isEvmNativeToken, caip19FungibleEvmToken, FacilitatorKeyType, createHdFacilitatorGroupFromEntropy, PublicKeyArgGroups, SB58_CHAIN_ID_SOLANA_MAINNET, caip19SplToken, DeliveryMethod, X_MAX_IMPACT_PERCENT, } from '@silentswap/sdk';
+import { getAddress } from 'viem';
+import { BigNumber } from 'bignumber.js';
+/**
+ * Hook for calculating quotes and USDC amounts
+ *
+ * Extracted from useSilentQuote to improve modularity and reusability.
+ * Handles:
+ * - USDC amount calculation for different asset types (Solana, EVM, direct USDC)
+ * - Facilitator group resolution
+ * - Quote request construction and fetching
+ * - Destination amount updates
+ */
+export function useQuoteCalculation({ address, evmAddress, wallet, depositorAddress, getQuote, getPrice, setDestinations, }) {
+    const [loadingAmounts, setLoadingAmounts] = useState(false);
+    const [depositAmountUsdc, setDepositAmountUsdc] = useState(0);
+    const calculateQuote = useCallback(async (debouncedSourceAsset, debouncedSourceAmount, destinations, splits) => {
+        if (!debouncedSourceAmount || parseFloat(debouncedSourceAmount) <= 0) {
+            return null;
+        }
+        const abortController = new AbortController();
+        try {
+            setLoadingAmounts(true);
+            if (abortController.signal.aborted) {
+                setLoadingAmounts(false);
+                return null;
+            }
+            const isSourceUsdcAvalanche = debouncedSourceAsset === S_CAIP19_USDC_AVALANCHE;
+            const isSourceSolana = isSolanaAsset(debouncedSourceAsset);
+            let usdcAmountOut;
+            let bridgeProviderResult = 'none';
+            let allowanceTargetResult = undefined;
+            if (isSourceUsdcAvalanche) {
+                const assetInfo = getAssetByCaip19(S_CAIP19_USDC_AVALANCHE);
+                if (!assetInfo)
+                    throw new Error(`USDC asset not found`);
+                const sourceAmountBN = BigNumber(debouncedSourceAmount);
+                usdcAmountOut = sourceAmountBN.shiftedBy(assetInfo.decimals).toFixed(0);
+            }
+            else if (isSourceSolana) {
+                // Solana assets - both relay.link and deBridge support Solana
+                // solveOptimalUsdcAmount will compare both providers and choose the best rate
+                const assetInfo = getAssetByCaip19(debouncedSourceAsset);
+                if (!assetInfo)
+                    throw new Error(`Solana asset not found`);
+                const sourceAmountBN = BigNumber(debouncedSourceAmount);
+                const sourceAmountInUnits = sourceAmountBN.shiftedBy(assetInfo.decimals).toFixed(0);
+                // Parse Solana CAIP-19 to get chain ID and token address
+                const solanaParsed = parseSolanaCaip19(debouncedSourceAsset);
+                if (!solanaParsed)
+                    throw new Error(`Invalid Solana CAIP-19 format: ${debouncedSourceAsset}`);
+                // Determine origin currency: system program for native SOL, token address for SPL tokens
+                // This matches relay_origin_asset() from silentswap-v2-ui/src/services/relay-link.ts
+                const originCurrency = isSolanaNativeToken(debouncedSourceAsset)
+                    ? SB58_ADDR_SOL_PROGRAM_SYSTEM
+                    : solanaParsed.tokenAddress ||
+                        (() => {
+                            throw new Error(`Missing token address for Solana asset: ${debouncedSourceAsset}`);
+                        })();
+                // For Solana swaps, we need:
+                // - Solana address for the 'user' parameter in relay quote (matches Svelte line 121: user: s_addr_sender)
+                // - EVM address for the 'recipient' parameter (matches Svelte line 122: recipient: s0x_signer)
+                // - EVM address for deposit calldata (matches Svelte line 156: signer: s0x_signer)
+                if (!evmAddress) {
+                    throw new Error('EVM address required for Solana swaps (needed for deposit calldata and recipient)');
+                }
+                const solanaAddress = typeof address === 'string' && !address.startsWith('0x') ? address : null;
+                if (!solanaAddress) {
+                    throw new Error('Solana address required for Solana swaps');
+                }
+                // Pass Solana address for user parameter, and EVM address for recipient and deposit calldata
+                // This matches Svelte behavior where s_addr_sender (Solana) is used for user, and s0x_signer (EVM) for recipient
+                const solveResult = await solveOptimalUsdcAmount(N_RELAY_CHAIN_ID_SOLANA, originCurrency, // Base58 Solana address (system program or SPL token)
+                sourceAmountInUnits, solanaAddress, // Pass Solana address for user parameter in relay quote
+                undefined, // depositCalldata will be created with EVM address
+                X_MAX_IMPACT_PERCENT, depositorAddress, // Required depositor address
+                getAddress(evmAddress));
+                if (abortController.signal.aborted) {
+                    setLoadingAmounts(false);
+                    return null;
+                }
+                // solveOptimalUsdcAmount compares both relay and deBridge and returns the best provider
+                usdcAmountOut = solveResult.usdcAmountOut.toString();
+                bridgeProviderResult = solveResult.provider; // Use the provider chosen by solveOptimalUsdcAmount
+                allowanceTargetResult = solveResult.allowanceTarget; // deBridge may return allowance target
+            }
+            else {
+                // EVM assets
+                const sourceAssetParsed = parseEvmCaip19(debouncedSourceAsset);
+                if (!sourceAssetParsed)
+                    throw new Error(`Invalid source asset format`);
+                const srcChainId = sourceAssetParsed.chainId;
+                const srcToken = sourceAssetParsed.tokenAddress || '0x0000000000000000000000000000000000000000';
+                const assetInfo = getAssetByCaip19(debouncedSourceAsset);
+                if (!assetInfo)
+                    throw new Error(`Asset not found`);
+                const sourceAmountBN = BigNumber(debouncedSourceAmount);
+                const sourceAmountInUnits = sourceAmountBN.shiftedBy(assetInfo.decimals).toFixed(0);
+                const solveResult = await solveOptimalUsdcAmount(srcChainId, srcToken, sourceAmountInUnits, address, undefined, // depositCalldata
+                X_MAX_IMPACT_PERCENT, depositorAddress);
+                if (abortController.signal.aborted) {
+                    setLoadingAmounts(false);
+                    return null;
+                }
+                usdcAmountOut = solveResult.usdcAmountOut.toString();
+                bridgeProviderResult = solveResult.provider;
+                allowanceTargetResult = solveResult.allowanceTarget;
+            }
+            // Use wallet's facilitator group if available, otherwise create a temporary one
+            let facilitatorGroupForQuote;
+            let viewerPk;
+            let groupPks;
+            if (wallet?.accounts[0]) {
+                facilitatorGroupForQuote = await wallet.accounts[0].group();
+                const viewer = await facilitatorGroupForQuote.viewer();
+                const { publicKeyBytes } = viewer.exportPublicKey('*', FacilitatorKeyType.SECP256K1);
+                viewerPk = publicKeyBytes;
+                groupPks = await facilitatorGroupForQuote.exportPublicKeys(destinations.length, PublicKeyArgGroups.GENERIC);
+            }
+            else {
+                const tempEntropy = new Uint8Array(32);
+                facilitatorGroupForQuote = await createHdFacilitatorGroupFromEntropy(tempEntropy, 0);
+                const viewer = await facilitatorGroupForQuote.viewer();
+                const { publicKeyBytes } = viewer.exportPublicKey('*', FacilitatorKeyType.SECP256K1);
+                viewerPk = publicKeyBytes;
+                groupPks = await facilitatorGroupForQuote.exportPublicKeys(destinations.length, PublicKeyArgGroups.GENERIC);
+            }
+            const usdcAmountBN = BigNumber(usdcAmountOut);
+            // Calculate split USDC amounts for each destination (matches Svelte Form.svelte lines 2550-2561)
+            // The value in the quote request should be USDC micro units, NOT the currencyOut.amount from egress quotes
+            // Egress quotes are used for retention rates and destination amounts, but NOT for quote request values
+            const splitUsdcAmounts = destinations.map((dest, idx) => {
+                const splitAmount = idx === 0 ? splits[0] : splits[idx] - splits[idx - 1];
+                return usdcAmountBN.times(splitAmount).toFixed(0);
+            });
+            const outputs = destinations.map((dest, idx) => {
+                const isDestSolana = isSolanaAsset(dest.asset);
+                let asset;
+                let recipientAddress; // Changed from `0x${string}` to string to support Solana addresses
+                if (isDestSolana) {
+                    // Solana destination
+                    const destParsed = parseSolanaCaip19(dest.asset);
+                    if (!destParsed)
+                        throw new Error(`Invalid Solana destination asset format`);
+                    const isNative = isSolanaNativeToken(dest.asset);
+                    // Extract base58 chain ID from CAIP-19 string for CAIP-19 construction
+                    const match = dest.asset.match(/^solana:([a-zA-Z0-9]+)\//);
+                    const chainIdBase58 = match ? match[1] : SB58_CHAIN_ID_SOLANA_MAINNET;
+                    asset = isNative ? dest.asset : caip19SplToken(chainIdBase58, destParsed.tokenAddress);
+                    // Extract Solana address from contact field
+                    // CRITICAL: Must be a valid Solana base58 address, not an EVM address
+                    if (dest.contact) {
+                        // Check if contact is in CAIP10 format
+                        if (dest.contact.startsWith('caip10:solana:')) {
+                            recipientAddress = getAddressFromCaip10(dest.contact);
+                            // Validate it's actually a Solana address
+                            if (!isValidSolanaAddress(recipientAddress)) {
+                                throw new Error(`Invalid Solana address extracted from CAIP10: ${dest.contact} -> ${recipientAddress}`);
+                            }
+                        }
+                        else if (isValidSolanaAddress(dest.contact)) {
+                            // Contact is already a plain Solana address (base58)
+                            recipientAddress = dest.contact;
+                        }
+                        else {
+                            // Contact is not a valid Solana address - this is an error
+                            throw new Error(`Invalid Solana recipient address for destination ${idx}: ${dest.contact}. Expected base58 Solana address or caip10:solana:*: format.`);
+                        }
+                    }
+                    else {
+                        throw new Error(`Solana destination ${idx} requires a recipient address in the contact field`);
+                    }
+                }
+                else {
+                    // EVM destination
+                    const destParsed = parseEvmCaip19(dest.asset);
+                    if (!destParsed)
+                        throw new Error(`Invalid destination asset format`);
+                    const isNative = isEvmNativeToken(dest.asset);
+                    const destChainId = destParsed.chainId;
+                    asset = isNative
+                        ? dest.asset
+                        : caip19FungibleEvmToken(destChainId, destParsed.tokenAddress);
+                    if (dest.contact) {
+                        try {
+                            // Extract EVM address from contact (handles both CAIP10 and plain addresses)
+                            if (dest.contact.startsWith('caip10:eip155:')) {
+                                recipientAddress = getAddressFromCaip10(dest.contact);
+                            }
+                            else {
+                                recipientAddress = getAddress(dest.contact);
+                            }
+                        }
+                        catch (error) {
+                            console.error('Failed to parse EVM recipient address:', {
+                                destination: idx,
+                                contact: dest.contact,
+                                error: error instanceof Error ? error.message : String(error),
+                            });
+                            throw new Error(`Invalid EVM recipient address for destination ${idx}: ${dest.contact}. ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                    }
+                    else {
+                        recipientAddress = EVM_PHONY_ADDRESS;
+                    }
+                }
+                // Use split USDC amount as the output value (matches Svelte Form.svelte line 2588)
+                // The value field in the quote request should be USDC micro units, not the destination asset amount
+                // This matches how Svelte calculates a_amounts_out and uses it as value in the quote request
+                const outputValue = splitUsdcAmounts[idx];
+                // Final validation: Ensure Solana destinations have Solana addresses, EVM destinations have EVM addresses
+                if (isDestSolana && !isValidSolanaAddress(recipientAddress)) {
+                    throw new Error(`Invalid recipient address type for Solana destination ${idx}: ${recipientAddress}. Expected base58 Solana address.`);
+                }
+                else if (!isDestSolana && !recipientAddress.startsWith('0x')) {
+                    throw new Error(`Invalid recipient address type for EVM destination ${idx}: ${recipientAddress}. Expected 0x-prefixed EVM address.`);
+                }
+                return {
+                    method: DeliveryMethod.SNIP,
+                    asset: asset,
+                    value: outputValue,
+                    recipient: recipientAddress,
+                    facilitatorPublicKeys: groupPks[idx],
+                };
+            });
+            if (abortController.signal.aborted) {
+                setLoadingAmounts(false);
+                return null;
+            }
+            // CRITICAL: Use user's wallet address for quote request (matches Svelte behavior)
+            // 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 must match the signer address in deposit calldata
+            // Both use the user's wallet address, not the facilitator group's derived address
+            const quoteSignerAddress = typeof evmAddress === 'string' && evmAddress.startsWith('0x')
+                ? getAddress(evmAddress)
+                : (() => {
+                    throw new Error('EVM address required for quote request');
+                })();
+            const quoteResult = await getQuote({
+                signer: quoteSignerAddress,
+                viewer: viewerPk,
+                outputs,
+            });
+            if (abortController.signal.aborted) {
+                setLoadingAmounts(false);
+                return null;
+            }
+            if (quoteResult) {
+                const depositAmount = BigNumber(usdcAmountOut).shiftedBy(-6).toNumber();
+                setDepositAmountUsdc(depositAmount);
+                // Store usdcAmount in micro units for swap execution
+                const updatedDestinations = await Promise.all(destinations.map(async (dest, idx) => {
+                    const outputValueMicroUsdc = outputs[idx]?.value;
+                    if (!outputValueMicroUsdc)
+                        return dest;
+                    const destAssetInfo = getAssetByCaip19(dest.asset);
+                    if (!destAssetInfo)
+                        return dest;
+                    const usdValue = BigNumber(outputValueMicroUsdc).shiftedBy(-6).toNumber();
+                    const isUsdc = dest.asset.includes(S0X_ADDR_USDC_AVALANCHE);
+                    let amount = '';
+                    if (isUsdc) {
+                        amount = BigNumber(outputValueMicroUsdc)
+                            .shiftedBy(-6)
+                            .toFixed(destAssetInfo.precision ?? 6);
+                    }
+                    else {
+                        try {
+                            const assetPrice = await getPrice(destAssetInfo);
+                            if (assetPrice > 0) {
+                                amount = BigNumber(usdValue / assetPrice).toFixed(destAssetInfo.precision ?? 6);
+                            }
+                            else {
+                                amount = `$${usdValue.toFixed(2)}`;
+                            }
+                        }
+                        catch (error) {
+                            console.error('Failed to get price for destination asset:', {
+                                asset: dest.asset,
+                                error: error instanceof Error ? error.message : String(error),
+                            });
+                            amount = `$${usdValue.toFixed(2)}`;
+                        }
+                    }
+                    return { ...dest, amount };
+                }));
+                setDestinations(updatedDestinations);
+                // Reset loading state only on successful quote
+                setLoadingAmounts(false);
+            }
+            // Return both quote, usdcAmount, and facilitatorGroup (matches Svelte's solve_uusdc_amount return [usdcAmount, provider, allowanceTarget])
+            // The facilitatorGroup is resolved during quote fetching and can be reused in executeSwap
+            return quoteResult
+                ? {
+                    quote: quoteResult,
+                    usdcAmount: usdcAmountOut,
+                    facilitatorGroup: facilitatorGroupForQuote,
+                    bridgeProvider: bridgeProviderResult,
+                    allowanceTarget: allowanceTargetResult,
+                }
+                : null;
+        }
+        catch (error) {
+            if (abortController.signal.aborted) {
+                setLoadingAmounts(false);
+                return null;
+            }
+            console.error('Quote failed:', {
+                sourceAsset: debouncedSourceAsset,
+                sourceAmount: debouncedSourceAmount,
+                destinationsCount: destinations.length,
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            // Always reset loading state on error to prevent UI freezing
+            setLoadingAmounts(false);
+            return null;
+        }
+        finally {
+            // Always ensure loading state is reset (safety net)
+            setLoadingAmounts(false);
+        }
+    }, [wallet, address, evmAddress, getQuote, getPrice, setDestinations, depositorAddress]);
+    return {
+        calculateQuote,
+        loadingAmounts,
+        depositAmountUsdc,
+    };
+}

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

@@ -0,0 +1,18 @@
+import type { SilentSwapClient, QuoteRequest, QuoteResponse } from '@silentswap/sdk';
+/**
+ * Hook for fetching SilentSwap quotes
+ *
+ * This hook provides a simple interface for fetching quotes from the SilentSwap API.
+ * It handles loading states and error management for quote requests.
+ *
+ * @param client - SilentSwap client instance
+ * @param address - User's address (EVM hex address or Solana base58 address)
+ * @param setIsLoading - Callback to set loading state
+ * @param setCurrentStep - Callback to set current step message
+ * @param setError - Callback to set error state
+ * @param onStatus - Optional status update callback
+ * @returns Function to fetch a quote
+ */
+export declare function useQuoteFetching(client: SilentSwapClient, address: `0x${string}` | string | null, setIsLoading: (loading: boolean) => void, setCurrentStep: (step: string) => void, setError: (error: Error | null) => void, onStatus?: (status: string) => void): {
+    getQuote: (request: QuoteRequest) => Promise<QuoteResponse | null>;
+};

package/dist/hooks/silent/useQuoteFetching.js

@@ -0,0 +1,54 @@
+import { useCallback } from 'react';
+/**
+ * Hook for fetching SilentSwap quotes
+ *
+ * This hook provides a simple interface for fetching quotes from the SilentSwap API.
+ * It handles loading states and error management for quote requests.
+ *
+ * @param client - SilentSwap client instance
+ * @param address - User's address (EVM hex address or Solana base58 address)
+ * @param setIsLoading - Callback to set loading state
+ * @param setCurrentStep - Callback to set current step message
+ * @param setError - Callback to set error state
+ * @param onStatus - Optional status update callback
+ * @returns Function to fetch a quote
+ */
+export function useQuoteFetching(client, address, setIsLoading, setCurrentStep, setError, onStatus) {
+    /**
+     * Get a quote for a swap
+     *
+     * Fetches a quote from the SilentSwap API based on the provided request.
+     * The quote includes all necessary information for executing a swap, including
+     * facilitator public keys, authorizations, and transaction details.
+     *
+     * @param request - Quote request with signer, viewer, and outputs
+     * @returns Promise resolving to quote response or null if failed
+     */
+    const getQuote = useCallback(async (request) => {
+        if (!address) {
+            throw new Error('Address required for quote request');
+        }
+        setIsLoading(true);
+        setCurrentStep('Fetching quote');
+        onStatus?.('Fetching quote');
+        setError(null);
+        try {
+            const [error, response] = await client.quote(request);
+            if (error) {
+                throw new Error(`Failed to get quote: ${error.error}`);
+            }
+            const quoteResponse = response;
+            return quoteResponse;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to fetch quote');
+            setError(error);
+            return null;
+        }
+        finally {
+            setIsLoading(false);
+            setCurrentStep('');
+        }
+    }, [client, address, setIsLoading, setCurrentStep, setError, onStatus]);
+    return { getQuote };
+}

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

@@ -0,0 +1,26 @@
+import type { PublicClient, WalletClient, Hex } from 'viem';
+import { type GatewayOrderStatus, type RefundEligibility } from '@silentswap/sdk';
+export interface UseRefundOptions {
+    orderId?: string;
+    publicClient?: PublicClient;
+    walletClient?: WalletClient;
+    s0xGatewayAddress: Hex;
+    onSuccess?: (txHash: Hex) => void;
+    onError?: (error: Error) => void;
+}
+export interface UseRefundReturn {
+    isLoading: boolean;
+    error: Error | null;
+    orderStatus: GatewayOrderStatus | null;
+    refundEligibility: RefundEligibility | null;
+    isRecoveryEligible: boolean;
+    checkOrderStatus: (orderId: string, s0xGatewayAddress: Hex) => Promise<GatewayOrderStatus | null>;
+    checkRefund: (orderId: string, s0xGatewayAddress: Hex) => Promise<RefundEligibility | null>;
+    checkRecovery: (orderId: string, depositTimestamp: number) => Promise<boolean>;
+    refund: (orderId: string, s0xGatewayAddress: Hex) => Promise<Hex | null>;
+    reset: () => void;
+}
+/**
+ * React hook for managing refunds and recovery
+ */
+export declare function useRefund({ orderId, publicClient, walletClient, s0xGatewayAddress, onSuccess, onError }: UseRefundOptions): UseRefundReturn;

package/dist/hooks/silent/useRefund.js

@@ -0,0 +1,134 @@
+import { useCallback, useState, useEffect } from 'react';
+import { queryOrderStatus, checkRefundEligibility, executeRefund, checkRecoveryEligibility, } from '@silentswap/sdk';
+/**
+ * React hook for managing refunds and recovery
+ */
+export function useRefund({ orderId, publicClient, walletClient, s0xGatewayAddress, onSuccess, onError }) {
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [orderStatus, setOrderStatus] = useState(null);
+    const [refundEligibility, setRefundEligibility] = useState(null);
+    const [isRecoveryEligible, setIsRecoveryEligible] = useState(false);
+    // Check order status from gateway contract
+    const checkOrderStatus = useCallback(async (orderId, s0xGatewayAddress) => {
+        if (!publicClient) {
+            setError(new Error('Public client not provided'));
+            return null;
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            const status = await queryOrderStatus(publicClient, orderId, s0xGatewayAddress);
+            setOrderStatus(status);
+            return status;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to check order status');
+            setError(error);
+            onError?.(error);
+            return null;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [publicClient, s0xGatewayAddress, onError]);
+    // Check if refund is available
+    const checkRefund = useCallback(async (orderId) => {
+        if (!publicClient) {
+            setError(new Error('Public client not provided'));
+            return null;
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            const eligibility = await checkRefundEligibility(publicClient, orderId, s0xGatewayAddress);
+            setRefundEligibility(eligibility);
+            return eligibility;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to check refund eligibility');
+            setError(error);
+            onError?.(error);
+            return null;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [publicClient, s0xGatewayAddress, onError]);
+    useEffect(() => {
+        if (!orderId)
+            return;
+        const tId = setInterval(() => {
+            checkRefund(orderId);
+        }, 10000);
+        return () => clearInterval(tId);
+    }, [orderId]);
+    // Check if recovery is available (for completed orders where delivery failed)
+    const checkRecovery = useCallback(async (orderId, depositTimestamp) => {
+        if (!publicClient) {
+            setError(new Error('Public client not provided'));
+            return false;
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            const eligible = await checkRecoveryEligibility(publicClient, orderId, s0xGatewayAddress, depositTimestamp);
+            setIsRecoveryEligible(eligible);
+            return eligible;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to check recovery eligibility');
+            setError(error);
+            onError?.(error);
+            return false;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [publicClient, s0xGatewayAddress, onError]);
+    // Execute refund
+    const refund = useCallback(async (orderId) => {
+        if (!walletClient) {
+            setError(new Error('Wallet client not provided'));
+            return null;
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            const txHash = await executeRefund(walletClient, orderId, s0xGatewayAddress);
+            onSuccess?.(txHash);
+            return txHash;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to execute refund');
+            setError(error);
+            onError?.(error);
+            return null;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [walletClient, s0xGatewayAddress, onSuccess, onError]);
+    // Reset state
+    const reset = useCallback(() => {
+        setIsLoading(false);
+        setError(null);
+        setOrderStatus(null);
+        setRefundEligibility(null);
+        setIsRecoveryEligible(false);
+    }, []);
+    return {
+        // State
+        isLoading,
+        error,
+        orderStatus,
+        refundEligibility,
+        isRecoveryEligible,
+        // Methods
+        checkOrderStatus,
+        checkRefund,
+        checkRecovery,
+        refund,
+        reset,
+    };
+}

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

@@ -0,0 +1,16 @@
+import { type SilentSwapClient, type SilentSwapClientConfig } from '@silentswap/sdk';
+export interface useSilentClientOptions {
+    config?: SilentSwapClientConfig;
+}
+export interface useSilentClientReturn {
+    client: SilentSwapClient;
+}
+/**
+ * React hook for creating and managing a SilentSwap client instance
+ *
+ * If config is not provided, it will use the environment from EnvironmentProvider
+ *
+ * @param options - Configuration options for the client (optional if using EnvironmentProvider)
+ * @returns Object containing the SilentSwap client instance
+ */
+export declare function useSilentClient({ config }?: useSilentClientOptions): useSilentClientReturn;

package/dist/hooks/silent/useSilentClient.js

@@ -0,0 +1,32 @@
+import { useMemo } from 'react';
+import { createSilentSwapClient } from '@silentswap/sdk';
+import { useSilentSwap } from '../../contexts/SilentSwapContext.js';
+/**
+ * React hook for creating and managing a SilentSwap client instance
+ *
+ * If config is not provided, it will use the environment from EnvironmentProvider
+ *
+ * @param options - Configuration options for the client (optional if using EnvironmentProvider)
+ * @returns Object containing the SilentSwap client instance
+ */
+export function useSilentClient({ config } = {}) {
+    // Try to get environment from context, but don't require it (for backward compatibility)
+    let environmentConfig;
+    try {
+        const { config: envConfig } = useSilentSwap();
+        environmentConfig = config || envConfig;
+    }
+    catch {
+        // Not in SilentSwapProvider - use provided config or throw
+        if (!config) {
+            throw new Error('useSilentClient requires either a config parameter or to be used within SilentSwapProvider');
+        }
+        environmentConfig = config;
+    }
+    const client = useMemo(() => {
+        return createSilentSwapClient(environmentConfig);
+    }, [environmentConfig]);
+    return {
+        client,
+    };
+}