@silentswap/react 0.0.41

package/dist/hooks/useQuote.js

@@ -0,0 +1,507 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import BigNumber from 'bignumber.js';
+import { NI_CHAIN_ID_AVALANCHE, S0X_ADDR_USDC_AVALANCHE, S_CAIP19_USDC_AVALANCHE, X_MAX_IMPACT_PERCENT, getBridgeQuote as sdkGetBridgeQuote, interpolateSamples as sdkInterpolateSamples, fetchRelayQuote, fetchDebridgeOrder, normalizeAddress, getAssetByCaip19, N_DEBRIDGE_CHAIN_ID_SOLANA, N_RELAY_CHAIN_ID_SOLANA, SB58_ADDR_SOL_PROGRAM_SYSTEM, S0X_ADDR_EVM_RELAY_LINK_DEAD, SB58_ADDR_SOL_RELAY_LINK_RECIPIENT, isSolanaAsset, } from '@silentswap/sdk';
+// Constants for estimateLive
+const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+const EVM_PHONY_ADDRESS_FALLBACK = '0x1111111111111111111111111111111111111111';
+/**
+ * Hook for getting optimized bridge quotes with retention rate tracking
+ * Implements the same functionality as estimate.ts from the original app
+ */
+export function useQuote({ address, maxImpactPercent = X_MAX_IMPACT_PERCENT } = {}) {
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    // Estimates cache (replaces H_ESTIMATES_INGRESS and H_ESTIMATES_EGRESS from original)
+    const ingressEstimatesRef = useRef({});
+    const egressEstimatesRef = useRef({});
+    // Normalize address - handle both EVM (hex) and Solana (base58) addresses
+    const normalizedAddress = address ? normalizeAddress(address) : null;
+    // Abort controller for cancelling requests
+    const abortControllerRef = useRef(null);
+    // Cleanup on unmount
+    useEffect(() => {
+        return () => {
+            // Cancel any pending requests when component unmounts
+            if (abortControllerRef.current) {
+                abortControllerRef.current.abort();
+                abortControllerRef.current = null;
+            }
+        };
+    }, []);
+    /**
+     * Cancel any ongoing requests and create a new abort controller
+     */
+    const createNewAbortController = useCallback(() => {
+        // Cancel previous request if any
+        if (abortControllerRef.current) {
+            abortControllerRef.current.abort();
+        }
+        // Create new abort controller
+        const controller = new AbortController();
+        abortControllerRef.current = controller;
+        return controller;
+    }, []);
+    /**
+     * Get quote for cross-chain swap
+     */
+    const getQuote = useCallback(async (srcChainId, srcToken, srcAmount, dstChainId, dstToken, recipientAddress, sourceAddress) => {
+        console.log('[Quote] Step 1: Starting getQuote', {
+            srcChainId,
+            srcToken,
+            srcAmount,
+            dstChainId,
+            dstToken,
+            hasRecipientAddress: !!recipientAddress,
+            hasSourceAddress: !!sourceAddress,
+        });
+        if (!normalizedAddress) {
+            throw new Error('Address required for bridge quote operations');
+        }
+        setIsLoading(true);
+        setError(null);
+        // Create abort controller for this request
+        const controller = createNewAbortController();
+        const signal = controller.signal;
+        try {
+            // Normalize addresses
+            console.log('[Quote] Step 2: Normalizing token addresses');
+            const srcTokenNorm = srcToken === '0x0' || srcToken === '0x0000000000000000000000000000000000000000' ? ZERO_ADDRESS : srcToken;
+            const dstTokenNorm = dstToken === '0x0' || dstToken === '0x0000000000000000000000000000000000000000' ? ZERO_ADDRESS : dstToken;
+            // Use shared quote fetching function
+            // normalizedAddress can be EVM (0x...) or Solana (base58) address
+            // sourceAddress is the address format for the source chain (for relay.link)
+            console.log('[Quote] Step 3: Calling sdkGetBridgeQuote');
+            const result = await sdkGetBridgeQuote(srcChainId, srcTokenNorm, srcAmount, dstChainId, dstTokenNorm, normalizedAddress, signal, recipientAddress, // Pass recipient address for Solana destinations
+            sourceAddress);
+            console.log('[Quote] Step 4: getQuote completed successfully', {
+                provider: result.provider,
+            });
+            return result;
+        }
+        catch (err) {
+            // Re-throw if it's an abort error
+            if (err instanceof Error && err.name === 'AbortError') {
+                console.log('[Quote] getQuote aborted');
+                throw err;
+            }
+            const error = err instanceof Error ? err : new Error('Failed to get quote');
+            console.error('[Quote] Error: Failed to get quote', error);
+            setError(error);
+            throw error;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [normalizedAddress, createNewAbortController]);
+    /**
+     * Get live estimate for a given asset and direction
+     */
+    const estimateLive = useCallback(async (direction, assetCaip19, chainId, tokenAddress, amount, usdPrice, externalSignal, recipientAddress, // Optional recipient address (required for Solana destinations in egress)
+    isReverseCalculation, // For reverse calculation (output-to-input)
+    targetAmount) => {
+        console.log('[Quote] Step 1: Starting estimateLive', {
+            direction,
+            assetCaip19,
+            chainId,
+            tokenAddress,
+            amount,
+            usdPrice,
+            isReverseCalculation,
+            targetAmount,
+        });
+        // Determine if this is a Solana chain by checking the asset CAIP-19
+        // This is more reliable than checking chainId format
+        const isSolanaChain = isSolanaAsset(assetCaip19);
+        console.log('[Quote] Step 2: Chain type determined', { isSolanaChain, chainId });
+        let numericChainId;
+        if (isSolanaChain) {
+            // For Solana, we'll use different chain IDs for different providers
+            // This will be set per-provider below
+            numericChainId = 0; // Placeholder, will be set per provider
+        }
+        else {
+            // For EVM chains, convert chainId to number if needed
+            if (typeof chainId === 'string') {
+                const parsed = parseInt(chainId, 10);
+                if (isNaN(parsed)) {
+                    throw new Error(`Invalid chain ID: ${chainId}`);
+                }
+                numericChainId = parsed;
+            }
+            else {
+                numericChainId = chainId;
+            }
+        }
+        if (!normalizedAddress) {
+            throw new Error('Address required');
+        }
+        // Use external signal if provided, otherwise create new abort controller
+        let signal;
+        if (externalSignal) {
+            // Use external signal (from estimateOrder)
+            signal = externalSignal;
+        }
+        else {
+            // Create new abort controller and cancel any pending requests
+            const controller = createNewAbortController();
+            signal = controller.signal;
+        }
+        try {
+            // Special case for USDC on Avalanche
+            // Check numericChainId (or converted chainId for non-Solana chains)
+            const checkChainId = isSolanaChain ? 0 : numericChainId; // Solana will never match Avalanche
+            if (checkChainId === NI_CHAIN_ID_AVALANCHE &&
+                tokenAddress.toLowerCase() === S0X_ADDR_USDC_AVALANCHE.toLowerCase()) {
+                console.log('[Quote] Step 3: Special case - USDC on Avalanche, returning identity estimate');
+                const estimate = {
+                    gasFee: 0,
+                    samples: [
+                        {
+                            baseline: Infinity,
+                            retention: 1,
+                            source: 'none',
+                        },
+                    ],
+                };
+                if (direction === 'ingress') {
+                    ingressEstimatesRef.current[assetCaip19] = estimate;
+                }
+                else {
+                    egressEstimatesRef.current[assetCaip19] = estimate;
+                }
+                return {
+                    estimate,
+                    gasAmount: BigInt(BigNumber(300_000).times(2).shiftedBy(9).toFixed(0)),
+                    response: {},
+                    provider: 'relay',
+                };
+            }
+            console.log('[Quote] Step 3: Getting asset info and preparing quote request');
+            // Get asset info to determine correct decimals
+            const assetInfo = getAssetByCaip19(assetCaip19);
+            if (!assetInfo) {
+                throw new Error(`Asset not found: ${assetCaip19}`);
+            }
+            // Calculate amount in token units
+            // For ingress: amount is in source asset human-readable format, convert using source asset decimals
+            // For egress: 
+            //   - Normal: amount is in USDC human-readable format (USD value when price = 1), convert using USDC decimals (6)
+            //   - Reverse: amount is in destination token human-readable format, convert using destination asset decimals
+            const decimalsToUse = (direction === 'egress' && !isReverseCalculation)
+                ? 6 // USDC has 6 decimals (for normal egress)
+                : assetInfo.decimals; // Use asset decimals (for ingress or reverse egress)
+            const tokenAmount = BigNumber(amount).shiftedBy(decimalsToUse).toFixed(0);
+            // Get quotes from both providers using SDK functions
+            // Determine user address based on direction and chain
+            // This matches the Svelte app behavior in estimate.ts
+            console.log('[Quote] Step 4: Determining user address and chain IDs');
+            let userAddress;
+            if (direction === 'ingress') {
+                // For ingress, user address should match the source chain
+                if (isSolanaChain) {
+                    // For Solana ingress, use Solana address (or phony if not available)
+                    userAddress = normalizedAddress && normalizedAddress.startsWith('0x') === false
+                        ? normalizedAddress
+                        : SB58_ADDR_SOL_PROGRAM_SYSTEM;
+                }
+                else {
+                    // For EVM ingress, use EVM address (or phony if not available)
+                    userAddress = normalizedAddress && normalizedAddress.startsWith('0x')
+                        ? normalizedAddress
+                        : EVM_PHONY_ADDRESS_FALLBACK;
+                }
+            }
+            else {
+                // For egress, origin is always Avalanche (EVM), so user must be EVM address
+                userAddress = normalizedAddress && normalizedAddress.startsWith('0x')
+                    ? normalizedAddress
+                    : EVM_PHONY_ADDRESS_FALLBACK;
+            }
+            // For Solana, use different chain IDs for different providers
+            const relayChainId = isSolanaChain ? N_RELAY_CHAIN_ID_SOLANA : numericChainId;
+            const debridgeChainId = isSolanaChain ? N_DEBRIDGE_CHAIN_ID_SOLANA : numericChainId;
+            console.log('[Quote] Step 4: Address and chain IDs determined', {
+                userAddress,
+                relayChainId,
+                debridgeChainId,
+                tradeType: isReverseCalculation ? 'EXACT_OUTPUT' : 'EXACT_INPUT',
+            });
+            console.log('[Quote] Step 5: Fetching quotes from Relay and DeBridge providers');
+            const [relayResult, debridgeResult] = await Promise.allSettled([
+                (async () => {
+                    try {
+                        // Determine trade type: EXACT_OUTPUT for reverse calculation, EXACT_INPUT for normal
+                        const tradeType = isReverseCalculation ? 'EXACT_OUTPUT' : 'EXACT_INPUT';
+                        // For reverse calculation ingress: use targetDepositUsd as destination amount
+                        // For reverse calculation egress: use targetOutputAmount as destination amount
+                        let quoteAmount = tokenAmount;
+                        if (isReverseCalculation && direction === 'ingress' && targetAmount) {
+                            // For ingress reverse: we want a specific deposit USD, calculate required input
+                            // Convert targetDepositUsd (USD) to USDC micro units
+                            const usdcAsset = getAssetByCaip19(S_CAIP19_USDC_AVALANCHE);
+                            if (usdcAsset) {
+                                quoteAmount = BigNumber(targetAmount).shiftedBy(usdcAsset.decimals).toFixed(0);
+                            }
+                            else {
+                                throw new Error('USDC asset not found');
+                            }
+                        }
+                        else if (isReverseCalculation && direction === 'egress' && targetAmount) {
+                            // For egress reverse: we want a specific output amount, calculate required USDC
+                            // targetAmount is the output amount in destination token units (human-readable)
+                            // For EXACT_OUTPUT, we need to pass the destination token amount in micro units
+                            // The quote will calculate how much USDC is needed to get this output
+                            quoteAmount = tokenAmount; // tokenAmount is already in micro units (calculated from targetAmount)
+                        }
+                        const quote = await fetchRelayQuote({
+                            user: userAddress,
+                            referrer: 'silentswap',
+                            tradeType,
+                            ...(direction === 'ingress'
+                                ? {
+                                    originChainId: relayChainId,
+                                    destinationChainId: NI_CHAIN_ID_AVALANCHE,
+                                    originCurrency: tokenAddress === ZERO_ADDRESS ? ZERO_ADDRESS : tokenAddress,
+                                    destinationCurrency: S0X_ADDR_USDC_AVALANCHE,
+                                    ...(isReverseCalculation && tradeType === 'EXACT_OUTPUT'
+                                        ? {
+                                            // For reverse ingress: we specify the destination (deposit) amount
+                                            amount: quoteAmount, // USDC micro units we want to receive
+                                        }
+                                        : {
+                                            // Normal ingress: we specify the source amount
+                                            amount: tokenAmount,
+                                        }),
+                                    // For Solana ingress, set recipient to EVM phony address (for Avalanche destination)
+                                    ...(isSolanaChain
+                                        ? { recipient: EVM_PHONY_ADDRESS_FALLBACK }
+                                        : {}),
+                                }
+                                : {
+                                    originChainId: NI_CHAIN_ID_AVALANCHE,
+                                    originCurrency: S0X_ADDR_USDC_AVALANCHE,
+                                    destinationChainId: relayChainId,
+                                    destinationCurrency: tokenAddress === ZERO_ADDRESS ? ZERO_ADDRESS : tokenAddress,
+                                    ...(isReverseCalculation && tradeType === 'EXACT_OUTPUT'
+                                        ? {
+                                            // For reverse egress: we specify the destination (output) amount
+                                            amount: quoteAmount, // Destination token amount we want to receive (in micro units)
+                                        }
+                                        : {
+                                            // Normal egress: we specify the source (USDC) amount
+                                            amount: tokenAmount,
+                                        }),
+                                    // For egress to Solana, use EVM dead address for user and Solana recipient
+                                    ...(isSolanaChain
+                                        ? {
+                                            user: S0X_ADDR_EVM_RELAY_LINK_DEAD,
+                                            recipient: recipientAddress || SB58_ADDR_SOL_RELAY_LINK_RECIPIENT,
+                                        }
+                                        : {}),
+                                }),
+                        }, signal);
+                        return quote;
+                    }
+                    catch (err) {
+                        // Don't log abort errors
+                        if (err instanceof Error && err.name !== 'AbortError') {
+                            console.warn('Relay quote failed:', err);
+                        }
+                        return null;
+                    }
+                })(),
+                (async () => {
+                    try {
+                        // DeBridge egress is not supported (matches Svelte app behavior)
+                        // Only Relay.link is used for egress quotes
+                        if (direction === 'egress') {
+                            return null; // Skip DeBridge for egress, will use Relay.link only
+                        }
+                        // For reverse calculation ingress: use srcChainTokenInAmount: 'auto' and specify dstChainTokenOutAmount
+                        const debridgeParams = {
+                            srcChainId: debridgeChainId,
+                            srcChainTokenIn: tokenAddress === ZERO_ADDRESS ? ZERO_ADDRESS : tokenAddress,
+                            dstChainId: NI_CHAIN_ID_AVALANCHE,
+                            dstChainTokenOut: S0X_ADDR_USDC_AVALANCHE,
+                        };
+                        if (isReverseCalculation && direction === 'ingress' && targetAmount) {
+                            // For reverse ingress: specify destination amount, let DeBridge calculate source
+                            const usdcAsset = getAssetByCaip19(S_CAIP19_USDC_AVALANCHE);
+                            if (usdcAsset) {
+                                debridgeParams.srcChainTokenInAmount = 'auto';
+                                debridgeParams.dstChainTokenOutAmount = BigNumber(targetAmount)
+                                    .shiftedBy(usdcAsset.decimals)
+                                    .toFixed(0);
+                            }
+                            else {
+                                throw new Error('USDC asset not found');
+                            }
+                        }
+                        else {
+                            // Normal calculation: specify source amount
+                            debridgeParams.srcChainTokenInAmount = tokenAmount;
+                            debridgeParams.dstChainTokenOutAmount = 'auto';
+                        }
+                        const quote = await fetchDebridgeOrder(debridgeParams, signal);
+                        return quote;
+                    }
+                    catch (err) {
+                        // Don't log abort errors
+                        if (err instanceof Error && err.name !== 'AbortError') {
+                            console.warn('DeBridge quote failed:', err);
+                        }
+                        return null;
+                    }
+                })(),
+            ]);
+            const relayQuote = relayResult.status === 'fulfilled' ? relayResult.value : null;
+            const debridgeQuote = debridgeResult.status === 'fulfilled' ? debridgeResult.value : null;
+            console.log('[Quote] Step 6: Quote results received', {
+                hasRelayQuote: !!relayQuote,
+                hasDebridgeQuote: !!debridgeQuote,
+                relayStatus: relayResult.status,
+                debridgeStatus: debridgeResult.status,
+            });
+            // Both failed
+            if (!relayQuote && !debridgeQuote) {
+                console.error('[Quote] Error: All quote providers failed');
+                throw new AggregateError([
+                    relayResult.status === 'rejected' ? relayResult.reason : null,
+                    debridgeResult.status === 'rejected' ? debridgeResult.reason : null,
+                ].filter(Boolean), 'All quote providers failed 2');
+            }
+            // Calculate retention rates
+            console.log('[Quote] Step 7: Calculating retention rates and gas amounts');
+            let retentionRelay = 0;
+            let retentionDebridge = 0;
+            let gasAmountRelay = 0n;
+            let gasAmountDebridge = 0n;
+            let gasFeeUsd = 0;
+            let calculatedInputAmount = undefined;
+            if (relayQuote) {
+                if (isReverseCalculation && direction === 'ingress') {
+                    console.log('[Quote] Step 7: Processing Relay quote (reverse calculation ingress)');
+                    // For reverse calculation, extract the calculated input amount from the quote
+                    // currencyIn is the source token amount we need to send
+                    calculatedInputAmount = Number(relayQuote.details.currencyIn.amount);
+                    if (!calculatedInputAmount) {
+                        const calculatedInputAmountUsd = Number(relayQuote.details.currencyIn.amountUsd || 0);
+                        if (calculatedInputAmountUsd > 0 && usdPrice > 0) {
+                            calculatedInputAmount = calculatedInputAmountUsd / usdPrice;
+                        }
+                    }
+                    // Retention is still output/input, but now input is calculated
+                    retentionRelay = BigNumber(relayQuote.details.currencyOut.amountUsd)
+                        .div(relayQuote.details.currencyIn.amountUsd)
+                        .toNumber();
+                    console.log('[Quote] Step 7: Relay quote processed (reverse)', { calculatedInputAmount, retentionRelay });
+                }
+                else {
+                    retentionRelay = BigNumber(relayQuote.details.currencyOut.amountUsd)
+                        .div(relayQuote.details.currencyIn.amountUsd)
+                        .toNumber();
+                    console.log('[Quote] Step 7: Relay quote processed (normal)', { retentionRelay });
+                }
+                gasFeeUsd = Number(relayQuote.fees.relayerGas.amountUsd || '0');
+                gasAmountRelay = BigInt((BigInt(relayQuote.fees.gas.amount || 0) * 15n) / 10n);
+            }
+            if (debridgeQuote) {
+                if (isReverseCalculation && direction === 'ingress') {
+                    console.log('[Quote] Step 7: Processing DeBridge quote (reverse calculation ingress)');
+                    // For reverse calculation, extract the calculated input amount from DeBridge quote
+                    calculatedInputAmount = Number(debridgeQuote.estimation.srcChainTokenIn.amount);
+                    if (!calculatedInputAmount) {
+                        const calculatedInputAmountUsd = Number(debridgeQuote.estimation.srcChainTokenIn.approximateUsdValue || 0);
+                        if (calculatedInputAmountUsd > 0 && usdPrice > 0) {
+                            calculatedInputAmount = calculatedInputAmountUsd / usdPrice;
+                        }
+                    }
+                    // Retention is still output/input, but now input is calculated
+                    retentionDebridge = BigNumber(debridgeQuote.estimation.dstChainTokenOut.approximateUsdValue)
+                        .div(debridgeQuote.estimation.srcChainTokenIn.approximateUsdValue)
+                        .toNumber();
+                    console.log('[Quote] Step 7: DeBridge quote processed (reverse)', { calculatedInputAmount, retentionDebridge });
+                }
+                else {
+                    retentionDebridge = BigNumber(debridgeQuote.estimation.dstChainTokenOut.approximateUsdValue)
+                        .div(debridgeQuote.estimation.srcChainTokenIn.approximateUsdValue)
+                        .toNumber();
+                    console.log('[Quote] Step 7: DeBridge quote processed (normal)', { retentionDebridge });
+                }
+                gasFeeUsd =
+                    debridgeQuote.estimation.costDetails?.reduce((sum, detail) => sum + Number(detail.payload?.feeApproximateUsdValue || 0), 0) || 0;
+                gasAmountDebridge = BigInt((BigInt(debridgeQuote.estimatedTransactionFee?.total || 0) * 15n) / 10n);
+            }
+            // Determine best source
+            console.log('[Quote] Step 8: Determining best provider', { retentionRelay, retentionDebridge });
+            const retention = Math.max(retentionRelay, retentionDebridge);
+            const source = retentionRelay >= retentionDebridge ? 'relay' : 'debridge';
+            const usdValue = BigNumber(usdPrice).times(amount).toNumber();
+            console.log('[Quote] Step 8: Best provider determined', { source, retention, usdValue });
+            // Create sample
+            const sample = {
+                baseline: usdValue,
+                retention,
+                source,
+            };
+            // Update estimates cache
+            console.log('[Quote] Step 9: Updating estimates cache', { direction, assetCaip19 });
+            const estimatesCache = direction === 'ingress' ? ingressEstimatesRef.current : egressEstimatesRef.current;
+            const existingEstimate = estimatesCache[assetCaip19];
+            // Filter out samples within $5 of this price
+            const filteredSamples = (existingEstimate?.samples || []).filter((s) => !(s.baseline >= sample.baseline - 5 && s.baseline <= sample.baseline + 5));
+            // Add new sample and sort
+            const samples = [...filteredSamples, sample].sort((a, b) => a.baseline - b.baseline);
+            const estimate = {
+                gasFee: direction === 'ingress' ? 0 : gasFeeUsd,
+                samples,
+            };
+            estimatesCache[assetCaip19] = estimate;
+            console.log('[Quote] Step 9: Estimates cache updated', {
+                samplesCount: samples.length,
+                gasFee: estimate.gasFee,
+            });
+            const result = {
+                estimate,
+                gasAmount: source === 'relay' ? gasAmountRelay : gasAmountDebridge,
+                response: (source === 'relay' ? relayQuote : debridgeQuote),
+                provider: source,
+                calculatedInputAmount, // Include calculated input amount for reverse calculation
+            };
+            console.log('[Quote] Step 10: estimateLive completed successfully', {
+                provider: source,
+                retention,
+                calculatedInputAmount,
+            });
+            return result;
+        }
+        catch (err) {
+            // Re-throw if it's an abort error
+            if (err instanceof Error && err.name === 'AbortError') {
+                console.log('[Quote] estimateLive aborted');
+                throw err;
+            }
+            // Wrap and re-throw other errors
+            const error = err instanceof Error ? err : new Error('Failed to get live estimate');
+            console.error('[Quote] Error: Failed to get live estimate', error);
+            throw error;
+        }
+    }, [normalizedAddress, createNewAbortController]);
+    /**
+     * Interpolate retention rate from samples
+     */
+    const interpolateSamples = useCallback((samples, usdValue, marginHi = Infinity) => {
+        return sdkInterpolateSamples(samples, usdValue, marginHi);
+    }, []);
+    return {
+        // State
+        isLoading,
+        error,
+        ingressEstimates: ingressEstimatesRef.current,
+        egressEstimates: egressEstimatesRef.current,
+        // Methods
+        getQuote,
+        estimateLive,
+        interpolateSamples,
+    };
+}

package/dist/hooks/useResetSwapForm.d.ts

@@ -0,0 +1,16 @@
+import type { SilentSwapWallet } from './silent/useWallet.js';
+import type { FacilitatorGroup } from '../contexts/OrdersContext.js';
+export interface UseResetSwapFormOptions {
+    clearQuote: () => void;
+    isConnected: boolean;
+    wallet: SilentSwapWallet | null;
+    setFacilitatorGroups: (groups: FacilitatorGroup[]) => void;
+    refreshWallet?: () => Promise<void>;
+}
+/**
+ * Hook to handle resetting the swap form after completion
+ * Matches Svelte Form.svelte "New swap" button behavior
+ */
+export declare function useResetSwapForm({ clearQuote, isConnected, wallet, setFacilitatorGroups, refreshWallet, }: UseResetSwapFormOptions): {
+    handleNewSwap: () => void;
+};

package/dist/hooks/useResetSwapForm.js

@@ -0,0 +1,68 @@
+import { useCallback } from 'react';
+import { useSwap } from './useSwap.js';
+/**
+ * Hook to handle resetting the swap form after completion
+ * Matches Svelte Form.svelte "New swap" button behavior
+ */
+export function useResetSwapForm({ clearQuote, isConnected, wallet, setFacilitatorGroups, refreshWallet, }) {
+    const setSplits = useSwap((state) => state.setSplits);
+    const setInputAmount = useSwap((state) => state.setInputAmount);
+    const setDestinations = useSwap((state) => state.setDestinations);
+    const handleNewSwap = useCallback(() => {
+        // Clear order tracking state (clears orderId and viewingAuth)
+        clearQuote();
+        // Reset splits to single output
+        setSplits([1]);
+        // Clear input amount
+        setInputAmount('');
+        // Clear destinations - keep first, remove others (matches Svelte: AppState.destinations.splice(1, ...))
+        setDestinations((prev) => {
+            if (prev.length > 0) {
+                // Keep first destination but reset amount and price
+                return [
+                    {
+                        asset: prev[0].asset,
+                        contact: prev[0].contact,
+                        amount: '',
+                    },
+                ];
+            }
+            return prev;
+        });
+        // Reset URL params (matches Svelte Form.svelte line 2740-2742)
+        // Preserve only src and dst params (if they exist), remove all others including order and auth
+        if (typeof window !== 'undefined') {
+            const currentParams = new URLSearchParams(window.location.search);
+            const params = new URLSearchParams();
+            // Preserve src and dst if they exist (matching Svelte behavior of preserving initial params)
+            const src = currentParams.get('src');
+            const dst = currentParams.get('dst');
+            if (src)
+                params.set('src', src);
+            if (dst)
+                params.set('dst', dst);
+            // Clear all other params (order, auth, etc.)
+            window.history.pushState({}, '', params.toString() ? `?${params.toString()}` : window.location.pathname);
+        }
+        // If connected, force regenerate all facilitator groups (matches Svelte: sender_resolve_group(-1, true))
+        if (isConnected && refreshWallet) {
+            // Regenerate wallet with all deposits to get fresh groups
+            void refreshWallet();
+        }
+        else if (isConnected && wallet?.accounts) {
+            // Fallback: if wallet is already loaded but refreshWallet not available,
+            // ensure all groups are set (matches Svelte behavior)
+            setFacilitatorGroups(wallet.accounts.map((account) => account.group));
+        }
+    }, [
+        clearQuote,
+        setSplits,
+        setInputAmount,
+        setDestinations,
+        isConnected,
+        wallet,
+        setFacilitatorGroups,
+        refreshWallet,
+    ]);
+    return { handleNewSwap };
+}

package/dist/hooks/useSlippageUsd.d.ts

@@ -0,0 +1,11 @@
+import type { AssetInfo } from '@silentswap/sdk';
+export interface UseSlippageUsdOptions {
+    inputUsdValue: number;
+    slippage: number;
+    inputAmount?: string;
+    token?: AssetInfo | null;
+}
+/**
+ * Hook to calculate slippage impact in USD
+ */
+export declare function useSlippageUsd({ inputUsdValue, slippage, inputAmount, token }: UseSlippageUsdOptions): number;

package/dist/hooks/useSlippageUsd.js

@@ -0,0 +1,19 @@
+import { useMemo } from 'react';
+/**
+ * Hook to calculate slippage impact in USD
+ */
+export function useSlippageUsd({ inputUsdValue, slippage, inputAmount, token }) {
+    return useMemo(() => {
+        if (inputAmount !== undefined && (!inputAmount || parseFloat(inputAmount) <= 0)) {
+            return 0;
+        }
+        if (token !== undefined && !token) {
+            return 0;
+        }
+        if (inputUsdValue <= 0) {
+            return 0;
+        }
+        const slippagePercent = slippage / 100;
+        return Math.abs(inputUsdValue * slippagePercent);
+    }, [inputUsdValue, slippage, inputAmount, token]);
+}

package/dist/hooks/useSolanaAdapter.d.ts

@@ -0,0 +1,15 @@
+import type { SolanaConnection } from './silent/solana-transaction.js';
+/**
+ * Reusable hook for Solana wallet adapter setup
+ * Returns the Solana connector and connection adapter for use with SilentSwap hooks
+ */
+export declare function useSolanaAdapter(): {
+    solanaConnector: {
+        signTransaction: (transaction: any) => Promise<any>;
+        sendTransaction: (transaction: any, connection: any) => Promise<string>;
+        publicKey: {
+            toString: () => string;
+        };
+    } | undefined;
+    solanaConnectionAdapter: SolanaConnection | undefined;
+};