@silentswap/react 0.1.49 → 0.1.51

package/dist/hooks/silent/useBridgeExecution.js

@@ -1,10 +1,9 @@
 import { useCallback } from 'react';
 import { encodeFunctionData, erc20Abi, getAddress } from 'viem';
-import { ensureChain, waitForTransactionConfirmation, createPublicClientWithRpc, NI_CHAIN_ID_AVALANCHE, S0X_ADDR_USDC_AVALANCHE, X_MAX_IMPACT_PERCENT, getRelayStatus, getDebridgeStatus, fetchDebridgeOrder, fetchRelayQuote, createPhonyDepositCalldata, isSolanaAsset, isBitcoinAsset, parseSolanaCaip19, isSolanaNativeToken, isSplToken, N_RELAY_CHAIN_ID_SOLANA, N_RELAY_CHAIN_ID_BITCOIN, SB58_ADDR_SOL_PROGRAM_SYSTEM, getChainById, SBTC_ADDR_BITCOIN_NATIVE, } from '@silentswap/sdk';
+import { ensureChain, waitForTransactionConfirmation, createPublicClientWithRpc, NI_CHAIN_ID_AVALANCHE, S0X_ADDR_USDC_AVALANCHE, S0X_ADDR_EVM_ZERO, UINT256_MAX, X_MAX_IMPACT_PERCENT, getRelayStatus, getDebridgeStatus, fetchDebridgeOrder, fetchRelayQuote, createPhonyDepositCalldata, isSolanaAsset, isBitcoinAsset, isTronAsset, parseSolanaCaip19, isSolanaNativeToken, isSplToken, N_RELAY_CHAIN_ID_SOLANA, N_RELAY_CHAIN_ID_BITCOIN, N_RELAY_CHAIN_ID_TRON, N_DEBRIDGE_CHAIN_ID_SOLANA, N_DEBRIDGE_CHAIN_ID_TRON, SB58_ADDR_SOL_PROGRAM_SYSTEM, getChainById, SBTC_ADDR_BITCOIN_NATIVE, S0X_ADDR_TRON_NATIVE, } from '@silentswap/sdk';
 import { createSolanaTransactionExecutor, convertRelaySolanaStepToTransaction } from './solana-transaction.js';
 import { createBitcoinTransactionExecutor, convertRelayBitcoinStepToTransaction } from './bitcoin-transaction.js';
-const S0X_ADDR_EVM_ZERO = '0x0000000000000000000000000000000000000000';
-const XG_UINT256_MAX = (1n << 256n) - 1n;
+import { createTronTransactionExecutor, convertRelayTronStepToTransaction, isRelayTronStepData } from './tron-transaction.js';
 /** Delay after approve tx so RPC/nodes confirm before next tx (avoids MetaMask RPC errors) */
 export const APPROVE_POST_DELAY_MS = 7000;
 /**
@@ -160,6 +159,15 @@ function getRelayOriginAssetFromCaip19(caip19) {
             originCurrency: SBTC_ADDR_BITCOIN_NATIVE, // Bitcoin native token (BTC) - relay.link requires this specific address
         };
     }
+    if (isTronAsset(caip19)) {
+        // Tron CAIP-19: native = tron:chainRef/slip44:195, TRC-20 = tron:chainRef/trc20:ADDRESS
+        const trc20Match = /^tron:[^/]+\/(?:trc20|token):([A-Za-z0-9]+)$/i.exec(caip19);
+        const originCurrency = trc20Match ? trc20Match[1] : S0X_ADDR_TRON_NATIVE;
+        return {
+            originChainId: N_RELAY_CHAIN_ID_TRON,
+            originCurrency,
+        };
+    }
     throw new Error(`Unsupported asset type: ${caip19}`);
 }
 // Depositor ABI for encoding deposit calldata
@@ -211,11 +219,13 @@ const DEPOSITOR_ABI = [
  * @param solanaRpcUrl - Optional Solana RPC URL
  * @param bitcoinConnector - Bitcoin wallet connector (required for Bitcoin swaps)
  * @param bitcoinConnection - Bitcoin connection (optional, for consistency)
+ * @param tronConnector - Tron wallet connector (required for Tron swaps)
+ * @param tronConnection - Tron connection (optional, for consistency)
  * @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, bitcoinConnector, bitcoinConnection) {
+export function useBridgeExecution(walletClient, connector, solanaConnector, solanaConnection, solanaRpcUrl, setCurrentStep, depositorAddress, onStatus, bitcoinConnector, bitcoinConnection, tronConnector, tronConnection) {
     /**
      * Execute Solana bridge transaction
      *
@@ -234,11 +244,13 @@ export function useBridgeExecution(walletClient, connector, solanaConnector, sol
      * @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) => {
+    const executeSolanaBridge = useCallback(async (sourceAsset, sourceAmount, usdcAmount, solanaSenderAddress, evmSignerAddress, options) => {
         try {
             if (!solanaConnector || !solanaConnection) {
                 throw new Error('Solana connector and connection are required for Solana swaps');
             }
+            const depositParams = options?.depositParams;
+            const provider = options?.provider;
             // Get relay origin asset parameters
             const { originChainId, originCurrency } = getRelayOriginAssetFromCaip19(sourceAsset);
             console.log('[SilentSwap:SolanaBridge] Start', {
@@ -264,7 +276,7 @@ export function useBridgeExecution(walletClient, connector, solanaConnector, sol
             const approveUsdcCalldata = encodeFunctionData({
                 abi: erc20Abi,
                 functionName: 'approve',
-                args: [depositorAddress, XG_UINT256_MAX],
+                args: [depositorAddress, 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
@@ -297,61 +309,71 @@ export function useBridgeExecution(walletClient, connector, solanaConnector, sol
                 console.warn('DepositParams not provided, using phony calldata for bridge quote');
                 depositCalldataForExecution = createPhonyDepositCalldata(evmSignerAddress);
             }
-            const relayQuoteRequest = {
-                user: solanaSenderAddress,
-                originChainId,
-                originCurrency,
-                destinationChainId: NI_CHAIN_ID_AVALANCHE,
-                destinationCurrency: S0X_ADDR_USDC_AVALANCHE,
-                amount: bridgeUsdcAmount,
-                recipient: depositorAddress,
-                tradeType: 'EXACT_OUTPUT',
-                txsGasLimit: 600_000,
-                txs: [
-                    {
-                        to: S0X_ADDR_USDC_AVALANCHE,
-                        value: '0',
-                        data: approveUsdcCalldata,
-                    },
-                    {
-                        to: depositorAddress,
-                        value: '0',
-                        data: depositCalldataForExecution,
-                    },
-                ],
-            };
-            console.log('[SilentSwap:SolanaBridge] Relay quote request (EXACT_OUTPUT)', {
-                user: relayQuoteRequest.user,
-                originChainId: relayQuoteRequest.originChainId,
-                originCurrency: relayQuoteRequest.originCurrency,
-                destinationChainId: relayQuoteRequest.destinationChainId,
-                amount: relayQuoteRequest.amount,
-                recipient: relayQuoteRequest.recipient,
-                tradeType: relayQuoteRequest.tradeType,
-                txsCount: relayQuoteRequest.txs.length,
-                depositCalldataLength: depositCalldataForExecution.length,
-            });
-            const relayQuote = await fetchRelayQuote(relayQuoteRequest);
-            console.log('[SilentSwap:SolanaBridge] Relay quote response', {
-                currencyIn: relayQuote.details?.currencyIn ? {
-                    amount: relayQuote.details.currencyIn.amount,
-                    amountUsd: relayQuote.details.currencyIn.amountUsd,
-                } : 'N/A',
-                currencyOut: relayQuote.details?.currencyOut ? {
-                    amount: relayQuote.details.currencyOut.amount,
-                    amountUsd: relayQuote.details.currencyOut.amountUsd,
-                } : 'N/A',
-                totalImpact: relayQuote.details?.totalImpact,
-                stepsCount: relayQuote.steps?.length,
-                stepIds: relayQuote.steps?.map((s) => s.id),
-            });
-            // Check price impact
-            const impactPercent = Number(relayQuote.details.totalImpact.percent);
-            if (impactPercent > X_MAX_IMPACT_PERCENT) {
-                throw new Error(`Price impact across bridge too high: ${impactPercent.toFixed(2)}%`);
+            const selectedProvider = provider === 'debridge' ? 'debridge' : 'relay';
+            let rawResponse;
+            if (selectedProvider === 'debridge') {
+                const debridgeQuote = await fetchDebridgeOrder({
+                    srcChainId: N_DEBRIDGE_CHAIN_ID_SOLANA,
+                    srcChainTokenIn: originCurrency,
+                    srcChainTokenInAmount: 'auto',
+                    dstChainId: NI_CHAIN_ID_AVALANCHE,
+                    dstChainTokenOut: S0X_ADDR_USDC_AVALANCHE,
+                    dstChainTokenOutAmount: `${BigInt(bridgeUsdcAmount)}`,
+                    dstChainTokenOutRecipient: depositorAddress,
+                    prependOperatingExpenses: true,
+                    additionalTakerRewardBps: 0,
+                    account: solanaSenderAddress,
+                    srcChainOrderAuthorityAddress: solanaSenderAddress,
+                    srcChainRefundAddress: solanaSenderAddress,
+                    dstChainOrderAuthorityAddress: depositorAddress,
+                    dlnHook: JSON.stringify({
+                        type: 'evm_transaction_call',
+                        data: {
+                            to: depositorAddress,
+                            calldata: depositCalldataForExecution,
+                            gas: 500_000,
+                        },
+                    }),
+                });
+                const usdIn = debridgeQuote.estimation?.srcChainTokenIn?.approximateUsdValue || 0;
+                const usdOut = debridgeQuote.estimation?.dstChainTokenOut?.approximateUsdValue || 0;
+                const impactPercent = usdIn > 0 ? 100 * (1 - usdOut / usdIn) : 0;
+                if (impactPercent > X_MAX_IMPACT_PERCENT) {
+                    throw new Error(`Price impact across bridge too high: ${impactPercent.toFixed(2)}%`);
+                }
+                rawResponse = debridgeQuote;
+            }
+            else {
+                const relayQuoteRequest = {
+                    user: solanaSenderAddress,
+                    originChainId,
+                    originCurrency,
+                    destinationChainId: NI_CHAIN_ID_AVALANCHE,
+                    destinationCurrency: S0X_ADDR_USDC_AVALANCHE,
+                    amount: bridgeUsdcAmount,
+                    recipient: depositorAddress,
+                    tradeType: 'EXACT_OUTPUT',
+                    txsGasLimit: 600_000,
+                    txs: [
+                        {
+                            to: S0X_ADDR_USDC_AVALANCHE,
+                            value: '0',
+                            data: approveUsdcCalldata,
+                        },
+                        {
+                            to: depositorAddress,
+                            value: '0',
+                            data: depositCalldataForExecution,
+                        },
+                    ],
+                };
+                const relayQuote = await fetchRelayQuote(relayQuoteRequest);
+                const impactPercent = Number(relayQuote.details.totalImpact.percent);
+                if (impactPercent > X_MAX_IMPACT_PERCENT) {
+                    throw new Error(`Price impact across bridge too high: ${impactPercent.toFixed(2)}%`);
+                }
+                rawResponse = relayQuote;
             }
-            const rawResponse = relayQuote;
-            const selectedProvider = 'relay';
             // Create Solana transaction executor
             const solanaExecutor = createSolanaTransactionExecutor(solanaConnector, solanaConnection);
             setCurrentStep('Executing bridge transaction');
@@ -424,8 +446,21 @@ export function useBridgeExecution(walletClient, connector, solanaConnector, sol
                 };
             }
             else if (selectedProvider === 'debridge') {
-                // DeBridge Solana execution not yet fully implemented
-                throw new Error('DeBridge Solana transaction execution not yet fully implemented');
+                const debridgeQuote = rawResponse;
+                if (!debridgeQuote.tx?.data) {
+                    throw new Error('No Solana transaction data in deBridge response');
+                }
+                setCurrentStep('Requesting bridge...');
+                onStatus?.('Requesting bridge...');
+                await solanaExecutor({
+                    chainId: N_DEBRIDGE_CHAIN_ID_SOLANA,
+                    data: debridgeQuote.tx.data,
+                });
+                const debridgeOrderId = debridgeQuote?.order?.orderId;
+                if (!debridgeOrderId) {
+                    throw new Error('Missing deBridge order ID');
+                }
+                return await monitorDebridgeBridgeStatus(debridgeOrderId, setCurrentStep, onStatus);
             }
             else {
                 throw new Error(`Unsupported bridge provider: ${selectedProvider}`);
@@ -485,7 +520,7 @@ export function useBridgeExecution(walletClient, connector, solanaConnector, sol
             const approveUsdcCalldata = encodeFunctionData({
                 abi: erc20Abi,
                 functionName: 'approve',
-                args: [depositorAddress, XG_UINT256_MAX],
+                args: [depositorAddress, UINT256_MAX],
             });
             // Encode depositProxy2 calldata from depositParams
             let depositCalldataForExecution;
@@ -609,6 +644,195 @@ export function useBridgeExecution(walletClient, connector, solanaConnector, sol
             throw error;
         }
     }, [bitcoinConnector, bitcoinConnection, setCurrentStep, onStatus, depositorAddress]);
+    /**
+     * Execute Tron bridge transaction
+     *
+     * Handles bridge execution for Tron source assets:
+     * 1. Solves for optimal USDC amount (if not provided)
+     * 2. Gets quotes from relay.link or deBridge
+     * 3. Executes Tron transactions (EVM-style to/value/data)
+     * 4. Monitors bridge status
+     */
+    const executeTronBridge = useCallback(async (sourceAsset, sourceAmount, usdcAmount, tronSenderAddress, evmSignerAddress, options) => {
+        try {
+            if (!tronConnector) {
+                throw new Error('Tron connector required for Tron swaps');
+            }
+            const depositParams = options?.depositParams;
+            const provider = options?.provider;
+            const { originChainId, originCurrency } = getRelayOriginAssetFromCaip19(sourceAsset);
+            if (!usdcAmount) {
+                throw new Error('USDC amount is required for Tron bridge execution. ' +
+                    'It should be provided from the initial solveOptimalUsdcAmount call in handleGetQuote.');
+            }
+            const bridgeUsdcAmount = usdcAmount;
+            setCurrentStep('Fetching bridge quote');
+            onStatus?.('Fetching bridge quote');
+            const approveUsdcCalldata = encodeFunctionData({
+                abi: erc20Abi,
+                functionName: 'approve',
+                args: [depositorAddress, UINT256_MAX],
+            });
+            let depositCalldataForExecution;
+            if (depositParams) {
+                const checksummedSigner = getAddress(evmSignerAddress);
+                const finalDepositParams = {
+                    ...depositParams,
+                    signer: checksummedSigner,
+                    approvalExpiration: typeof depositParams.approvalExpiration === 'bigint'
+                        ? depositParams.approvalExpiration
+                        : BigInt(String(depositParams.approvalExpiration)),
+                    duration: typeof depositParams.duration === 'bigint'
+                        ? depositParams.duration
+                        : BigInt(String(depositParams.duration)),
+                };
+                depositCalldataForExecution = encodeFunctionData({
+                    abi: DEPOSITOR_ABI,
+                    functionName: 'depositProxy2',
+                    args: [finalDepositParams],
+                });
+            }
+            else {
+                depositCalldataForExecution = createPhonyDepositCalldata(evmSignerAddress);
+            }
+            const selectedProvider = provider;
+            let rawResponse;
+            if (selectedProvider === 'debridge') {
+                const debridgeQuote = await fetchDebridgeOrder({
+                    srcChainId: N_DEBRIDGE_CHAIN_ID_TRON,
+                    srcChainTokenIn: originCurrency,
+                    srcChainTokenInAmount: 'auto',
+                    dstChainId: NI_CHAIN_ID_AVALANCHE,
+                    dstChainTokenOut: S0X_ADDR_USDC_AVALANCHE,
+                    dstChainTokenOutAmount: `${BigInt(bridgeUsdcAmount)}`,
+                    dstChainTokenOutRecipient: depositorAddress,
+                    prependOperatingExpenses: true,
+                    additionalTakerRewardBps: 0,
+                    account: tronSenderAddress,
+                    srcChainOrderAuthorityAddress: tronSenderAddress,
+                    srcChainRefundAddress: tronSenderAddress,
+                    dstChainOrderAuthorityAddress: depositorAddress,
+                    enableEstimate: false,
+                    dlnHook: JSON.stringify({
+                        type: 'evm_transaction_call',
+                        data: {
+                            to: depositorAddress,
+                            calldata: depositCalldataForExecution,
+                            gas: 500_000,
+                        },
+                    }),
+                });
+                const usdIn = debridgeQuote.estimation?.srcChainTokenIn?.approximateUsdValue || 0;
+                const usdOut = debridgeQuote.estimation?.dstChainTokenOut?.approximateUsdValue || 0;
+                const impactPercent = usdIn > 0 ? 100 * (1 - usdOut / usdIn) : 0;
+                if (impactPercent > X_MAX_IMPACT_PERCENT) {
+                    throw new Error(`Price impact across bridge too high: ${impactPercent.toFixed(2)}%`);
+                }
+                rawResponse = debridgeQuote;
+            }
+            else {
+                const relayQuote = await fetchRelayQuote({
+                    user: tronSenderAddress,
+                    originChainId,
+                    originCurrency,
+                    destinationChainId: NI_CHAIN_ID_AVALANCHE,
+                    destinationCurrency: S0X_ADDR_USDC_AVALANCHE,
+                    amount: bridgeUsdcAmount,
+                    recipient: depositorAddress,
+                    tradeType: 'EXACT_OUTPUT',
+                    txsGasLimit: 600_000,
+                    txs: [
+                        { to: S0X_ADDR_USDC_AVALANCHE, value: '0', data: approveUsdcCalldata },
+                        { to: depositorAddress, value: '0', data: depositCalldataForExecution },
+                    ],
+                });
+                const impactPercent = Number(relayQuote.details.totalImpact.percent);
+                if (impactPercent > X_MAX_IMPACT_PERCENT) {
+                    throw new Error(`Price impact across bridge too high: ${impactPercent.toFixed(2)}%`);
+                }
+                rawResponse = relayQuote;
+            }
+            const tronExecutor = createTronTransactionExecutor(tronConnector, tronConnection);
+            setCurrentStep('Executing bridge transaction');
+            onStatus?.('Executing bridge transaction');
+            if (selectedProvider === 'relay') {
+                const relayQuoteTyped = rawResponse;
+                if (!relayQuoteTyped.steps) {
+                    throw new Error('No steps in relay quote response');
+                }
+                for (const step of relayQuoteTyped.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;
+                    // Relay returns Tron steps as nested TriggerSmartContract payloads
+                    // (no top-level chainId), so we discriminate by shape. Non-Tron
+                    // steps in a Tron bridge response are unexpected — throw instead
+                    // of silently skipping so failures surface loudly.
+                    if (!isRelayTronStepData(itemData)) {
+                        throw new Error(`Unexpected relay step data in Tron bridge flow (step id: ${step.id}). ` +
+                            `Expected TriggerSmartContract payload with 'parameter' field.`);
+                    }
+                    const label = step.id === 'approve'
+                        ? 'Requesting approval...'
+                        : step.id === 'deposit'
+                            ? 'Requesting deposit...'
+                            : 'Requesting bridge...';
+                    setCurrentStep(label);
+                    onStatus?.(label);
+                    const tronTx = convertRelayTronStepToTransaction(itemData, N_RELAY_CHAIN_ID_TRON);
+                    await tronExecutor(tronTx);
+                }
+                const requestId = relayQuoteTyped.steps.find((s) => s.requestId)?.requestId;
+                if (!requestId) {
+                    throw new Error('Missing relay.link request ID');
+                }
+                const depositTxHash = await monitorRelayBridgeStatus(requestId, setCurrentStep, onStatus);
+                return {
+                    depositTxHash: depositTxHash,
+                    provider: 'relay',
+                };
+            }
+            else {
+                // DeBridge execution for Tron
+                const debridgeQuote = rawResponse;
+                const debridgeTx = debridgeQuote.tx;
+                if (!debridgeTx) {
+                    throw new Error('No transaction in DeBridge order response');
+                }
+                setCurrentStep('Requesting bridge...');
+                onStatus?.('Requesting bridge...');
+                const tronTx = convertRelayTronStepToTransaction({
+                    to: debridgeTx.to,
+                    value: debridgeTx.value || '0',
+                    data: debridgeTx.data,
+                    chainId: N_RELAY_CHAIN_ID_TRON,
+                }, N_RELAY_CHAIN_ID_TRON);
+                await tronExecutor(tronTx);
+                const orderId = debridgeQuote.orderId;
+                if (!orderId) {
+                    throw new Error('Missing DeBridge order ID');
+                }
+                return await monitorDebridgeBridgeStatus(orderId, setCurrentStep, onStatus);
+            }
+        }
+        catch (error) {
+            console.error('Tron bridge execution failed:', {
+                sourceAsset,
+                sourceAmount,
+                usdcAmount,
+                tronSenderAddress,
+                evmSignerAddress,
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            throw error;
+        }
+    }, [tronConnector, tronConnection, setCurrentStep, onStatus, depositorAddress]);
     /**
      * Execute EVM bridge transaction
      *
@@ -655,7 +879,7 @@ export function useBridgeExecution(walletClient, connector, solanaConnector, sol
             const approveUsdcCalldata = encodeFunctionData({
                 abi: erc20Abi,
                 functionName: 'approve',
-                args: [depositorAddress, XG_UINT256_MAX],
+                args: [depositorAddress, 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
@@ -751,6 +975,7 @@ export function useBridgeExecution(walletClient, connector, solanaConnector, sol
     return {
         executeSolanaBridge,
         executeBitcoinBridge,
+        executeTronBridge,
         executeEvmBridge,
     };
 }
@@ -952,7 +1177,7 @@ walletClient, connector, setCurrentStep, onStatus) {
                     address: sourceTokenAddress,
                     abi: erc20Abi,
                     functionName: 'approve',
-                    args: [targetAllowance, XG_UINT256_MAX],
+                    args: [targetAllowance, UINT256_MAX],
                     account: walletClient.account,
                     chain: null,
                 });
@@ -993,60 +1218,12 @@ walletClient, connector, setCurrentStep, onStatus) {
         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',
-    };
+    return await monitorDebridgeBridgeStatus(debridgeOrderId, setCurrentStep, onStatus);
 }
 /**
  * Monitor relay.link bridge status until deposit arrives
@@ -1129,3 +1306,53 @@ async function monitorRelayBridgeStatus(requestId, setCurrentStep, onStatus) {
     }
     return depositTxHash;
 }
+/**
+ * Monitor deBridge bridge status until deposit arrives
+ * With exponential backoff and timeout
+ */
+async function monitorDebridgeBridgeStatus(debridgeOrderId, setCurrentStep, onStatus) {
+    setCurrentStep('Waiting for bridge');
+    onStatus?.('Waiting for bridge');
+    let depositTxHash;
+    const startTime = Date.now();
+    const timeout = 10 * 60 * 1000;
+    let pollInterval = 2_000;
+    const maxPollInterval = 10_000;
+    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;
+            }
+            if (status.status === 'failed' || status.status === 'refund') {
+                throw new Error(`DeBridge transaction failed: ${status.details || 'Unknown error'}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('DeBridge transaction failed')) {
+                throw error;
+            }
+            console.error('Failed to fetch deBridge status:', {
+                debridgeOrderId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        const elapsedSeconds = Math.floor((Date.now() - startTime) / 1000);
+        setCurrentStep(`Waiting for bridge (${elapsedSeconds}s)...`);
+        onStatus?.(`Waiting for bridge (${elapsedSeconds}s)...`);
+        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',
+    };
+}

package/dist/hooks/silent/useQuoteCalculation.d.ts

@@ -32,6 +32,8 @@ export interface UseQuoteCalculationOptions {
     setDestinations: (updater: Destination[] | ((prev: Destination[]) => Destination[])) => void;
     /** Pro user ID for volume tracking (sent with quote request) */
     proId?: string;
+    /** User's Tron address (TVM base58). Used as recipient fallback for Tron destinations. */
+    tronAddress?: string;
     /** Optional: force a single bridge provider for testing. */
     forceBridgeProvider?: 'relay' | 'debridge';
 }
@@ -53,4 +55,4 @@ export interface UseQuoteCalculationReturn {
  * - Quote request construction and fetching
  * - Destination amount updates
  */
-export declare function useQuoteCalculation({ address, evmAddress, wallet, depositorAddress, getQuote, getPrice, setDestinations, proId, forceBridgeProvider, }: UseQuoteCalculationOptions): UseQuoteCalculationReturn;
+export declare function useQuoteCalculation({ address, evmAddress, wallet, depositorAddress, getQuote, getPrice, setDestinations, proId, tronAddress, forceBridgeProvider, }: UseQuoteCalculationOptions): UseQuoteCalculationReturn;