@silentswap/react 0.0.41

package/dist/hooks/useAssetPrice.js

@@ -0,0 +1,47 @@
+import { useEffect, useState } from 'react';
+import { usePricesContext } from '../contexts/PricesContext.js';
+/**
+ * Hook to fetch and manage asset price from the global context.
+ * Handles price fetching with optional override.
+ * This hook now uses the PricesContext to prevent duplicate API calls.
+ * Automatically updates when prices are refreshed (after 10 seconds).
+ */
+export function useAssetPrice(asset, priceOverride) {
+    const { getPrice, prices } = usePricesContext();
+    const [price, setPrice] = useState(priceOverride);
+    useEffect(() => {
+        if (priceOverride !== undefined) {
+            setPrice(priceOverride);
+            return;
+        }
+        if (!asset) {
+            setPrice(undefined);
+            return;
+        }
+        // Get price from context (will trigger fetch if not cached or stale)
+        const contextPrice = getPrice(asset);
+        setPrice(contextPrice);
+        // Set up a small interval to check for updated price if it was undefined
+        // This handles the case where the price is being fetched asynchronously
+        if (contextPrice === undefined) {
+            const interval = setInterval(() => {
+                const updatedPrice = getPrice(asset);
+                if (updatedPrice !== undefined) {
+                    setPrice(updatedPrice);
+                    clearInterval(interval);
+                }
+            }, 100);
+            return () => clearInterval(interval);
+        }
+    }, [asset, priceOverride, getPrice]);
+    // Update price when context price changes (handles stale price refreshes)
+    useEffect(() => {
+        if (asset && priceOverride === undefined) {
+            const contextPrice = prices[asset.caip19];
+            if (contextPrice !== undefined && contextPrice !== price) {
+                setPrice(contextPrice);
+            }
+        }
+    }, [asset, priceOverride, prices, price]);
+    return price;
+}

package/dist/hooks/useContacts.d.ts

@@ -0,0 +1,52 @@
+export declare enum AddressBookContactSource {
+    UNKNOWN = "unknown",
+    WALLET = "wallet",
+    SAVED = "saved"
+}
+export type AddressBookContactId = `caip10:${string}` | `ens:${string}` | `sns:${string}`;
+export type AddressBookContactInfo = {
+    id: AddressBookContactId;
+    label?: string;
+    source?: AddressBookContactSource;
+    resolved?: string;
+    updated?: number;
+};
+export declare class AddressBookContact {
+    protected _g_info: AddressBookContactInfo;
+    protected _s_caip10: string;
+    protected _s_ens: string;
+    protected _s_sns: string;
+    protected _s_caip2_ns: 'eip155' | 'solana' | 'bip122' | 'cosmos';
+    private _saveCallback?;
+    constructor(_g_info: AddressBookContactInfo, b_from_id?: boolean, saveCallback?: (contact: AddressBookContact) => void);
+    private updateENSRecord;
+    get id(): AddressBookContactId;
+    get info(): AddressBookContactInfo;
+    get caip10(): string;
+    get ens(): string;
+    get sns(): string;
+    get label(): string;
+    set label(s_label: string);
+    get source(): AddressBookContactSource;
+    get caip2Ns(): 'eip155' | 'solana' | 'bip122' | 'cosmos';
+    isEvm(): boolean;
+    isSolana(): boolean;
+    isBip122(): boolean;
+    isCosmos(): boolean;
+    rawAddress(): string | undefined;
+    address(): Promise<string>;
+    save(): this;
+}
+export type AddressBookContactsQuery = {
+    exclude?: ('' | undefined | AddressBookContactId)[];
+    include?: ('' | undefined | AddressBookContactId)[];
+};
+export declare const useContacts: () => {
+    contacts: AddressBookContact[];
+    loading: boolean;
+    addContact: (contact: AddressBookContact) => void;
+    findContact: (id: AddressBookContactId) => AddressBookContact | undefined;
+    getContacts: (query?: AddressBookContactsQuery) => AddressBookContact[];
+    createContactFromId: (id: AddressBookContactId) => AddressBookContact;
+    deleteContact: (id: AddressBookContactId) => void;
+};

package/dist/hooks/useContacts.js

@@ -0,0 +1,259 @@
+import { useState, useEffect, useCallback } from 'react';
+import { getAddress, http } from 'viem';
+import { mainnet } from 'viem/chains';
+import { createEnsPublicClient } from '@ensdomains/ensjs';
+export var AddressBookContactSource;
+(function (AddressBookContactSource) {
+    AddressBookContactSource["UNKNOWN"] = "unknown";
+    AddressBookContactSource["WALLET"] = "wallet";
+    AddressBookContactSource["SAVED"] = "saved";
+})(AddressBookContactSource || (AddressBookContactSource = {}));
+export class AddressBookContact {
+    _g_info;
+    _s_caip10 = '';
+    _s_ens = '';
+    _s_sns = '';
+    _s_caip2_ns;
+    _saveCallback;
+    constructor(_g_info, b_from_id, saveCallback) {
+        this._g_info = _g_info;
+        this._saveCallback = saveCallback;
+        if (!this._g_info.id)
+            throw new Error('Improper contact info');
+        const namespaceMatch = /^([^:]+):(.+)$/.exec(_g_info.id);
+        if (!namespaceMatch)
+            throw new Error(`Invalid contact ID "${_g_info.id}"`);
+        const [, s_type, s_qualifier] = namespaceMatch;
+        if (s_type === 'caip10') {
+            this._s_caip10 = s_qualifier;
+            this._s_caip2_ns = s_qualifier.split(':')[0];
+        }
+        else if (s_type === 'ens') {
+            this._s_ens = s_qualifier;
+            this._s_caip2_ns = 'eip155';
+        }
+        else if (s_type === 'sns') {
+            this._s_sns = s_qualifier;
+            this._s_caip2_ns = 'solana';
+        }
+        else {
+            throw new Error(`Invalid contact ID "${_g_info.id}"`);
+        }
+        // Update ENS if needed
+        if (s_type === 'ens' && !b_from_id && this._saveCallback) {
+            this.updateENSRecord();
+        }
+    }
+    async updateENSRecord() {
+        const XT_MAX_ENS_CACHE_DURATION = 3600 * 1000 * 24; // 24 hours
+        if (Date.now() - (this._g_info.updated ?? 0) > XT_MAX_ENS_CACHE_DURATION) {
+            try {
+                const ensClient = createEnsPublicClient({
+                    chain: mainnet,
+                    transport: http(),
+                });
+                const record = await ensClient.getAddressRecord({
+                    name: this._s_ens,
+                });
+                if (record?.value) {
+                    this._g_info.resolved = getAddress(record.value);
+                    this._g_info.updated = Date.now();
+                    // Use callback to save if available
+                    if (this._saveCallback) {
+                        this._saveCallback(this);
+                    }
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to resolve ENS ${this._s_ens}:`, error);
+            }
+        }
+    }
+    get id() {
+        return this._g_info.id;
+    }
+    get info() {
+        return this._g_info;
+    }
+    get caip10() {
+        return this._s_caip10;
+    }
+    get ens() {
+        return this._s_ens;
+    }
+    get sns() {
+        return this._s_sns;
+    }
+    get label() {
+        return this._g_info.label || this._s_ens || this._s_sns || this._s_caip10.replace(/^([^:]*:)*/, '');
+    }
+    set label(s_label) {
+        this._g_info.label = s_label;
+        if (this._saveCallback) {
+            this._saveCallback(this);
+        }
+    }
+    get source() {
+        return this._g_info.source ?? AddressBookContactSource.UNKNOWN;
+    }
+    get caip2Ns() {
+        return this._s_caip2_ns;
+    }
+    isEvm() {
+        return this._s_caip2_ns === 'eip155';
+    }
+    isSolana() {
+        return this._s_caip2_ns === 'solana';
+    }
+    isBip122() {
+        return this._s_caip2_ns === 'bip122';
+    }
+    isCosmos() {
+        return this._s_caip2_ns === 'cosmos';
+    }
+    rawAddress() {
+        if (this._s_caip10) {
+            const caip10Match = /^([^:]*):(.+)$/.exec(this._s_caip10);
+            if (caip10Match) {
+                const addressMatch = /^([^:]*):(.+)$/.exec(caip10Match[2]);
+                return addressMatch?.[2];
+            }
+        }
+        return this._g_info.resolved;
+    }
+    async address() {
+        const rawAddr = this.rawAddress();
+        if (rawAddr)
+            return rawAddr;
+        if (this._s_ens) {
+            try {
+                const ensClient = createEnsPublicClient({
+                    chain: mainnet,
+                    transport: http(),
+                });
+                const record = await ensClient.getAddressRecord({
+                    name: this._s_ens,
+                });
+                if (record?.value) {
+                    return getAddress(record.value);
+                }
+                throw new Error(`Could not resolve ENS name "${this._s_ens}"`);
+            }
+            catch (error) {
+                throw new Error(`Could not resolve ENS name "${this._s_ens}": ${error}`);
+            }
+        }
+        if (this._s_sns) {
+            throw new Error(`SNS resolution not implemented for "${this._s_sns}"`);
+        }
+        throw new Error(`Could not resolve address for contact "${this._g_info.id}"`);
+    }
+    save() {
+        if (this._saveCallback) {
+            this._saveCallback(this);
+        }
+        return this;
+    }
+}
+const STORAGE_KEY_CONTACTS = 'silentswap:contacts';
+export const useContacts = () => {
+    const [contacts, setContacts] = useState([]);
+    const [loading, setLoading] = useState(true);
+    // Create save callback that directly updates state
+    const createSaveCallback = useCallback((contact) => {
+        setContacts((prev) => {
+            // Remove existing contact if it exists
+            const filtered = prev.filter((c) => c.id !== contact.id);
+            // Add updated contact and sort by label
+            const updated = [...filtered, contact].sort((a, b) => a.label.localeCompare(b.label));
+            return updated;
+        });
+    }, []);
+    const addContact = useCallback((contact) => {
+        setContacts((prev) => {
+            // Remove existing contact if it exists
+            const filtered = prev.filter((c) => c.id !== contact.id);
+            // Ensure contact has save callback
+            if (!contact._saveCallback) {
+                // Create new contact instance with callback
+                const contactWithCallback = new AddressBookContact(contact.info, false, createSaveCallback);
+                const updated = [...filtered, contactWithCallback].sort((a, b) => a.label.localeCompare(b.label));
+                return updated;
+            }
+            // Add new contact and sort by label
+            const updated = [...filtered, contact].sort((a, b) => a.label.localeCompare(b.label));
+            return updated;
+        });
+    }, [createSaveCallback]);
+    // Load contacts from localStorage on mount
+    useEffect(() => {
+        const loadContacts = () => {
+            try {
+                if (typeof localStorage === 'undefined')
+                    return;
+                const stored = localStorage.getItem(STORAGE_KEY_CONTACTS);
+                if (stored) {
+                    try {
+                        const parsed = JSON.parse(stored);
+                        if (Array.isArray(parsed) && parsed.every((item) => typeof item === 'object' && item !== null)) {
+                            const contactInfos = parsed;
+                            // Create contacts with save callback from the start
+                            const contactInstances = contactInfos.map((info) => new AddressBookContact(info, true, createSaveCallback));
+                            setContacts(contactInstances);
+                        }
+                    }
+                    catch (error) {
+                        console.warn('Failed to parse contacts from localStorage:', error);
+                    }
+                }
+            }
+            catch (error) {
+                console.warn('Failed to load contacts from localStorage:', error);
+            }
+            finally {
+                setLoading(false);
+            }
+        };
+        loadContacts();
+    }, [createSaveCallback]);
+    // Save contacts to localStorage whenever contacts change
+    useEffect(() => {
+        if (!loading) {
+            try {
+                const serialized = contacts.map((contact) => contact.info);
+                localStorage.setItem(STORAGE_KEY_CONTACTS, JSON.stringify(serialized));
+            }
+            catch (error) {
+                console.warn('Failed to save contacts to localStorage:', error);
+            }
+        }
+    }, [contacts, loading]);
+    const findContact = useCallback((id) => {
+        return contacts.find((contact) => contact.id === id);
+    }, [contacts]);
+    const getContacts = useCallback((query) => {
+        let result = [...contacts];
+        if (query?.exclude) {
+            result = result.filter((contact) => !query.exclude?.includes(contact.id));
+        }
+        if (query?.include) {
+            result = result.filter((contact) => query.include?.includes(contact.id));
+        }
+        return result;
+    }, [contacts]);
+    const createContactFromId = useCallback((id) => {
+        return new AddressBookContact({ id }, true, createSaveCallback);
+    }, [createSaveCallback]);
+    const deleteContact = useCallback((id) => {
+        setContacts((prev) => prev.filter((contact) => contact.id !== id));
+    }, []);
+    return {
+        contacts,
+        loading,
+        addContact,
+        findContact,
+        getContacts,
+        createContactFromId,
+        deleteContact,
+    };
+};

package/dist/hooks/useEgressEstimates.d.ts

@@ -0,0 +1,32 @@
+import { BridgeProvider, type AssetInfo } from '@silentswap/sdk';
+import type { Destination } from './useSwap.js';
+export interface UseEgressEstimatesOptions {
+    evmAddress: `0x${string}` | string | undefined;
+    solAddress: string | undefined;
+    quoteAddress: string | undefined;
+    tokenIn: AssetInfo | null;
+    inputAmount: string;
+    destinations: Destination[];
+    splits: number[];
+    updateDestinationAmount: (index: number, amount: string) => void;
+    serviceFeeRate?: number;
+    overheadUsd?: number;
+    calculationDirection?: 'input-to-output' | 'output-to-input';
+    setInputAmount?: (amount: string) => void;
+}
+/**
+ * Hook to fetch egress estimates and calculate accurate output amounts
+ * Matches the behavior of Svelte Form.svelte's fetch_live_estimate()
+ */
+export declare function useEgressEstimates({ evmAddress, solAddress, quoteAddress, tokenIn, inputAmount, destinations, splits, updateDestinationAmount, serviceFeeRate, overheadUsd, calculationDirection, setInputAmount, }: UseEgressEstimatesOptions): {
+    fetchEstimates: (direction?: "input-to-output" | "output-to-input") => Promise<any>;
+    isLoading: boolean;
+    error: Error | null;
+    egressRates: number[];
+    egressQuotes: any[];
+    ingressRate: number;
+    ingressQuote: any;
+    depositAmountUsd: number;
+    bridgeProviderFromQuote: BridgeProvider | null;
+    usdcPrice: number;
+};

package/dist/hooks/useEgressEstimates.js

@@ -0,0 +1,230 @@
+import { useState, useCallback, useRef, useMemo } from 'react';
+import { BigNumber } from 'bignumber.js';
+import { useOrderEstimates } from './useOrderEstimates.js';
+import { getAssetByCaip19, S_CAIP19_USDC_AVALANCHE } from '@silentswap/sdk';
+import { usePrices } from './usePrices.js';
+/**
+ * Hook to fetch egress estimates and calculate accurate output amounts
+ * Matches the behavior of Svelte Form.svelte's fetch_live_estimate()
+ */
+export function useEgressEstimates({ evmAddress, solAddress, quoteAddress, tokenIn, inputAmount, destinations, splits, updateDestinationAmount, serviceFeeRate = 0.01, overheadUsd = 0, calculationDirection = 'input-to-output', setInputAmount, }) {
+    const { estimateOrder, isLoading, error } = useOrderEstimates({
+        evmAddress: evmAddress,
+        solAddress: solAddress,
+        sourceAsset: tokenIn,
+    });
+    const { getPrice } = usePrices();
+    // Store egress rates and quotes
+    const [egressRates, setEgressRates] = useState([]);
+    const [egressQuotes, setEgressQuotes] = useState([]);
+    const [ingressRate, setIngressRate] = useState(1);
+    const [ingressQuote, setIngressQuote] = useState(null);
+    const [depositAmountUsd, setDepositAmountUsd] = useState(0); // USD value after ingress retention
+    const [usdcPrice, setUsdcPrice] = useState(1); // USDC price (usually ~1)
+    const lastEstimateParams = useRef('');
+    const inFlightRequestRef = useRef(null);
+    /**
+     * Fetch egress estimates and calculate output amounts
+     * This matches Svelte's fetch_live_estimate() function
+     * @param direction - Calculation direction: 'input-to-output' (normal) or 'output-to-input' (reverse)
+     */
+    const fetchEstimates = useCallback(async (direction = 'input-to-output') => {
+        console.log('[EgressEstimates] Step 1: Starting fetchEstimates', { direction, tokenIn: tokenIn?.caip19, inputAmount, destinationsCount: destinations.length });
+        // Validate all required inputs before proceeding
+        if (!tokenIn ||
+            !tokenIn.caip19 ||
+            !inputAmount ||
+            parseFloat(inputAmount) <= 0 ||
+            destinations.length === 0 ||
+            !quoteAddress) {
+            console.log('[EgressEstimates] Step 1: Validation failed - missing required inputs');
+            return;
+        }
+        const estimateKey = `${tokenIn.caip19}-${inputAmount}-${destinations.map((d) => d.asset).join(',')}-${splits.join(',')}`;
+        // If same parameters and request is in flight, return the existing promise (prevents duplicate requests)
+        if (lastEstimateParams.current === estimateKey && inFlightRequestRef.current) {
+            console.log('[EgressEstimates] Step 1: Request already in flight with same parameters, returning existing promise');
+            return inFlightRequestRef.current;
+        }
+        // Update params before starting request
+        lastEstimateParams.current = estimateKey;
+        console.log('[EgressEstimates] Step 2: Fetching prices for USDC, source token, and destinations');
+        try {
+            // Get prices
+            const usdcAsset = getAssetByCaip19(S_CAIP19_USDC_AVALANCHE);
+            if (!usdcAsset)
+                throw new Error('USDC asset not found');
+            const [fetchedUsdcPrice, sourcePrice, ...destinationPrices] = await Promise.all([
+                getPrice(usdcAsset),
+                getPrice(tokenIn),
+                ...destinations.map((dest) => {
+                    const destAsset = getAssetByCaip19(dest.asset);
+                    return destAsset ? getPrice(destAsset) : Promise.resolve(0);
+                }),
+            ]);
+            console.log('[EgressEstimates] Step 2: Prices fetched', { usdcPrice: fetchedUsdcPrice, sourcePrice, destinationPrices });
+            // Store USDC price for use in fee calculations
+            setUsdcPrice(fetchedUsdcPrice || 1);
+            // Get destination assets
+            console.log('[EgressEstimates] Step 3: Resolving destination assets');
+            const destinationAssets = destinations
+                .map((dest) => getAssetByCaip19(dest.asset))
+                .filter((asset) => asset !== null);
+            if (destinationAssets.length !== destinations.length) {
+                throw new Error('Some destination assets not found');
+            }
+            // Fetch estimates (both ingress and egress in parallel)
+            // For reverse calculation (output-to-input), pass output amounts and use EXACT_OUTPUT
+            const effectiveDirection = direction || calculationDirection || 'input-to-output';
+            console.log('[EgressEstimates] Step 4: Calling estimateOrder', {
+                effectiveDirection,
+                sourceAsset: tokenIn.caip19,
+                inputAmount,
+                destinationsCount: destinationAssets.length,
+                splits,
+            });
+            const requestPromise = estimateOrder(fetchedUsdcPrice || 1, tokenIn, sourcePrice, inputAmount, destinationAssets, destinationPrices, splits, effectiveDirection, effectiveDirection === 'output-to-input'
+                ? destinations.map((dest) => dest.amount) // Pass output amounts for reverse calculation
+                : undefined);
+            // Store the in-flight request
+            inFlightRequestRef.current = requestPromise;
+            console.log('[EgressEstimates] Step 5: Waiting for estimateOrder result');
+            const result = await requestPromise;
+            console.log('[EgressEstimates] Step 5: estimateOrder completed', {
+                ingressRate: result.ingressRate,
+                egressRatesCount: result.egressRates.length,
+                calculatedInputAmount: result.calculatedInputAmount,
+            });
+            // Clear in-flight request when done
+            if (inFlightRequestRef.current === requestPromise) {
+                inFlightRequestRef.current = null;
+            }
+            // Store rates and quotes
+            console.log('[EgressEstimates] Step 6: Storing rates and quotes');
+            setIngressRate(result.ingressRate);
+            setIngressQuote(result.ingressQuote);
+            setEgressRates(result.egressRates);
+            setEgressQuotes(result.egressQuotes || []);
+            // Calculate deposit amount in USD (matches Svelte calculation - lines 173-177)
+            // Note: This is the USD value after ingress retention, not the USDC amount
+            let depositUsd;
+            // Handle reverse calculation: if direction is 'output-to-input', 
+            // the estimate system calculated the required input amount
+            if (effectiveDirection === 'output-to-input' && result.calculatedInputAmount && setInputAmount) {
+                console.log('[EgressEstimates] Step 7: Handling reverse calculation - updating input amount', {
+                    calculatedInputAmount: result.calculatedInputAmount,
+                });
+                // Update input amount with the value calculated by the estimate system
+                const precision = tokenIn.precision ?? 6;
+                const decimals = tokenIn.decimals ?? 6;
+                const formattedInputAmount = BigNumber(result.calculatedInputAmount).shiftedBy(-decimals)
+                    .toFixed(Math.min(precision, 8));
+                setInputAmount(formattedInputAmount);
+                console.log('[EgressEstimates] Step 7: Input amount updated', { formattedInputAmount });
+                // Recalculate depositUsd with the new input amount
+                const newInputAmountNum = parseFloat(formattedInputAmount) || 0;
+                depositUsd = BigNumber.max(0, BigNumber(newInputAmountNum).times(sourcePrice).times(result.ingressRate)).toNumber();
+            }
+            else {
+                console.log('[EgressEstimates] Step 7: Normal calculation - calculating deposit from input');
+                // Normal calculation: calculate deposit amount from input
+                depositUsd = BigNumber.max(0, BigNumber(inputAmount).times(sourcePrice).times(result.ingressRate)).toNumber();
+            }
+            console.log('[EgressEstimates] Step 8: Calculating fees and actionable amount', { depositUsd });
+            // Store USD deposit value (for fee calculations)
+            // This is the USD value after ingress retention (matches Svelte _yx_usd_deposit)
+            setDepositAmountUsd(depositUsd);
+            // USD value of actionable (after service fees) - matches Svelte line 215
+            const serviceFeeUsd = depositUsd * serviceFeeRate + overheadUsd;
+            const actionableUsd = depositUsd - serviceFeeUsd;
+            // Update destination amounts (matches Svelte Form.svelte lines 217-229)
+            // For reverse calculation, preserve user's manual changes
+            if (effectiveDirection === 'output-to-input') {
+                console.log('[EgressEstimates] Step 9: Reverse calculation - preserving user output amounts');
+                // Don't overwrite user's manual output changes
+                // The outputs are already set correctly
+            }
+            else {
+                console.log('[EgressEstimates] Step 9: Normal calculation - updating destination amounts', {
+                    actionableUsd,
+                    destinationsCount: destinations.length,
+                });
+                // Normal calculation: calculate outputs from input
+                destinations.forEach((dest, idx) => {
+                    const destAsset = destinationAssets[idx];
+                    if (!destAsset)
+                        return;
+                    // Calculate split difference: for first destination, use splits[0] - 0
+                    // For subsequent destinations, use splits[idx] - splits[idx - 1]
+                    // Special case: if only one destination, ensure it gets 100% (splitDiff = 1.0)
+                    const prevSplit = idx > 0 ? splits[idx - 1] : 0;
+                    let splitDiff = splits[idx] - prevSplit;
+                    // Ensure single destination always gets 100%
+                    if (destinations.length === 1) {
+                        splitDiff = 1.0;
+                    }
+                    const egressRate = result.egressRates[idx] || 1;
+                    const destPrice = destinationPrices[idx] || 1;
+                    // Calculate output amount (matches Svelte Form.svelte line 225-228)
+                    // Formula: actionableUsd / destPrice * splitDiff * egressRate
+                    const outputAmount = BigNumber(actionableUsd)
+                        .div(destPrice)
+                        .times(splitDiff)
+                        .times(egressRate)
+                        .toFixed(destAsset.precision ?? 6);
+                    updateDestinationAmount(idx, outputAmount);
+                });
+            }
+            console.log('[EgressEstimates] Step 10: fetchEstimates completed successfully');
+            return result;
+        }
+        catch (err) {
+            // Clear in-flight request on error
+            inFlightRequestRef.current = null;
+            if (err instanceof Error && err.name === 'AbortError') {
+                console.log('[EgressEstimates] Request aborted');
+                return;
+            }
+            console.error('[EgressEstimates] Error: Failed to fetch egress estimates', err);
+            throw err;
+        }
+    }, [
+        tokenIn,
+        inputAmount,
+        destinations,
+        splits,
+        estimateOrder,
+        getPrice,
+        updateDestinationAmount,
+        quoteAddress,
+        serviceFeeRate,
+        overheadUsd,
+        calculationDirection,
+        setInputAmount,
+    ]);
+    // Determine provider from ingress quote (matches Svelte behavior where provider is determined from solve_uusdc_amount)
+    // Relay quotes have 'fees' property, DeBridge quotes have 'estimation' property
+    const bridgeProviderFromQuote = useMemo(() => {
+        if (!ingressQuote)
+            return null;
+        if ('fees' in ingressQuote) {
+            return 'relay';
+        }
+        else if ('estimation' in ingressQuote) {
+            return 'debridge';
+        }
+        return null;
+    }, [ingressQuote]);
+    return {
+        fetchEstimates,
+        isLoading,
+        error,
+        egressRates,
+        egressQuotes,
+        ingressRate,
+        ingressQuote,
+        depositAmountUsd, // USD value after ingress retention (for fee calculations)
+        bridgeProviderFromQuote,
+        usdcPrice, // USDC price (usually ~1, matches x_usd_price_usdc in Svelte)
+    };
+}

package/dist/hooks/useHiddenSwapFees.d.ts

@@ -0,0 +1,22 @@
+import type { RelayQuoteResponse, DeBridgeOrderResponse } from '@silentswap/sdk';
+export interface HiddenSwapFees {
+    serviceFeeUsd: number;
+    bridgeFeeIngressUsd: number;
+    bridgeFeeEgressUsd: number;
+    totalFeesUsd: number;
+}
+export interface UseHiddenSwapFeesOptions {
+    depositAmountUsdc: number;
+    bridgeProvider: string | null;
+    serviceFeeRate?: number;
+    overheadUsd?: number;
+    usdcPrice?: number;
+    bridgeFeeRate?: number;
+    ingressQuote?: RelayQuoteResponse | DeBridgeOrderResponse | null;
+    egressQuotes?: (RelayQuoteResponse | DeBridgeOrderResponse)[] | null;
+}
+/**
+ * Hook to calculate fees for hidden swap
+ * Extracts actual fees from bridge quotes when available, otherwise uses estimated rates
+ */
+export declare function useHiddenSwapFees({ depositAmountUsdc, bridgeProvider, serviceFeeRate, overheadUsd, usdcPrice, bridgeFeeRate, ingressQuote, egressQuotes, }: UseHiddenSwapFeesOptions): HiddenSwapFees;