@silentswap/react 0.1.50 → 0.1.52

package/dist/contexts/AssetsContext.js

@@ -12,6 +12,7 @@ const CHAIN_WHITELIST_GLOBAL = new Set([
     'eip155:1',
     'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
     'bip122:000000000019d6689c085ae165831e93',
+    'tron:0x2b6653dc',
     'eip155:56',
     'eip155:8453',
     'eip155:42161',

package/dist/contexts/BalancesContext.d.ts

@@ -11,7 +11,7 @@ export type BalancesContextType = {
     totalUsdValue: number;
     errors: Record<string, string>;
     refetch: () => Promise<void>;
-    refetchChains: (chainIds: (number | 'solana' | 'bitcoin')[]) => Promise<void>;
+    refetchChains: (chainIds: (number | 'solana' | 'bitcoin' | 'tron')[]) => Promise<void>;
 };
 /**
  * Provider for user balances across all supported chains
@@ -23,6 +23,8 @@ export declare const BalancesProvider: React.FC<{
     solanaRpcUrl?: string;
     bitcoinAddress?: string;
     bitcoinRpcUrl?: string;
+    tronAddress?: string;
+    tronRpcUrl?: string;
 }>;
 /**
  * Hook to access user balances

package/dist/contexts/BalancesContext.js

@@ -8,7 +8,7 @@ import { getAssociatedTokenAddress } from '@solana/spl-token';
 import { PublicKey } from '@solana/web3.js';
 import { useAssetsContext } from './AssetsContext.js';
 import { usePrices } from '../hooks/usePrices.js';
-import { isSolanaAsset, parseSolanaCaip19, isSolanaNativeToken, isSplToken, isEvmNativeToken, isBitcoinAsset, isBitcoinMainnetAsset, SB58_CHAIN_ID_SOLANA_MAINNET, A_VIEM_CHAINS, BITCOIN_CHAIN_ID, H_RPCS, } from '@silentswap/sdk';
+import { isSolanaAsset, parseSolanaCaip19, isSolanaNativeToken, isSplToken, isEvmNativeToken, isBitcoinAsset, isBitcoinMainnetAsset, SB58_CHAIN_ID_SOLANA_MAINNET, A_VIEM_CHAINS, BITCOIN_CHAIN_ID, TRON_CHAIN_ID, H_RPCS, } from '@silentswap/sdk';
 const BalancesContext = createContext(undefined);
 // Utility: Create viem client with custom RPC endpoints where available
 // Uses H_RPCS from @silentswap/sdk (rpc.ts) as the single source of truth
@@ -75,6 +75,79 @@ const separateBitcoinAssets = (bitcoinAssets) => {
     }
     return { a_assets_native };
 };
+const TRON_BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+function decodeBase58(input) {
+    let value = 0n;
+    for (const char of input) {
+        const idx = TRON_BASE58_ALPHABET.indexOf(char);
+        if (idx < 0)
+            throw new Error('Invalid base58 character');
+        value = value * 58n + BigInt(idx);
+    }
+    const bytes = [];
+    while (value > 0n) {
+        bytes.push(Number(value % 256n));
+        value /= 256n;
+    }
+    bytes.reverse();
+    let leadingZeroes = 0;
+    while (leadingZeroes < input.length && input[leadingZeroes] === '1') {
+        leadingZeroes++;
+    }
+    const out = new Uint8Array(leadingZeroes + bytes.length);
+    for (let i = 0; i < bytes.length; i++)
+        out[leadingZeroes + i] = bytes[i];
+    return out;
+}
+function tronAddressToHex20(address) {
+    const trimmed = address.trim();
+    const lower = trimmed.toLowerCase();
+    if (lower.startsWith('0x') && lower.length === 42) {
+        return lower;
+    }
+    if (lower.startsWith('0x41') && lower.length === 44) {
+        return `0x${lower.slice(4)}`;
+    }
+    if (lower.startsWith('41') && lower.length === 42) {
+        return `0x${lower.slice(2)}`;
+    }
+    if (!trimmed.startsWith('T'))
+        return null;
+    try {
+        const decoded = decodeBase58(trimmed);
+        // Tron base58check payload: 21 bytes (0x41 + 20-byte address) + 4 checksum bytes
+        if (decoded.length < 25)
+            return null;
+        const payload = decoded.slice(0, decoded.length - 4);
+        if (payload.length !== 21 || payload[0] !== 0x41)
+            return null;
+        const hex = Array.from(payload.slice(1))
+            .map((b) => b.toString(16).padStart(2, '0'))
+            .join('');
+        return `0x${hex}`;
+    }
+    catch {
+        return null;
+    }
+}
+function encodeTrc20BalanceOf(ownerHex20) {
+    const arg = ownerHex20.slice(2).padStart(64, '0');
+    return `0x70a08231${arg}`;
+}
+// Utility: Separate Tron assets into native and TRC20 tokens
+const separateTronAssets = (tronAssets) => {
+    const a_assets_native = [];
+    const a_assets_tokens = [];
+    for (const asset of tronAssets) {
+        if (asset.caip19.includes('/slip44:195')) {
+            a_assets_native.push(asset);
+        }
+        else if (asset.caip19.includes('/trc20:') || asset.caip19.includes('/token:')) {
+            a_assets_tokens.push(asset);
+        }
+    }
+    return { a_assets_native, a_assets_tokens };
+};
 // Utility: Fetch ERC-20 balance for a single token (fallback when multicall not available)
 const fetchSingleErc20Balance = async (y_client, s0x_account, k_asset, getUnitValueUsd) => {
     try {
@@ -433,10 +506,150 @@ assets, getUnitValueUsd) => {
         return { balances: {}, error: errorMsg };
     }
 };
+// Utility: Fetch Tron native balances from account payload
+const fetchTronNativeBalances = async (a_assets_native, balanceSun, getUnitValueUsd) => {
+    const updatedBalances = {};
+    if (a_assets_native.length === 0)
+        return updatedBalances;
+    await Promise.all(a_assets_native.map(async (asset) => {
+        let usdValue = 0;
+        try {
+            usdValue = await getUnitValueUsd(asset, balanceSun);
+        }
+        catch {
+            // ignore pricing errors, keep balance
+        }
+        updatedBalances[asset.caip19] = {
+            asset,
+            balance: balanceSun,
+            usdValue,
+        };
+    }));
+    return updatedBalances;
+};
+// Utility: Fetch Tron TRC20 balances from account payload
+const fetchTronTokenBalances = async (a_assets_tokens, trc20Rows, tronAddress, tronRpcUrl, getUnitValueUsd) => {
+    const updatedBalances = {};
+    if (a_assets_tokens.length === 0)
+        return updatedBalances;
+    const tokenAmounts = new Map();
+    for (const row of trc20Rows) {
+        for (const [tokenAddress, amountRaw] of Object.entries(row || {})) {
+            const key = tokenAddress.toLowerCase();
+            const amount = BigInt(amountRaw || '0');
+            tokenAmounts.set(key, (tokenAmounts.get(key) || 0n) + amount);
+            const tokenHex = tronAddressToHex20(tokenAddress);
+            if (tokenHex) {
+                const keyHex = tokenHex.toLowerCase();
+                tokenAmounts.set(keyHex, (tokenAmounts.get(keyHex) || 0n) + amount);
+            }
+        }
+    }
+    const ownerHex20 = tronAddressToHex20(tronAddress);
+    const resolvedRpcUrl = tronRpcUrl || H_RPCS[TRON_CHAIN_ID];
+    await Promise.all(a_assets_tokens.map(async (asset) => {
+        const tokenAddress = asset.caip19.split('/trc20:')[1] ||
+            asset.caip19.split('/token:')[1] ||
+            '';
+        if (!tokenAddress)
+            return;
+        const tokenAddressLower = tokenAddress.toLowerCase();
+        const tokenHex = tronAddressToHex20(tokenAddress);
+        const fromRows = tokenAmounts.get(tokenAddressLower) ||
+            (tokenHex ? tokenAmounts.get(tokenHex.toLowerCase()) : undefined) ||
+            0n;
+        let balance = fromRows;
+        // Fallback to Tron RPC eth_call when TronGrid account.trc20 is missing/empty.
+        if (balance <= 0n && ownerHex20 && tokenHex && resolvedRpcUrl) {
+            try {
+                const response = await fetch(resolvedRpcUrl, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        jsonrpc: '2.0',
+                        id: 1,
+                        method: 'eth_call',
+                        params: [
+                            {
+                                to: tokenHex,
+                                data: encodeTrc20BalanceOf(ownerHex20),
+                            },
+                            'latest',
+                        ],
+                    }),
+                });
+                if (response.ok) {
+                    const data = await response.json();
+                    if (typeof data?.result === 'string' && data.result.startsWith('0x')) {
+                        balance = BigInt(data.result);
+                    }
+                }
+            }
+            catch {
+                // ignore rpc errors and keep best-known balance
+            }
+        }
+        if (balance <= 0n)
+            return;
+        let usdValue = 0;
+        try {
+            usdValue = await getUnitValueUsd(asset, balance);
+        }
+        catch {
+            // ignore pricing errors, keep balance
+        }
+        updatedBalances[asset.caip19] = {
+            asset,
+            balance,
+            usdValue,
+        };
+    }));
+    return updatedBalances;
+};
+// Utility: Fetch all Tron balances (native TRX + TRC20) using TronGrid
+const fetchTronBalances = async (tronAddress, tronRpcUrl, // kept for future RPC usage
+assets, getUnitValueUsd) => {
+    try {
+        const tronAssets = Object.values(assets).filter((asset) => asset.caip19.startsWith('tron:'));
+        const { a_assets_native, a_assets_tokens } = separateTronAssets(tronAssets);
+        const response = await fetch(`https://api.trongrid.io/v1/accounts/${tronAddress}`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch Tron balance: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        const account = Array.isArray(data?.data) ? data.data[0] : undefined;
+        const balanceSun = BigInt(account?.balance ?? 0);
+        const trc20Rows = Array.isArray(account?.trc20) ? account.trc20 : [];
+        const [nativeResult, tokenResult] = await Promise.allSettled([
+            fetchTronNativeBalances(a_assets_native, balanceSun, getUnitValueUsd),
+            fetchTronTokenBalances(a_assets_tokens, trc20Rows, tronAddress, tronRpcUrl, getUnitValueUsd),
+        ]);
+        const nativeBalances = nativeResult.status === 'fulfilled' ? nativeResult.value : {};
+        const tokenBalances = tokenResult.status === 'fulfilled' ? tokenResult.value : {};
+        const errors = [];
+        if (nativeResult.status === 'rejected') {
+            errors.push(`Native: ${nativeResult.reason?.message || 'Unknown error'}`);
+        }
+        if (tokenResult.status === 'rejected') {
+            errors.push(`Tokens: ${tokenResult.reason?.message || 'Unknown error'}`);
+        }
+        return {
+            balances: { ...nativeBalances, ...tokenBalances },
+            error: errors.length > 0 ? errors.join('; ') : undefined,
+        };
+    }
+    catch (error) {
+        const errorMsg = `Failed to fetch Tron balances: ${error instanceof Error ? error.message : String(error)}`;
+        if (process.env.NODE_ENV === 'development') {
+            console.error(errorMsg, error);
+        }
+        return { balances: {}, error: errorMsg };
+    }
+};
 /**
  * Provider for user balances across all supported chains
  */
-export const BalancesProvider = ({ children, evmAddress, solAddress, solanaRpcUrl, bitcoinAddress, bitcoinRpcUrl }) => {
+export const BalancesProvider = ({ children, evmAddress, solAddress, solanaRpcUrl, bitcoinAddress, bitcoinRpcUrl, tronAddress, tronRpcUrl }) => {
     const { assets, loading: assetsLoading } = useAssetsContext();
     const { getUnitValueUsd } = usePrices();
     const [balances, setBalances] = useState({});
@@ -476,6 +689,13 @@ export const BalancesProvider = ({ children, evmAddress, solAddress, solanaRpcUr
                     promise: fetchBitcoinBalances(bitcoinAddress, bitcoinRpcUrl, assets, getUnitValueUsd),
                 });
             }
+            // Process Tron balances if Tron address is available
+            if (tronAddress) {
+                balanceTasks.push({
+                    chainId: 'tron',
+                    promise: fetchTronBalances(tronAddress, tronRpcUrl, assets, getUnitValueUsd),
+                });
+            }
             // Use Promise.allSettled to handle partial failures gracefully
             // This ensures one chain failure doesn't prevent others from updating
             const results = await Promise.allSettled(balanceTasks.map((task) => task.promise));
@@ -512,7 +732,7 @@ export const BalancesProvider = ({ children, evmAddress, solAddress, solanaRpcUr
         finally {
             setLoading(false);
         }
-    }, [evmAddress, solAddress, bitcoinAddress, bitcoinRpcUrl, solanaRpcUrl, assets, assetsLoading, getUnitValueUsd]);
+    }, [evmAddress, solAddress, bitcoinAddress, bitcoinRpcUrl, tronAddress, tronRpcUrl, solanaRpcUrl, assets, assetsLoading, getUnitValueUsd]);
     // Refetch balances for specific chains only
     const refetchChains = useCallback(async (chainIds) => {
         if (assetsLoading || chainIds.length === 0)
@@ -524,6 +744,7 @@ export const BalancesProvider = ({ children, evmAddress, solAddress, solanaRpcUr
             // Separate EVM and Solana chain IDs
             const evmChainIds = chainIds.filter((id) => typeof id === 'number');
             const shouldRefetchSolana = chainIds.includes('solana');
+            const shouldRefetchTron = chainIds.includes('tron');
             // Process EVM balances for specific chains
             if (evmAddress && evmChainIds.length > 0) {
                 const s0x_account = getAddress(evmAddress);
@@ -542,6 +763,13 @@ export const BalancesProvider = ({ children, evmAddress, solAddress, solanaRpcUr
                     promise: fetchSolanaBalances(solAddress, solanaRpcUrl, assets, getUnitValueUsd),
                 });
             }
+            // Process Tron balances if requested
+            if (tronAddress && shouldRefetchTron) {
+                balanceTasks.push({
+                    chainId: 'tron',
+                    promise: fetchTronBalances(tronAddress, tronRpcUrl, assets, getUnitValueUsd),
+                });
+            }
             // Process Bitcoin balances if requested
             const shouldRefetchBitcoin = chainIds.includes(BITCOIN_CHAIN_ID);
             console.log('[BalancesContext] shouldRefetchBitcoin', shouldRefetchBitcoin);
@@ -597,17 +825,17 @@ export const BalancesProvider = ({ children, evmAddress, solAddress, solanaRpcUr
         finally {
             setLoading(false);
         }
-    }, [evmAddress, solAddress, solanaRpcUrl, bitcoinAddress, bitcoinRpcUrl, assets, assetsLoading, getUnitValueUsd]);
+    }, [evmAddress, solAddress, solanaRpcUrl, bitcoinAddress, bitcoinRpcUrl, tronAddress, tronRpcUrl, assets, assetsLoading, getUnitValueUsd]);
     // Calculate total USD value
     const totalUsdValue = useMemo(() => {
         return Object.values(balances).reduce((total, balance) => total + balance.usdValue, 0);
     }, [balances]);
-    // Auto-update balances when address, solAddress, bitcoinAddress, or assets change
+    // Auto-update balances when address, solAddress, bitcoinAddress, tronAddress, or assets change
     useEffect(() => {
-        if ((evmAddress || solAddress || bitcoinAddress) && !assetsLoading) {
+        if ((evmAddress || solAddress || bitcoinAddress || tronAddress) && !assetsLoading) {
             updateBalances();
         }
-    }, [evmAddress, solAddress, solanaRpcUrl, bitcoinAddress, bitcoinRpcUrl, assetsLoading, updateBalances]);
+    }, [evmAddress, solAddress, solanaRpcUrl, bitcoinAddress, bitcoinRpcUrl, tronAddress, tronRpcUrl, assetsLoading, updateBalances]);
     const value = useMemo(() => ({
         balances,
         loading: loading || assetsLoading,

package/dist/contexts/SilentSwapContext.d.ts

@@ -7,6 +7,7 @@ import { type ExecuteSwapParams, type SwapResult } from '../hooks/silent/useSile
 import { type OutputStatus } from '../hooks/silent/useOrderTracking.js';
 import { type SolanaWalletConnector, type SolanaConnection } from '../hooks/silent/solana-transaction.js';
 import { type BitcoinWalletConnector, type BitcoinConnection } from '../hooks/silent/bitcoin-transaction.js';
+import { type TronWalletConnector, type TronConnection } from '../hooks/silent/tron-transaction.js';
 import { type SilentSwapWallet } from '../hooks/silent/useWallet.js';
 export interface SilentSwapStatusData {
     platformHealth: PlatformHealthStatus | undefined;
@@ -67,7 +68,7 @@ export interface SilentSwapContextType {
     solanaRpcUrl?: string;
 }
 export declare function useSilentSwap(): SilentSwapContextType;
-export declare function SilentSwapProvider({ children, client, evmAddress, solAddress, connector, isConnected, solanaConnector, solanaConnection, bitcoinConnector, bitcoinConnection, environment, baseUrl, solanaRpcUrl, walletClient, bitcoinAddress, bitcoinRpcUrl, proId, requestWalletConnect, forceBridgeProvider, onAuthStatus, onWalletStatus, }: {
+export declare function SilentSwapProvider({ children, client, evmAddress, solAddress, connector, isConnected, solanaConnector, solanaConnection, bitcoinConnector, bitcoinConnection, tronConnector, tronConnection, environment, baseUrl, solanaRpcUrl, walletClient, bitcoinAddress, tronAddress, bitcoinRpcUrl, tronRpcUrl, proId, requestWalletConnect, forceBridgeProvider, onAuthStatus, onWalletStatus, }: {
     children: React.ReactNode;
     client: SilentSwapClient;
     evmAddress?: string;
@@ -79,11 +80,15 @@ export declare function SilentSwapProvider({ children, client, evmAddress, solAd
     solanaConnection?: SolanaConnection;
     bitcoinConnector?: BitcoinWalletConnector;
     bitcoinConnection?: BitcoinConnection;
+    tronConnector?: TronWalletConnector;
+    tronConnection?: TronConnection;
     environment?: ENVIRONMENT;
     baseUrl?: string;
     solanaRpcUrl?: string;
     bitcoinAddress?: string;
+    tronAddress?: string;
     bitcoinRpcUrl?: string;
+    tronRpcUrl?: string;
     /** Pro user ID for volume tracking (from ?pro= URL or localStorage silentswap:pro) */
     proId?: string;
     /** Optional: request wallet connection when walletClient is missing (e.g. user switched account on mobile). */

package/dist/contexts/SilentSwapContext.js

@@ -81,7 +81,7 @@ export function useSilentSwap() {
     }
     return context;
 }
-function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, bitcoinAddress, solanaConnector, solanaConnection, bitcoinConnector, bitcoinConnection, environment, config, solanaRpcUrl, connector, isConnected = false, walletClient, proId, requestWalletConnect, forceBridgeProvider, onAuthStatus, onWalletStatus, }) {
+function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, bitcoinAddress, tronAddress, solanaConnector, solanaConnection, bitcoinConnector, bitcoinConnection, tronConnector, tronConnection, environment, config, solanaRpcUrl, connector, isConnected = false, walletClient, proId, requestWalletConnect, forceBridgeProvider, onAuthStatus, onWalletStatus, }) {
     // Authentication hook - only for EVM
     const { auth, isLoading: authLoading, authenticate, authExhausted } = useAuth({
         client,
@@ -111,7 +111,7 @@ function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, bit
     const setDestinations = useSwap((state) => state.setDestinations);
     const updateDestinationAmount = useSwap((state) => state.updateDestinationAmount);
     const splits = useSwap((state) => state.splits);
-    const transactionAddress = useTransactionAddress(tokenIn, evmAddress, solAddress, bitcoinAddress);
+    const transactionAddress = useTransactionAddress(tokenIn, evmAddress, solAddress, bitcoinAddress, tronAddress);
     const effectiveQuoteAddress = transactionAddress;
     const { getPrice } = usePrices();
     const { serviceFeeRate, overheadUsd, platformHealth: statusPlatformHealth, minimumDepositUusdc, maximumDepositUusdc, outputLimit, identity, volume, liquidity, storage, isLoading: statusLoading, } = useStatus({ baseUrl: config.baseUrl ?? '', environment: config.environment, proId });
@@ -155,6 +155,9 @@ function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, bit
         solanaConnection,
         bitcoinConnector,
         bitcoinConnection,
+        tronConnector,
+        tronConnection,
+        tronAddress,
         getPrice,
         proId,
         forceBridgeProvider,
@@ -267,7 +270,7 @@ function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, bit
             solanaRpcUrl,
         }, children: children });
 }
-export function SilentSwapProvider({ children, client, evmAddress, solAddress, connector, isConnected, solanaConnector, solanaConnection, bitcoinConnector, bitcoinConnection, environment = ENVIRONMENT.STAGING, baseUrl, solanaRpcUrl, walletClient, bitcoinAddress, bitcoinRpcUrl, proId, requestWalletConnect, forceBridgeProvider, onAuthStatus, onWalletStatus, }) {
+export function SilentSwapProvider({ children, client, evmAddress, solAddress, connector, isConnected, solanaConnector, solanaConnection, bitcoinConnector, bitcoinConnection, tronConnector, tronConnection, environment = ENVIRONMENT.STAGING, baseUrl, solanaRpcUrl, walletClient, bitcoinAddress, tronAddress, bitcoinRpcUrl, tronRpcUrl, proId, requestWalletConnect, forceBridgeProvider, onAuthStatus, onWalletStatus, }) {
     const config = useMemo(() => {
         const computedBaseUrl = baseUrl ?? ENVIRONMENT_CONFIGS[environment].baseUrl;
         return {
@@ -275,5 +278,5 @@ export function SilentSwapProvider({ children, client, evmAddress, solAddress, c
             baseUrl: computedBaseUrl,
         };
     }, [environment, baseUrl]);
-    return (_jsx(AssetsProvider, { children: _jsx(PricesProvider, { children: _jsx(BalancesProvider, { evmAddress: evmAddress, solAddress: solAddress, solanaRpcUrl: solanaRpcUrl, bitcoinAddress: bitcoinAddress, bitcoinRpcUrl: bitcoinRpcUrl, children: _jsx(OrdersProvider, { baseUrl: config.baseUrl, children: _jsx(SilentSwapInnerProvider, { client: client, connector: connector, isConnected: isConnected, evmAddress: evmAddress, solAddress: solAddress, bitcoinAddress: bitcoinAddress, solanaConnector: solanaConnector, solanaConnection: solanaConnection, bitcoinConnector: bitcoinConnector, bitcoinConnection: bitcoinConnection, environment: environment, config: config, solanaRpcUrl: solanaRpcUrl, walletClient: walletClient, proId: proId, requestWalletConnect: requestWalletConnect, forceBridgeProvider: forceBridgeProvider, onAuthStatus: onAuthStatus, onWalletStatus: onWalletStatus, children: children }) }) }) }) }));
+    return (_jsx(AssetsProvider, { children: _jsx(PricesProvider, { children: _jsx(BalancesProvider, { evmAddress: evmAddress, solAddress: solAddress, solanaRpcUrl: solanaRpcUrl, bitcoinAddress: bitcoinAddress, bitcoinRpcUrl: bitcoinRpcUrl, tronAddress: tronAddress, tronRpcUrl: tronRpcUrl, children: _jsx(OrdersProvider, { baseUrl: config.baseUrl, children: _jsx(SilentSwapInnerProvider, { client: client, connector: connector, isConnected: isConnected, evmAddress: evmAddress, solAddress: solAddress, bitcoinAddress: bitcoinAddress, tronAddress: tronAddress, solanaConnector: solanaConnector, solanaConnection: solanaConnection, bitcoinConnector: bitcoinConnector, bitcoinConnection: bitcoinConnection, tronConnector: tronConnector, tronConnection: tronConnection, environment: environment, config: config, solanaRpcUrl: solanaRpcUrl, walletClient: walletClient, proId: proId, requestWalletConnect: requestWalletConnect, forceBridgeProvider: forceBridgeProvider, onAuthStatus: onAuthStatus, onWalletStatus: onWalletStatus, children: children }) }) }) }) }));
 }

package/dist/hooks/silent/tron-transaction.d.ts

@@ -31,13 +31,43 @@ export type TronTransactionExecutor = (tx: BridgeTransaction) => Promise<string>
  */
 export declare function createTronTransactionExecutor(connector: TronWalletConnector, _connection?: TronConnection): TronTransactionExecutor;
 /**
- * Helper to convert relay.link Tron step data to BridgeTransaction.
- * Relay may return EVM-style fields (chainId, to, value, data) for Tron.
+ * Shape of a relay.link step item `data` for Tron.
+ * Relay returns a nested TriggerSmartContract payload (NOT the EVM-style
+ * flat { chainId, to, value, data } shape). Example:
+ *
+ *   {
+ *     type: 'TriggerSmartContract',
+ *     parameter: {
+ *       owner_address: '414527...',      // 21-byte Tron hex (no 0x prefix)
+ *       contract_address: '41a614...',   // 21-byte Tron hex (no 0x prefix)
+ *       call_value: 0,
+ *       data: '095ea7b3...'              // calldata hex (no 0x prefix)
+ *     }
+ *   }
  */
-export declare function convertRelayTronStepToTransaction(stepData: {
+export interface RelayTronStepData {
+    type?: string;
+    parameter?: {
+        owner_address?: string;
+        contract_address?: string;
+        call_value?: number | string;
+        data?: string;
+    };
     chainId?: number;
     to?: string;
     value?: string;
     data?: string;
     gas?: string;
-}, chainId?: number): BridgeTransaction;
+}
+/**
+ * Returns true if the given relay step item data looks like a Tron step.
+ * Used to discriminate Tron steps from Solana / Bitcoin / EVM in a mixed
+ * relay response.
+ */
+export declare function isRelayTronStepData(itemData: unknown): itemData is RelayTronStepData;
+/**
+ * Helper to convert relay.link Tron step data to BridgeTransaction.
+ * Handles both the nested TriggerSmartContract shape (current relay API)
+ * and a legacy EVM-style flat shape.
+ */
+export declare function convertRelayTronStepToTransaction(stepData: RelayTronStepData, chainId?: number): BridgeTransaction;

package/dist/hooks/silent/tron-transaction.js

@@ -22,11 +22,55 @@ export function createTronTransactionExecutor(connector, _connection) {
         return txHash;
     };
 }
+/**
+ * Returns true if the given relay step item data looks like a Tron step.
+ * Used to discriminate Tron steps from Solana / Bitcoin / EVM in a mixed
+ * relay response.
+ */
+export function isRelayTronStepData(itemData) {
+    if (!itemData || typeof itemData !== 'object')
+        return false;
+    const d = itemData;
+    // Nested TriggerSmartContract shape (what relay actually returns today).
+    if (d.type === 'TriggerSmartContract' && d.parameter && typeof d.parameter === 'object') {
+        return true;
+    }
+    // Legacy flat shape fallback.
+    if (typeof d.chainId === 'number' && d.chainId === N_RELAY_CHAIN_ID_TRON) {
+        return true;
+    }
+    return false;
+}
 /**
  * Helper to convert relay.link Tron step data to BridgeTransaction.
- * Relay may return EVM-style fields (chainId, to, value, data) for Tron.
+ * Handles both the nested TriggerSmartContract shape (current relay API)
+ * and a legacy EVM-style flat shape.
  */
 export function convertRelayTronStepToTransaction(stepData, chainId = N_RELAY_CHAIN_ID_TRON) {
+    // Preferred: nested TriggerSmartContract shape from relay.
+    if (stepData.parameter && typeof stepData.parameter === 'object') {
+        const { contract_address, data, call_value } = stepData.parameter;
+        if (!contract_address) {
+            throw new Error('Tron transaction step is missing parameter.contract_address');
+        }
+        if (data === undefined) {
+            throw new Error('Tron transaction step is missing parameter.data');
+        }
+        // Normalize the calldata to include a 0x prefix (downstream connectors
+        // strip/expect this consistently).
+        const normalizedData = data.startsWith('0x') ? data : `0x${data}`;
+        const normalizedValue = call_value === undefined || call_value === null ? '0' : String(call_value);
+        return {
+            chainId,
+            // contract_address is Tron 21-byte hex (e.g. "41a614..."). We pass
+            // it through unchanged — the Tron connector is responsible for
+            // normalizing to base58 / whichever format tronWeb expects.
+            to: contract_address,
+            value: normalizedValue,
+            data: normalizedData,
+        };
+    }
+    // Legacy flat shape fallback.
     if (!stepData.to || stepData.data === undefined) {
         throw new Error('Tron transaction step must have to and data fields');
     }

package/dist/hooks/silent/useAuth.js

@@ -164,6 +164,20 @@ export function useAuth({ client, address, walletClient, connector, domain = typ
                     throw new Error('WalletConnect session is stale, skipping sign-in attempt');
                 }
             }
+            // Liveness check — verify the wallet actually responds to a lightweight
+            // JSON-RPC call before attempting the heavier signMessage. For WC connections
+            // the ping above tests relay connectivity, but a real RPC round-trip catches
+            // cases where the relay is alive but the peer wallet is unresponsive.
+            const LIVENESS_TIMEOUT_MS = 5_000;
+            try {
+                await Promise.race([
+                    walletClient.request({ method: 'eth_chainId' }),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error('Wallet liveness check timed out')), LIVENESS_TIMEOUT_MS)),
+                ]);
+            }
+            catch (livenessErr) {
+                throw new Error(`Wallet not responding to requests: ${livenessErr.message}`);
+            }
             // Create SIWE message
             const siweMessage = createSignInMessageCallback(normalizedAddress, nonceValue, domain);
             // Notify consumer that a wallet signature is about to be requested

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

@@ -3,6 +3,7 @@ import type { Connector } from 'wagmi';
 import type { DepositParams } from '@silentswap/sdk';
 import type { SolanaWalletConnector, SolanaConnection } from './solana-transaction.js';
 import type { BitcoinWalletConnector, BitcoinConnection } from './bitcoin-transaction.js';
+import type { TronWalletConnector, TronConnection } from './tron-transaction.js';
 /** Delay after approve tx so RPC/nodes confirm before next tx (avoids MetaMask RPC errors) */
 export declare const APPROVE_POST_DELAY_MS = 7000;
 /**
@@ -34,12 +35,21 @@ export interface BridgeExecutionResult {
  * @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 declare function useBridgeExecution(walletClient: WalletClient | undefined, connector: Connector | undefined, solanaConnector: SolanaWalletConnector | undefined, solanaConnection: SolanaConnection | undefined, solanaRpcUrl: string | undefined, setCurrentStep: (step: string) => void, depositorAddress: Hex, onStatus?: (status: string) => void, bitcoinConnector?: BitcoinWalletConnector, bitcoinConnection?: BitcoinConnection): {
-    executeSolanaBridge: (sourceAsset: string, sourceAmount: string, usdcAmount: string | undefined, solanaSenderAddress: string, evmSignerAddress: `0x${string}`, depositParams?: DepositParams<`${bigint}`>) => Promise<BridgeExecutionResult>;
+export declare function useBridgeExecution(walletClient: WalletClient | undefined, connector: Connector | undefined, solanaConnector: SolanaWalletConnector | undefined, solanaConnection: SolanaConnection | undefined, solanaRpcUrl: string | undefined, setCurrentStep: (step: string) => void, depositorAddress: Hex, onStatus?: (status: string) => void, bitcoinConnector?: BitcoinWalletConnector, bitcoinConnection?: BitcoinConnection, tronConnector?: TronWalletConnector, tronConnection?: TronConnection): {
+    executeSolanaBridge: (sourceAsset: string, sourceAmount: string, usdcAmount: string | undefined, solanaSenderAddress: string, evmSignerAddress: `0x${string}`, options?: {
+        depositParams?: DepositParams<`${bigint}`>;
+        provider?: "relay" | "debridge";
+    }) => Promise<BridgeExecutionResult>;
     executeBitcoinBridge: (sourceAsset: string, sourceAmount: string, usdcAmount: string | undefined, bitcoinSenderAddress: string, evmSignerAddress: `0x${string}`, depositParams?: DepositParams<`${bigint}`>) => Promise<BridgeExecutionResult>;
+    executeTronBridge: (sourceAsset: string, sourceAmount: string, usdcAmount: string | undefined, tronSenderAddress: string, evmSignerAddress: `0x${string}`, options?: {
+        depositParams?: DepositParams<`${bigint}`>;
+        provider?: "relay" | "debridge";
+    }) => Promise<BridgeExecutionResult>;
     executeEvmBridge: (sourceChainId: number, sourceTokenAddress: string, sourceAmount: string, usdcAmount: string | undefined, depositParams: DepositParams<`${bigint}`>, evmSignerAddress: `0x${string}`, evmSenderAddress?: `0x${string}`, provider?: "relay" | "debridge", allowanceTarget?: string) => Promise<BridgeExecutionResult>;
 };