@silentswap/react 0.1.50 → 0.1.51

package/dist/hooks/silent/useQuoteCalculation.js

@@ -1,5 +1,5 @@
 import { useCallback, useState } from 'react';
-import { isSolanaAsset, isBitcoinAsset, parseEvmCaip19, S_CAIP19_USDC_AVALANCHE, getAssetByCaip19, solveOptimalUsdcAmount, N_RELAY_CHAIN_ID_SOLANA, N_RELAY_CHAIN_ID_BITCOIN, SB58_ADDR_SOL_PROGRAM_SYSTEM, isSolanaNativeToken, parseSolanaCaip19, EVM_PHONY_ADDRESS, isValidSolanaAddress, isValidBitcoinAddress, isValidEvmAddress, getAddressFromCaip10, S0X_ADDR_USDC_AVALANCHE, caip19FungibleEvmToken, FacilitatorKeyType, createHdFacilitatorGroupFromEntropy, PublicKeyArgGroups, SB58_CHAIN_ID_SOLANA_MAINNET, caip19SplToken, DeliveryMethod, X_MAX_IMPACT_PERCENT, SBTC_ADDR_BITCOIN_NATIVE, isEvmAsset, } from '@silentswap/sdk';
+import { isSolanaAsset, isBitcoinAsset, isTronAsset, parseEvmCaip19, S_CAIP19_USDC_AVALANCHE, getAssetByCaip19, solveOptimalUsdcAmount, N_RELAY_CHAIN_ID_SOLANA, N_RELAY_CHAIN_ID_BITCOIN, N_RELAY_CHAIN_ID_TRON, SB58_ADDR_SOL_PROGRAM_SYSTEM, isSolanaNativeToken, parseSolanaCaip19, parseTronCaip19, EVM_PHONY_ADDRESS, isValidSolanaAddress, isValidBitcoinAddress, isValidEvmAddress, isValidTronAddress, getAddressFromCaip10, S0X_ADDR_USDC_AVALANCHE, caip19FungibleEvmToken, FacilitatorKeyType, createHdFacilitatorGroupFromEntropy, PublicKeyArgGroups, SB58_CHAIN_ID_SOLANA_MAINNET, caip19SplToken, DeliveryMethod, X_MAX_IMPACT_PERCENT, SBTC_ADDR_BITCOIN_NATIVE, S0X_ADDR_TRON_NATIVE, isEvmAsset, } from '@silentswap/sdk';
 import { getAddress } from 'viem';
 import { BigNumber } from 'bignumber.js';
 /**
@@ -13,7 +13,7 @@ import { BigNumber } from 'bignumber.js';
  * - Destination amount updates
  */
 // TODO: Simplify this hook by removing the useCallback and useState and just returning the calculateQuote function.
-export function useQuoteCalculation({ address, evmAddress, wallet, depositorAddress, getQuote, getPrice, setDestinations, proId, forceBridgeProvider, }) {
+export function useQuoteCalculation({ address, evmAddress, wallet, depositorAddress, getQuote, getPrice, setDestinations, proId, tronAddress, forceBridgeProvider, }) {
     const [loadingAmounts, setLoadingAmounts] = useState(false);
     const [depositAmountUsdc, setDepositAmountUsdc] = useState(0);
     const calculateQuote = useCallback(async (debouncedSourceAsset, debouncedSourceAmount, destinations, splits) => {
@@ -30,6 +30,7 @@ export function useQuoteCalculation({ address, evmAddress, wallet, depositorAddr
             const isSourceUsdcAvalanche = debouncedSourceAsset === S_CAIP19_USDC_AVALANCHE;
             const isSourceSolana = isSolanaAsset(debouncedSourceAsset);
             const isSourceBitcoin = isBitcoinAsset(debouncedSourceAsset);
+            const isSourceTron = isTronAsset(debouncedSourceAsset);
             let usdcAmountOut;
             let sourceAmountInUnitsForQuote;
             let bridgeProviderResult = 'none';
@@ -40,6 +41,7 @@ export function useQuoteCalculation({ address, evmAddress, wallet, depositorAddr
                 isSourceUsdcAvalanche,
                 isSourceSolana,
                 isSourceBitcoin,
+                isSourceTron,
                 destinationsCount: destinations.length,
                 splits,
             });
@@ -131,6 +133,31 @@ export function useQuoteCalculation({ address, evmAddress, wallet, depositorAddr
                 bridgeProviderResult = solveResult.provider;
                 allowanceTargetResult = solveResult.allowanceTarget;
             }
+            else if (isSourceTron) {
+                const assetInfo = getAssetByCaip19(debouncedSourceAsset);
+                if (!assetInfo)
+                    throw new Error(`Tron asset not found`);
+                const tronParsed = parseTronCaip19(debouncedSourceAsset);
+                if (!tronParsed)
+                    throw new Error(`Invalid Tron CAIP-19 format: ${debouncedSourceAsset}`);
+                const sourceAmountBN = BigNumber(debouncedSourceAmount);
+                sourceAmountInUnitsForQuote = sourceAmountBN.shiftedBy(assetInfo.decimals).toFixed(0);
+                if (!evmAddress) {
+                    throw new Error('EVM address required for Tron swaps (needed for deposit calldata and recipient)');
+                }
+                const tronSenderAddress = typeof address === 'string' && !address.startsWith('0x') ? address : null;
+                if (!tronSenderAddress) {
+                    throw new Error('Tron address required for Tron swaps');
+                }
+                const solveResult = await solveOptimalUsdcAmount(N_RELAY_CHAIN_ID_TRON, tronParsed.isNative ? S0X_ADDR_TRON_NATIVE : (tronParsed.tokenAddress || S0X_ADDR_TRON_NATIVE), sourceAmountInUnitsForQuote, tronSenderAddress, undefined, X_MAX_IMPACT_PERCENT, depositorAddress, getAddress(evmAddress), forceBridgeProvider);
+                if (abortController.signal.aborted) {
+                    setLoadingAmounts(false);
+                    return null;
+                }
+                usdcAmountOut = solveResult.usdcAmountOut.toString();
+                bridgeProviderResult = solveResult.provider;
+                allowanceTargetResult = solveResult.allowanceTarget;
+            }
             else {
                 // EVM assets
                 const sourceAssetParsed = parseEvmCaip19(debouncedSourceAsset);
@@ -200,8 +227,9 @@ export function useQuoteCalculation({ address, evmAddress, wallet, depositorAddr
                 }
                 const isDestSolana = isSolanaAsset(dest.asset);
                 const isDestBitcoin = isBitcoinAsset(dest.asset);
+                const isDestTron = isTronAsset(dest.asset);
                 let asset;
-                let recipientAddress; // Changed from `0x${string}` to string to support Solana and Bitcoin addresses
+                let recipientAddress; // Includes Solana, Bitcoin, Tron, and EVM addresses
                 if (isDestSolana) {
                     // Solana destination
                     const destParsed = parseSolanaCaip19(dest.asset);
@@ -265,6 +293,40 @@ export function useQuoteCalculation({ address, evmAddress, wallet, depositorAddr
                         throw new Error(`Bitcoin destination ${idx} requires a recipient address in the contact field`);
                     }
                 }
+                else if (isDestTron) {
+                    asset = dest.asset;
+                    if (dest.contact) {
+                        if (dest.contact.startsWith('caip10:tron:')) {
+                            recipientAddress = getAddressFromCaip10(dest.contact);
+                            if (!(isValidTronAddress(recipientAddress) && recipientAddress !== S0X_ADDR_TRON_NATIVE)) {
+                                throw new Error(`Invalid Tron address extracted from CAIP10: ${dest.contact} -> ${recipientAddress}`);
+                            }
+                        }
+                        else if (isValidTronAddress(dest.contact) && dest.contact !== S0X_ADDR_TRON_NATIVE) {
+                            recipientAddress = dest.contact;
+                        }
+                        else {
+                            if (tronAddress && isValidTronAddress(tronAddress) && tronAddress !== S0X_ADDR_TRON_NATIVE) {
+                                console.warn(`[SilentSwap:QuoteCalc] Invalid Tron destination contact for index ${idx}, falling back to connected Tron address`, {
+                                    contact: dest.contact,
+                                    tronAddress,
+                                });
+                                recipientAddress = tronAddress;
+                            }
+                            else {
+                                throw new Error(`Invalid Tron recipient address for destination ${idx}: ${dest.contact}. Expected Tron address or caip10:tron:*: format.`);
+                            }
+                        }
+                    }
+                    else {
+                        if (tronAddress && isValidTronAddress(tronAddress) && tronAddress !== S0X_ADDR_TRON_NATIVE) {
+                            recipientAddress = tronAddress;
+                        }
+                        else {
+                            throw new Error(`Tron destination ${idx} requires a recipient address in the contact field`);
+                        }
+                    }
+                }
                 else {
                     // EVM destination (including XRPL which uses eip155 namespace)
                     const destParsed = parseEvmCaip19(dest.asset);
@@ -345,7 +407,12 @@ export function useQuoteCalculation({ address, evmAddress, wallet, depositorAddr
                         throw new Error(`Invalid recipient address type for Bitcoin destination ${idx}: ${recipientAddress}. Expected Bitcoin address (bc1, 1, or 3 prefix).`);
                     }
                 }
-                else if (!isDestSolana && !isDestBitcoin) {
+                else if (isDestTron) {
+                    if (!(isValidTronAddress(recipientAddress) && recipientAddress !== S0X_ADDR_TRON_NATIVE)) {
+                        throw new Error(`Invalid recipient address type for Tron destination ${idx}: ${recipientAddress}. Expected Tron address.`);
+                    }
+                }
+                else if (!isDestSolana && !isDestBitcoin && !isDestTron) {
                     // Validate EVM address format
                     if (isEvmAsset(dest.asset) && !isValidEvmAddress(recipientAddress)) {
                         throw new Error(`Invalid recipient address type for EVM destination ${idx}: ${recipientAddress}. Expected 0x-prefixed EVM address.`);
@@ -460,7 +527,7 @@ export function useQuoteCalculation({ address, evmAddress, wallet, depositorAddr
             // Always ensure loading state is reset (safety net)
             setLoadingAmounts(false);
         }
-    }, [wallet, address, evmAddress, getQuote, getPrice, setDestinations, depositorAddress, proId]);
+    }, [wallet, address, evmAddress, getQuote, getPrice, setDestinations, depositorAddress, proId, tronAddress, forceBridgeProvider]);
     return {
         calculateQuote,
         loadingAmounts,

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

@@ -3,6 +3,7 @@ import type { WalletClient } from 'viem';
 import type { Connector } from 'wagmi';
 import type { SolanaWalletConnector, SolanaConnection } from './solana-transaction.js';
 import type { BitcoinWalletConnector, BitcoinConnection } from './bitcoin-transaction.js';
+import type { TronWalletConnector, TronConnection } from './tron-transaction.js';
 import { type SwapTransaction } from '../useTransaction.js';
 import type { SilentSwapWallet } from './useWallet.js';
 export type { SwapTransaction };
@@ -63,6 +64,12 @@ export interface useSilentQuoteOptions {
     bitcoinConnector?: BitcoinWalletConnector;
     /** Bitcoin connection (optional, for consistency) */
     bitcoinConnection?: BitcoinConnection;
+    /** Tron wallet connector (required for Tron swaps) */
+    tronConnector?: TronWalletConnector;
+    /** Tron connection (optional, for consistency) */
+    tronConnection?: TronConnection;
+    /** Connected Tron address used for Tron destination recipient fallback. */
+    tronAddress?: string;
     /** Get price function */
     getPrice: (asset: AssetInfo) => Promise<number>;
     setDestinations: (updater: Destination[] | ((prev: Destination[]) => Destination[])) => void;
@@ -105,4 +112,4 @@ export interface ExecuteSwapParams {
     /** Optional integrator ID for tracking */
     integratorId?: string;
 }
-export declare function useSilentQuote({ client, address, evmAddress, solAddress, walletClient, connector, auth, authenticate, wallet, walletLoading, walletError, generateWallet, requestWalletConnect, onStatus, solanaConnector, solanaConnection, solanaRpcUrl, bitcoinConnector, bitcoinConnection, getPrice, setDestinations, proId, forceBridgeProvider, }: useSilentQuoteOptions): useSilentQuoteReturn;
+export declare function useSilentQuote({ client, address, evmAddress, solAddress, walletClient, connector, auth, authenticate, wallet, walletLoading, walletError, generateWallet, requestWalletConnect, onStatus, solanaConnector, solanaConnection, solanaRpcUrl, bitcoinConnector, bitcoinConnection, tronConnector, tronConnection, tronAddress, getPrice, setDestinations, proId, forceBridgeProvider, }: useSilentQuoteOptions): useSilentQuoteReturn;

package/dist/hooks/silent/useSilentQuote.js

@@ -1,12 +1,12 @@
 import { useCallback, useMemo, useState, useRef, useEffect } from 'react';
-import { hexToBase58, isSolanaAsset, isBitcoinAsset, parseEvmCaip19, S_CAIP19_USDC_AVALANCHE, NI_CHAIN_ID_AVALANCHE, } from '@silentswap/sdk';
+import { hexToBase58, isSolanaAsset, isBitcoinAsset, isTronAsset, parseEvmCaip19, S_CAIP19_USDC_AVALANCHE, NI_CHAIN_ID_AVALANCHE, } from '@silentswap/sdk';
 import { getAddress } from 'viem';
 import { useQuoteFetching } from './useQuoteFetching.js';
 import { useOrderSigning } from './useOrderSigning.js';
 import { APPROVE_POST_DELAY_MS, useBridgeExecution } from './useBridgeExecution.js';
 import { useTransaction } from '../useTransaction.js';
 import { useQuoteCalculation } from './useQuoteCalculation.js';
-export function useSilentQuote({ client, address, evmAddress, solAddress, walletClient, connector, auth, authenticate, wallet, walletLoading = false, walletError = null, generateWallet, requestWalletConnect, onStatus, solanaConnector, solanaConnection, solanaRpcUrl, bitcoinConnector, bitcoinConnection, getPrice, setDestinations, proId, forceBridgeProvider, }) {
+export function useSilentQuote({ client, address, evmAddress, solAddress, walletClient, connector, auth, authenticate, wallet, walletLoading = false, walletError = null, generateWallet, requestWalletConnect, onStatus, solanaConnector, solanaConnection, solanaRpcUrl, bitcoinConnector, bitcoinConnection, tronConnector, tronConnection, tronAddress, getPrice, setDestinations, proId, forceBridgeProvider, }) {
     const [isLoading, setIsLoading] = useState(false);
     const [currentStep, setCurrentStep] = useState('');
     const [quote, setQuote] = useState(null);
@@ -57,7 +57,7 @@ export function useSilentQuote({ client, address, evmAddress, solAddress, wallet
     // Initialize specialized hooks
     const { getQuote: getQuoteInternal } = useQuoteFetching(client, rawAddress, setIsLoading, setCurrentStep, setError, onStatus);
     const { signAuthorizations, createOrder } = useOrderSigning(walletClient, connector, client, setCurrentStep, onStatus);
-    const { executeSolanaBridge, executeBitcoinBridge, executeEvmBridge } = useBridgeExecution(walletClient, connector, solanaConnector, solanaConnection, solanaRpcUrl, setCurrentStep, depositorAddress, onStatus, bitcoinConnector, bitcoinConnection);
+    const { executeSolanaBridge, executeBitcoinBridge, executeTronBridge, executeEvmBridge } = useBridgeExecution(walletClient, connector, solanaConnector, solanaConnection, solanaRpcUrl, setCurrentStep, depositorAddress, onStatus, bitcoinConnector, bitcoinConnection, tronConnector, tronConnection);
     const { executeSwapTransaction, approveTokenSpending } = useTransaction({
         address: normalizedAddress || '0x0000000000000000000000000000000000000000',
         walletClient,
@@ -65,6 +65,10 @@ export function useSilentQuote({ client, address, evmAddress, solAddress, wallet
         solanaConnector,
         solanaConnection,
         solanaRpcUrl,
+        bitcoinConnector,
+        bitcoinConnection,
+        tronConnector,
+        tronConnection,
         setCurrentStep,
         onStatus,
     });
@@ -90,6 +94,7 @@ export function useSilentQuote({ client, address, evmAddress, solAddress, wallet
         getPrice,
         setDestinations,
         proId,
+        tronAddress,
         forceBridgeProvider,
     });
     /**
@@ -268,8 +273,9 @@ export function useSilentQuote({ client, address, evmAddress, solAddress, wallet
             // Check swap type
             const isSourceSolana = isSolanaAsset(sourceAsset);
             const isSourceBitcoin = isBitcoinAsset(sourceAsset);
+            const isSourceTron = isTronAsset(sourceAsset);
             const isDepositingDirectly = sourceAsset === S_CAIP19_USDC_AVALANCHE;
-            const isSourceEvm = !isSourceSolana && !isSourceBitcoin && !isDepositingDirectly && sourceAsset.startsWith('eip155:');
+            const isSourceEvm = !isSourceSolana && !isSourceBitcoin && !isSourceTron && !isDepositingDirectly && sourceAsset.startsWith('eip155:');
             // Generate viewing authorization
             const viewer = await resolvedGroup.viewer();
             const evmSigner = await viewer.evmSigner();
@@ -292,7 +298,7 @@ export function useSilentQuote({ client, address, evmAddress, solAddress, wallet
                     viewingAuth,
                     provider: providerForSwap,
                 });
-                const result = await executeSolanaSwap(quoteResponse, sourceAsset, sourceAmountInUnits, effectiveUsdcAmount, senderContactId, solanaConnector, evmSignerAddress, viewingAuth, createOrder, executeSolanaBridge, resolvedGroup, integratorId);
+                const result = await executeSolanaSwap(quoteResponse, sourceAsset, sourceAmountInUnits, effectiveUsdcAmount, senderContactId, solanaConnector, evmSignerAddress, viewingAuth, createOrder, executeSolanaBridge, resolvedGroup, providerForSwap, integratorId);
                 setOrderId(result.orderId);
                 setViewingAuth(result.viewingAuth);
                 return result;
@@ -306,6 +312,13 @@ export function useSilentQuote({ client, address, evmAddress, solAddress, wallet
                 setViewingAuth(result.viewingAuth);
                 return result;
             }
+            // Handle Tron swaps
+            if (isSourceTron) {
+                const result = await executeTronSwap(quoteResponse, sourceAsset, sourceAmountInUnits, effectiveUsdcAmount, senderContactId, tronConnector, evmSignerAddress, viewingAuth, createOrder, executeTronBridge, resolvedGroup, providerForSwap, integratorId);
+                setOrderId(result.orderId);
+                setViewingAuth(result.viewingAuth);
+                return result;
+            }
             // Sign authorizations (for EVM swaps)
             const signedAuths = await signAuthorizations(quoteResponse.authorizations, isDepositingDirectly);
             // Create order with resolved facilitator group
@@ -389,10 +402,13 @@ export function useSilentQuote({ client, address, evmAddress, solAddress, wallet
         generateWallet,
         solanaConnector,
         bitcoinConnector,
+        tronConnector,
         signAuthorizations,
         createOrder,
         approveTokenSpending,
         executeSolanaBridge,
+        executeBitcoinBridge,
+        executeTronBridge,
         executeEvmBridge,
         executeSwapTransaction,
         calculateQuote,
@@ -433,7 +449,7 @@ export function useSilentQuote({ client, address, evmAddress, solAddress, wallet
  * 4. Returns swap result
  */
 async function executeSolanaSwap(quoteResponse, sourceAsset, sourceAmount, usdcAmount, senderContactId, solanaConnector, evmSignerAddress, // EVM signer address (matches Svelte's s0x_signer)
-viewingAuth, createOrder, executeSolanaBridge, facilitatorGroup, integratorId) {
+viewingAuth, createOrder, executeSolanaBridge, facilitatorGroup, provider, integratorId) {
     if (!solanaConnector) {
         throw new Error('Solana connector required for Solana swaps');
     }
@@ -489,7 +505,10 @@ viewingAuth, createOrder, executeSolanaBridge, facilitatorGroup, integratorId) {
         depositParamsKeys: Object.keys(depositParams),
     });
     // Execute bridge transaction
-    const bridgeResult = await executeSolanaBridge(sourceAsset, sourceAmount, usdcAmount, solanaSenderAddress, evmSignerAddress, depositParams);
+    const bridgeResult = await executeSolanaBridge(sourceAsset, sourceAmount, usdcAmount, solanaSenderAddress, evmSignerAddress, {
+        depositParams,
+        provider,
+    });
     console.log('[SilentSwap:SolanaSwap] Bridge result', {
         depositTxHash: bridgeResult.depositTxHash,
         provider: bridgeResult.provider,
@@ -569,6 +588,57 @@ viewingAuth, createOrder, executeBitcoinBridge, facilitatorGroup, integratorId)
         },
     };
 }
+/**
+ * Execute Tron swap flow
+ *
+ * Handles the complete flow for Tron-based bridge swaps:
+ * 1. Validates Tron connection
+ * 2. Creates order (with empty authorizations for Tron)
+ * 3. Executes bridge transaction
+ * 4. Returns swap result
+ */
+async function executeTronSwap(quoteResponse, sourceAsset, sourceAmount, usdcAmount, senderContactId, tronConnector, evmSignerAddress, viewingAuth, createOrder, executeTronBridge, facilitatorGroup, provider, integratorId) {
+    if (!tronConnector) {
+        throw new Error('Tron connector required for Tron swaps');
+    }
+    const accounts = await tronConnector.getAccounts();
+    const tronSenderAddress = tronConnector.currentAccount || accounts[0] || '';
+    if (!tronSenderAddress) {
+        throw new Error('Failed to get Tron sender address');
+    }
+    const orderResponse = await createOrder(quoteResponse, quoteResponse.authorizations.map((auth) => ({
+        ...auth,
+        signature: '0x',
+    })), {
+        sourceAsset: {
+            caip19: sourceAsset,
+            amount: `${BigInt(sourceAmount)}`,
+        },
+        sourceSender: {
+            contactId: senderContactId,
+        },
+        ...(integratorId && { integratorId }),
+    }, facilitatorGroup);
+    const depositParams = orderResponse.transaction.metadata?.params;
+    if (!depositParams) {
+        throw new Error('Missing deposit parameters in order response');
+    }
+    const bridgeResult = await executeTronBridge(sourceAsset, sourceAmount, usdcAmount, tronSenderAddress, evmSignerAddress, {
+        depositParams,
+        provider,
+    });
+    const resultOrderId = orderResponse.response.orderId;
+    return {
+        orderId: resultOrderId,
+        viewingAuth,
+        depositTransaction: {
+            hash: bridgeResult.depositTxHash,
+            chainId: NI_CHAIN_ID_AVALANCHE,
+            status: 'confirmed',
+            confirmations: 1,
+        },
+    };
+}
 /**
  * Execute EVM swap flow
  *

package/dist/hooks/useContacts.d.ts

@@ -16,7 +16,7 @@ export declare class AddressBookContact {
     protected _s_caip10: string;
     protected _s_ens: string;
     protected _s_sns: string;
-    protected _s_caip2_ns: 'eip155' | 'solana' | 'bip122' | 'cosmos';
+    protected _s_caip2_ns: 'eip155' | 'solana' | 'bip122' | 'cosmos' | 'tron';
     private _saveCallback?;
     constructor(_g_info: AddressBookContactInfo, b_from_id?: boolean, saveCallback?: (contact: AddressBookContact) => void);
     private updateENSRecord;
@@ -28,7 +28,7 @@ export declare class AddressBookContact {
     get label(): string;
     set label(s_label: string);
     get source(): AddressBookContactSource;
-    get caip2Ns(): 'eip155' | 'solana' | 'bip122' | 'cosmos';
+    get caip2Ns(): 'eip155' | 'solana' | 'bip122' | 'cosmos' | 'tron';
     isEvm(): boolean;
     isSolana(): boolean;
     isBip122(): boolean;

package/dist/hooks/useOrderEstimates.d.ts

@@ -15,6 +15,8 @@ export interface UseOrderEstimatesOptions {
     evmAddress?: `0x${string}`;
     /** User's Solana address (base58 address) */
     solAddress?: string;
+    /** User's Tron address (TVM base58 address) */
+    tronAddress?: string;
     /** User's Bitcoin address */
     bitcoinAddress?: string;
     /** Source asset for determining which address to use (if Solana, use solAddress; if EVM, use evmAddress) */
@@ -32,7 +34,7 @@ export interface UseOrderEstimatesOptions {
  *
  * Returns retention rates that account for bridge fees and slippage
  */
-export declare function useOrderEstimates({ evmAddress, solAddress, bitcoinAddress, sourceAsset, maxImpactPercent, }?: UseOrderEstimatesOptions): {
+export declare function useOrderEstimates({ evmAddress, solAddress, tronAddress, bitcoinAddress, sourceAsset, maxImpactPercent, }?: UseOrderEstimatesOptions): {
     estimateOrder: (usdcPrice: number, sourceAsset: AssetInfo, sourcePrice: number, sourceAmount: number | string, destinationAssets: AssetInfo[], destinationPrices: number[], splits: number[], calculationDirection?: CalculationDirection, outputAmounts?: string[], destinationContacts?: string[]) => Promise<OrderEstimateResult>;
     isLoading: boolean;
     error: Error | null;

package/dist/hooks/useOrderEstimates.js

@@ -1,6 +1,6 @@
 import { useCallback, useRef, useState, useMemo } from 'react';
 import BigNumber from 'bignumber.js';
-import { parseEvmCaip19, parseSolanaCaip19, isEvmNativeToken, isSolanaNativeToken, isSolanaAsset, isBitcoinAsset, EVM_PHONY_ADDRESS, SB58_ADDR_SOL_PROGRAM_SYSTEM, CALCULATION_DIRECTION_INPUT_TO_OUTPUT, CALCULATION_DIRECTION_OUTPUT_TO_INPUT, N_RELAY_CHAIN_ID_BITCOIN, SBTC_ADDR_BITCOIN_NATIVE, } from '@silentswap/sdk';
+import { parseEvmCaip19, parseSolanaCaip19, parseTronCaip19, isEvmNativeToken, isSolanaNativeToken, isSolanaAsset, isBitcoinAsset, isTronAsset, EVM_PHONY_ADDRESS, SB58_ADDR_SOL_PROGRAM_SYSTEM, S0X_ADDR_TRON_NATIVE, CALCULATION_DIRECTION_INPUT_TO_OUTPUT, CALCULATION_DIRECTION_OUTPUT_TO_INPUT, N_RELAY_CHAIN_ID_BITCOIN, SBTC_ADDR_BITCOIN_NATIVE, } from '@silentswap/sdk';
 import { useQuote } from './useQuote.js';
 /**
  * Hook for fetching both ingress and egress estimates in parallel
@@ -12,7 +12,7 @@ import { useQuote } from './useQuote.js';
  *
  * Returns retention rates that account for bridge fees and slippage
  */
-export function useOrderEstimates({ evmAddress, solAddress, bitcoinAddress, sourceAsset, maxImpactPercent, } = {}) {
+export function useOrderEstimates({ evmAddress, solAddress, tronAddress, bitcoinAddress, sourceAsset, maxImpactPercent, } = {}) {
     const [error, setError] = useState(null);
     const [isLoading, setIsLoading] = useState(false);
     // Determine address for ingress quotes based on source chain
@@ -120,18 +120,23 @@ export function useOrderEstimates({ evmAddress, solAddress, bitcoinAddress, sour
                 console.log('[OrderEstimates] Step 3: Parsing source asset CAIP-19');
                 const isSourceSolana = isSolanaAsset(sourceAsset.caip19);
                 const isSourceBitcoin = isBitcoinAsset(sourceAsset.caip19);
-                const sourceEvmParsed = !isSourceSolana && !isSourceBitcoin ? parseEvmCaip19(sourceAsset.caip19) : null;
+                const isSourceTron = isTronAsset(sourceAsset.caip19);
+                const sourceEvmParsed = !isSourceSolana && !isSourceBitcoin && !isSourceTron ? parseEvmCaip19(sourceAsset.caip19) : null;
                 const sourceSolanaParsed = isSourceSolana ? parseSolanaCaip19(sourceAsset.caip19) : null;
+                const sourceTronParsed = isSourceTron ? parseTronCaip19(sourceAsset.caip19) : null;
                 const sourceChainId = sourceEvmParsed?.chainId
                     ?? sourceSolanaParsed?.chainId
+                    ?? sourceTronParsed?.chainId
                     ?? (isSourceBitcoin ? N_RELAY_CHAIN_ID_BITCOIN : 0);
                 const sourceTokenAddress = isEvmNativeToken(sourceAsset.caip19)
                     ? '0x0000000000000000000000000000000000000000'
                     : isSolanaNativeToken(sourceAsset.caip19)
                         ? '11111111111111111111111111111111'
-                        : isSourceBitcoin
-                            ? SBTC_ADDR_BITCOIN_NATIVE
-                            : (sourceEvmParsed?.tokenAddress ?? sourceSolanaParsed?.tokenAddress ?? '');
+                        : isSourceTron
+                            ? (sourceTronParsed?.isNative ? S0X_ADDR_TRON_NATIVE : (sourceTronParsed?.tokenAddress ?? ''))
+                            : isSourceBitcoin
+                                ? SBTC_ADDR_BITCOIN_NATIVE
+                                : (sourceEvmParsed?.tokenAddress ?? sourceSolanaParsed?.tokenAddress ?? '');
                 console.log('[OrderEstimates] Step 3: Source asset parsed', { sourceChainId, sourceTokenAddress, isSourceSolana, isSourceBitcoin });
                 // For reverse calculation, calculate total output USD value first
                 let totalOutputUsd = 0;
@@ -184,18 +189,23 @@ export function useOrderEstimates({ evmAddress, solAddress, bitcoinAddress, sour
                         // Parse destination asset to get chain ID and token address from CAIP-19
                         const isDestSolana = isSolanaAsset(destAsset.caip19);
                         const isDestBitcoin = isBitcoinAsset(destAsset.caip19);
-                        const destEvmParsed = !isDestSolana && !isDestBitcoin ? parseEvmCaip19(destAsset.caip19) : null;
+                        const isDestTron = isTronAsset(destAsset.caip19);
+                        const destEvmParsed = !isDestSolana && !isDestBitcoin && !isDestTron ? parseEvmCaip19(destAsset.caip19) : null;
                         const destSolanaParsed = isDestSolana ? parseSolanaCaip19(destAsset.caip19) : null;
+                        const destTronParsed = isDestTron ? parseTronCaip19(destAsset.caip19) : null;
                         const destChainId = destEvmParsed?.chainId
                             ?? destSolanaParsed?.chainId
+                            ?? destTronParsed?.chainId
                             ?? (isDestBitcoin ? N_RELAY_CHAIN_ID_BITCOIN : 0);
                         const destTokenAddress = isEvmNativeToken(destAsset.caip19)
                             ? '0x0000000000000000000000000000000000000000'
                             : isSolanaNativeToken(destAsset.caip19)
                                 ? '11111111111111111111111111111111'
-                                : isDestBitcoin
-                                    ? SBTC_ADDR_BITCOIN_NATIVE
-                                    : (destEvmParsed?.tokenAddress ?? destSolanaParsed?.tokenAddress ?? '');
+                                : isDestTron
+                                    ? (destTronParsed?.isNative ? S0X_ADDR_TRON_NATIVE : (destTronParsed?.tokenAddress ?? ''))
+                                    : isDestBitcoin
+                                        ? SBTC_ADDR_BITCOIN_NATIVE
+                                        : (destEvmParsed?.tokenAddress ?? destSolanaParsed?.tokenAddress ?? '');
                         // Determine recipient address based on destination chain
                         // Prefer the entered contact address (e.g. user-entered BTC address without wallet connected)
                         const contact = destinationContacts?.[idx];
@@ -203,7 +213,9 @@ export function useOrderEstimates({ evmAddress, solAddress, bitcoinAddress, sour
                             ? (contact || solAddress)
                             : isDestBitcoin
                                 ? (contact || bitcoinAddress || SBTC_ADDR_BITCOIN_NATIVE)
-                                : (contact && contact.startsWith('0x') ? contact : evmAddress);
+                                : isDestTron
+                                    ? (contact || tronAddress)
+                                    : (contact && contact.startsWith('0x') ? contact : evmAddress);
                         // For reverse calculation, use output amount directly with EXACT_OUTPUT
                         if (calculationDirection === CALCULATION_DIRECTION_OUTPUT_TO_INPUT && outputAmounts && outputAmounts[idx]) {
                             const outputAmount = parseFloat(outputAmounts[idx]);

package/dist/hooks/useQuote.js

@@ -1,8 +1,6 @@
 import { useCallback, useEffect, useRef, useState } from 'react';
 import BigNumber from 'bignumber.js';
-import { NI_CHAIN_ID_AVALANCHE, S0X_ADDR_USDC_AVALANCHE, S_CAIP19_USDC_AVALANCHE, X_MAX_IMPACT_PERCENT, getBridgeQuote, interpolateSamples as sdkInterpolateSamples, fetchRelayQuote, fetchDebridgeOrder, normalizeAddress, getAssetByCaip19, N_DEBRIDGE_CHAIN_ID_SOLANA, N_RELAY_CHAIN_ID_SOLANA, N_RELAY_CHAIN_ID_BITCOIN, SBTC_ADDR_BITCOIN_NATIVE, SBTC_ADDR_BTC_RELAY_LINK_RECIPIENT, SB58_ADDR_SOL_PROGRAM_SYSTEM, S0X_ADDR_EVM_RELAY_LINK_DEAD, SB58_ADDR_SOL_RELAY_LINK_RECIPIENT, isSolanaAsset, isBitcoinAsset, EVM_PHONY_ADDRESS, } from '@silentswap/sdk';
-// Constants for estimateLive
-const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+import { NI_CHAIN_ID_AVALANCHE, S0X_ADDR_USDC_AVALANCHE, S_CAIP19_USDC_AVALANCHE, X_MAX_IMPACT_PERCENT, getBridgeQuote, interpolateSamples as sdkInterpolateSamples, fetchRelayQuote, fetchDebridgeOrder, normalizeAddress, getAssetByCaip19, N_DEBRIDGE_CHAIN_ID_SOLANA, N_RELAY_CHAIN_ID_SOLANA, N_RELAY_CHAIN_ID_BITCOIN, SBTC_ADDR_BITCOIN_NATIVE, SBTC_ADDR_BTC_RELAY_LINK_RECIPIENT, SB58_ADDR_SOL_PROGRAM_SYSTEM, S0X_ADDR_EVM_ZERO, S0X_ADDR_EVM_RELAY_LINK_DEAD, SB58_ADDR_SOL_RELAY_LINK_RECIPIENT, isSolanaAsset, isBitcoinAsset, isTronAsset, N_RELAY_CHAIN_ID_TRON, N_DEBRIDGE_CHAIN_ID_TRON, S0X_ADDR_TRON_NATIVE, SB58_ADDR_TRON_DEAD, EVM_PHONY_ADDRESS, } from '@silentswap/sdk';
 /**
  * Hook for getting optimized bridge quotes with retention rate tracking
  * Implements the same functionality as estimate.ts from the original app
@@ -66,8 +64,8 @@ export function useQuote({ address, maxImpactPercent = X_MAX_IMPACT_PERCENT, for
         try {
             // Normalize addresses
             console.log('[Quote] Step 2: Normalizing token addresses');
-            const srcTokenNorm = srcToken === '0x0' || srcToken === '0x0000000000000000000000000000000000000000' ? ZERO_ADDRESS : srcToken;
-            const dstTokenNorm = dstToken === '0x0' || dstToken === '0x0000000000000000000000000000000000000000' ? ZERO_ADDRESS : dstToken;
+            const srcTokenNorm = srcToken === '0x0' || srcToken === S0X_ADDR_EVM_ZERO ? S0X_ADDR_EVM_ZERO : srcToken;
+            const dstTokenNorm = dstToken === '0x0' || dstToken === S0X_ADDR_EVM_ZERO ? S0X_ADDR_EVM_ZERO : dstToken;
             // Use shared quote fetching function
             // normalizedAddress can be EVM (0x...) or Solana (base58) address
             // sourceAddress is the address format for the source chain (for relay.link)
@@ -112,11 +110,12 @@ export function useQuote({ address, maxImpactPercent = X_MAX_IMPACT_PERCENT, for
             isReverseCalculation,
             targetAmount,
         });
-        // Determine if this is a Solana or Bitcoin chain by checking the asset CAIP-19
+        // Determine if this is a Solana, Bitcoin, or Tron chain by checking the asset CAIP-19
         // This is more reliable than checking chainId format
         const isSolanaChain = isSolanaAsset(assetCaip19);
         const isBitcoinChain = isBitcoinAsset(assetCaip19);
-        console.log('[Quote] Step 2: Chain type determined', { isSolanaChain, isBitcoinChain, chainId });
+        const isTronChain = isTronAsset(assetCaip19);
+        console.log('[Quote] Step 2: Chain type determined', { isSolanaChain, isBitcoinChain, isTronChain, chainId });
         let numericChainId;
         if (isSolanaChain) {
             // For Solana, we'll use different chain IDs for different providers
@@ -127,6 +126,10 @@ export function useQuote({ address, maxImpactPercent = X_MAX_IMPACT_PERCENT, for
             // Bitcoin uses the relay chain ID directly (only relay supports Bitcoin)
             numericChainId = N_RELAY_CHAIN_ID_BITCOIN;
         }
+        else if (isTronChain) {
+            // Tron uses different chain IDs per provider, set per-provider below
+            numericChainId = 0; // Placeholder, will be set per provider
+        }
         else {
             // For EVM chains, convert chainId to number if needed
             if (typeof chainId === 'string') {
@@ -157,7 +160,7 @@ export function useQuote({ address, maxImpactPercent = X_MAX_IMPACT_PERCENT, for
         try {
             // Special case for USDC on Avalanche
             // Check numericChainId (exclude non-EVM chains which use relay chain IDs)
-            const checkChainId = (isSolanaChain || isBitcoinChain) ? 0 : numericChainId;
+            const checkChainId = (isSolanaChain || isBitcoinChain || isTronChain) ? 0 : numericChainId;
             if (checkChainId === NI_CHAIN_ID_AVALANCHE &&
                 tokenAddress.toLowerCase() === S0X_ADDR_USDC_AVALANCHE.toLowerCase()) {
                 console.log('[Quote] Step 3: Special case - USDC on Avalanche, returning identity estimate');
@@ -218,6 +221,12 @@ export function useQuote({ address, maxImpactPercent = X_MAX_IMPACT_PERCENT, for
                         ? normalizedAddress
                         : SBTC_ADDR_BITCOIN_NATIVE;
                 }
+                else if (isTronChain) {
+                    // For Tron ingress, use Tron address (starts with T) or dead address as fallback
+                    userAddress = normalizedAddress && normalizedAddress.startsWith('T')
+                        ? normalizedAddress
+                        : SB58_ADDR_TRON_DEAD;
+                }
                 else {
                     // For EVM ingress, use EVM address (or phony if not available)
                     userAddress = normalizedAddress && normalizedAddress.startsWith('0x')
@@ -231,11 +240,14 @@ export function useQuote({ address, maxImpactPercent = X_MAX_IMPACT_PERCENT, for
                     ? normalizedAddress
                     : EVM_PHONY_ADDRESS;
             }
-            // Map chain IDs per provider (Solana and Bitcoin use provider-specific IDs)
+            // Map chain IDs per provider (Solana, Bitcoin, and Tron use provider-specific IDs)
             const relayChainId = isSolanaChain ? N_RELAY_CHAIN_ID_SOLANA
                 : isBitcoinChain ? N_RELAY_CHAIN_ID_BITCOIN
+                    : isTronChain ? N_RELAY_CHAIN_ID_TRON
+                        : numericChainId;
+            const debridgeChainId = isSolanaChain ? N_DEBRIDGE_CHAIN_ID_SOLANA
+                : isTronChain ? N_DEBRIDGE_CHAIN_ID_TRON
                     : numericChainId;
-            const debridgeChainId = isSolanaChain ? N_DEBRIDGE_CHAIN_ID_SOLANA : numericChainId;
             console.log('[Quote] Step 4: Address and chain IDs determined', {
                 userAddress,
                 relayChainId,
@@ -279,7 +291,9 @@ export function useQuote({ address, maxImpactPercent = X_MAX_IMPACT_PERCENT, for
                                     destinationChainId: NI_CHAIN_ID_AVALANCHE,
                                     originCurrency: isBitcoinChain
                                         ? (tokenAddress || SBTC_ADDR_BITCOIN_NATIVE)
-                                        : (tokenAddress === ZERO_ADDRESS ? ZERO_ADDRESS : tokenAddress),
+                                        : isTronChain
+                                            ? (tokenAddress || S0X_ADDR_TRON_NATIVE)
+                                            : (tokenAddress === S0X_ADDR_EVM_ZERO ? S0X_ADDR_EVM_ZERO : tokenAddress),
                                     destinationCurrency: S0X_ADDR_USDC_AVALANCHE,
                                     ...(isReverseCalculation && tradeType === 'EXACT_OUTPUT'
                                         ? {
@@ -295,7 +309,9 @@ export function useQuote({ address, maxImpactPercent = X_MAX_IMPACT_PERCENT, for
                                         ? { recipient: EVM_PHONY_ADDRESS }
                                         : isBitcoinChain
                                             ? { recipient: EVM_PHONY_ADDRESS }
-                                            : {}),
+                                            : isTronChain
+                                                ? { recipient: EVM_PHONY_ADDRESS }
+                                                : {}),
                                 }
                                 : {
                                     originChainId: NI_CHAIN_ID_AVALANCHE,
@@ -303,7 +319,9 @@ export function useQuote({ address, maxImpactPercent = X_MAX_IMPACT_PERCENT, for
                                     destinationChainId: relayChainId,
                                     destinationCurrency: isBitcoinChain
                                         ? (tokenAddress || SBTC_ADDR_BITCOIN_NATIVE)
-                                        : (tokenAddress === ZERO_ADDRESS ? ZERO_ADDRESS : tokenAddress),
+                                        : isTronChain
+                                            ? (tokenAddress || S0X_ADDR_TRON_NATIVE)
+                                            : (tokenAddress === S0X_ADDR_EVM_ZERO ? S0X_ADDR_EVM_ZERO : tokenAddress),
                                     ...(isReverseCalculation && tradeType === 'EXACT_OUTPUT'
                                         ? {
                                             // For reverse egress: we specify the destination (output) amount
@@ -326,7 +344,14 @@ export function useQuote({ address, maxImpactPercent = X_MAX_IMPACT_PERCENT, for
                                                     ? recipientAddress
                                                     : SBTC_ADDR_BTC_RELAY_LINK_RECIPIENT,
                                             }
-                                            : {}),
+                                            : isTronChain
+                                                ? {
+                                                    // Tron egress: recipient must be a valid Tron address (starts with T)
+                                                    recipient: recipientAddress && recipientAddress.startsWith('T')
+                                                        ? recipientAddress
+                                                        : SB58_ADDR_TRON_DEAD,
+                                                }
+                                                : {}),
                                 }),
                         }, signal);
                         return quote;
@@ -351,9 +376,12 @@ export function useQuote({ address, maxImpactPercent = X_MAX_IMPACT_PERCENT, for
                             return null; // Skip DeBridge for Bitcoin, will use Relay.link only
                         }
                         // For reverse calculation ingress: use srcChainTokenInAmount: 'auto' and specify dstChainTokenOutAmount
+                        const srcTokenForDebridge = isTronChain
+                            ? (tokenAddress || S0X_ADDR_TRON_NATIVE)
+                            : (tokenAddress === S0X_ADDR_EVM_ZERO ? S0X_ADDR_EVM_ZERO : tokenAddress);
                         const debridgeParams = {
                             srcChainId: debridgeChainId,
-                            srcChainTokenIn: tokenAddress === ZERO_ADDRESS ? ZERO_ADDRESS : tokenAddress,
+                            srcChainTokenIn: srcTokenForDebridge,
                             dstChainId: NI_CHAIN_ID_AVALANCHE,
                             dstChainTokenOut: S0X_ADDR_USDC_AVALANCHE,
                             prependOperatingExpenses: true,
@@ -386,6 +414,16 @@ export function useQuote({ address, maxImpactPercent = X_MAX_IMPACT_PERCENT, for
                             debridgeParams.dstChainTokenOutRecipient = EVM_PHONY_ADDRESS;
                             debridgeParams.dstChainOrderAuthorityAddress = EVM_PHONY_ADDRESS;
                         }
+                        else if (isTronChain) {
+                            // Tron source requires Tron-format authority fields and estimate disabled
+                            const tronAddr = userAddress.startsWith('T') ? userAddress : SB58_ADDR_TRON_DEAD;
+                            debridgeParams.enableEstimate = false;
+                            debridgeParams.account = tronAddr;
+                            debridgeParams.srcChainOrderAuthorityAddress = tronAddr;
+                            debridgeParams.srcChainRefundAddress = tronAddr;
+                            debridgeParams.dstChainTokenOutRecipient = EVM_PHONY_ADDRESS;
+                            debridgeParams.dstChainOrderAuthorityAddress = EVM_PHONY_ADDRESS;
+                        }
                         const quote = await fetchDebridgeOrder(debridgeParams, signal);
                         return quote;
                     }