@silentswap/react 0.1.49 → 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/usePlatformHealth.d.ts

@@ -50,13 +50,20 @@ export type PlatformHealthProviderProps = {
      * API's own maximumDepositUusdc limit applies.
      */
     maxDepositUsd?: number;
+    /**
+     * Optional maintenance override from admin dashboard settings. When true, the effective
+     * platform health is forced to 'MAINTENANCE' regardless of what the platform status API
+     * reports — flipping formDisabled and trackingDisabled to true and letting consumers
+     * show a maintenance screen.
+     */
+    maintenanceMode?: boolean;
 };
 /**
  * Provider that monitors platform health from SilentSwapContext (which calls useStatus
  * once with proId) and provides validation functions for deposit amounts, output limits,
  * and service fee rates.
  */
-export declare function PlatformHealthProvider({ children, onFormDisabledChange, onTrackingDisabledChange, maxDepositUsd, }: PlatformHealthProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function PlatformHealthProvider({ children, onFormDisabledChange, onTrackingDisabledChange, maxDepositUsd, maintenanceMode, }: PlatformHealthProviderProps): import("react/jsx-runtime").JSX.Element;
 /**
  * Hook to access platform health context
  */

package/dist/hooks/usePlatformHealth.js

@@ -9,16 +9,19 @@ const PlatformHealthContext = createContext(undefined);
  * once with proId) and provides validation functions for deposit amounts, output limits,
  * and service fee rates.
  */
-export function PlatformHealthProvider({ children, onFormDisabledChange, onTrackingDisabledChange, maxDepositUsd, }) {
+export function PlatformHealthProvider({ children, onFormDisabledChange, onTrackingDisabledChange, maxDepositUsd, maintenanceMode, }) {
     // Consume status data from parent SilentSwapContext instead of calling useStatus again
     const { status } = useSilentSwap();
     const { platformHealth: statusPlatformHealth, maximumDepositUusdc, minimumDepositUusdc, outputLimit, serviceFeeRate, overheadUsd, identity, volume, liquidity, storage, } = status;
-    // Normalize platform health status
+    // Normalize platform health status. A dashboard-driven maintenance override forces
+    // the effective status to 'MAINTENANCE' regardless of what the status API reports.
     const platformHealth = useMemo(() => {
+        if (maintenanceMode)
+            return 'MAINTENANCE';
         if (!statusPlatformHealth)
             return null;
         return statusPlatformHealth;
-    }, [statusPlatformHealth]);
+    }, [statusPlatformHealth, maintenanceMode]);
     // Track disabled states locally for context value
     const [formDisabled, setFormDisabled] = React.useState(false);
     const [trackingDisabled, setTrackingDisabled] = React.useState(false);