@silentswap/react 0.0.41

package/dist/hooks/silent/useBridgeExecution.js

@@ -0,0 +1,877 @@
+import { useCallback } from 'react';
+import { createPublicClient, http, encodeFunctionData, erc20Abi, getAddress } from 'viem';
+import { ensureChain, waitForTransactionConfirmation, NI_CHAIN_ID_AVALANCHE, S0X_ADDR_USDC_AVALANCHE, X_MAX_IMPACT_PERCENT, getRelayStatus, getDebridgeStatus, fetchDebridgeOrder, fetchRelayQuote, createPhonyDepositCalldata, isSolanaAsset, parseSolanaCaip19, isSolanaNativeToken, isSplToken, N_RELAY_CHAIN_ID_SOLANA, SB58_ADDR_SOL_PROGRAM_SYSTEM, getChainById, } from '@silentswap/sdk';
+import { createSolanaTransactionExecutor, convertRelaySolanaStepToTransaction } from './solana-transaction.js';
+const S0X_ADDR_EVM_ZERO = '0x0000000000000000000000000000000000000000';
+const XG_UINT256_MAX = (1n << 256n) - 1n;
+/**
+ * Get normalized wallet account address from wallet client
+ * This ensures the address matches the account that will send transactions
+ *
+ * Note: This pattern is similar to useTransaction.ts but kept here for bridge-specific needs
+ */
+function getWalletAccountAddress(walletClient) {
+    const walletAccountAddress = walletClient.account?.address;
+    if (!walletAccountAddress) {
+        throw new Error('Wallet account address is required');
+    }
+    return getAddress(walletAccountAddress);
+}
+/**
+ * Ensure chain is active and create public client
+ * Returns both wallet client (after chain switch) and public client
+ *
+ * Note: This follows the same pattern as useTransaction.ts but is optimized for bridge execution
+ * with gas estimation and confirmation waiting built-in
+ */
+async function ensureChainAndCreateClient(chainId, walletClient, connector) {
+    const wallet = await ensureChain(chainId, walletClient, connector);
+    // Use wallet's chain if available, otherwise look up chain by ID
+    const chain = wallet.chain || getChainById(chainId);
+    if (!chain) {
+        throw new Error(`Unsupported chain ID: ${chainId}. Please ensure the chain is supported.`);
+    }
+    // Create public client - viem has complex union types that TypeScript struggles with
+    const publicClient = createPublicClient({
+        chain,
+        transport: http(),
+    });
+    return { wallet, publicClient };
+}
+/**
+ * Estimate and adjust gas fees, using the greater of estimated vs provided fees
+ * This matches Svelte's behavior to ensure sufficient gas fees
+ */
+async function estimateAndAdjustGasFees(publicClient, providedMaxFeePerGas, providedMaxPriorityFeePerGas) {
+    if (providedMaxFeePerGas === undefined && providedMaxPriorityFeePerGas === undefined) {
+        return {};
+    }
+    try {
+        const estimatedFees = await publicClient.estimateFeesPerGas();
+        // Use the greater of estimated fees or provided fees (matching Svelte's bigint_greater)
+        const maxFeePerGas = providedMaxFeePerGas !== undefined && estimatedFees.maxFeePerGas
+            ? estimatedFees.maxFeePerGas > providedMaxFeePerGas
+                ? estimatedFees.maxFeePerGas
+                : providedMaxFeePerGas
+            : estimatedFees.maxFeePerGas || providedMaxFeePerGas;
+        const maxPriorityFeePerGas = providedMaxPriorityFeePerGas !== undefined && estimatedFees.maxPriorityFeePerGas
+            ? estimatedFees.maxPriorityFeePerGas > providedMaxPriorityFeePerGas
+                ? estimatedFees.maxPriorityFeePerGas
+                : providedMaxPriorityFeePerGas
+            : estimatedFees.maxPriorityFeePerGas || providedMaxPriorityFeePerGas;
+        return { maxFeePerGas, maxPriorityFeePerGas };
+    }
+    catch (error) {
+        // If gas estimation fails, use provided fees (or let wallet handle it)
+        console.warn('Failed to estimate gas fees, using provided values:', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return {
+            maxFeePerGas: providedMaxFeePerGas,
+            maxPriorityFeePerGas: providedMaxPriorityFeePerGas,
+        };
+    }
+}
+/**
+ * Send EVM transaction and wait for confirmation
+ * Handles chain switching, gas estimation, and confirmation waiting
+ *
+ * Note: This is more feature-rich than createTransactionExecutor from the SDK
+ * because it includes gas fee estimation and transaction confirmation,
+ * which are essential for bridge execution reliability.
+ *
+ * Similar pattern to useTransaction.ts executeSwapTransaction but optimized
+ * for bridge execution with gas estimation built-in.
+ */
+async function sendTransactionAndWait(walletClient, connector, chainId, transaction, setCurrentStep, onStatus) {
+    setCurrentStep?.('Switching to chain...');
+    onStatus?.('Switching to chain...');
+    const { publicClient } = await ensureChainAndCreateClient(chainId, walletClient, connector);
+    // Convert string gas values to bigint
+    let maxFeePerGas;
+    let maxPriorityFeePerGas;
+    if (transaction.maxFeePerGas) {
+        maxFeePerGas = BigInt(transaction.maxFeePerGas);
+    }
+    if (transaction.maxPriorityFeePerGas) {
+        maxPriorityFeePerGas = BigInt(transaction.maxPriorityFeePerGas);
+    }
+    // Estimate and adjust gas fees if provided
+    if (maxFeePerGas !== undefined || maxPriorityFeePerGas !== undefined) {
+        setCurrentStep?.('Estimating gas...');
+        onStatus?.('Estimating gas...');
+        const adjustedFees = await estimateAndAdjustGasFees(publicClient, maxFeePerGas, maxPriorityFeePerGas);
+        maxFeePerGas = adjustedFees.maxFeePerGas;
+        maxPriorityFeePerGas = adjustedFees.maxPriorityFeePerGas;
+    }
+    setCurrentStep?.('Sending transaction...');
+    onStatus?.('Sending transaction...');
+    const hash = await walletClient.sendTransaction({
+        account: walletClient.account,
+        chain: null,
+        to: transaction.to,
+        value: BigInt(transaction.value || '0'),
+        data: transaction.data,
+        gas: transaction.gas ? BigInt(transaction.gas) : undefined,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+    });
+    setCurrentStep?.('Waiting for confirmation...');
+    onStatus?.('Waiting for confirmation...');
+    const receipt = await waitForTransactionConfirmation(hash, publicClient);
+    if (receipt.status !== 'success') {
+        console.error('Transaction failed:', {
+            hash: receipt.transactionHash,
+            status: receipt.status,
+        });
+        // Note: We return the receipt even if failed, allowing caller to decide whether to throw
+    }
+    return { hash, receipt };
+}
+/**
+ * Get relay.link origin asset parameters from CAIP-19
+ */
+function getRelayOriginAsset(caip19) {
+    if (!isSolanaAsset(caip19)) {
+        throw new Error('Only Solana assets are supported by this helper');
+    }
+    const parsed = parseSolanaCaip19(caip19);
+    if (!parsed) {
+        throw new Error(`Invalid Solana CAIP-19: ${caip19}`);
+    }
+    const originCurrency = isSolanaNativeToken(caip19)
+        ? SB58_ADDR_SOL_PROGRAM_SYSTEM
+        : isSplToken(caip19)
+            ? parsed.tokenAddress ||
+                (() => {
+                    throw new Error(`Missing token address in Solana CAIP-19: ${caip19}`);
+                })()
+            : (() => {
+                throw new Error(`Unsupported Solana asset type: ${caip19}`);
+            })();
+    return {
+        originChainId: N_RELAY_CHAIN_ID_SOLANA,
+        originCurrency,
+    };
+}
+// Depositor ABI for encoding deposit calldata
+const DEPOSITOR_ABI = [
+    {
+        inputs: [
+            {
+                components: [
+                    { internalType: 'address', name: 'signer', type: 'address' },
+                    { internalType: 'bytes32', name: 'orderId', type: 'bytes32' },
+                    { internalType: 'address', name: 'notary', type: 'address' },
+                    { internalType: 'address', name: 'approver', type: 'address' },
+                    { internalType: 'bytes', name: 'orderApproval', type: 'bytes' },
+                    { internalType: 'uint256', name: 'approvalExpiration', type: 'uint256' },
+                    { internalType: 'uint256', name: 'duration', type: 'uint256' },
+                    { internalType: 'bytes32', name: 'domainSepHash', type: 'bytes32' },
+                    { internalType: 'bytes32', name: 'payloadHash', type: 'bytes32' },
+                    { internalType: 'bytes', name: 'typedDataSignature', type: 'bytes' },
+                    { internalType: 'bytes', name: 'receiveAuthorization', type: 'bytes' },
+                ],
+                internalType: 'struct SilentSwapV2Gateway.DepositParams',
+                name: 'params',
+                type: 'tuple',
+            },
+        ],
+        name: 'depositProxy2',
+        outputs: [],
+        stateMutability: 'nonpayable',
+        type: 'function',
+    },
+];
+/**
+ * Hook for executing bridge transactions (Solana → Avalanche or EVM → Avalanche)
+ *
+ * This hook handles the complete bridge execution flow:
+ * - Solving for optimal USDC amount (if not provided)
+ * - Fetching quotes from both relay.link and deBridge
+ * - Selecting the best provider based on rates
+ * - Executing bridge transactions (Solana or EVM)
+ * - Monitoring bridge status until deposit arrives
+ *
+ * Supports both Solana and EVM source chains, automatically selecting
+ * the best bridge provider (relay.link or deBridge) based on rates.
+ *
+ * @param walletClient - Wallet client for EVM transactions
+ * @param connector - Wagmi connector for chain switching
+ * @param solanaConnector - Solana wallet connector (required for Solana swaps)
+ * @param solanaConnection - Solana RPC connection (required for Solana swaps)
+ * @param solanaRpcUrl - Optional Solana RPC URL
+ * @param setCurrentStep - Callback to set current step message
+ * @param onStatus - Optional status update callback
+ * @returns Functions for executing bridge transactions
+ */
+export function useBridgeExecution(walletClient, connector, solanaConnector, solanaConnection, solanaRpcUrl, setCurrentStep, depositorAddress, onStatus) {
+    /**
+     * Execute Solana bridge transaction
+     *
+     * Handles bridge execution for Solana source assets:
+     * 1. Solves for optimal USDC amount (if not provided)
+     * 2. Gets quotes from both relay.link and deBridge
+     * 3. Selects best provider
+     * 4. Executes Solana transactions
+     * 5. Monitors bridge status
+     *
+     * @param sourceAsset - Source asset CAIP-19 (Solana)
+     * @param sourceAmount - Source amount in token units
+     * @param usdcAmount - Optional USDC amount (will be solved if not provided)
+     * @param depositParams - Deposit parameters from order response
+     * @param solanaSenderAddress - Solana sender address (base58)
+     * @param evmSignerAddress - EVM signer address for deposit operations
+     * @returns Promise resolving to bridge execution result
+     */
+    const executeSolanaBridge = useCallback(async (sourceAsset, sourceAmount, usdcAmount, solanaSenderAddress, evmSignerAddress, depositParams) => {
+        try {
+            if (!solanaConnector || !solanaConnection) {
+                throw new Error('Solana connector and connection are required for Solana swaps');
+            }
+            // Get relay origin asset parameters
+            const { originChainId, originCurrency } = getRelayOriginAsset(sourceAsset);
+            // CRITICAL: In Svelte, solve_uusdc_amount is called ONCE before order creation,
+            // and the result (usdcAmount) is used directly in bridge execution.
+            // We should NEVER solve again here - the usdcAmount must be provided
+            // from the initial solve in handleGetQuote (matching Svelte Form.svelte line 2535 and 2576-2584).
+            if (!usdcAmount) {
+                throw new Error('USDC amount is required for Solana bridge execution. ' +
+                    'It should be provided from the initial solveOptimalUsdcAmount call in handleGetQuote. ' +
+                    'This matches Svelte behavior where solve_uusdc_amount is called once before order creation.');
+            }
+            // Use the provided usdcAmount directly (matches Svelte behavior)
+            // In Svelte: zg_amount_src_usdc is used directly without re-solving
+            const bridgeUsdcAmount = usdcAmount;
+            setCurrentStep('Fetching bridge quote');
+            onStatus?.('Fetching bridge quote');
+            // Encode USDC on Avalanche approval calldata (matches Svelte line 896-903)
+            const approveUsdcCalldata = encodeFunctionData({
+                abi: erc20Abi,
+                functionName: 'approve',
+                args: [depositorAddress, XG_UINT256_MAX],
+            });
+            // Encode depositProxy2 calldata from depositParams (matches Svelte line 914-925)
+            // CRITICAL: The signer must match EXACTLY (including checksum) the one used in the SilentSwap quote request
+            // Use getAddress() to ensure checksummed format matches quote request
+            // In Svelte (line 919-922): spreads g_params and only overrides signer, approvalExpiration, and duration
+            // IMPORTANT: The approver is NOT overridden - it comes from the API response (g_params.approver) and is used as-is
+            let depositCalldataForExecution;
+            if (depositParams) {
+                const checksummedSigner = getAddress(evmSignerAddress);
+                const finalDepositParams = {
+                    ...depositParams,
+                    signer: checksummedSigner,
+                    // Convert to BigInt to match Svelte's BigInt() conversion (lines 921-922)
+                    approvalExpiration: typeof depositParams.approvalExpiration === 'bigint'
+                        ? depositParams.approvalExpiration
+                        : BigInt(String(depositParams.approvalExpiration)),
+                    duration: typeof depositParams.duration === 'bigint'
+                        ? depositParams.duration
+                        : BigInt(String(depositParams.duration)),
+                    // NOTE: approver is NOT overridden - it comes from depositParams as-is (matches Svelte line 919)
+                };
+                depositCalldataForExecution = encodeFunctionData({
+                    abi: DEPOSITOR_ABI,
+                    functionName: 'depositProxy2',
+                    args: [finalDepositParams],
+                });
+            }
+            else {
+                // Fallback to phony calldata if depositParams not provided (should not happen in normal flow)
+                console.warn('DepositParams not provided, using phony calldata for bridge quote');
+                depositCalldataForExecution = createPhonyDepositCalldata(evmSignerAddress);
+            }
+            // Request bridge quote for Solana → USDC Avalanche using EXACT_OUTPUT (matches Svelte line 1302-1323)
+            // CRITICAL: For execution, we must use EXACT_OUTPUT with txs parameter, not getBridgeQuote
+            // getBridgeQuote uses EXACT_INPUT and doesn't support txs parameter for execution
+            const relayQuote = await fetchRelayQuote({
+                user: solanaSenderAddress, // Solana address (matches Svelte line 1303: user: sb58_pk_sender)
+                originChainId, // Matches Svelte line 1304: ...relay_origin_asset(k_asset_src)
+                originCurrency, // Matches Svelte line 1304: ...relay_origin_asset(k_asset_src)
+                destinationChainId: NI_CHAIN_ID_AVALANCHE, // Matches Svelte line 1305
+                destinationCurrency: S0X_ADDR_USDC_AVALANCHE, // Matches Svelte line 1306
+                amount: bridgeUsdcAmount, // USDC amount in micro units (EXACT_OUTPUT target) - matches Svelte line 1307
+                recipient: depositorAddress, // EVM depositor address (matches Svelte line 1308: recipient: S0X_ADDR_DEPOSITOR)
+                tradeType: 'EXACT_OUTPUT', // CRITICAL: Must use EXACT_OUTPUT for execution (matches Svelte line 1309)
+                txsGasLimit: 600_000, // Matches Svelte line 1310
+                txs: [
+                    {
+                        to: S0X_ADDR_USDC_AVALANCHE, // Matches Svelte line 1313
+                        value: '0', // Matches Svelte line 1314
+                        data: approveUsdcCalldata, // USDC approval calldata (matches Svelte line 1315)
+                    },
+                    {
+                        to: depositorAddress, // Matches Svelte line 1318: to: S0X_ADDR_DEPOSITOR
+                        value: '0', // Matches Svelte line 1319
+                        data: depositCalldataForExecution, // Deposit calldata (matches Svelte line 1320)
+                    },
+                ],
+            });
+            // Check price impact (matches Svelte line 1343-1348)
+            const impactPercent = Number(relayQuote.details.totalImpact.percent);
+            // TODO: check negative impact
+            if (impactPercent > X_MAX_IMPACT_PERCENT) {
+                throw new Error(`Price impact across bridge too high: ${impactPercent.toFixed(2)}%`);
+            }
+            const rawResponse = relayQuote;
+            const selectedProvider = 'relay';
+            // Create Solana transaction executor
+            const solanaExecutor = createSolanaTransactionExecutor(solanaConnector, solanaConnection);
+            setCurrentStep('Executing bridge transaction');
+            onStatus?.('Executing bridge transaction');
+            // Execute transactions based on selected provider
+            if (selectedProvider === 'relay') {
+                const relayQuote = rawResponse;
+                if (!relayQuote.steps) {
+                    throw new Error('No steps in relay quote response');
+                }
+                // Execute each step from relay.link
+                for (const step of relayQuote.steps) {
+                    if (step.kind !== 'transaction') {
+                        throw new Error(`Unsupported relay step kind: ${step.kind}`);
+                    }
+                    if (step.items.length > 1) {
+                        throw new Error('Multiple items in transaction step not implemented');
+                    }
+                    const item = step.items[0];
+                    const itemData = item.data;
+                    // Solana transaction
+                    if ('instructions' in itemData) {
+                        setCurrentStep(step.id === 'approve'
+                            ? 'Requesting approval...'
+                            : step.id === 'deposit'
+                                ? 'Requesting deposit...'
+                                : 'Requesting bridge...');
+                        onStatus?.(step.id === 'approve'
+                            ? 'Requesting approval...'
+                            : step.id === 'deposit'
+                                ? 'Requesting deposit...'
+                                : 'Requesting bridge...');
+                        // Convert relay step to BridgeTransaction
+                        const solanaTx = convertRelaySolanaStepToTransaction(itemData, solanaSenderAddress, N_RELAY_CHAIN_ID_SOLANA);
+                        // Execute Solana transaction
+                        await solanaExecutor(solanaTx);
+                    }
+                }
+                // Find request ID for status monitoring
+                const requestId = relayQuote.steps.find((s) => s.requestId)?.requestId;
+                if (!requestId) {
+                    throw new Error('Missing relay.link request ID');
+                }
+                // Monitor bridge status
+                const depositTxHash = await monitorRelayBridgeStatus(requestId, setCurrentStep, onStatus);
+                return {
+                    depositTxHash: depositTxHash,
+                    provider: 'relay',
+                };
+            }
+            else if (selectedProvider === 'debridge') {
+                // DeBridge Solana execution not yet fully implemented
+                throw new Error('DeBridge Solana transaction execution not yet fully implemented');
+            }
+            else {
+                throw new Error(`Unsupported bridge provider: ${selectedProvider}`);
+            }
+        }
+        catch (error) {
+            console.error('Solana bridge execution failed:', {
+                sourceAsset,
+                sourceAmount,
+                usdcAmount,
+                solanaSenderAddress,
+                evmSignerAddress,
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            throw error;
+        }
+    }, [solanaConnector, solanaConnection, solanaRpcUrl, setCurrentStep, onStatus, depositorAddress]);
+    /**
+     * Execute EVM bridge transaction
+     *
+     * Handles bridge execution for EVM source assets:
+     * 1. Solves for optimal USDC amount (if not provided)
+     * 2. Gets quotes from both relay.link and deBridge
+     * 3. Selects best provider
+     * 4. Executes EVM transactions
+     * 5. Monitors bridge status
+     *
+     * @param sourceChainId - Source chain ID
+     * @param sourceTokenAddress - Source token address (0x0 for native)
+     * @param sourceAmount - Source amount in token units
+     * @param usdcAmount - Optional USDC amount (will be solved if not provided)
+     * @param depositParams - Deposit parameters from order response
+     * @param evmSignerAddress - EVM signer address (must match quote request signer, used for deposit calldata)
+     * @param provider - Bridge provider to use
+     * @param evmSenderAddress - Optional EVM sender address (used for bridge quotes, defaults to signer address)
+     * @returns Promise resolving to bridge execution result
+     */
+    const executeEvmBridge = useCallback(async (sourceChainId, sourceTokenAddress, sourceAmount, usdcAmount, depositParams, evmSignerAddress, // EVM signer address (must match quote request signer, used for deposit calldata)
+    evmSenderAddress, // Optional EVM sender address (used for bridge quotes, matches Svelte's s0x_sender)
+    provider) => {
+        try {
+            if (!walletClient || !connector) {
+                throw new Error('Wallet client and connector required for EVM bridge execution');
+            }
+            if (!provider) {
+                throw new Error('Provider is required for EVM bridge execution');
+            }
+            // CRITICAL: The user address in bridge quotes MUST match the wallet account address
+            // that will actually send the transaction. This is required for relay.link to properly
+            // route and execute the transaction. In Svelte: s0x_sender matches y_viem.account.address
+            const evmUserForBridge = getWalletAccountAddress(walletClient);
+            // Verify that wallet account matches expected sender/signer (for debugging)
+            // In most cases they should match, but we use wallet account as the source of truth
+            if (evmSenderAddress && getAddress(evmSenderAddress) !== evmUserForBridge) {
+                console.warn(`Wallet account address (${evmUserForBridge}) differs from sender address (${evmSenderAddress}). Using wallet account address.`);
+            }
+            if (getAddress(evmSignerAddress) !== evmUserForBridge) {
+                console.warn(`Wallet account address (${evmUserForBridge}) differs from signer address (${evmSignerAddress}). Using wallet account address for bridge quotes.`);
+            }
+            // Encode USDC on Avalanche approval calldata
+            const approveUsdcCalldata = encodeFunctionData({
+                abi: erc20Abi,
+                functionName: 'approve',
+                args: [depositorAddress, XG_UINT256_MAX],
+            });
+            // Match Svelte implementation exactly: spread g_params, then override signer, approvalExpiration, and duration
+            // CRITICAL: The signer must match EXACTLY (including checksum) the one used in the SilentSwap quote request
+            // Use getAddress() to ensure checksummed format matches quote request (see useQuoteFetching.ts line 327)
+            // In Svelte (line 919-922): spreads g_params and only overrides signer, approvalExpiration, and duration
+            // IMPORTANT: The approver is NOT overridden - it comes from the API response (g_params.approver) and is used as-is
+            const checksummedSigner = getAddress(evmSignerAddress);
+            const finalDepositParams = {
+                ...depositParams,
+                signer: checksummedSigner,
+                // Convert to BigInt to match Svelte's BigInt() conversion (lines 921-922)
+                // These should already be numbers/strings from the API, but ensure BigInt conversion
+                approvalExpiration: typeof depositParams.approvalExpiration === 'bigint'
+                    ? depositParams.approvalExpiration
+                    : BigInt(String(depositParams.approvalExpiration)),
+                duration: typeof depositParams.duration === 'bigint' ? depositParams.duration : BigInt(String(depositParams.duration)),
+                // NOTE: approver is NOT overridden - it comes from depositParams as-is (matches Svelte line 919)
+            };
+            const isSourceNative = sourceTokenAddress === S0X_ADDR_EVM_ZERO;
+            // CRITICAL: In Svelte, solve_uusdc_amount is called ONCE before order creation,
+            // and the result (usdcAmount + provider) is used directly in bridge execution.
+            // We should NEVER solve again here - the usdcAmount and provider must be provided
+            // from the initial solve in handleGetQuote (matching Svelte Form.svelte line 2535 and 2576-2584).
+            if (!usdcAmount) {
+                throw new Error('USDC amount is required for bridge execution. ' +
+                    'It should be provided from the initial solveOptimalUsdcAmount call in handleGetQuote. ' +
+                    'This matches Svelte behavior where solve_uusdc_amount is called once before order creation.');
+            }
+            if (!provider) {
+                throw new Error('Provider is required for bridge execution. ' +
+                    'It should be provided from the initial solveOptimalUsdcAmount call in handleGetQuote. ' +
+                    'This matches Svelte behavior where the provider is selected once during solve_uusdc_amount.');
+            }
+            // Use the provided usdcAmount and provider directly (matches Svelte behavior)
+            // In Svelte: zg_amount_src_usdc and s_source are used directly without re-solving
+            // (see Svelte silentswap.ts lines 990-1012 for relay, 1015-1039 for deBridge)
+            const bridgeUsdcAmount = usdcAmount;
+            const selectedProvider = provider;
+            // Encode depositProxy2 calldata - use the same calldata for both relay and deBridge (matches Svelte)
+            const depositCalldata = encodeFunctionData({
+                abi: DEPOSITOR_ABI,
+                functionName: 'depositProxy2',
+                args: [finalDepositParams],
+            });
+            // Handle bridge execution based on selected provider
+            if (selectedProvider === 'debridge') {
+                // Note: allowanceTarget is not needed here because approval is already handled
+                // in executeSwap before bridge execution (matching Svelte silentswap.ts line 985-986).
+                // DeBridge will provide its own allowanceTarget from the response if needed.
+                return await executeDebridgeBridge(sourceChainId, sourceTokenAddress, isSourceNative, bridgeUsdcAmount, depositCalldata, evmSignerAddress, // Use EVM signer address for deposit calldata
+                '', // allowanceTarget not needed - approval handled before bridge execution
+                depositorAddress, // Pass environment-based depositor address
+                walletClient, connector, setCurrentStep, onStatus);
+            }
+            else if (selectedProvider === 'relay') {
+                return await executeRelayBridge(walletClient, connector, sourceChainId, sourceTokenAddress, isSourceNative, bridgeUsdcAmount, approveUsdcCalldata, depositCalldata, evmUserForBridge, // Use wallet account address for bridge quotes
+                depositorAddress, // Pass environment-based depositor address
+                setCurrentStep, onStatus);
+            }
+            else {
+                throw new Error(`Unsupported bridge provider: ${selectedProvider}`);
+            }
+        }
+        catch (error) {
+            console.error('EVM bridge execution failed:', {
+                sourceChainId,
+                sourceTokenAddress,
+                sourceAmount,
+                usdcAmount,
+                provider,
+                evmSignerAddress,
+                evmSenderAddress,
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            throw error;
+        }
+    }, [walletClient, connector, setCurrentStep, onStatus, depositorAddress]);
+    return {
+        executeSolanaBridge,
+        executeEvmBridge,
+    };
+}
+/**
+ * Execute relay.link bridge transaction for EVM
+ */
+async function executeRelayBridge(walletClient, connector, sourceChainId, sourceTokenAddress, isSourceNative, bridgeUsdcAmount, approveUsdcCalldata, depositCalldata, evmSenderAddress, // Optional EVM sender address (matches Svelte's s0x_sender, used for bridge quotes)
+depositorAddress, // Environment-based depositor address
+setCurrentStep, onStatus) {
+    console.log('executeRelayBridge:', {
+        sourceChainId,
+        sourceTokenAddress,
+        isSourceNative,
+        bridgeUsdcAmount,
+        evmSenderAddress,
+        depositorAddress,
+    });
+    setCurrentStep('Executing bridge transaction');
+    onStatus?.('Executing bridge transaction');
+    // Request relay.link quote (matching Svelte app parameters)
+    // Note: Svelte's create_relay_deposit does NOT include referrer for execution quotes
+    // referrer is only used for estimates/solving, not for actual execution
+    // In Svelte: user: s0x_sender (sender address) - matches line 992 in silentswap.ts
+    // CRITICAL: The user address must match the wallet account address that will send the transaction
+    // This ensures relay.link can properly route and execute the transaction
+    const evmUserForBridge = getWalletAccountAddress(walletClient);
+    const relayQuote = await fetchRelayQuote({
+        user: evmUserForBridge, // Use wallet account address (must match transaction sender)
+        originChainId: sourceChainId,
+        destinationChainId: NI_CHAIN_ID_AVALANCHE,
+        originCurrency: isSourceNative ? S0X_ADDR_EVM_ZERO : sourceTokenAddress,
+        destinationCurrency: S0X_ADDR_USDC_AVALANCHE,
+        amount: bridgeUsdcAmount, // Already a string, no need for BigInt conversion
+        recipient: depositorAddress,
+        tradeType: 'EXACT_OUTPUT',
+        txsGasLimit: 600_000,
+        txs: [
+            {
+                to: S0X_ADDR_USDC_AVALANCHE,
+                value: '0',
+                data: approveUsdcCalldata,
+            },
+            {
+                to: depositorAddress,
+                value: '0',
+                data: depositCalldata,
+            },
+        ],
+    });
+    // Check price impact
+    const impactPercent = Number(relayQuote.details.totalImpact.percent);
+    // TODO: check negative impact
+    if (impactPercent > X_MAX_IMPACT_PERCENT) {
+        throw new Error(`Price impact across bridge too high: ${impactPercent.toFixed(2)}%`);
+    }
+    // Execute each step from relay.link
+    if (!relayQuote.steps) {
+        throw new Error('No steps in relay quote response');
+    }
+    for (const step of relayQuote.steps) {
+        if (step.kind !== 'transaction') {
+            throw new Error(`Unsupported relay step kind: ${step.kind}`);
+        }
+        if (step.items.length > 1) {
+            throw new Error('Multiple items in transaction step not implemented');
+        }
+        const item = step.items[0];
+        const itemData = item.data;
+        // EVM transaction
+        if ('chainId' in itemData && typeof itemData.chainId === 'number') {
+            const stepMessage = step.id === 'approve'
+                ? 'Requesting approval...'
+                : step.id === 'deposit'
+                    ? 'Requesting deposit...'
+                    : 'Requesting bridge...';
+            setCurrentStep(stepMessage);
+            onStatus?.(stepMessage);
+            console.log('Sending EVM transaction:', {
+                stepId: step.id,
+                chainId: itemData.chainId,
+                to: itemData.to,
+                value: itemData.value,
+                gas: itemData.gas,
+            });
+            const { hash, receipt } = await sendTransactionAndWait(walletClient, connector, itemData.chainId, {
+                to: itemData.to,
+                value: itemData.value || '0',
+                data: itemData.data,
+                gas: itemData.gas,
+                maxFeePerGas: itemData.maxFeePerGas,
+                maxPriorityFeePerGas: itemData.maxPriorityFeePerGas,
+            }, setCurrentStep, onStatus);
+            if (receipt.status === 'success') {
+                console.log('Transaction confirmed:', { stepId: step.id, hash: receipt.transactionHash });
+            }
+            else {
+                // Transaction confirmation failed or timed out, but transaction may still be pending
+                // Log warning and continue - status monitoring will check if it succeeded
+                console.warn('Transaction confirmation failed or timed out, proceeding to status checks:', {
+                    stepId: step.id,
+                    hash: receipt.transactionHash,
+                    status: receipt.status,
+                });
+            }
+        }
+    }
+    // Find request ID for status monitoring
+    const requestId = relayQuote.steps.find((s) => s.requestId)?.requestId;
+    if (!requestId) {
+        throw new Error('Missing relay.link request ID');
+    }
+    // Monitor bridge status
+    const depositTxHash = await monitorRelayBridgeStatus(requestId, setCurrentStep, onStatus);
+    return {
+        depositTxHash: depositTxHash,
+        provider: 'relay',
+    };
+}
+/**
+ * Execute deBridge bridge transaction for EVM
+ */
+async function executeDebridgeBridge(sourceChainId, sourceTokenAddress, isSourceNative, bridgeUsdcAmount, depositCalldata, evmSignerAddress, // EVM signer address (matches Svelte's s0x_signer, used for deposit calldata)
+allowanceTarget, depositorAddress, // Environment-based depositor address
+walletClient, connector, setCurrentStep, onStatus) {
+    setCurrentStep('Fetching bridge quote');
+    onStatus?.('Fetching bridge quote...');
+    // Request deBridge quote
+    let debridgeQuote;
+    let debridgeResponse;
+    let debridgeTx;
+    let retryCount = 0;
+    const maxRetries = 2;
+    // CRITICAL: The account address must match the wallet account address that will send the transaction
+    // In Svelte: s0x_sender is used for bridge quotes (line 1020), s0x_signer is used for deposit calldata
+    // For deBridge, we need to use the wallet account address, not the extracted sender address
+    // This ensures the transaction can be properly executed by the connected wallet
+    const evmUserForBridge = getWalletAccountAddress(walletClient);
+    while (retryCount < maxRetries) {
+        debridgeQuote = await fetchDebridgeOrder({
+            account: evmUserForBridge, // Use wallet account address (must match transaction sender)
+            srcChainId: sourceChainId,
+            dstChainId: NI_CHAIN_ID_AVALANCHE,
+            srcChainTokenIn: isSourceNative ? S0X_ADDR_EVM_ZERO : sourceTokenAddress,
+            dstChainTokenOut: S0X_ADDR_USDC_AVALANCHE,
+            srcChainTokenInAmount: 'auto',
+            dstChainTokenOutAmount: `${BigInt(bridgeUsdcAmount)}`,
+            dstChainTokenOutRecipient: depositorAddress,
+            prependOperatingExpenses: true,
+            enableEstimate: true,
+            srcChainOrderAuthorityAddress: evmUserForBridge, // Use wallet account address (must match transaction sender)
+            srcChainRefundAddress: evmUserForBridge, // Use wallet account address (must match transaction sender)
+            dstChainOrderAuthorityAddress: evmUserForBridge, // Use wallet account address (must match transaction sender)
+            dlnHook: JSON.stringify({
+                type: 'evm_transaction_call',
+                data: {
+                    to: depositorAddress,
+                    calldata: depositCalldata,
+                    gas: 500_000,
+                },
+            }),
+        });
+        debridgeTx = debridgeQuote.tx;
+        debridgeResponse = debridgeQuote;
+        // Check if approval is needed
+        const targetAllowance = debridgeTx.allowanceTarget || allowanceTarget;
+        if (targetAllowance && !isSourceNative) {
+            const allowanceValue = debridgeTx.allowanceValue;
+            if (!allowanceValue) {
+                throw new Error('DeBridge response missing allowance value');
+            }
+            setCurrentStep('Approving token spending');
+            onStatus?.('Approving token spending');
+            // Switch to source chain for approval
+            const { publicClient } = await ensureChainAndCreateClient(sourceChainId, walletClient, connector);
+            const currentAllowance = (await publicClient.readContract({
+                address: sourceTokenAddress,
+                abi: erc20Abi,
+                functionName: 'allowance',
+                args: [evmSignerAddress, targetAllowance],
+            }));
+            // Approve if needed
+            if (currentAllowance < BigInt(allowanceValue)) {
+                const hash = await walletClient.writeContract({
+                    address: sourceTokenAddress,
+                    abi: erc20Abi,
+                    functionName: 'approve',
+                    args: [targetAllowance, BigInt(allowanceValue)],
+                    account: walletClient.account,
+                    chain: null,
+                });
+                await waitForTransactionConfirmation(hash, publicClient);
+            }
+            retryCount++;
+            continue;
+        }
+        // Check price impact
+        const impactPercent = (100 * (debridgeQuote.usdPriceImpact ?? 0)) / (debridgeQuote.estimation.srcChainTokenIn.approximateUsdValue || 1);
+        // TODO: check negative impact
+        if (impactPercent > X_MAX_IMPACT_PERCENT) {
+            throw new Error(`Price impact across bridge too high: ${impactPercent.toFixed(2)}%`);
+        }
+        break;
+    }
+    if (!debridgeQuote) {
+        throw new Error('Failed to get deBridge quote after approvals');
+    }
+    setCurrentStep('Switching to source chain');
+    onStatus?.('Switching to source chain');
+    setCurrentStep('Sending bridge transaction');
+    onStatus?.('Sending bridge transaction');
+    // Send deBridge transaction
+    console.log('Sending deBridge transaction:', {
+        to: debridgeQuote.tx.to,
+        value: debridgeQuote.tx.value,
+        sourceChainId,
+    });
+    const { hash: debridgeHash, receipt } = await sendTransactionAndWait(walletClient, connector, sourceChainId, {
+        to: debridgeQuote.tx.to,
+        value: debridgeQuote.tx.value || '0',
+        data: debridgeQuote.tx.data,
+    }, setCurrentStep, onStatus);
+    if (receipt.status !== 'success') {
+        throw new Error(`DeBridge transaction failed: ${receipt.transactionHash}`);
+    }
+    console.log('DeBridge transaction confirmed:', { hash: receipt.transactionHash });
+    setCurrentStep('Waiting for bridge');
+    onStatus?.('Waiting for bridge');
+    // Monitor deBridge status
+    const debridgeOrderId = debridgeResponse.orderId;
+    if (!debridgeOrderId) {
+        throw new Error('Missing deBridge order ID');
+    }
+    // Poll for deBridge status with exponential backoff
+    let depositTxHash;
+    const startTime = Date.now();
+    const timeout = 10 * 60 * 1000; // 10 minutes (bridges can take several minutes)
+    let pollInterval = 2_000; // Start with 2 seconds
+    const maxPollInterval = 10_000; // Max 10 seconds between polls
+    let attemptCount = 0;
+    while (Date.now() - startTime < timeout) {
+        attemptCount++;
+        try {
+            const status = await getDebridgeStatus(debridgeOrderId);
+            if (status.status === 'success') {
+                depositTxHash = status.txHashes?.[0] || '0x';
+                break;
+            }
+            else if (status.status === 'failed' || status.status === 'refund') {
+                throw new Error(`DeBridge transaction failed: ${status.details || 'Unknown error'}`);
+            }
+        }
+        catch (error) {
+            // If error is thrown from status check, re-throw it
+            if (error instanceof Error && error.message.includes('DeBridge transaction failed')) {
+                throw error;
+            }
+            // Otherwise log and continue polling
+            console.error('Failed to fetch deBridge status:', {
+                debridgeOrderId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        // Update status message with elapsed time
+        const elapsedSeconds = Math.floor((Date.now() - startTime) / 1000);
+        setCurrentStep(`Waiting for bridge (${elapsedSeconds}s)...`);
+        onStatus?.(`Waiting for bridge (${elapsedSeconds}s)...`);
+        // Exponential backoff: increase interval after every 3 attempts
+        if (attemptCount % 3 === 0) {
+            pollInterval = Math.min(pollInterval * 1.5, maxPollInterval);
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    if (!depositTxHash) {
+        throw new Error('DeBridge transaction timed out after 10 minutes');
+    }
+    return {
+        depositTxHash: depositTxHash,
+        provider: 'debridge',
+    };
+}
+/**
+ * Monitor relay.link bridge status until deposit arrives
+ * With exponential backoff and timeout
+ */
+async function monitorRelayBridgeStatus(requestId, setCurrentStep, onStatus) {
+    console.log('Starting relay.link bridge status monitoring:', { requestId });
+    setCurrentStep('Waiting for bridge');
+    onStatus?.('Waiting for bridge');
+    let depositTxHash;
+    let bridgeStatus;
+    const startTime = Date.now();
+    const timeout = 10 * 60 * 1000; // 10 minutes (bridges can take several minutes)
+    let pollInterval = 2_000; // Start with 2 seconds
+    const maxPollInterval = 10_000; // Max 10 seconds between polls
+    let attemptCount = 0;
+    // Poll for bridge status with timeout
+    while (Date.now() - startTime < timeout) {
+        attemptCount++;
+        try {
+            bridgeStatus = await getRelayStatus(requestId);
+        }
+        catch (error) {
+            // If status check fails, log and retry with backoff
+            console.warn('Failed to get relay status, retrying...', error);
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+            continue;
+        }
+        const elapsedSeconds = Math.floor((Date.now() - startTime) / 1000);
+        switch (bridgeStatus.status) {
+            case 'success': {
+                depositTxHash = bridgeStatus.txHashes?.[0] || '0x';
+                break;
+            }
+            case 'failed': {
+                throw new Error(`Bridge tx failed: ${bridgeStatus.details || 'Unknown error'}`);
+            }
+            case 'refund': {
+                throw new Error('Bridge tx refunded due to an error');
+            }
+            case 'fallback': {
+                throw new Error('Bridge tx is refunding due to a fallback');
+            }
+            case 'delayed': {
+                setCurrentStep(`Bridge delayed (${elapsedSeconds}s)...`);
+                onStatus?.(`Bridge delayed (${elapsedSeconds}s)...`);
+                await new Promise((resolve) => setTimeout(resolve, pollInterval));
+                continue;
+            }
+            case 'received': {
+                setCurrentStep(`Bridge received (${elapsedSeconds}s)...`);
+                onStatus?.(`Bridge received (${elapsedSeconds}s)...`);
+                await new Promise((resolve) => setTimeout(resolve, pollInterval));
+                continue;
+            }
+            case 'pending':
+            case 'unknown':
+            default: {
+                setCurrentStep(`Waiting for bridge (${elapsedSeconds}s)...`);
+                onStatus?.(`Waiting for bridge (${elapsedSeconds}s)...`);
+                await new Promise((resolve) => setTimeout(resolve, pollInterval));
+                continue;
+            }
+        }
+        // If we got here with success status, break
+        if (bridgeStatus.status === 'success') {
+            break;
+        }
+        // Exponential backoff: increase interval after every 3 attempts
+        if (attemptCount % 3 === 0) {
+            pollInterval = Math.min(pollInterval * 1.5, maxPollInterval);
+        }
+    }
+    // Check if we timed out
+    if (!depositTxHash && Date.now() - startTime >= timeout) {
+        throw new Error('Bridge transaction timed out after 10 minutes');
+    }
+    if (!depositTxHash) {
+        throw new Error('Failed to get deposit transaction hash');
+    }
+    return depositTxHash;
+}