@silentswap/react 0.0.41

package/dist/hooks/usePrices.js

@@ -0,0 +1,188 @@
+import { useState, useCallback, useMemo } from 'react';
+import BigNumber from 'bignumber.js';
+// Global price cache (similar to Svelte's H_PRICES)
+const priceCache = {};
+const PRICE_CACHE_DURATION = 60 * 1000; // 60 seconds
+const MAX_PRICE_AGE = 15 * 1000; // 15 seconds for fresh prices
+// Mutex pool for preventing duplicate requests
+const loadingMutexes = {};
+/**
+ * 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 function usePrices(options = {}) {
+    const { maxPriceAge = MAX_PRICE_AGE, coingeckoApiKey = 'CG-QftACwuv13UVKqCnDdf4fkfn' } = options;
+    const [loadingPrices, setLoadingPrices] = useState(new Set());
+    // Get USD price for a single asset (similar to Asset.priceUsd())
+    const getPrice = useCallback(async (asset, maxAge = maxPriceAge) => {
+        const caip19 = asset.caip19;
+        // Check cache first
+        const cached = priceCache[caip19];
+        if (cached && cached.published + maxAge > Date.now()) {
+            return cached.priceUsd;
+        }
+        // Check if already loading - prevent double requests
+        if (!!loadingMutexes[caip19]) {
+            return loadingMutexes[caip19];
+        }
+        // Start loading - set mutex immediately to prevent race condition
+        setLoadingPrices((prev) => new Set(prev).add(caip19));
+        // Create and assign promise immediately to prevent concurrent requests
+        const pricePromise = (async () => {
+            try {
+                if (asset.coingeckoId) {
+                    // Fetch from CoinGecko Pro API (same as Svelte)
+                    const response = await fetch(`https://pro-api.coingecko.com/api/v3/simple/price?ids=${asset.coingeckoId}&vs_currencies=usd`, {
+                        headers: {
+                            'X-CG-Pro-Api-Key': coingeckoApiKey,
+                        },
+                        signal: AbortSignal.timeout(30 * 1000),
+                    });
+                    if (response.ok) {
+                        const data = await response.json();
+                        const price = data[asset.coingeckoId]?.usd || 0;
+                        // Cache the price
+                        priceCache[caip19] = {
+                            priceUsd: price,
+                            published: Date.now(),
+                            expiration: Date.now() + PRICE_CACHE_DURATION,
+                            source: 'coingecko',
+                        };
+                        // Also cache for other assets with same CoinGecko ID
+                        // (Note: This would require access to all assets, which we don't have here)
+                        // The Svelte version does this, but for simplicity we'll just cache this asset
+                        return price;
+                    }
+                }
+                // Fallback: retry after delay
+                await new Promise((resolve) => setTimeout(resolve, 10 * 1000));
+                return getPrice(asset, maxAge);
+            }
+            catch (error) {
+                console.warn(`Failed to fetch price for ${caip19}:`, error);
+                // Fallback: retry after delay
+                await new Promise((resolve) => setTimeout(resolve, 10 * 1000));
+                return getPrice(asset, maxAge);
+            }
+            finally {
+                delete loadingMutexes[caip19];
+                setLoadingPrices((prev) => {
+                    const next = new Set(prev);
+                    next.delete(caip19);
+                    return next;
+                });
+            }
+        })();
+        // Assign mutex BEFORE returning to prevent race condition
+        loadingMutexes[caip19] = pricePromise;
+        return pricePromise;
+    }, [maxPriceAge, coingeckoApiKey]);
+    // Get prices for multiple assets (batch fetch, similar to asset_prices())
+    const getPrices = useCallback(async (assets, maxAge = maxPriceAge) => {
+        const prices = [];
+        // Group by CoinGecko ID for batch requests
+        const coingeckoGroups = {};
+        for (const asset of assets) {
+            if (asset.coingeckoId) {
+                if (!coingeckoGroups[asset.coingeckoId]) {
+                    coingeckoGroups[asset.coingeckoId] = [];
+                }
+                coingeckoGroups[asset.coingeckoId].push(asset);
+            }
+        }
+        // Process each CoinGecko ID group
+        const coingeckoIds = Object.keys(coingeckoGroups);
+        if (coingeckoIds.length > 0) {
+            try {
+                const response = await fetch(`https://pro-api.coingecko.com/api/v3/simple/price?ids=${coingeckoIds.join(',')}&vs_currencies=usd`, {
+                    headers: {
+                        'X-CG-Pro-Api-Key': coingeckoApiKey,
+                    },
+                    signal: AbortSignal.timeout(30 * 1000),
+                });
+                if (response.ok) {
+                    const data = await response.json();
+                    // Update cache for all returned prices
+                    for (const [coingeckoId, priceData] of Object.entries(data)) {
+                        const price = priceData.usd || 0;
+                        const groupAssets = coingeckoGroups[coingeckoId];
+                        groupAssets.forEach((asset) => {
+                            priceCache[asset.caip19] = {
+                                priceUsd: price,
+                                published: Date.now(),
+                                expiration: Date.now() + PRICE_CACHE_DURATION,
+                                source: 'coingecko',
+                            };
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                console.warn('Failed to batch fetch prices:', error);
+            }
+        }
+        // Return prices from cache (or 0 if not available)
+        return assets.map((asset) => {
+            const cached = priceCache[asset.caip19];
+            return cached && cached.published + maxAge > Date.now() ? cached.priceUsd : 0;
+        });
+    }, [maxPriceAge, coingeckoApiKey]);
+    // Get USD value for atomic units (similar to Asset.unitValueUsd)
+    const getUnitValueUsd = useCallback(async (asset, amount) => {
+        const price = await getPrice(asset);
+        const humanAmount = Number(BigNumber(amount.toString()).shiftedBy(-asset.decimals));
+        return humanAmount * price;
+    }, [getPrice]);
+    // Get USD value for human-readable amounts (similar to Asset.wholeValueUsd)
+    const getWholeValueUsd = useCallback(async (asset, amount) => {
+        const price = await getPrice(asset);
+        return BigNumber(amount.toString()).times(price).toNumber();
+    }, [getPrice]);
+    // Check if price is loading
+    const isPriceLoading = useCallback((caip19) => {
+        return loadingPrices.has(caip19);
+    }, [loadingPrices]);
+    // Get cached price (without fetching)
+    const getCachedPrice = useCallback((caip19, maxAge = maxPriceAge) => {
+        const cached = priceCache[caip19];
+        if (cached && cached.published + maxAge > Date.now()) {
+            return cached.priceUsd;
+        }
+        return null;
+    }, [maxPriceAge]);
+    const loadingPricesValue = useMemo(() => loadingPrices.size > 0, [loadingPrices]);
+    return {
+        getPrice,
+        getPrices,
+        getUnitValueUsd,
+        getWholeValueUsd,
+        isPriceLoading,
+        getCachedPrice,
+        loadingPrices: loadingPricesValue,
+    };
+}

package/dist/hooks/useQuote.d.ts

@@ -0,0 +1,73 @@
+import type { BridgeProvider, RelayQuoteResponse, DeBridgeOrderResponse, SolveUsdcResult } from '@silentswap/sdk';
+import { type EstimateSample, type Estimate, type BridgeQuoteResult } from '@silentswap/sdk';
+export interface useQuoteOptions {
+    /** User's address (EVM hex address or Solana base58 address) */
+    address?: `0x${string}` | string;
+    /** Maximum price impact percentage allowed (default from SDK constants) */
+    maxImpactPercent?: number;
+    /** Timeout for quote requests in milliseconds (default: 30000) */
+    quoteTimeout?: number;
+}
+export type { RelayQuoteResponse, DeBridgeOrderResponse, SolveUsdcResult, EstimateSample, Estimate, BridgeQuoteResult, } from '@silentswap/sdk';
+export type SolveResult = SolveUsdcResult;
+/**
+ * Estimate result with quote details
+ */
+export interface EstimateResult {
+    /** Estimate data with samples */
+    estimate: Estimate;
+    /** Amount of gas needed on source chain */
+    gasAmount: bigint;
+    /** Raw response from provider */
+    response: RelayQuoteResponse | DeBridgeOrderResponse;
+    /** Bridge provider used */
+    provider: BridgeProvider;
+    /** Calculated input amount for reverse calculation (output-to-input) */
+    calculatedInputAmount?: number;
+}
+export interface useQuoteReturn {
+    isLoading: boolean;
+    error: Error | null;
+    ingressEstimates: Record<string, Estimate>;
+    egressEstimates: Record<string, Estimate>;
+    /**
+     * Get quote for cross-chain swap
+     * @param srcChainId - Source chain ID
+     * @param srcToken - Source token address (0x0 for native)
+     * @param srcAmount - Source amount in token units (as string)
+     * @param dstChainId - Destination chain ID
+     * @param dstToken - Destination token address (0x0 for native)
+     * @param recipientAddress - Optional recipient address (required for Solana destinations)
+     * @param sourceAddress - Optional source chain address (for relay.link, must match source chain format)
+     * @returns Promise resolving to best quote with all details
+     */
+    getQuote: (srcChainId: number, srcToken: string, srcAmount: string, dstChainId: number, dstToken: string, recipientAddress?: string, sourceAddress?: string) => Promise<BridgeQuoteResult>;
+    /**
+     * Get live estimate for a given direction
+     * @param direction - 'ingress' (into Silent) or 'egress' (out of Silent)
+     * @param assetCaip19 - CAIP-19 asset identifier
+     * @param chainId - Chain ID
+     * @param tokenAddress - Token address (0x0 for native)
+     * @param amount - Amount in human-readable format
+     * @param usdPrice - USD price per token
+     * @param externalSignal - Optional abort signal
+     * @param recipientAddress - Optional recipient address (required for Solana destinations in egress)
+     * @param isReverseCalculation - For reverse calculation (output-to-input)
+     * @param targetAmount - Target amount for reverse calculation (output USD for ingress, output amount for egress)
+     * @returns Promise resolving to estimate result
+     */
+    estimateLive: (direction: 'ingress' | 'egress', assetCaip19: string, chainId: number | string, tokenAddress: string, amount: number, usdPrice: number, externalSignal?: AbortSignal, recipientAddress?: string, isReverseCalculation?: boolean, targetAmount?: number) => Promise<EstimateResult>;
+    /**
+     * Interpolate retention rate from samples
+     * @param samples - Array of estimate samples
+     * @param usdValue - USD value to interpolate for
+     * @param marginHi - Maximum margin above highest sample (default: Infinity)
+     * @returns Interpolated retention rate
+     */
+    interpolateSamples: (samples: EstimateSample[], usdValue: number, marginHi?: number) => number;
+}
+/**
+ * Hook for getting optimized bridge quotes with retention rate tracking
+ * Implements the same functionality as estimate.ts from the original app
+ */
+export declare function useQuote({ address, maxImpactPercent }?: useQuoteOptions): useQuoteReturn;