@silentswap/sdk 0.0.21 → 0.0.23

package/dist/bridge.js

@@ -0,0 +1,615 @@
+import { encodeFunctionData, erc20Abi } from 'viem';
+import { NI_CHAIN_ID_AVALANCHE, S0X_ADDR_USDC_AVALANCHE, S0X_ADDR_DEPOSITOR, X_MAX_IMPACT_PERCENT, } from './constants.js';
+import { createPhonyDepositCalldata } from './wallet.js';
+/**
+ * Get a quote from relay.link
+ */
+export async function getRelayQuote(params, apiKey) {
+    const { srcChainId, dstChainId, srcToken, dstToken, amount, tradeType, recipient, user, additionalTxs = [], } = params;
+    // relay.link API call - using the correct parameters from relay-link.ts
+    const response = await fetch('https://api.relay.link/quote', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            user,
+            referrer: 'silentswap',
+            originChainId: srcChainId,
+            destinationChainId: dstChainId,
+            originCurrency: srcToken === '0x0000000000000000000000000000000000000000' ? '0x0000000000000000000000000000000000000000' : srcToken,
+            destinationCurrency: dstToken,
+            amount,
+            tradeType,
+            recipient,
+            txsGasLimit: additionalTxs.length > 0 ? 600_000 : undefined,
+            txs: additionalTxs.map(tx => ({
+                to: tx.to,
+                value: tx.value,
+                data: tx.data,
+            })),
+        }),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Relay API error: ${response.status} ${response.statusText} - ${errorText}`);
+    }
+    const data = await response.json();
+    return {
+        provider: 'relay',
+        estimatedTime: data.details?.timeEstimate || 300, // Use timeEstimate from response
+        fee: {
+            amount: data.fees?.gas?.amountFormatted || data.fees?.relayer?.amountFormatted || '0',
+            token: data.fees?.gas?.currency?.symbol || data.fees?.relayer?.currency?.symbol || 'ETH',
+            usdValue: data.fees?.gas?.amountUsd || data.fees?.relayer?.amountUsd,
+        },
+        slippage: parseFloat(data.details?.slippageTolerance?.percent || '0.005') * 100, // Convert to percentage
+        route: data,
+        txs: data.steps?.flatMap((step) => step.items?.map((item) => ({
+            to: item.data?.to,
+            value: item.data?.value || '0',
+            data: item.data?.data || '0x',
+            gasLimit: item.data?.gas,
+            chainId: item.data?.chainId || srcChainId,
+        })) || []) || [],
+    };
+}
+/**
+ * Get a quote from debridge (handles both cross-chain and same-chain swaps)
+ */
+export async function getDebridgeQuote(params, apiKey) {
+    const { srcChainId, dstChainId, srcToken, dstToken, amount, recipient, user, additionalTxs = [], prependOperatingExpenses = true, enableEstimate = true, } = params;
+    // Use single-chain swap endpoint if source and destination chains are the same
+    if (srcChainId === dstChainId) {
+        return getDebridgeSingleChainQuote(params, apiKey);
+    }
+    // debridge cross-chain API call - using the correct parameters from original debridge.ts
+    const queryParams = new URLSearchParams({
+        srcChainId: srcChainId.toString(),
+        srcChainTokenIn: srcToken,
+        srcChainTokenInAmount: amount,
+        dstChainId: dstChainId.toString(),
+        dstChainTokenOut: dstToken,
+        dstChainTokenOutRecipient: recipient,
+        senderAddress: user, // Changed from 'account' to 'senderAddress' for enableEstimate=true
+        srcChainOrderAuthorityAddress: user,
+        dstChainOrderAuthorityAddress: user,
+        prependOperatingExpenses: prependOperatingExpenses.toString(),
+        enableEstimate: enableEstimate.toString(),
+    });
+    // Add dlnHook if additional transactions are provided
+    if (additionalTxs.length > 0) {
+        const hookData = {
+            type: 'evm_transaction_call',
+            data: {
+                to: additionalTxs[0].to,
+                calldata: additionalTxs[0].data,
+                gas: 500_000,
+            },
+        };
+        queryParams.append('dlnHook', JSON.stringify(hookData));
+    }
+    const response = await fetch(`https://dln.debridge.finance/v1.0/dln/order/create-tx?${queryParams.toString()}`, {
+        method: 'GET', // debridge uses GET with query parameters
+        headers: {
+            'Content-Type': 'application/json',
+        },
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Debridge API error: ${response.status} ${response.statusText} - ${errorText}`);
+    }
+    const data = await response.json();
+    return {
+        provider: 'debridge',
+        estimatedTime: data.order?.approximateFulfillmentDelay || 600, // Use approximateFulfillmentDelay from response
+        fee: {
+            amount: data.estimation?.srcChainTokenIn?.amount || '0',
+            token: data.estimation?.srcChainTokenIn?.currency?.symbol || 'UNKNOWN',
+            usdValue: data.estimation?.srcChainTokenIn?.approximateUsdValue,
+        },
+        slippage: data.recommendedSlippage || 0.5, // Use recommendedSlippage from response
+        route: data,
+        txs: data.tx ? [{
+                to: data.tx.to,
+                value: data.tx.value || '0',
+                data: data.tx.data || '0x',
+                chainId: srcChainId,
+            }] : [],
+    };
+}
+/**
+ * Get a quote for same-chain swap from deBridge single-chain swap endpoint
+ * Documentation: https://api.dln.trade/v1.0/#/single%20chain%20swap
+ */
+async function getDebridgeSingleChainQuote(params, apiKey) {
+    const { srcChainId, srcToken, dstToken, amount, recipient, user, } = params;
+    // Single-chain swap API call
+    const queryParams = new URLSearchParams({
+        chainId: srcChainId.toString(),
+        tokenIn: srcToken,
+        tokenInAmount: amount,
+        tokenOut: dstToken,
+        recipient: recipient,
+        senderAddress: user,
+    });
+    const response = await fetch(`https://api.dln.trade/v1.0/chain/transaction?${queryParams.toString()}`, {
+        method: 'GET',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Debridge single-chain swap API error: ${response.status} ${response.statusText} - ${errorText}`);
+    }
+    const data = await response.json();
+    return {
+        provider: 'debridge',
+        estimatedTime: 60, // Single-chain swaps are faster
+        fee: {
+            amount: data.estimation?.srcChainTokenIn?.amount || '0',
+            token: data.estimation?.srcChainTokenIn?.currency?.symbol || 'UNKNOWN',
+            usdValue: data.estimation?.srcChainTokenIn?.approximateUsdValue,
+        },
+        slippage: data.recommendedSlippage || 0.5,
+        route: data,
+        txs: data.tx ? [{
+                to: data.tx.to,
+                value: data.tx.value || '0',
+                data: data.tx.data || '0x',
+                chainId: srcChainId,
+            }] : [],
+    };
+}
+/**
+ * Execute a relay.link bridge transaction
+ */
+export async function executeRelayBridge(quote, executeTransaction, switchChain, setStep) {
+    const txHashes = [];
+    for (const tx of quote.txs) {
+        setStep(`Switching to chain ${tx.chainId}`);
+        // Switch to the correct chain
+        await switchChain(tx.chainId);
+        setStep('Sending bridge transaction');
+        // Send transaction
+        const hash = await executeTransaction(tx);
+        txHashes.push(hash);
+    }
+    // Extract request ID for status monitoring
+    const requestId = quote.route.steps?.find((s) => s.requestId)?.requestId;
+    return {
+        status: 'pending',
+        txHashes,
+        requestId,
+    };
+}
+/**
+ * Execute a debridge bridge transaction
+ */
+export async function executeDebridgeBridge(quote, executeTransaction, switchChain, setStep) {
+    if (quote.txs.length === 0) {
+        throw new Error('No transactions in debridge quote');
+    }
+    const tx = quote.txs[0];
+    setStep(`Switching to chain ${tx.chainId}`);
+    // Switch to the correct chain
+    await switchChain(tx.chainId);
+    setStep('Sending bridge transaction');
+    // Send transaction
+    const hash = await executeTransaction(tx);
+    return {
+        status: 'pending',
+        txHashes: [hash],
+        requestId: quote.route.orderId,
+    };
+}
+/**
+ * Get relay.link bridge status
+ */
+export async function getRelayStatus(requestId) {
+    const response = await fetch(`https://api.relay.link/intents/status?requestId=${encodeURIComponent(requestId)}`);
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Relay status API error: ${response.status} ${response.statusText} - ${errorText}`);
+    }
+    const data = await response.json();
+    return {
+        status: mapRelayStatus(data.status),
+        txHashes: data.txHashes || data.inTxHashes,
+        details: data.details,
+        requestId,
+    };
+}
+/**
+ * Get debridge bridge status
+ */
+export async function getDebridgeStatus(requestId) {
+    const response = await fetch(`https://dln.debridge.finance/v1.0/dln/order/status?orderId=${encodeURIComponent(requestId)}`);
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Debridge status API error: ${response.status} ${response.statusText} - ${errorText}`);
+    }
+    const data = await response.json();
+    return {
+        status: mapDebridgeStatus(data.orderId ? 'Fulfilled' : 'Created'), // Simplified status mapping
+        txHashes: data.txHashes,
+        details: data.status,
+        requestId,
+    };
+}
+/**
+ * Map relay.link status to unified status
+ */
+function mapRelayStatus(status) {
+    switch (status?.toLowerCase()) {
+        case 'success':
+        case 'completed':
+            return 'success';
+        case 'failed':
+        case 'error':
+            return 'failed';
+        case 'refund':
+        case 'refunded':
+            return 'refund';
+        case 'fallback':
+            return 'fallback';
+        case 'pending':
+        case 'processing':
+        default:
+            return 'pending';
+    }
+}
+/**
+ * Map debridge status to unified status
+ */
+function mapDebridgeStatus(status) {
+    switch (status) {
+        case 'Fulfilled':
+        case 'ClaimedUnlock':
+        case 'Completed':
+            return 'success';
+        case 'OrderCancelled':
+        case 'SentOrderCancel':
+        case 'ClaimedOrderCancel':
+        case 'Cancelled':
+            return 'failed';
+        case 'Created':
+        case 'SentUnlock':
+        case 'Pending':
+        default:
+            return 'pending';
+    }
+}
+/**
+ * Fetch a relay.link quote with detailed response
+ */
+export async function fetchRelayQuote(params, signal) {
+    const response = await fetch('https://api.relay.link/quote', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(params),
+        signal,
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`HTTP ${response.status}: ${text}`);
+    }
+    return response.json();
+}
+/**
+ * Fetch a deBridge order with detailed response (handles both cross-chain and same-chain swaps)
+ */
+export async function fetchDebridgeOrder(params, signal) {
+    // Use single-chain swap endpoint if source and destination chains are the same
+    if (params.srcChainId === params.dstChainId) {
+        return fetchDebridgeSingleChainOrder(params, signal);
+    }
+    const queryParams = new URLSearchParams(Object.entries(params).reduce((acc, [key, value]) => {
+        if (value !== undefined) {
+            acc[key] = typeof value === 'object' ? JSON.stringify(value) : String(value);
+        }
+        return acc;
+    }, {}));
+    const response = await fetch(`https://dln.debridge.finance/v1.0/dln/order/create-tx?${queryParams}`, { signal });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`HTTP ${response.status}: ${text}`);
+    }
+    return response.json();
+}
+/**
+ * Fetch a deBridge single-chain swap order
+ * Documentation: https://api.dln.trade/v1.0/#/single%20chain%20swap
+ */
+async function fetchDebridgeSingleChainOrder(params, signal) {
+    const queryParams = new URLSearchParams({
+        chainId: params.srcChainId.toString(),
+        tokenIn: params.srcChainTokenIn,
+        tokenInAmount: params.srcChainTokenInAmount,
+        tokenOut: params.dstChainTokenOut,
+        recipient: params.dstChainTokenOutRecipient || params.account || '',
+        senderAddress: params.account || '',
+    });
+    const response = await fetch(`https://api.dln.trade/v1.0/chain/transaction?${queryParams}`, { signal });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`HTTP ${response.status}: ${text}`);
+    }
+    return response.json();
+}
+const UINT256_MAX = 2n ** 256n - 1n;
+/**
+ * Solve for optimal USDC amount using relay.link
+ */
+async function solveRelayUsdcAmount(srcChainId, srcToken, srcAmount, userAddress, depositCalldata, maxImpactPercent) {
+    // Get initial quote to estimate expected output
+    const initialQuote = await fetchRelayQuote({
+        user: userAddress,
+        referrer: 'silentswap',
+        originChainId: srcChainId,
+        destinationChainId: NI_CHAIN_ID_AVALANCHE,
+        originCurrency: srcToken,
+        destinationCurrency: S0X_ADDR_USDC_AVALANCHE,
+        amount: srcAmount,
+        tradeType: 'EXACT_INPUT',
+    });
+    const baseUsdcOut = BigInt(initialQuote.details.currencyOut.amount);
+    // Overshoot by +1 USDC to +5% (max +100 USDC)
+    let targetUsdcOut = BigInt(Math.max(Number(baseUsdcOut) + 1_000_000, Math.min(Number(baseUsdcOut) + 100_000_000, Number(baseUsdcOut) * 1.05)));
+    // Try up to 4 times to find optimal amount
+    for (let attempt = 0; attempt < 4; attempt++) {
+        const quote = await fetchRelayQuote({
+            user: userAddress,
+            referrer: 'silentswap',
+            originChainId: srcChainId,
+            destinationChainId: NI_CHAIN_ID_AVALANCHE,
+            originCurrency: srcToken,
+            destinationCurrency: S0X_ADDR_USDC_AVALANCHE,
+            amount: targetUsdcOut.toString(),
+            tradeType: 'EXACT_OUTPUT',
+            recipient: S0X_ADDR_DEPOSITOR,
+            txsGasLimit: 500_000,
+            txs: [
+                {
+                    to: S0X_ADDR_USDC_AVALANCHE,
+                    value: '0',
+                    data: encodeFunctionData({
+                        abi: erc20Abi,
+                        functionName: 'approve',
+                        args: [S0X_ADDR_DEPOSITOR, UINT256_MAX],
+                    }),
+                },
+                {
+                    to: S0X_ADDR_DEPOSITOR,
+                    value: '0',
+                    data: depositCalldata,
+                },
+            ],
+        });
+        const impactPercent = Number(quote.details.totalImpact.percent);
+        if (impactPercent > maxImpactPercent) {
+            throw new Error(`Price impact too high: ${impactPercent.toFixed(2)}%`);
+        }
+        const amountIn = BigInt(quote.details.currencyIn.amount);
+        // Amount in is within our budget
+        if (amountIn <= BigInt(srcAmount)) {
+            return [BigInt(quote.details.currencyOut.amount), amountIn, ''];
+        }
+        // Calculate new target based on overshoot
+        const usdcPrice = quote.details.currencyOut.amountUsd / Number(quote.details.currencyOut.amount);
+        const tokenPrice = quote.details.currencyIn.amountUsd / Number(quote.details.currencyIn.amount);
+        const usdcOver = (Number(quote.details.currencyIn.amount) - Number(srcAmount)) * tokenPrice / usdcPrice;
+        const newTarget = Number(quote.details.currencyOut.amount) - usdcOver;
+        if (BigInt(newTarget) >= targetUsdcOut) {
+            throw new Error('Failed to find optimal bridge price');
+        }
+        targetUsdcOut = BigInt(newTarget);
+    }
+    throw new Error('Failed to find optimal bridge price after 4 attempts');
+}
+/**
+ * Solve for optimal USDC amount using deBridge
+ */
+async function solveDebridgeUsdcAmount(srcChainId, srcToken, srcAmount, userAddress, depositCalldata, maxImpactPercent) {
+    // For same-chain swaps (Avalanche to Avalanche), use the single-chain endpoint
+    if (srcChainId === NI_CHAIN_ID_AVALANCHE) {
+        return solveDebridgeSingleChainUsdcAmount(srcChainId, srcToken, srcAmount, userAddress, depositCalldata, maxImpactPercent);
+    }
+    // Get initial quote for cross-chain swap
+    const initialQuote = await fetchDebridgeOrder({
+        srcChainId,
+        srcChainTokenIn: srcToken,
+        srcChainTokenInAmount: srcAmount,
+        dstChainId: NI_CHAIN_ID_AVALANCHE,
+        dstChainTokenOut: S0X_ADDR_USDC_AVALANCHE,
+        dstChainTokenOutAmount: 'auto',
+        account: userAddress,
+        prependOperatingExpenses: true,
+    });
+    const baseUsdcOut = BigInt(initialQuote.estimation.dstChainTokenOut.amount);
+    // Overshoot by +1 USDC to +5% (max +100 USDC)
+    let targetUsdcOut = BigInt(Math.max(Number(baseUsdcOut) + 1_000_000, Math.min(Number(baseUsdcOut) + 100_000_000, Number(baseUsdcOut) * 1.05)));
+    // Try up to 4 times to find optimal amount
+    for (let attempt = 0; attempt < 4; attempt++) {
+        const quote = await fetchDebridgeOrder({
+            srcChainId,
+            srcChainTokenIn: srcToken,
+            srcChainTokenInAmount: 'auto',
+            dstChainId: NI_CHAIN_ID_AVALANCHE,
+            dstChainTokenOut: S0X_ADDR_USDC_AVALANCHE,
+            dstChainTokenOutAmount: targetUsdcOut.toString(),
+            dstChainTokenOutRecipient: S0X_ADDR_DEPOSITOR,
+            account: userAddress,
+            prependOperatingExpenses: true,
+            dlnHook: JSON.stringify({
+                type: 'evm_transaction_call',
+                data: {
+                    to: S0X_ADDR_DEPOSITOR,
+                    calldata: depositCalldata,
+                    gas: 500_000,
+                },
+            }),
+        });
+        // Calculate price impact
+        const usdIn = quote.estimation.srcChainTokenIn.approximateUsdValue;
+        const usdOut = quote.estimation.dstChainTokenOut.approximateUsdValue;
+        const impactPercent = 100 * (1 - usdOut / usdIn);
+        if (impactPercent > maxImpactPercent) {
+            throw new Error(`Price impact too high: ${impactPercent.toFixed(2)}%`);
+        }
+        const amountIn = BigInt(quote.estimation.srcChainTokenIn.amount);
+        // Amount in is within our budget
+        if (amountIn <= BigInt(srcAmount)) {
+            return [
+                BigInt(quote.estimation.dstChainTokenOut.amount),
+                amountIn,
+                quote.tx.allowanceTarget || '',
+            ];
+        }
+        // Calculate new target based on overshoot
+        const usdcPrice = usdOut / Number(quote.estimation.dstChainTokenOut.amount);
+        const tokenPrice = usdIn / Number(quote.estimation.srcChainTokenIn.amount);
+        const usdcOver = (Number(quote.estimation.srcChainTokenIn.amount) - Number(srcAmount)) * tokenPrice / usdcPrice;
+        const newTarget = Number(quote.estimation.dstChainTokenOut.amount) - usdcOver;
+        if (BigInt(newTarget) >= targetUsdcOut) {
+            throw new Error('Failed to find optimal bridge price');
+        }
+        targetUsdcOut = BigInt(newTarget);
+    }
+    throw new Error('Failed to find optimal bridge price after 4 attempts');
+}
+/**
+ * Solve for optimal USDC amount using deBridge single-chain swap
+ * For same-chain swaps like Avalanche to Avalanche
+ */
+async function solveDebridgeSingleChainUsdcAmount(chainId, srcToken, srcAmount, userAddress, depositCalldata, maxImpactPercent) {
+    // Get initial quote for same-chain swap
+    const initialQuote = await fetchDebridgeSingleChainOrder({
+        srcChainId: chainId,
+        srcChainTokenIn: srcToken,
+        srcChainTokenInAmount: srcAmount,
+        dstChainId: chainId,
+        dstChainTokenOut: S0X_ADDR_USDC_AVALANCHE,
+        dstChainTokenOutAmount: 'auto',
+        account: userAddress,
+        prependOperatingExpenses: true,
+    });
+    const baseUsdcOut = BigInt(initialQuote.estimation.dstChainTokenOut.amount);
+    // Overshoot by +1 USDC to +5% (max +100 USDC)
+    let targetUsdcOut = BigInt(Math.max(Number(baseUsdcOut) + 1_000_000, Math.min(Number(baseUsdcOut) + 100_000_000, Number(baseUsdcOut) * 1.05)));
+    // Try up to 4 times to find optimal amount
+    for (let attempt = 0; attempt < 4; attempt++) {
+        const quote = await fetchDebridgeSingleChainOrder({
+            srcChainId: chainId,
+            srcChainTokenIn: srcToken,
+            srcChainTokenInAmount: 'auto',
+            dstChainId: chainId,
+            dstChainTokenOut: S0X_ADDR_USDC_AVALANCHE,
+            dstChainTokenOutAmount: targetUsdcOut.toString(),
+            dstChainTokenOutRecipient: S0X_ADDR_DEPOSITOR,
+            account: userAddress,
+            prependOperatingExpenses: true,
+        });
+        // Calculate price impact
+        const usdIn = quote.estimation.srcChainTokenIn.approximateUsdValue;
+        const usdOut = quote.estimation.dstChainTokenOut.approximateUsdValue;
+        const impactPercent = 100 * (1 - usdOut / usdIn);
+        if (impactPercent > maxImpactPercent) {
+            throw new Error(`Price impact too high: ${impactPercent.toFixed(2)}%`);
+        }
+        const amountIn = BigInt(quote.estimation.srcChainTokenIn.amount);
+        // Amount in is within our budget
+        if (amountIn <= BigInt(srcAmount)) {
+            return [
+                BigInt(quote.estimation.dstChainTokenOut.amount),
+                amountIn,
+                quote.tx.allowanceTarget || '',
+            ];
+        }
+        // Calculate new target based on overshoot
+        const usdcPrice = usdOut / Number(quote.estimation.dstChainTokenOut.amount);
+        const tokenPrice = usdIn / Number(quote.estimation.srcChainTokenIn.amount);
+        const usdcOver = (Number(quote.estimation.srcChainTokenIn.amount) - Number(srcAmount)) * tokenPrice / usdcPrice;
+        const newTarget = Number(quote.estimation.dstChainTokenOut.amount) - usdcOver;
+        if (BigInt(newTarget) >= targetUsdcOut) {
+            throw new Error('Failed to find optimal bridge price');
+        }
+        targetUsdcOut = BigInt(newTarget);
+    }
+    throw new Error('Failed to find optimal bridge price after 4 attempts');
+}
+/**
+ * Solve for optimal USDC amount using both relay and debridge providers
+ * Compares rates and returns the best option
+ *
+ * @param srcChainId - Source chain ID
+ * @param srcToken - Source token address (use 0x0 for native)
+ * @param srcAmount - Source amount in token units (as string)
+ * @param userAddress - User's EVM address
+ * @param depositCalldata - Optional deposit calldata (will use phony if not provided)
+ * @param maxImpactPercent - Maximum price impact percentage allowed (default from constants)
+ * @returns Promise resolving to solve result with optimal amounts
+ */
+export async function solveOptimalUsdcAmount(srcChainId, srcToken, srcAmount, userAddress, depositCalldata, maxImpactPercent = X_MAX_IMPACT_PERCENT) {
+    // Create phony deposit calldata if not provided
+    const calldata = depositCalldata || createPhonyDepositCalldata(userAddress);
+    // Try both providers in parallel
+    const [relayResult, debridgeResult] = await Promise.allSettled([
+        solveRelayUsdcAmount(srcChainId, srcToken, srcAmount, userAddress, calldata, maxImpactPercent),
+        solveDebridgeUsdcAmount(srcChainId, srcToken, srcAmount, userAddress, calldata, maxImpactPercent),
+    ]);
+    // Extract results
+    const relayData = relayResult.status === 'fulfilled' ? relayResult.value : null;
+    const debridgeData = debridgeResult.status === 'fulfilled' ? debridgeResult.value : null;
+    // Both failed
+    if (!relayData && !debridgeData) {
+        const errors = [
+            relayResult.status === 'rejected' ? relayResult.reason : null,
+            debridgeResult.status === 'rejected' ? debridgeResult.reason : null,
+        ].filter(Boolean);
+        throw new AggregateError(errors, 'All bridge providers failed');
+    }
+    // Only one succeeded
+    if (!relayData) {
+        console.info('Using deBridge (relay failed)');
+        return {
+            usdcAmountOut: debridgeData[0],
+            actualAmountIn: debridgeData[1],
+            provider: 'debridge',
+            allowanceTarget: debridgeData[2],
+        };
+    }
+    if (!debridgeData) {
+        console.info('Using relay.link (deBridge failed)');
+        return {
+            usdcAmountOut: relayData[0],
+            actualAmountIn: relayData[1],
+            provider: 'relay',
+            allowanceTarget: relayData[2],
+        };
+    }
+    // Compare rates (USDC out / amount in)
+    const relayRate = Number(relayData[0]) / Number(relayData[1]);
+    const debridgeRate = Number(debridgeData[0]) / Number(debridgeData[1]);
+    if (relayRate >= debridgeRate) {
+        console.info(`Using relay.link: ${relayRate} >= ${debridgeRate}`);
+        return {
+            usdcAmountOut: relayData[0],
+            actualAmountIn: relayData[1],
+            provider: 'relay',
+            allowanceTarget: '',
+        };
+    }
+    else {
+        console.info(`Using deBridge: ${debridgeRate} >= ${relayRate}`);
+        return {
+            usdcAmountOut: debridgeData[0],
+            actualAmountIn: debridgeData[1],
+            provider: 'debridge',
+            allowanceTarget: debridgeData[2],
+        };
+    }
+}

package/dist/chain.d.ts

@@ -0,0 +1,35 @@
+import type { WalletClient, SendTransactionParameters, Hex, PublicClient } from 'viem';
+import type { Connector } from 'wagmi';
+/**
+ * Ensure the correct chain is active
+ *
+ * @param chainId - The target chain ID
+ * @param walletClient - The wallet client
+ * @param connector - The wagmi connector for chain switching
+ * @returns The wallet client (after ensuring correct chain)
+ */
+export declare function ensureChain(chainId: number, walletClient: WalletClient, connector: Connector): Promise<WalletClient>;
+/**
+ * Wait for transaction confirmation using viem's waitForTransactionReceipt
+ *
+ * @param hash - The transaction hash to wait for
+ * @param publicClient - The public client to use for waiting
+ * @param timeoutMs - Timeout in milliseconds (default: 30000)
+ * @returns Promise resolving when transaction is confirmed
+ */
+export declare function waitForTransactionConfirmation(hash: Hex, publicClient: PublicClient, timeoutMs?: number): Promise<{
+    status: 'success' | 'failed';
+    transactionHash: Hex;
+}>;
+/**
+ * Execute a transaction with confirmation waiting
+ *
+ * @param params - Transaction parameters
+ * @param walletClient - The wallet client
+ * @param publicClient - The public client to use for waiting
+ * @returns Promise resolving to transaction result
+ */
+export declare function executeTransaction(params: SendTransactionParameters, walletClient: WalletClient, publicClient: PublicClient): Promise<{
+    hash: Hex;
+    status: 'success' | 'failed';
+}>;