@silentswap/react 0.0.41

package/dist/hooks/useHiddenSwapFees.js

@@ -0,0 +1,81 @@
+import { useMemo } from 'react';
+import { BigNumber } from 'bignumber.js';
+/**
+ * Hook to calculate fees for hidden swap
+ * Extracts actual fees from bridge quotes when available, otherwise uses estimated rates
+ */
+export function useHiddenSwapFees({ depositAmountUsdc, bridgeProvider, serviceFeeRate = 0.01, overheadUsd = 0, usdcPrice = 1, bridgeFeeRate = 0.001, ingressQuote, egressQuotes, }) {
+    const fees = useMemo(() => {
+        if (depositAmountUsdc <= 0) {
+            return {
+                serviceFeeUsd: 0,
+                bridgeFeeIngressUsd: 0,
+                bridgeFeeEgressUsd: 0,
+                totalFeesUsd: 0,
+            };
+        }
+        // Extract ingress bridge fee from quote
+        let bridgeFeeIngress = 0;
+        if (ingressQuote) {
+            if ('fees' in ingressQuote) {
+                // Relay.link quote
+                bridgeFeeIngress = BigNumber(ingressQuote.fees?.relayer?.amountUsd || 0).toNumber();
+            }
+            else if ('estimation' in ingressQuote) {
+                // DeBridge quote
+                const debridgeQuote = ingressQuote;
+                bridgeFeeIngress = BigNumber(debridgeQuote.estimation.costDetails
+                    ?.map((detail) => Number(detail.payload?.feeApproximateUsdValue || 0))
+                    ?.reduce((sum, fee) => sum + fee, 0) || 0).toNumber();
+            }
+        }
+        else if (bridgeProvider && bridgeProvider !== 'none') {
+            bridgeFeeIngress = depositAmountUsdc * bridgeFeeRate;
+        }
+        // Extract egress bridge fees from quotes
+        let bridgeFeeEgress = 0;
+        if (egressQuotes && egressQuotes.length > 0) {
+            const egressFees = egressQuotes.map((quote) => {
+                if (!quote)
+                    return BigNumber(0);
+                if ('fees' in quote) {
+                    const relayerFee = BigNumber(quote.fees?.relayer?.amountUsd || 0);
+                    const gasFee = BigNumber(quote.fees?.gas?.amountUsd || 0);
+                    return relayerFee.plus(gasFee);
+                }
+                else if ('estimation' in quote) {
+                    const debridgeQuote = quote;
+                    const feeFromCostDetails = BigNumber(debridgeQuote.estimation.costDetails
+                        ?.map((detail) => Number(detail.payload?.feeApproximateUsdValue || 0))
+                        ?.reduce((sum, fee) => sum + fee, 0) || 0);
+                    // Match Svelte behavior: add the same value twice
+                    return feeFromCostDetails.plus(feeFromCostDetails);
+                }
+                return BigNumber(0);
+            });
+            bridgeFeeEgress = egressFees.reduce((sum, fee) => sum.plus(fee), BigNumber(0)).toNumber();
+        }
+        else if (bridgeProvider && bridgeProvider !== 'none') {
+            bridgeFeeEgress = depositAmountUsdc * bridgeFeeRate;
+        }
+        // Calculate service fees
+        const serviceFee = BigNumber(depositAmountUsdc).times(serviceFeeRate).plus(overheadUsd).times(usdcPrice).toNumber();
+        const totalFees = serviceFee + bridgeFeeIngress + bridgeFeeEgress;
+        return {
+            serviceFeeUsd: serviceFee,
+            bridgeFeeIngressUsd: bridgeFeeIngress,
+            bridgeFeeEgressUsd: bridgeFeeEgress,
+            totalFeesUsd: totalFees,
+        };
+    }, [
+        depositAmountUsdc,
+        bridgeProvider,
+        serviceFeeRate,
+        overheadUsd,
+        usdcPrice,
+        bridgeFeeRate,
+        ingressQuote,
+        egressQuotes,
+    ]);
+    return fees;
+}

package/dist/hooks/useOrderEstimates.d.ts

@@ -0,0 +1,37 @@
+import type { Estimate, RelayQuoteResponse, DeBridgeOrderResponse } from '@silentswap/sdk';
+import { type AssetInfo } from '@silentswap/sdk';
+export interface OrderEstimateResult {
+    ingressGasAmount: bigint;
+    ingressRate: number;
+    egressRates: number[];
+    ingressEstimate: Estimate;
+    egressEstimates: Estimate[];
+    ingressQuote?: RelayQuoteResponse | DeBridgeOrderResponse;
+    egressQuotes?: (RelayQuoteResponse | DeBridgeOrderResponse)[];
+    calculatedInputAmount?: number;
+}
+export interface UseOrderEstimatesOptions {
+    /** User's EVM address (hex address starting with 0x) */
+    evmAddress?: `0x${string}`;
+    /** User's Solana address (base58 address) */
+    solAddress?: string;
+    /** Source asset for determining which address to use (if Solana, use solAddress; if EVM, use evmAddress) */
+    sourceAsset?: AssetInfo | null;
+    /** Maximum price impact percentage allowed */
+    maxImpactPercent?: number;
+}
+/**
+ * Hook for fetching both ingress and egress estimates in parallel
+ * Matches the behavior of estimate_order() from silentswap-v2-ui/src/web3/estimate.ts
+ *
+ * This hook fetches:
+ * - Ingress quote: from source chain to Avalanche (as USDC)
+ * - Egress quotes: from Avalanche (USDC) to each destination chain
+ *
+ * Returns retention rates that account for bridge fees and slippage
+ */
+export declare function useOrderEstimates({ evmAddress, solAddress, sourceAsset, maxImpactPercent, }?: UseOrderEstimatesOptions): {
+    estimateOrder: (usdcPrice: number, sourceAsset: AssetInfo, sourcePrice: number, sourceAmount: number | string, destinationAssets: AssetInfo[], destinationPrices: number[], splits: number[], calculationDirection?: "input-to-output" | "output-to-input", outputAmounts?: string[]) => Promise<OrderEstimateResult>;
+    isLoading: boolean;
+    error: Error | null;
+};

package/dist/hooks/useOrderEstimates.js

@@ -0,0 +1,393 @@
+import { useCallback, useRef, useState, useMemo } from 'react';
+import BigNumber from 'bignumber.js';
+import { parseEvmCaip19, parseSolanaCaip19, isEvmNativeToken, isSolanaNativeToken, isSolanaAsset, } from '@silentswap/sdk';
+import { useQuote } from './useQuote.js';
+// Fallback EVM address for egress quotes when evmAddress is not available
+// Egress quotes always start from Avalanche (EVM), so they require an EVM address
+const EVM_PHONY_ADDRESS_FALLBACK = '0x1111111111111111111111111111111111111111';
+/**
+ * Hook for fetching both ingress and egress estimates in parallel
+ * Matches the behavior of estimate_order() from silentswap-v2-ui/src/web3/estimate.ts
+ *
+ * This hook fetches:
+ * - Ingress quote: from source chain to Avalanche (as USDC)
+ * - Egress quotes: from Avalanche (USDC) to each destination chain
+ *
+ * Returns retention rates that account for bridge fees and slippage
+ */
+export function useOrderEstimates({ evmAddress, solAddress, sourceAsset, maxImpactPercent, } = {}) {
+    const [error, setError] = useState(null);
+    // Determine address for ingress quotes based on source chain
+    // For ingress, we need the address that matches the source chain (not sourceAsset)
+    // For egress, we always start from Avalanche (EVM), so we can use evmAddress as default
+    // But we'll create separate useQuote instances to handle this correctly
+    const ingressAddress = useMemo(() => {
+        if (sourceAsset) {
+            // For ingress, address should match the source chain
+            return sourceAsset.caip19.includes('solana') ? solAddress : evmAddress;
+        }
+        return undefined;
+    }, [sourceAsset, solAddress, evmAddress]);
+    // For egress, we always start from Avalanche (EVM), so use EVM address
+    // If evmAddress is undefined, use the phony EVM address as fallback
+    // This ensures egress quotes always use an EVM address format (required for Avalanche origin)
+    const egressAddress = evmAddress || EVM_PHONY_ADDRESS_FALLBACK;
+    // Initialize useQuote hooks - one for ingress (uses address based on source chain)
+    // and one for egress (uses EVM address since egress always starts from Avalanche)
+    const ingressQuote = useQuote({
+        address: ingressAddress,
+        maxImpactPercent,
+    });
+    const egressQuote = useQuote({
+        address: egressAddress, // Always an EVM address (either evmAddress or EVM_PHONY_ADDRESS_FALLBACK)
+        maxImpactPercent,
+    });
+    const { estimateLive: estimateLiveIngress, interpolateSamples: interpolate } = ingressQuote;
+    const { estimateLive: estimateLiveEgress } = egressQuote;
+    const abortControllerRef = useRef(null);
+    const lastEstimateParamsRef = useRef('');
+    const inFlightRequestRef = useRef(null);
+    /**
+     * Fetch both ingress and egress estimates in parallel
+     * Matches estimate_order() from Svelte app
+     */
+    const estimateOrder = useCallback(async (usdcPrice, sourceAsset, sourcePrice, sourceAmount, destinationAssets, destinationPrices, splits, calculationDirection = 'input-to-output', outputAmounts) => {
+        // Validate inputs
+        if (!sourceAsset) {
+            throw new Error('sourceAsset is required');
+        }
+        if (!sourceAsset.caip19) {
+            throw new Error('sourceAsset.caip19 is required');
+        }
+        if (!destinationAssets || destinationAssets.length === 0) {
+            throw new Error('destinationAssets is required and must not be empty');
+        }
+        if (destinationAssets.some((asset) => !asset || !asset.caip19)) {
+            throw new Error('All destinationAssets must have a valid caip19 property');
+        }
+        // For reverse calculation, validate output amounts
+        if (calculationDirection === 'output-to-input') {
+            if (!outputAmounts || outputAmounts.length !== destinationAssets.length) {
+                throw new Error('outputAmounts are required for reverse calculation');
+            }
+            if (outputAmounts.some((amt) => !amt || parseFloat(amt) <= 0)) {
+                throw new Error('All outputAmounts must be valid positive numbers for reverse calculation');
+            }
+        }
+        // Create a key for these parameters to detect duplicate calls
+        const sourceAmountStr = typeof sourceAmount === 'string' ? sourceAmount : sourceAmount.toString();
+        const estimateKey = `${sourceAsset.caip19}-${sourceAmountStr}-${destinationAssets.map((a) => a.caip19).join(',')}-${splits.join(',')}`;
+        // If same parameters and request is in flight, return the existing promise (prevents duplicate requests)
+        if (lastEstimateParamsRef.current === estimateKey && inFlightRequestRef.current) {
+            return inFlightRequestRef.current;
+        }
+        // Cancel any previous request (parameters changed)
+        if (abortControllerRef.current) {
+            abortControllerRef.current.abort();
+        }
+        lastEstimateParamsRef.current = estimateKey;
+        const abortController = new AbortController();
+        abortControllerRef.current = abortController;
+        setError(null);
+        // Create the request promise (declare first to avoid closure issues)
+        let requestPromise;
+        requestPromise = (async () => {
+            try {
+                console.log('[OrderEstimates] Step 1: Starting estimateOrder', {
+                    calculationDirection,
+                    sourceAsset: sourceAsset.caip19,
+                    sourceAmount,
+                    destinationsCount: destinationAssets.length,
+                    splits,
+                    hasOutputAmounts: !!outputAmounts,
+                });
+                // Calculate USD value of source amount
+                const sourceAmountNum = typeof sourceAmount === 'string' ? parseFloat(sourceAmount) : sourceAmount;
+                const usdValueSrc = BigNumber(sourcePrice).times(sourceAmountNum).toNumber();
+                console.log('[OrderEstimates] Step 2: Calculated source USD value', { sourceAmountNum, sourcePrice, usdValueSrc });
+                // Parse source asset to get chain ID and token address from CAIP-19
+                console.log('[OrderEstimates] Step 3: Parsing source asset CAIP-19');
+                const isSourceSolana = isSolanaAsset(sourceAsset.caip19);
+                const sourceEvmParsed = !isSourceSolana ? parseEvmCaip19(sourceAsset.caip19) : null;
+                const sourceSolanaParsed = isSourceSolana ? parseSolanaCaip19(sourceAsset.caip19) : null;
+                const sourceChainId = sourceEvmParsed?.chainId ?? sourceSolanaParsed?.chainId ?? 0;
+                const sourceTokenAddress = isEvmNativeToken(sourceAsset.caip19)
+                    ? '0x0000000000000000000000000000000000000000'
+                    : isSolanaNativeToken(sourceAsset.caip19)
+                        ? '11111111111111111111111111111111'
+                        : (sourceEvmParsed?.tokenAddress ?? sourceSolanaParsed?.tokenAddress ?? '');
+                console.log('[OrderEstimates] Step 3: Source asset parsed', { sourceChainId, sourceTokenAddress, isSourceSolana });
+                // For reverse calculation, calculate total output USD value first
+                let totalOutputUsd = 0;
+                let calculatedInputAmount = undefined;
+                if (calculationDirection === 'output-to-input' && outputAmounts) {
+                    console.log('[OrderEstimates] Step 4: Reverse calculation - calculating total output USD');
+                    // Calculate total USD value of outputs
+                    totalOutputUsd = destinationAssets.reduce((sum, destAsset, idx) => {
+                        const outputAmount = parseFloat(outputAmounts[idx] || '0');
+                        const destPrice = destinationPrices[idx] || 0;
+                        return sum + (outputAmount * destPrice);
+                    }, 0);
+                    console.log('[OrderEstimates] Step 4: Total output USD calculated', { totalOutputUsd, outputAmounts });
+                    // For reverse calculation, we'll use EXACT_OUTPUT for egress quotes
+                    // and let ingress calculate the required input with srcChainTokenInAmount: 'auto'
+                }
+                else {
+                    console.log('[OrderEstimates] Step 4: Normal calculation (input-to-output)');
+                }
+                // Fetch ingress and egress estimates in parallel (matching Svelte behavior)
+                // Pass abort signal to estimateLive so both can be cancelled together
+                console.log('[OrderEstimates] Step 5: Fetching ingress and egress estimates in parallel', {
+                    calculationDirection,
+                    sourceChainId,
+                    sourceTokenAddress,
+                    destinationsCount: destinationAssets.length,
+                });
+                const [ingressResult, egressResults] = await Promise.all([
+                    // Ingress: source chain -> Avalanche (USDC)
+                    // For reverse calculation, use EXACT_OUTPUT with calculated deposit USD
+                    // For normal calculation, use EXACT_INPUT with source amount
+                    calculationDirection === 'output-to-input' && totalOutputUsd > 0
+                        ? estimateLiveIngress('ingress', sourceAsset.caip19, sourceChainId, sourceTokenAddress, totalOutputUsd / sourcePrice, // Approximate input for quote (will be refined)
+                        sourcePrice, abortController.signal, undefined, // recipientAddress (not needed for ingress)
+                        true, // isReverseCalculation
+                        totalOutputUsd).catch((err) => {
+                            if (err instanceof Error && err.name === 'AbortError')
+                                throw err;
+                            console.warn('Ingress estimate failed (reverse):', err);
+                            return null;
+                        })
+                        : estimateLiveIngress('ingress', sourceAsset.caip19, sourceChainId, sourceTokenAddress, sourceAmountNum, sourcePrice, abortController.signal).catch((err) => {
+                            if (err instanceof Error && err.name === 'AbortError')
+                                throw err;
+                            console.warn('Ingress estimate failed:', err);
+                            return null;
+                        }),
+                    // Egress: Avalanche (USDC) -> each destination chain
+                    Promise.all(destinationAssets.map((destAsset, idx) => {
+                        // Parse destination asset to get chain ID and token address from CAIP-19
+                        const isDestSolana = isSolanaAsset(destAsset.caip19);
+                        const destEvmParsed = !isDestSolana ? parseEvmCaip19(destAsset.caip19) : null;
+                        const destSolanaParsed = isDestSolana ? parseSolanaCaip19(destAsset.caip19) : null;
+                        const destChainId = destEvmParsed?.chainId ?? destSolanaParsed?.chainId ?? 0;
+                        const destTokenAddress = isEvmNativeToken(destAsset.caip19)
+                            ? '0x0000000000000000000000000000000000000000'
+                            : isSolanaNativeToken(destAsset.caip19)
+                                ? '11111111111111111111111111111111'
+                                : (destEvmParsed?.tokenAddress ?? destSolanaParsed?.tokenAddress ?? '');
+                        // Determine recipient address based on destination chain
+                        // For Solana destinations, use Solana address; for EVM, use EVM address
+                        const recipientAddress = isDestSolana ? solAddress : evmAddress;
+                        // For reverse calculation, use output amount directly with EXACT_OUTPUT
+                        if (calculationDirection === 'output-to-input' && outputAmounts && outputAmounts[idx]) {
+                            const outputAmount = parseFloat(outputAmounts[idx]);
+                            // Use EXACT_OUTPUT for egress: we know the output amount, calculate required USDC
+                            // Pass the output amount directly (in human-readable format)
+                            // estimateLive will convert it to micro units and use EXACT_OUTPUT tradeType
+                            return estimateLiveEgress('egress', destAsset.caip19, destChainId, destTokenAddress, outputAmount, // Output amount in human-readable format (destination token)
+                            destinationPrices[idx] || 1, // Destination token price for USD conversion
+                            abortController.signal, recipientAddress, // recipientAddress
+                            true, // isReverseCalculation
+                            outputAmount).catch((err) => {
+                                if (err instanceof Error && err.name === 'AbortError')
+                                    throw err;
+                                console.warn(`Egress estimate failed (reverse) for ${destAsset.caip19}:`, err);
+                                return null;
+                            });
+                        }
+                        else {
+                            // Normal calculation: calculate from input
+                            const splitDiff = idx === 0 ? splits[0] : splits[idx] - splits[idx - 1];
+                            const splitUsdValue = usdValueSrc * splitDiff;
+                            // For egress quotes, pass USD value directly (matches Svelte behavior)
+                            // Svelte passes USD value to estimate_live, which then converts to USDC micro units
+                            // In Svelte: amount = splitDiff * x_usd_value_src (USD value)
+                            // Then estimate_live calls: asset_get(S_CAIP19_USDC_AVALANCHE)?.humanToUnit(zx_amount)
+                            // Since USDC price ≈ 1, USD value ≈ USDC amount in human-readable format
+                            // estimateLive will convert this to micro units using shiftedBy(6) for USDC
+                            // So we pass the USD value directly, and estimateLive treats it as human-readable USDC
+                            const usdcAmountHumanReadable = splitUsdValue; // USD value ≈ USDC amount when price = 1
+                            // Use egress-specific estimateLive which uses EVM address (since egress always starts from Avalanche)
+                            return estimateLiveEgress('egress', destAsset.caip19, destChainId, // Already a number from parseSolanaCaip19 (7565164) or parseEvmCaip19
+                            destTokenAddress, usdcAmountHumanReadable, usdcPrice, abortController.signal, recipientAddress).catch((err) => {
+                                if (err instanceof Error && err.name === 'AbortError')
+                                    throw err;
+                                console.warn(`Egress estimate failed for ${destAsset.caip19}:`, err);
+                                return null;
+                            });
+                        }
+                    })),
+                ]);
+                if (abortController.signal.aborted) {
+                    console.log('[OrderEstimates] Request aborted');
+                    throw new Error('Request aborted');
+                }
+                console.log('[OrderEstimates] Step 6: Estimates received', {
+                    hasIngressResult: !!ingressResult,
+                    egressResultsCount: egressResults.length,
+                });
+                // Handle ingress result
+                if (!ingressResult) {
+                    throw new Error('Ingress estimate failed');
+                }
+                const ingressEstimate = ingressResult.estimate;
+                const ingressQuote = ingressResult.response;
+                const ingressGasAmount = ingressResult.gasAmount;
+                console.log('[OrderEstimates] Step 7: Processing ingress result', {
+                    ingressRate: ingressResult.estimate?.samples?.[0]?.retention,
+                    ingressGasAmount: ingressGasAmount.toString(),
+                    calculatedInputAmount: ingressResult.calculatedInputAmount,
+                });
+                // Handle egress results first (needed for both normal and reverse calculation)
+                console.log('[OrderEstimates] Step 8: Processing egress results', {
+                    destinationsCount: destinationAssets.length,
+                    egressResultsCount: egressResults.length,
+                });
+                const egressEstimates = [];
+                const egressQuotes = [];
+                const egressRetentions = [];
+                for (let idx = 0; idx < destinationAssets.length; idx++) {
+                    const egressResult = egressResults[idx];
+                    if (calculationDirection === 'output-to-input' && outputAmounts && outputAmounts[idx]) {
+                        // For reverse calculation, use output USD value for interpolation
+                        const outputAmount = parseFloat(outputAmounts[idx]);
+                        const destPrice = destinationPrices[idx] || 1;
+                        const outputUsdValue = outputAmount * destPrice;
+                        console.log('[OrderEstimates] Step 8: Processing egress result (reverse)', {
+                            index: idx,
+                            outputAmount,
+                            outputUsdValue,
+                            hasResult: !!egressResult,
+                        });
+                        if (egressResult) {
+                            egressEstimates.push(egressResult.estimate);
+                            egressQuotes.push(egressResult.response);
+                            // Interpolate egress retention rate using output USD value
+                            const egressRetention = interpolate(egressResult.estimate.samples, outputUsdValue);
+                            egressRetentions.push(egressRetention);
+                        }
+                        else {
+                            // Fallback: use 1.0 retention if egress estimate failed
+                            egressEstimates.push({
+                                gasFee: 0,
+                                samples: [
+                                    {
+                                        baseline: Infinity,
+                                        retention: 1,
+                                        source: 'none',
+                                    },
+                                ],
+                            });
+                            egressQuotes.push({});
+                            egressRetentions.push(1.0);
+                        }
+                    }
+                    else {
+                        // Normal calculation: use split USD value
+                        const splitDiff = idx === 0 ? splits[0] : splits[idx] - splits[idx - 1];
+                        const splitUsdValue = usdValueSrc * splitDiff;
+                        console.log('[OrderEstimates] Step 8: Processing egress result (normal)', {
+                            index: idx,
+                            splitDiff,
+                            splitUsdValue,
+                            hasResult: !!egressResult,
+                        });
+                        if (egressResult) {
+                            egressEstimates.push(egressResult.estimate);
+                            egressQuotes.push(egressResult.response);
+                            // Interpolate egress retention rate for this split
+                            const egressRetention = interpolate(egressResult.estimate.samples, splitUsdValue);
+                            egressRetentions.push(egressRetention);
+                        }
+                        else {
+                            // Fallback: use 1.0 retention if egress estimate failed
+                            // This matches Svelte behavior where missing estimates use cached values
+                            egressEstimates.push({
+                                gasFee: 0,
+                                samples: [
+                                    {
+                                        baseline: Infinity,
+                                        retention: 1,
+                                        source: 'none',
+                                    },
+                                ],
+                            });
+                            egressQuotes.push({});
+                            egressRetentions.push(1.0);
+                        }
+                    }
+                }
+                console.log('[OrderEstimates] Step 8: Egress results processed', {
+                    egressRetentions,
+                });
+                // For reverse calculation, extract calculated input amount from ingress result
+                if (calculationDirection === 'output-to-input' && ingressResult.calculatedInputAmount) {
+                    console.log('[OrderEstimates] Step 9: Reverse calculation - interpolating retention with calculated input', {
+                        calculatedInputAmount: ingressResult.calculatedInputAmount,
+                    });
+                    calculatedInputAmount = ingressResult.calculatedInputAmount;
+                    // Use the calculated input amount for retention rate interpolation
+                    const calculatedInputUsd = calculatedInputAmount * sourcePrice;
+                    const ingressRetention = interpolate(ingressEstimate.samples, calculatedInputUsd);
+                    const result = {
+                        ingressGasAmount,
+                        ingressRate: ingressRetention,
+                        egressRates: egressRetentions,
+                        ingressEstimate,
+                        egressEstimates,
+                        ingressQuote,
+                        egressQuotes,
+                        calculatedInputAmount,
+                    };
+                    console.log('[OrderEstimates] Step 10: estimateOrder completed (reverse)', {
+                        ingressRate: ingressRetention,
+                        egressRates: egressRetentions,
+                        calculatedInputAmount,
+                    });
+                    return result;
+                }
+                // Normal calculation: interpolate ingress retention rate
+                console.log('[OrderEstimates] Step 9: Normal calculation - interpolating ingress retention', { usdValueSrc });
+                const ingressRetention = interpolate(ingressEstimate.samples, usdValueSrc);
+                const result = {
+                    ingressGasAmount,
+                    ingressRate: ingressRetention,
+                    egressRates: egressRetentions,
+                    ingressEstimate,
+                    egressEstimates,
+                    ingressQuote,
+                    egressQuotes,
+                };
+                console.log('[OrderEstimates] Step 10: estimateOrder completed (normal)', {
+                    ingressRate: ingressRetention,
+                    egressRates: egressRetentions,
+                });
+                return result;
+            }
+            catch (err) {
+                if (err instanceof Error && err.name === 'AbortError') {
+                    console.log('[OrderEstimates] Request aborted');
+                    throw err;
+                }
+                const error = err instanceof Error ? err : new Error('Failed to estimate order');
+                console.error('[OrderEstimates] Error: Failed to estimate order', error);
+                setError(error);
+                throw error;
+            }
+        })();
+        // Store the in-flight request
+        inFlightRequestRef.current = requestPromise;
+        // Clear in-flight request when promise completes (success or error)
+        requestPromise.finally(() => {
+            if (inFlightRequestRef.current === requestPromise) {
+                inFlightRequestRef.current = null;
+            }
+        });
+        return requestPromise;
+    }, [estimateLiveIngress, estimateLiveEgress, interpolate, ingressAddress, egressAddress, sourceAsset, solAddress, evmAddress, maxImpactPercent]);
+    return {
+        estimateOrder,
+        isLoading: !!inFlightRequestRef.current,
+        error,
+    };
+}

package/dist/hooks/useOutputAssetInfo.d.ts

@@ -0,0 +1,12 @@
+import type { AssetInfo } from '@silentswap/sdk';
+import type { Destination } from './useSwap.js';
+/**
+ * Hook to calculate output asset info and secondary value for swap transaction card
+ * Used in InputPlate and OutputSwapTransactionCard
+ */
+export declare function useOutputAssetInfo(destinations: Destination[], tokenOut: AssetInfo | null): {
+    outputAssetInfo: AssetInfo | null | undefined;
+    outputAmount: string;
+    outputAssetPrice: number | undefined;
+    outputSecondaryValue: string | null;
+};

package/dist/hooks/useOutputAssetInfo.js

@@ -0,0 +1,38 @@
+import { useMemo } from 'react';
+import { getAssetByCaip19 } from '@silentswap/sdk';
+import { useAssetPrice } from './useAssetPrice.js';
+import { useUsdValue } from './useUsdValue.js';
+import { formatSecondaryValue } from '../utils/formatters.js';
+/**
+ * Hook to calculate output asset info and secondary value for swap transaction card
+ * Used in InputPlate and OutputSwapTransactionCard
+ */
+export function useOutputAssetInfo(destinations, tokenOut) {
+    // Get output asset info for swap transaction card
+    const outputAssetInfo = useMemo(() => {
+        if (destinations.length > 0 && destinations[0].asset) {
+            return getAssetByCaip19(destinations[0].asset);
+        }
+        return tokenOut;
+    }, [destinations, tokenOut]);
+    const outputAmount = useMemo(() => {
+        if (destinations.length > 0 && destinations[0].amount) {
+            return destinations[0].amount;
+        }
+        return '';
+    }, [destinations]);
+    // Calculate secondary value for output asset (USD equivalent)
+    const outputAssetPrice = useAssetPrice(outputAssetInfo || null, destinations[0]?.priceUsd);
+    const { usdValue: outputUsdValue } = useUsdValue(outputAmount, outputAssetPrice);
+    const outputSecondaryValue = useMemo(() => {
+        if (!outputAssetPrice || !outputAmount)
+            return null;
+        return formatSecondaryValue(outputAssetInfo || null, outputUsdValue);
+    }, [outputAssetPrice, outputAmount, outputUsdValue, outputAssetInfo]);
+    return {
+        outputAssetInfo,
+        outputAmount,
+        outputAssetPrice,
+        outputSecondaryValue,
+    };
+}

package/dist/hooks/usePrices.d.ts

@@ -0,0 +1,60 @@
+import BigNumber from 'bignumber.js';
+import type { AssetInfo } from '@silentswap/sdk';
+export type CachedPrice = {
+    priceUsd: number;
+    published: number;
+    expiration: number;
+    source: string;
+};
+export interface usePricesOptions {
+    /** Maximum age for cached prices in milliseconds (default: 15000) */
+    maxPriceAge?: number;
+    /** CoinGecko Pro API key (optional, uses default if not provided) */
+    coingeckoApiKey?: string;
+}
+export interface usePricesReturn {
+    /** Get USD price for a single asset */
+    getPrice: (asset: AssetInfo, maxAge?: number) => Promise<number>;
+    /** Get prices for multiple assets (batch fetch) */
+    getPrices: (assets: AssetInfo[], maxAge?: number) => Promise<number[]>;
+    /** Get USD value for atomic units */
+    getUnitValueUsd: (asset: AssetInfo, amount: bigint) => Promise<number>;
+    /** Get USD value for human-readable amounts */
+    getWholeValueUsd: (asset: AssetInfo, amount: number | string | BigNumber) => Promise<number>;
+    /** Check if price is currently loading */
+    isPriceLoading: (caip19: string) => boolean;
+    /** Get cached price without fetching */
+    getCachedPrice: (caip19: string, maxAge?: number) => number | null;
+    /** Whether any prices are currently loading */
+    loadingPrices: boolean;
+}
+/**
+ * React hook for fetching and caching asset prices from CoinGecko
+ *
+ * Provides price fetching functionality similar to the Svelte Asset.priceUsd() method
+ * with caching and batch fetching support.
+ *
+ * @param options - Configuration options
+ * @returns Object with price fetching methods and state
+ *
+ * @example
+ * ```typescript
+ * import { usePrices } from '@silentswap/react';
+ * import { getAssetByCaip19 } from '@silentswap/sdk';
+ *
+ * function MyComponent() {
+ *   const { getPrice, getPrices } = usePrices();
+ *
+ *   const handleGetPrice = async () => {
+ *     const asset = getAssetByCaip19('eip155:1/erc20:0xA0b8...');
+ *     if (asset) {
+ *       const price = await getPrice(asset);
+ *       console.log('Price:', price);
+ *     }
+ *   };
+ *
+ *   return <button onClick={handleGetPrice}>Get Price</button>;
+ * }
+ * ```
+ */
+export declare function usePrices(options?: usePricesOptions): usePricesReturn;