@silentswap/sdk 0.1.50 → 0.1.52

package/dist/address.d.ts

@@ -1,6 +1,6 @@
 /**
  * Address utilities for validating, formatting, and working with blockchain addresses.
- * Supports EVM (Ethereum-compatible) and Solana addresses.
+ * Supports EVM (Ethereum-compatible), Solana, Bitcoin, and Tron addresses.
  */
 /**
  * Contact source types
@@ -45,6 +45,15 @@ export declare function isValidSolanaAddress(address: string): boolean;
  * @returns True if valid Bitcoin address format
  */
 export declare function isValidBitcoinAddress(address: string): boolean;
+/**
+ * Validate Tron address format
+ * Supports:
+ * - Base58 addresses starting with 'T' (common user-facing format)
+ * - Hex addresses starting with 0x41 (low-level representation)
+ * @param address - Address string to validate
+ * @returns True if valid Tron address format
+ */
+export declare function isValidTronAddress(address: string): boolean;
 /**
  * Validate any supported blockchain address
  * @param address - Address string to validate
@@ -52,7 +61,7 @@ export declare function isValidBitcoinAddress(address: string): boolean;
  */
 export declare function validateAddress(address: string): {
     valid: boolean;
-    type: 'evm' | 'solana' | 'bitcoin' | 'unknown';
+    type: 'evm' | 'solana' | 'bitcoin' | 'tron' | 'unknown';
 };
 /**
  * Normalize an address to its canonical form

package/dist/address.js

@@ -1,6 +1,6 @@
 /**
  * Address utilities for validating, formatting, and working with blockchain addresses.
- * Supports EVM (Ethereum-compatible) and Solana addresses.
+ * Supports EVM (Ethereum-compatible), Solana, Bitcoin, and Tron addresses.
  */
 import { getAddress as viemGetAddress, isAddress as isEvmAddress } from 'viem';
 // ============================================================================
@@ -48,6 +48,26 @@ export function isValidBitcoinAddress(address) {
     }
     return false;
 }
+/**
+ * Validate Tron address format
+ * Supports:
+ * - Base58 addresses starting with 'T' (common user-facing format)
+ * - Hex addresses starting with 0x41 (low-level representation)
+ * @param address - Address string to validate
+ * @returns True if valid Tron address format
+ */
+export function isValidTronAddress(address) {
+    const trimmed = address.trim();
+    // Base58 Tron address (starts with 'T', 34 chars typical)
+    if (/^T[1-9A-HJ-NP-Za-km-z]{33}$/.test(trimmed)) {
+        return true;
+    }
+    // Hex Tron address (0x41 + 20 bytes)
+    if (/^0x41[a-fA-F0-9]{40}$/.test(trimmed)) {
+        return true;
+    }
+    return false;
+}
 /**
  * Validate any supported blockchain address
  * @param address - Address string to validate
@@ -63,6 +83,9 @@ export function validateAddress(address) {
     if (isValidBitcoinAddress(address)) {
         return { valid: true, type: 'bitcoin' };
     }
+    if (isValidTronAddress(address)) {
+        return { valid: true, type: 'tron' };
+    }
     return { valid: false, type: 'unknown' };
 }
 /**

package/dist/asset-utils.d.ts

@@ -68,7 +68,7 @@ export declare const extractChainIdsFromAssets: (assets: string[], options?: {
  * Extract chain ID from a single asset (CAIP-19 string or AssetInfo)
  * Returns number for EVM chains, 'solana' for Solana, null if invalid
  */
-export declare const extractChainIdFromAsset: (asset: string | AssetInfo | null, solanaChainId?: number) => number | "solana" | "bitcoin" | null;
+export declare const extractChainIdFromAsset: (asset: string | AssetInfo | null, solanaChainId?: number) => number | "solana" | "bitcoin" | "tron" | null;
 /**
  * Get chain info object for the token's chain
  */

package/dist/asset-utils.js

@@ -1,7 +1,7 @@
 import { getChainByCaip2 } from './assets.js';
 // Core CAIP-19 parsing utilities
-import { parseCaip19 as coreParseCaip19, getChainNamespace as coreGetChainNamespace, getChainId as coreGetChainId, getAssetNamespace as coreGetAssetNamespace, getAssetReference as coreGetAssetReference, getCaip2FromCaip19, getEvmChainId, isNativeToken as coreIsNativeToken, isEvmAsset, isSolanaAsset, parseEvmCaip19, isEvmNativeToken as coreIsEvmNativeToken, isErc20Token, isSolanaNativeToken as coreIsSolanaNativeToken, isSplToken, isBitcoinAsset, } from './caip19.js';
-import { BITCOIN_CHAIN_ID } from './chains.js';
+import { parseCaip19 as coreParseCaip19, getChainNamespace as coreGetChainNamespace, getChainId as coreGetChainId, getAssetNamespace as coreGetAssetNamespace, getAssetReference as coreGetAssetReference, getCaip2FromCaip19, getEvmChainId, isNativeToken as coreIsNativeToken, isEvmAsset, isSolanaAsset, parseEvmCaip19, isEvmNativeToken as coreIsEvmNativeToken, isErc20Token, isSolanaNativeToken as coreIsSolanaNativeToken, isSplToken, isBitcoinAsset, isTronAsset as coreIsTronAsset, } from './caip19.js';
+import { BITCOIN_CHAIN_ID, TRON_CHAIN_ID } from './chains.js';
 import { N_DEBRIDGE_CHAIN_ID_SOLANA } from './constants.js';
 // ============================================================================
 // CAIP-19 Parsing Wrappers (for AssetInfo convenience)
@@ -130,6 +130,9 @@ export const getTokenChainId = (token) => {
     if (isBitcoinAsset(token.caip19)) {
         return BITCOIN_CHAIN_ID;
     }
+    if (coreIsTronAsset(token.caip19)) {
+        return TRON_CHAIN_ID;
+    }
     // For EVM chains, return the numeric chain ID
     return getEvmChainId(token.caip19);
 };
@@ -179,6 +182,9 @@ export const extractChainIdFromAsset = (asset, solanaChainId) => {
     if (isBitcoinAsset(caip19)) {
         return 'bitcoin';
     }
+    if (coreIsTronAsset(caip19)) {
+        return 'tron';
+    }
     const parsed = parseEvmCaip19(caip19);
     if (parsed?.chainId) {
         // Convert Solana numeric chain ID to 'solana' if provided

package/dist/assets.js

@@ -27,6 +27,7 @@ export function getAllAssetsArray() {
 export const COMMON_ASSETS = getAllAssetsArray().filter(asset => {
     // Filter to commonly used tokens (matches Svelte PopularTokensArea.svelte)
     const commonCaip19s = [
+        'tron:0x2b6653dc/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t', // USDT on Tron
         'bip122:000000000019d6689c085ae165831e93/slip44:0', // BTC on Bitcoin
         'eip155:1/slip44:60', // ETH on Ethereum
         'eip155:1/erc20:0xdAC17F958D2ee523a2206206994597C13D831ec7', // USDT on Ethereum

package/dist/bridge.js

@@ -1,18 +1,19 @@
 import { encodeFunctionData, erc20Abi } from 'viem';
 import BigNumber from 'bignumber.js';
-import { NI_CHAIN_ID_AVALANCHE, S0X_ADDR_USDC_AVALANCHE, N_DEBRIDGE_CHAIN_ID_SOLANA, N_RELAY_CHAIN_ID_SOLANA, N_RELAY_CHAIN_ID_BITCOIN, N_RELAY_CHAIN_ID_SUI, N_RELAY_CHAIN_ID_TRON, SB58_ADDR_SOL_PROGRAM_SYSTEM, } from './constants.js';
+import { NI_CHAIN_ID_AVALANCHE, S0X_ADDR_USDC_AVALANCHE, S0X_ADDR_EVM_ZERO, UINT256_MAX, N_DEBRIDGE_CHAIN_ID_SOLANA, N_DEBRIDGE_CHAIN_ID_TRON, N_RELAY_CHAIN_ID_SOLANA, N_RELAY_CHAIN_ID_BITCOIN, N_RELAY_CHAIN_ID_SUI, N_RELAY_CHAIN_ID_TRON, S0X_ADDR_TRON_NATIVE, SB58_ADDR_SOL_PROGRAM_SYSTEM, } from './constants.js';
 import { createPhonyDepositCalldata } from './wallet.js';
-// Zero address for native tokens (EVM)
-const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
 /**
  * Map relay.link chain IDs to deBridge chain IDs
  * Different bridge providers use different chain ID schemes
  */
 function mapChainIdToDebridge(chainId) {
     // Map relay.link Solana chain ID to deBridge Solana chain ID
-    if (chainId === 792703809) { // N_RELAY_CHAIN_ID_SOLANA
+    if (chainId === N_RELAY_CHAIN_ID_SOLANA) {
         return N_DEBRIDGE_CHAIN_ID_SOLANA;
     }
+    if (chainId === N_RELAY_CHAIN_ID_TRON) {
+        return N_DEBRIDGE_CHAIN_ID_TRON;
+    }
     // For other chains, return as-is (EVM chains use the same IDs)
     return chainId;
 }
@@ -22,6 +23,9 @@ function mapChainIdToDebridge(chainId) {
 function isSolanaChainId(chainId) {
     return chainId === N_DEBRIDGE_CHAIN_ID_SOLANA || chainId === N_RELAY_CHAIN_ID_SOLANA;
 }
+function isTronChainId(chainId) {
+    return chainId === N_RELAY_CHAIN_ID_TRON || chainId === N_DEBRIDGE_CHAIN_ID_TRON;
+}
 /**
  * Check if a chain ID represents a non-EVM chain (Solana, Bitcoin, Sui, Tron)
  */
@@ -80,6 +84,7 @@ export function getRelayOriginAsset(srcChainId, srcToken) {
 function normalizeTokenAddress(srcChainId, srcToken) {
     // Check if this is a Solana chain
     const isSolanaChain = isSolanaChainId(srcChainId);
+    const tronChain = isTronChainId(srcChainId);
     if (isSolanaChain) {
         // For Solana, check if it's a native token (system program) or empty
         // Solana native token address is the system program: 11111111111111111111111111111111
@@ -91,11 +96,17 @@ function normalizeTokenAddress(srcChainId, srcToken) {
         // Matches relay_origin_asset() line 191: k_asset_src.isSolanaToken()? k_asset_src.address()
         return srcToken;
     }
+    else if (tronChain) {
+        if (!srcToken || srcToken === '' || srcToken === '0x0' || srcToken === '0x0000000000000000000000000000000000000000') {
+            return S0X_ADDR_TRON_NATIVE;
+        }
+        return srcToken;
+    }
     else {
         // For EVM chains, normalize to zero address for native tokens
         // Matches relay_origin_asset() line 188: k_asset_src.isEvmNative()? S0X_ADDR_EVM_ZERO
         if (!srcToken || srcToken === '0x0' || srcToken === '0x0000000000000000000000000000000000000000') {
-            return ZERO_ADDRESS;
+            return S0X_ADDR_EVM_ZERO;
         }
         // Return the EVM token address as-is
         // Matches relay_origin_asset() line 189: k_asset_src.isEvmErc20()? k_asset_src.address()
@@ -109,9 +120,10 @@ function normalizeTokenAddress(srcChainId, srcToken) {
 export async function executeRelayBridge(quote, executeTransaction, switchChain, setStep) {
     const txHashes = [];
     for (const tx of quote.txs) {
-        // Solana and Bitcoin transactions don't need chain switching (handled by connector)
+        // Solana, Bitcoin, and Tron transactions don't need EVM chain switching (handled by chain-specific connectors)
         const isBitcoinTx = tx.chainId === N_RELAY_CHAIN_ID_BITCOIN || tx.psbt;
-        if (!tx.instructions && !isBitcoinTx) {
+        const isTronTx = tx.chainId === N_RELAY_CHAIN_ID_TRON;
+        if (!tx.instructions && !isBitcoinTx && !isTronTx) {
             setStep(`Switching to chain ${tx.chainId}`);
             // Switch to the correct chain for EVM transactions
             await switchChain(tx.chainId);
@@ -139,12 +151,13 @@ export async function executeDebridgeBridge(quote, executeTransaction, switchCha
         throw new Error('No transactions in debridge quote');
     }
     const tx = quote.txs[0];
-    // Non-EVM transactions don't need EVM chain switching.
+    // Non-EVM transactions (Solana/Bitcoin/Tron) don't need EVM chain switching.
     const isNonEvmTx = !!tx.instructions ||
         tx.chainId === N_DEBRIDGE_CHAIN_ID_SOLANA ||
         tx.chainId === N_RELAY_CHAIN_ID_SOLANA ||
         tx.chainId === N_RELAY_CHAIN_ID_BITCOIN ||
         tx.chainId === N_RELAY_CHAIN_ID_TRON ||
+        tx.chainId === N_DEBRIDGE_CHAIN_ID_TRON ||
         !!tx.psbt;
     if (!isNonEvmTx) {
         setStep(`Switching to chain ${tx.chainId}`);
@@ -336,6 +349,7 @@ export async function fetchDebridgeOrder(params, signal) {
  * Note: DLN does not support same-chain swaps via create-tx endpoint
  */
 async function fetchDebridgeSingleChainOrder(params, signal) {
+    console.log('fetchDebridgeSingleChainOrder');
     // Build query parameters for single-chain swap endpoint
     const queryParams = new URLSearchParams({
         chainId: params.srcChainId.toString(),
@@ -417,7 +431,6 @@ async function fetchDebridgeSingleChainOrder(params, signal) {
         },
     };
 }
-const UINT256_MAX = 2n ** 256n - 1n;
 /**
  * Solve for optimal USDC amount using relay.link
  */

package/dist/caip19.d.ts

@@ -16,6 +16,13 @@ export declare const EVM_CAIP19_REGEX: RegExp;
  * Groups: [1] chainId, [2] token address (for token), [3] slip44 number (for native)
  */
 export declare const SOLANA_CAIP19_REGEX: RegExp;
+/**
+ * Tron CAIP-19 regex pattern for parsing native and TRC-20 tokens
+ * Native:  tron:chainRef/slip44:195
+ * TRC-20:  tron:chainRef/trc20:ADDRESS  or  tron:chainRef/token:ADDRESS
+ */
+export declare const TRON_CAIP19_NATIVE_REGEX: RegExp;
+export declare const TRON_CAIP19_TOKEN_REGEX: RegExp;
 export declare enum Caip19Namespace {
     BIP122 = "bip122",
     EIP155 = "eip155",
@@ -57,6 +64,14 @@ export interface ParsedSolanaCaip19 {
     tokenAddress: string | null;
     slip44: number | null;
 }
+/**
+ * Parsed Tron CAIP-19 result
+ */
+export interface ParsedTronCaip19 {
+    chainId: number;
+    isNative: boolean;
+    tokenAddress: string | null;
+}
 /**
  * Parse a CAIP-19 string into its components
  * @param caip19 - CAIP-19 formatted string
@@ -82,6 +97,15 @@ export declare function parseEvmCaip19(caip19: string): ParsedEvmCaip19 | null;
  * @returns Parsed Solana-specific components or null if not Solana
  */
 export declare function parseSolanaCaip19(caip19: string): ParsedSolanaCaip19 | null;
+/**
+ * Parse a Tron CAIP-19 string
+ * @param caip19 - CAIP-19 formatted string
+ * @returns Parsed Tron-specific components or null if not Tron
+ * @example
+ * parseTronCaip19('tron:728126428/slip44:195') // { chainId: 728126428, isNative: true, tokenAddress: null }
+ * parseTronCaip19('tron:728126428/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t') // { chainId: 728126428, isNative: false, tokenAddress: 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t' }
+ */
+export declare function parseTronCaip19(caip19: string): ParsedTronCaip19 | null;
 /**
  * Get chain namespace from CAIP-19
  * @param caip19 - CAIP-19 string
@@ -142,6 +166,12 @@ export declare function isEvmAsset(caip19: string): boolean;
  * @returns True if Solana asset
  */
 export declare function isSolanaAsset(caip19: string): boolean;
+/**
+ * Check if CAIP-19 represents a Tron asset
+ * @param caip19 - CAIP-19 string
+ * @returns True if Tron asset
+ */
+export declare function isTronAsset(caip19: string): boolean;
 /** BIP122 chain ID for Bitcoin mainnet (genesis hash). */
 export declare const BIP122_BITCOIN_MAINNET_CHAIN_ID = "000000000019d6689c085ae165831e93";
 /**

package/dist/caip19.js

@@ -18,6 +18,13 @@ export const EVM_CAIP19_REGEX = /eip155:(\d+)\/(?:erc20:(0x[a-fA-F0-9]+)|slip44:
  * Groups: [1] chainId, [2] token address (for token), [3] slip44 number (for native)
  */
 export const SOLANA_CAIP19_REGEX = /solana:([a-zA-Z0-9]+)\/(?:token:([a-zA-Z0-9]+)|slip44:(\d+))/;
+/**
+ * Tron CAIP-19 regex pattern for parsing native and TRC-20 tokens
+ * Native:  tron:chainRef/slip44:195
+ * TRC-20:  tron:chainRef/trc20:ADDRESS  or  tron:chainRef/token:ADDRESS
+ */
+export const TRON_CAIP19_NATIVE_REGEX = /^tron:([^/]+)\/slip44:\d+$/i;
+export const TRON_CAIP19_TOKEN_REGEX = /^tron:([^/]+)\/(?:trc20|token):([A-Za-z0-9]+)$/i;
 // ============================================================================
 // Enums / Types
 // ============================================================================
@@ -97,6 +104,35 @@ export function parseSolanaCaip19(caip19) {
         slip44,
     };
 }
+/**
+ * Parse a Tron CAIP-19 string
+ * @param caip19 - CAIP-19 formatted string
+ * @returns Parsed Tron-specific components or null if not Tron
+ * @example
+ * parseTronCaip19('tron:728126428/slip44:195') // { chainId: 728126428, isNative: true, tokenAddress: null }
+ * parseTronCaip19('tron:728126428/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t') // { chainId: 728126428, isNative: false, tokenAddress: 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t' }
+ */
+export function parseTronCaip19(caip19) {
+    const nativeMatch = TRON_CAIP19_NATIVE_REGEX.exec(caip19);
+    if (nativeMatch) {
+        const chainId = Number(nativeMatch[1]);
+        return {
+            chainId: Number.isFinite(chainId) ? chainId : 0,
+            isNative: true,
+            tokenAddress: null,
+        };
+    }
+    const tokenMatch = TRON_CAIP19_TOKEN_REGEX.exec(caip19);
+    if (tokenMatch) {
+        const chainId = Number(tokenMatch[1]);
+        return {
+            chainId: Number.isFinite(chainId) ? chainId : 0,
+            isNative: false,
+            tokenAddress: tokenMatch[2] || null,
+        };
+    }
+    return null;
+}
 // ============================================================================
 // Helper Functions - Extraction
 // ============================================================================
@@ -187,6 +223,14 @@ export function isEvmAsset(caip19) {
 export function isSolanaAsset(caip19) {
     return caip19.startsWith('solana:');
 }
+/**
+ * Check if CAIP-19 represents a Tron asset
+ * @param caip19 - CAIP-19 string
+ * @returns True if Tron asset
+ */
+export function isTronAsset(caip19) {
+    return caip19.startsWith('tron:');
+}
 /** BIP122 chain ID for Bitcoin mainnet (genesis hash). */
 export const BIP122_BITCOIN_MAINNET_CHAIN_ID = '000000000019d6689c085ae165831e93';
 /**

package/dist/chain.d.ts

@@ -26,6 +26,17 @@ export declare function pingWalletConnectSession(connector: {
     type: string;
     getProvider: () => Promise<unknown>;
 }): Promise<boolean>;
+/**
+ * Clear stale WalletConnect data from localStorage.
+ *
+ * Browsers accumulate WC relay messages, expired pairings, and orphaned session
+ * keys across page reloads. Stale symmetric keys cause "onRelayMessage → failed
+ * to process an inbound message" errors because the relay delivers messages for
+ * topics whose keys have already been garbage-collected locally.
+ *
+ * Call on app startup and after disconnecting a wallet.
+ */
+export declare function clearStaleWalletConnectSessions(): void;
 /**
  * Create a public client with RPC fallback configuration
  *

package/dist/chain.js

@@ -115,6 +115,78 @@ export async function pingWalletConnectSession(connector) {
         return false;
     }
 }
+/**
+ * Clear stale WalletConnect data from localStorage.
+ *
+ * Browsers accumulate WC relay messages, expired pairings, and orphaned session
+ * keys across page reloads. Stale symmetric keys cause "onRelayMessage → failed
+ * to process an inbound message" errors because the relay delivers messages for
+ * topics whose keys have already been garbage-collected locally.
+ *
+ * Call on app startup and after disconnecting a wallet.
+ */
+export function clearStaleWalletConnectSessions() {
+    if (typeof localStorage === 'undefined')
+        return;
+    try {
+        const keys = Object.keys(localStorage).filter(k => k.startsWith('wc@2:'));
+        const nowSec = Math.floor(Date.now() / 1000);
+        let cleaned = 0;
+        for (const key of keys) {
+            // Accumulated relay messages — safe to purge entirely; the relay
+            // will re-deliver anything the active session still needs.
+            if (key.includes('//messages')) {
+                localStorage.removeItem(key);
+                cleaned++;
+                continue;
+            }
+            // Prune expired pairings
+            if (key.includes('//pairing')) {
+                cleaned += pruneExpiredEntries(key, nowSec);
+                continue;
+            }
+            // Prune expired sessions
+            if (key.includes('//session')) {
+                cleaned += pruneExpiredEntries(key, nowSec);
+                continue;
+            }
+            // Prune expired proposals
+            if (key.includes('//proposal')) {
+                cleaned += pruneExpiredEntries(key, nowSec);
+                continue;
+            }
+        }
+        if (cleaned > 0) {
+            console.log(`[clearStaleWC] cleaned ${cleaned} stale WalletConnect entries`);
+        }
+    }
+    catch (err) {
+        console.warn('[clearStaleWC] cleanup failed:', err.message);
+    }
+}
+/** Remove expired entries from a JSON-array localStorage key. Returns 1 if anything was pruned, 0 otherwise. */
+function pruneExpiredEntries(storageKey, nowSec) {
+    try {
+        const raw = localStorage.getItem(storageKey);
+        if (!raw)
+            return 0;
+        const data = JSON.parse(raw);
+        if (!Array.isArray(data))
+            return 0;
+        const valid = data.filter((entry) => !entry.expiry || entry.expiry > nowSec);
+        if (valid.length < data.length) {
+            if (valid.length === 0) {
+                localStorage.removeItem(storageKey);
+            }
+            else {
+                localStorage.setItem(storageKey, JSON.stringify(valid));
+            }
+            return 1;
+        }
+    }
+    catch { /* ignore parse errors */ }
+    return 0;
+}
 /**
  * Create a public client with RPC fallback configuration
  *

package/dist/chains.d.ts

@@ -1,6 +1,7 @@
 import { type Chain } from 'viem/chains';
 export declare const SOLANA_CHAIN_ID = 7565164;
 export declare const BITCOIN_CHAIN_ID = 8253038;
+export declare const TRON_CHAIN_ID = 728126428;
 /**
  * Supported EVM chains for public client creation
  *

package/dist/chains.js

@@ -1,6 +1,7 @@
 import { mainnet, avalanche, base, polygon, arbitrum, bsc, optimism, berachain, kava, taiko, filecoin, gnosis, coreDao, soneium, hedera, immutableZkEvm, hemi, unichain, rootstock, cronos, sei, linea, mantle, pulsechain, evmos, } from 'viem/chains';
 export const SOLANA_CHAIN_ID = 7565164;
 export const BITCOIN_CHAIN_ID = 8253038; // Relay chain ID for Bitcoin
+export const TRON_CHAIN_ID = 728126428; // Relay chain ID for Tron
 /**
  * Supported EVM chains for public client creation
  *

package/dist/constants.d.ts

@@ -2,6 +2,8 @@ import { type Hex } from 'viem';
 export declare const EVM_PHONY_ADDRESS: Hex;
 export declare const EVM_NATIVE_ADDRESS: Hex;
 export declare const DEAD_ADDRESS: Hex;
+export declare const S0X_ADDR_EVM_ZERO: Hex;
+export declare const UINT256_MAX: bigint;
 export declare const MAINNET_GATEWAY_ADDRESS = "0xA798d4D04faad17C309127C2B9B99Cc459635eDC";
 export declare const MAINNET_GATEWAY_PUBLIC_KEY = "0x0494913354a94d40604cd453d2a654489aa78472daf953c63cae4ceaaa40740d682905847e99618c34b360d8ef4645a954cc9686619995465dfdba6da34f35642f";
 export declare enum ENVIRONMENT {
@@ -31,12 +33,15 @@ export declare const SB58_ADDR_SOL_PROGRAM_SYSTEM = "111111111111111111111111111
 export declare const SB58_ADDR_SOL_RELAY_LINK_RECIPIENT = "CbKGgVKLJFb8bBrf58DnAkdryX6ubewVytn7X957YwNr";
 export declare const SB58_ADDR_SOL_DEAD = "1nc1nerator11111111111111111111111111111111";
 export declare const SBTC_ADDR_BITCOIN_NATIVE = "bc1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqmql8k8";
-export declare const SBTC_ADDR_BTC_RELAY_LINK_RECIPIENT = "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4";
+export declare const SBTC_ADDR_BTC_RELAY_LINK_RECIPIENT = "bc1q4vxn43l44h30nkluqfxd9eckf45vr2awz38lwa";
+export declare const S0X_ADDR_TRON_NATIVE: "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb";
+export declare const SB58_ADDR_TRON_DEAD = "TLsV52sRDL79HXGGm9yzwKibb6BeruhUzy";
 export declare const N_RELAY_CHAIN_ID_SOLANA = 792703809;
 export declare const N_RELAY_CHAIN_ID_BITCOIN = 8253038;
 export declare const N_RELAY_CHAIN_ID_TRON = 728126428;
 export declare const N_RELAY_CHAIN_ID_SUI = 103665049;
 export declare const N_DEBRIDGE_CHAIN_ID_SOLANA = 7565164;
+export declare const N_DEBRIDGE_CHAIN_ID_TRON = 100000026;
 export declare const S0X_ADDR_EVM_RELAY_LINK_DEAD = "0x000000000000000000000000000000000000dead";
 export declare const P_URL_API_RPC_SOLANA = "https://api.mainnet-beta.solana.com";
 export declare const CALCULATION_DIRECTION_INPUT_TO_OUTPUT: "input-to-output";

package/dist/constants.js

@@ -2,6 +2,8 @@
 export const EVM_PHONY_ADDRESS = '0x1111111111111111111111111111111111111111';
 export const EVM_NATIVE_ADDRESS = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
 export const DEAD_ADDRESS = '0x000000000000000000000000000000000000dead';
+export const S0X_ADDR_EVM_ZERO = '0x0000000000000000000000000000000000000000';
+export const UINT256_MAX = 2n ** 256n - 1n;
 // Mainnet constants
 const MAINNET_SILENTSWAP_API = 'https://api.silentswap.com';
 const STAGING_SILENTSWAP_API = 'https://api-staging.silentswap.com';
@@ -58,7 +60,14 @@ export const SB58_ADDR_SOL_DEAD = '1nc1nerator11111111111111111111111111111111';
 export const SBTC_ADDR_BITCOIN_NATIVE = 'bc1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqmql8k8';
 // Valid Bitcoin recipient address for relay.link quote estimation (BIP-173 test vector P2WPKH)
 // relay.link rejects the phony zero address (SBTC_ADDR_BITCOIN_NATIVE) as recipient — use this fallback
-export const SBTC_ADDR_BTC_RELAY_LINK_RECIPIENT = 'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4';
+export const SBTC_ADDR_BTC_RELAY_LINK_RECIPIENT = 'bc1q4vxn43l44h30nkluqfxd9eckf45vr2awz38lwa';
+// Tron constants
+// Tron native token (TRX) pseudo-address used by Relay/deBridge for native TRX.
+// Note: despite the historic "dead" naming, this is the canonical Tron native placeholder.
+export const S0X_ADDR_TRON_NATIVE = 'T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb';
+// Valid Tron recipient address for relay.link quote estimation (Tron Foundation burn address).
+// relay.link rejects the native TRX pseudo-address (S0X_ADDR_TRON_NATIVE) as recipient — use this fallback.
+export const SB58_ADDR_TRON_DEAD = 'TLsV52sRDL79HXGGm9yzwKibb6BeruhUzy';
 // Relay.link chain IDs for non-EVM chains
 export const N_RELAY_CHAIN_ID_SOLANA = 792703809;
 export const N_RELAY_CHAIN_ID_BITCOIN = 8253038;
@@ -66,6 +75,7 @@ export const N_RELAY_CHAIN_ID_TRON = 728126428;
 export const N_RELAY_CHAIN_ID_SUI = 103665049;
 // deBridge chain IDs for non-EVM chains
 export const N_DEBRIDGE_CHAIN_ID_SOLANA = 7565164;
+export const N_DEBRIDGE_CHAIN_ID_TRON = 100000026;
 // Relay.link EVM constants
 export const S0X_ADDR_EVM_RELAY_LINK_DEAD = '0x000000000000000000000000000000000000dead';
 // Solana RPC endpoint (default, can be overridden via environment)

package/dist/data/filtered.json

@@ -485,6 +485,18 @@
 			"nativeCoinId": "ethereum",
 			"name": "Soneium"
 		},
+		"tron:0x2b6653dc": {
+			"coingeckoPlatformId": "tron",
+			"coingeckoId": "tron",
+			"native": {
+				"slip44": 195,
+				"decimals": 6,
+				"symbol": "TRX"
+			},
+			"caip2": "tron:0x2b6653dc",
+			"nativeCoinId": "tron",
+			"name": "TRON"
+		},
 		"bip122:000000000019d6689c085ae165831e93": {
 			"coingeckoPlatformId": "bitcoin",
 			"coingeckoId": "bitcoin",
@@ -3590,6 +3602,28 @@
 				"1C0E00"
 			]
 		},
+		"tron:0x2b6653dc/slip44:195": {
+			"caip19": "tron:0x2b6653dc/slip44:195",
+			"coingeckoId": "tron",
+			"name": "TRON",
+			"symbol": "TRX",
+			"decimals": 6,
+			"gradient": [
+				"000000",
+				"1C0E00"
+			]
+		},
+		"tron:0x2b6653dc/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t": {
+			"caip19": "tron:0x2b6653dc/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+			"coingeckoId": "tether",
+			"name": "Tether USD (Tron)",
+			"symbol": "USDT",
+			"decimals": 6,
+			"gradient": [
+				"26A17B",
+				"125C48"
+			]
+		},
 		"eip155:56/erc20:0x000Ae314E2A2172a039B26378814C252734f556A": {
 			"caip19": "eip155:56/erc20:0x000Ae314E2A2172a039B26378814C252734f556A",
 			"coingeckoId": "aster-2",

package/dist/quote-utils.js

@@ -1,16 +1,19 @@
 import BigNumber from 'bignumber.js';
 import { fetchRelayQuote, fetchDebridgeOrder, } from './bridge.js';
-import { N_DEBRIDGE_CHAIN_ID_SOLANA, N_RELAY_CHAIN_ID_SOLANA, N_RELAY_CHAIN_ID_BITCOIN, SB58_ADDR_SOL_PROGRAM_SYSTEM, SB58_ADDR_SOL_DEAD, SB58_ADDR_SOL_RELAY_LINK_RECIPIENT, SBTC_ADDR_BITCOIN_NATIVE, SBTC_ADDR_BTC_RELAY_LINK_RECIPIENT, DEAD_ADDRESS, } from './constants.js';
-const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+import { N_DEBRIDGE_CHAIN_ID_SOLANA, N_DEBRIDGE_CHAIN_ID_TRON, N_RELAY_CHAIN_ID_SOLANA, N_RELAY_CHAIN_ID_BITCOIN, N_RELAY_CHAIN_ID_TRON, S0X_ADDR_EVM_ZERO, SB58_ADDR_SOL_PROGRAM_SYSTEM, SB58_ADDR_SOL_DEAD, SB58_ADDR_SOL_RELAY_LINK_RECIPIENT, SBTC_ADDR_BITCOIN_NATIVE, SB58_ADDR_TRON_DEAD, S0X_ADDR_TRON_NATIVE, SBTC_ADDR_BTC_RELAY_LINK_RECIPIENT, DEAD_ADDRESS, } from './constants.js';
 /**
  * Map relay.link chain IDs to deBridge chain IDs
  * Different bridge providers use different chain ID schemes
  */
 function mapChainIdToDebridge(chainId) {
     // Map relay.link Solana chain ID to deBridge Solana chain ID
-    if (chainId === 792703809) { // N_RELAY_CHAIN_ID_SOLANA
+    if (chainId === N_RELAY_CHAIN_ID_SOLANA) {
         return N_DEBRIDGE_CHAIN_ID_SOLANA;
     }
+    // Map relay.link Tron chain ID to deBridge Tron chain ID
+    if (chainId === N_RELAY_CHAIN_ID_TRON) {
+        return N_DEBRIDGE_CHAIN_ID_TRON;
+    }
     // For other chains, return as-is (EVM chains use the same IDs)
     return chainId;
 }
@@ -18,7 +21,7 @@ function mapChainIdToDebridge(chainId) {
  * Check if a chain ID represents Solana (either relay or deBridge format)
  */
 function isSolanaChainId(chainId) {
-    return chainId === N_DEBRIDGE_CHAIN_ID_SOLANA || chainId === 792703809; // N_RELAY_CHAIN_ID_SOLANA
+    return chainId === N_DEBRIDGE_CHAIN_ID_SOLANA || chainId === N_RELAY_CHAIN_ID_SOLANA;
 }
 /**
  * Check if a chain ID represents Bitcoin
@@ -26,6 +29,23 @@ function isSolanaChainId(chainId) {
 function isBitcoinChainId(chainId) {
     return chainId === N_RELAY_CHAIN_ID_BITCOIN;
 }
+/**
+ * Check if a chain ID represents Tron
+ */
+function isTronChainId(chainId) {
+    return chainId === N_RELAY_CHAIN_ID_TRON || chainId === N_DEBRIDGE_CHAIN_ID_TRON;
+}
+function isTronAddress(address) {
+    if (!address)
+        return false;
+    return /^T[1-9A-HJ-NP-Za-km-z]{33}$/.test(address) || /^0x41[a-fA-F0-9]{40}$/.test(address);
+}
+function isValidTronRecipientAddress(address) {
+    if (!isTronAddress(address))
+        return false;
+    // The native-token pseudo-address must never be used as recipient/authority.
+    return address !== S0X_ADDR_TRON_NATIVE;
+}
 /**
  * Normalize token address for bridge API calls
  * Handles EVM (hex addresses), Solana (base58 addresses), and Bitcoin
@@ -35,7 +55,16 @@ function normalizeTokenAddressForQuote(chainId, token) {
     const isSolanaChain = isSolanaChainId(chainId);
     // Check if this is a Bitcoin chain
     const isBitcoinChain = isBitcoinChainId(chainId);
-    if (isBitcoinChain) {
+    // Check if this is a Tron chain
+    const isTronChain = isTronChainId(chainId);
+    if (isTronChain) {
+        // For Tron native, relay/deBridge expect Tron native pseudo-address (T9y...).
+        if (!token || token === '' || token === '0x0' || token === '0x0000000000000000000000000000000000000000') {
+            return S0X_ADDR_TRON_NATIVE;
+        }
+        return token;
+    }
+    else if (isBitcoinChain) {
         // For Bitcoin, native token (BTC) uses the Bitcoin native token address
         // relay.link expects "bc1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqmql8k8" for native Bitcoin
         if (!token || token === '' || token === '0x0' || token === '0x0000000000000000000000000000000000000000') {
@@ -56,7 +85,7 @@ function normalizeTokenAddressForQuote(chainId, token) {
     else {
         // For EVM chains, normalize to zero address for native tokens
         if (!token || token === '0x0' || token === '0x0000000000000000000000000000000000000000') {
-            return ZERO_ADDRESS;
+            return S0X_ADDR_EVM_ZERO;
         }
         return token;
     }
@@ -323,15 +352,31 @@ forceProvider, tradeType = 'EXACT_INPUT', dstAmount) {
     // Map chain IDs for deBridge (relay.link uses different chain IDs for Solana)
     const debridgeSrcChainId = mapChainIdToDebridge(srcChainId);
     const debridgeDstChainId = mapChainIdToDebridge(dstChainId);
-    // Check if destination is Solana or Bitcoin
+    // Check if destination is Solana, Bitcoin, or Tron
     const isDestSolana = isSolanaChainId(debridgeDstChainId);
     const isSrcSolana = isSolanaChainId(debridgeSrcChainId);
     const isDestBitcoin = isBitcoinChainId(dstChainId);
     const isSrcBitcoin = isBitcoinChainId(srcChainId);
+    const isDestTron = isTronChainId(dstChainId);
+    const isSrcTron = isTronChainId(srcChainId);
     // Determine the correct user address for relay.link based on source chain
     // Relay.link requires the user address to match the source chain format
     let relayUserAddress;
-    if (isSrcBitcoin) {
+    if (isSrcTron) {
+        // Source is Tron - user must be Tron address (starts with 'T')
+        if (sourceAddress && sourceAddress.startsWith('T')) {
+            relayUserAddress = sourceAddress;
+        }
+        else if (typeof userAddress === 'string' && userAddress.startsWith('T')) {
+            relayUserAddress = userAddress;
+        }
+        else {
+            // Fallback to Tron dead address for estimation
+            console.warn('Tron address required for Tron source chain, using Tron dead address');
+            relayUserAddress = SB58_ADDR_TRON_DEAD;
+        }
+    }
+    else if (isSrcBitcoin) {
         // Source is Bitcoin - user must be Bitcoin address
         // Prefer sourceAddress if provided, then check userAddress format
         if (sourceAddress && !sourceAddress.startsWith('0x') && !sourceAddress.startsWith('1111')) {
@@ -341,8 +386,9 @@ forceProvider, tradeType = 'EXACT_INPUT', dstAmount) {
             relayUserAddress = userAddress;
         }
         else {
-            // If we can't determine Bitcoin address, throw error (Bitcoin requires valid address)
-            throw new Error('Bitcoin address required for Bitcoin source chain');
+            // Fallback to Bitcoin dead address for estimation
+            console.warn('Bitcoin address required for Bitcoin source chain, using Bitcoin dead address');
+            relayUserAddress = SBTC_ADDR_BTC_RELAY_LINK_RECIPIENT;
         }
     }
     else if (isSrcSolana) {
@@ -430,7 +476,11 @@ forceProvider, tradeType = 'EXACT_INPUT', dstAmount) {
                 };
                 // Set user address (must match source chain format)
                 relayParams.user = relayUserAddress;
-                // Set recipient based on destination chain
+                // Set recipient based on destination chain.
+                // IMPORTANT: Destination-based branches MUST come before source-based branches.
+                // The recipient format is dictated by the DESTINATION chain, not the source.
+                // Otherwise e.g. BTC→SOL would fall into `isSrcBitcoin` and get an EVM
+                // dead address as the Solana recipient, which relay.link rejects.
                 if (isDestBitcoin) {
                     // For Bitcoin destinations, relay.link requires:
                     // - user to be the source chain address (EVM address if source is EVM)
@@ -446,24 +496,23 @@ forceProvider, tradeType = 'EXACT_INPUT', dstAmount) {
                         relayParams.recipient = SBTC_ADDR_BTC_RELAY_LINK_RECIPIENT;
                     }
                 }
-                else if (isSrcBitcoin) {
-                    // For EVM destinations when source is Bitcoin, relay.link requires:
-                    // - user to be the Bitcoin address (source chain)
-                    // - recipient to be the EVM address (destination chain)
-                    if (recipientAddress && recipientAddress.startsWith('0x')) {
-                        // Use provided EVM recipient address
+                else if (isDestTron) {
+                    // For Tron destinations, relay.link requires:
+                    // - recipient to be a valid Tron address (starts with 'T')
+                    if (isValidTronRecipientAddress(recipientAddress)) {
                         relayParams.recipient = recipientAddress;
                     }
                     else {
-                        // Fallback to EVM dead address if no recipient provided
-                        relayParams.recipient = DEAD_ADDRESS;
+                        throw new Error('Tron recipient address required for Tron destination');
                     }
                 }
                 else if (isDestSolana) {
                     // For Solana destinations, relay.link requires:
                     // - user to be DEAD_ADDRESS (EVM dead address) when source is EVM
                     // - recipient to be the Solana address
-                    if (!isSrcSolana) {
+                    // For non-EVM sources (Solana/Bitcoin/Tron), keep the source-chain user
+                    // address that relayUserAddress was already populated with above.
+                    if (!isSrcSolana && !isSrcBitcoin && !isSrcTron) {
                         // Source is EVM, destination is Solana
                         relayParams.user = DEAD_ADDRESS;
                     }
@@ -477,6 +526,23 @@ forceProvider, tradeType = 'EXACT_INPUT', dstAmount) {
                         relayParams.recipient = SB58_ADDR_SOL_RELAY_LINK_RECIPIENT;
                     }
                 }
+                else if (isSrcBitcoin) {
+                    // For EVM destinations when source is Bitcoin, relay.link requires:
+                    // - user to be the Bitcoin address (source chain)
+                    // - recipient to be the EVM address (destination chain)
+                    // - useDepositAddress: false to use PSBT flow instead of deposit-address mode
+                    // - topupGas: false to skip gas topup
+                    relayParams.useDepositAddress = false;
+                    relayParams.topupGas = false;
+                    if (recipientAddress && recipientAddress.startsWith('0x')) {
+                        // Use provided EVM recipient address
+                        relayParams.recipient = recipientAddress;
+                    }
+                    else {
+                        // Fallback to EVM dead address if no recipient provided
+                        relayParams.recipient = DEAD_ADDRESS;
+                    }
+                }
                 else if (isSrcSolana) {
                     // For EVM destinations when source is Solana, relay.link requires:
                     // - user to be the Solana address (source chain)
@@ -512,10 +578,12 @@ forceProvider, tradeType = 'EXACT_INPUT', dstAmount) {
             if (!useDebridge)
                 return null;
             try {
-                // Skip deBridge for Bitcoin - Bitcoin only supports relay
+                // Skip deBridge for Bitcoin only.
                 if (isSrcBitcoin || isDestBitcoin) {
                     return null;
                 }
+                // deBridge account/authority should follow source-chain address format
+                const debridgeSourceAddress = relayUserAddress;
                 const isExactOutput = tradeType === 'EXACT_OUTPUT' && dstAmount;
                 const debridgeParams = {
                     srcChainId: debridgeSrcChainId,
@@ -523,16 +591,14 @@ forceProvider, tradeType = 'EXACT_INPUT', dstAmount) {
                     srcChainTokenInAmount: isExactOutput ? 'auto' : srcAmount,
                     dstChainId: debridgeDstChainId,
                     dstChainTokenOut: dstTokenNorm,
+                    dstChainTokenOutAmount: isExactOutput ? dstAmount : 'auto',
                     prependOperatingExpenses: true,
-                    account: userAddress,
+                    additionalTakerRewardBps: 0,
+                    account: debridgeSourceAddress,
                 };
-                if (isExactOutput) {
-                    debridgeParams.dstChainTokenOutAmount = dstAmount;
-                }
                 // Handle Solana source or destination
                 if (isSrcSolana || isDestSolana) {
                     // For Solana source or destination
-                    // Don't set dstChainTokenOutAmount unless EXACT_OUTPUT (omit it for EXACT_INPUT mode)
                     debridgeParams.enableEstimate = false;
                     // Set recipient address (required for Solana source or destination)
                     if (!recipientAddress) {
@@ -544,13 +610,22 @@ forceProvider, tradeType = 'EXACT_INPUT', dstAmount) {
                     // Set authority addresses based on source/destination
                     if (isSrcSolana) {
                         // Source is Solana
-                        debridgeParams.srcChainOrderAuthorityAddress = userAddress; // Solana sender
-                        debridgeParams.srcChainRefundAddress = userAddress; // Solana sender
+                        debridgeParams.srcChainOrderAuthorityAddress = debridgeSourceAddress; // Solana sender
+                        debridgeParams.srcChainRefundAddress = debridgeSourceAddress; // Solana sender
                         if (isDestSolana) {
                             // Solana to Solana
                             debridgeParams.dstChainTokenOutRecipient = recipientAddress; // Solana recipient
                             debridgeParams.dstChainOrderAuthorityAddress = recipientAddress; // Solana recipient
                         }
+                        else if (isDestTron) {
+                            // Solana to Tron
+                            if (!isValidTronRecipientAddress(recipientAddress)) {
+                                throw new Error('Tron recipient address required for Tron destination');
+                            }
+                            const tronRecipient = recipientAddress;
+                            debridgeParams.dstChainTokenOutRecipient = tronRecipient; // Tron recipient (TVM)
+                            debridgeParams.dstChainOrderAuthorityAddress = tronRecipient; // Tron authority (TVM)
+                        }
                         else {
                             // Solana to EVM
                             debridgeParams.dstChainTokenOutRecipient = recipientAddress; // EVM recipient
@@ -559,8 +634,8 @@ forceProvider, tradeType = 'EXACT_INPUT', dstAmount) {
                     }
                     else {
                         // Source is EVM, destination is Solana
-                        debridgeParams.srcChainOrderAuthorityAddress = userAddress; // EVM sender
-                        debridgeParams.srcChainRefundAddress = userAddress; // EVM sender
+                        debridgeParams.srcChainOrderAuthorityAddress = debridgeSourceAddress; // EVM sender
+                        debridgeParams.srcChainRefundAddress = debridgeSourceAddress; // EVM sender
                         debridgeParams.dstChainTokenOutRecipient = recipientAddress; // Solana recipient
                         debridgeParams.dstChainOrderAuthorityAddress = recipientAddress; // Solana recipient
                     }
@@ -569,18 +644,18 @@ forceProvider, tradeType = 'EXACT_INPUT', dstAmount) {
                     // Both source and destination are EVM
                     // API requires dstChainTokenOutRecipient, srcChainOrderAuthorityAddress, dstChainOrderAuthorityAddress for transaction construction
                     // Use recipientAddress when provided (user-set recipient), otherwise fall back to userAddress (send to self)
-                    const evmRecipient = recipientAddress && recipientAddress.startsWith('0x') ? recipientAddress : userAddress;
-                    debridgeParams.dstChainTokenOutRecipient = evmRecipient;
-                    debridgeParams.srcChainOrderAuthorityAddress = userAddress;
-                    debridgeParams.dstChainOrderAuthorityAddress = evmRecipient;
-                    debridgeParams.srcChainRefundAddress = userAddress;
-                    debridgeParams.senderAddress = userAddress;
-                    if (!isExactOutput) {
-                        debridgeParams.dstChainTokenOutAmount = 'auto';
+                    const evmRecipient = recipientAddress && recipientAddress.startsWith('0x') ? recipientAddress : debridgeSourceAddress;
+                    if (isDestTron && !isValidTronRecipientAddress(recipientAddress)) {
+                        throw new Error('Tron recipient address required for Tron destination');
                     }
-                    debridgeParams.enableEstimate = true;
+                    const tronRecipient = recipientAddress;
+                    debridgeParams.dstChainTokenOutRecipient = isDestTron ? tronRecipient : evmRecipient;
+                    debridgeParams.srcChainOrderAuthorityAddress = debridgeSourceAddress;
+                    debridgeParams.dstChainOrderAuthorityAddress = isDestTron ? tronRecipient : evmRecipient;
+                    debridgeParams.srcChainRefundAddress = debridgeSourceAddress;
+                    debridgeParams.senderAddress = debridgeSourceAddress;
+                    debridgeParams.enableEstimate = isDestTron || isSrcTron ? false : true;
                     // Optional params matching deSwap app for consistent API behavior
-                    debridgeParams.additionalTakerRewardBps = 0;
                     debridgeParams.deBridgeApp = 'DESWAP';
                     debridgeParams.ptp = false;
                     debridgeParams.srcChainPriorityLevel = 'normal';

package/dist/rpc.js

@@ -1,5 +1,5 @@
 import { arbitrum, avalanche, base, berachain, bsc, mainnet, optimism, polygon } from 'viem/chains';
-import { SOLANA_CHAIN_ID, BITCOIN_CHAIN_ID } from './chains.js';
+import { SOLANA_CHAIN_ID, BITCOIN_CHAIN_ID, TRON_CHAIN_ID } from './chains.js';
 /**
  * Custom RPC endpoint configuration for EVM chains, Solana, and Bitcoin
  *
@@ -36,4 +36,6 @@ export const H_RPCS = {
     [bsc.id]: 'https://yolo-wandering-fire.bsc.quiknode.pro/07aae5c8f9c95c4d596a6997e6a28a786dc3d4a0/',
     // Berachain
     [berachain.id]: 'https://capable-purple-dream.bera-mainnet.quiknode.pro/11502780a6ec104db00d7940f6a61c90868a4402/',
+    // Tron
+    [TRON_CHAIN_ID]: 'https://multi-icy-borough.tron-mainnet.quiknode.pro/58b72b5b6563a1122911fb254444777c9214d96c/jsonrpc',
 };

package/dist/transaction-utils.d.ts

@@ -11,25 +11,30 @@ export type SolanaTransactionExecutor = (tx: BridgeTransaction) => Promise<strin
  * Returns transaction signature string
  */
 export type BitcoinTransactionExecutor = (tx: BridgeTransaction) => Promise<string>;
+/**
+ * Tron transaction executor type
+ * Returns transaction signature string
+ */
+export type TronTransactionExecutor = (tx: BridgeTransaction) => Promise<string>;
 /**
  * Universal transaction executor type
- * Returns Hex for EVM, base58 string for Solana, string for Bitcoin
+ * Returns Hex for EVM, base58 string for Solana, string for Bitcoin/Tron
  */
 export type UniversalTransactionExecutor = (tx: BridgeTransaction) => Promise<Hex | string>;
 /**
  * Create transaction execution wrapper for framework-agnostic bridge execution
- * Supports EVM, Solana, and Bitcoin transactions
+ * Supports EVM, Solana, Bitcoin, and Tron transactions
  */
-export declare function createTransactionExecutor(walletClient: WalletClient, connector: Connector, solanaExecutor?: SolanaTransactionExecutor, bitcoinExecutor?: BitcoinTransactionExecutor): UniversalTransactionExecutor;
+export declare function createTransactionExecutor(walletClient: WalletClient | undefined, connector: Connector | undefined, solanaExecutor?: SolanaTransactionExecutor, bitcoinExecutor?: BitcoinTransactionExecutor, tronExecutor?: TronTransactionExecutor): UniversalTransactionExecutor;
 /**
  * Create chain switching wrapper
  */
 export declare function createChainSwitcher(walletClient: WalletClient, connector: Connector): (chainId: number) => Promise<void>;
 /**
  * Execute a bridge transaction (framework-agnostic)
- * Supports EVM, Solana, and Bitcoin transactions
+ * Supports EVM, Solana, Bitcoin, and Tron transactions
  */
-export declare function executeBridgeTransaction(quote: BridgeQuote, walletClient: WalletClient, connector: Connector, setStep: (step: string) => void, solanaExecutor?: SolanaTransactionExecutor, bitcoinExecutor?: BitcoinTransactionExecutor): Promise<BridgeStatus>;
+export declare function executeBridgeTransaction(quote: BridgeQuote, walletClient: WalletClient, connector: Connector, setStep: (step: string) => void, solanaExecutor?: SolanaTransactionExecutor, bitcoinExecutor?: BitcoinTransactionExecutor, tronExecutor?: TronTransactionExecutor): Promise<BridgeStatus>;
 /**
  * Get bridge status (framework-agnostic)
  */

package/dist/transaction-utils.js

@@ -1,10 +1,10 @@
 import { executeRelayBridge, executeDebridgeBridge, getRelayStatus, getDebridgeStatus, } from './bridge.js';
-import { N_DEBRIDGE_CHAIN_ID_SOLANA, N_RELAY_CHAIN_ID_BITCOIN, N_RELAY_CHAIN_ID_SOLANA } from './constants.js';
+import { N_RELAY_CHAIN_ID_BITCOIN, N_RELAY_CHAIN_ID_TRON, N_RELAY_CHAIN_ID_SOLANA, N_DEBRIDGE_CHAIN_ID_SOLANA, N_DEBRIDGE_CHAIN_ID_TRON, } from './constants.js';
 /**
  * Create transaction execution wrapper for framework-agnostic bridge execution
- * Supports EVM, Solana, and Bitcoin transactions
+ * Supports EVM, Solana, Bitcoin, and Tron transactions
  */
-export function createTransactionExecutor(walletClient, connector, solanaExecutor, bitcoinExecutor) {
+export function createTransactionExecutor(walletClient, connector, solanaExecutor, bitcoinExecutor, tronExecutor) {
     return async (tx) => {
         // Bitcoin transaction - check for Bitcoin chainId or psbt field
         if (tx.chainId === N_RELAY_CHAIN_ID_BITCOIN || tx.psbt) {
@@ -14,7 +14,15 @@ export function createTransactionExecutor(walletClient, connector, solanaExecuto
             }
             return await bitcoinExecutor(tx);
         }
-        // Solana transaction - relay instructions or deBridge serialized Solana tx
+        // Tron transaction - check for both relay and deBridge Tron chain IDs
+        if (tx.chainId === N_RELAY_CHAIN_ID_TRON || tx.chainId === N_DEBRIDGE_CHAIN_ID_TRON) {
+            if (!tronExecutor) {
+                throw new Error('Tron transaction detected but Tron executor not provided. ' +
+                    'Please provide tronExecutor when creating the transaction executor.');
+            }
+            return await tronExecutor(tx);
+        }
+        // Solana transaction - relay instructions or deBridge serialized Solana tx.
         const isSolanaTx = !!tx.instructions ||
             tx.chainId === N_RELAY_CHAIN_ID_SOLANA ||
             tx.chainId === N_DEBRIDGE_CHAIN_ID_SOLANA;
@@ -29,6 +37,9 @@ export function createTransactionExecutor(walletClient, connector, solanaExecuto
         if (!tx.to || tx.value === undefined || !tx.data) {
             throw new Error('Invalid EVM transaction: missing required fields (to, value, data)');
         }
+        if (!walletClient || !connector) {
+            throw new Error('EVM transaction detected but walletClient/connector not provided.');
+        }
         // Switch to the correct chain if needed
         let currentChainId;
         try {
@@ -82,10 +93,10 @@ export function createChainSwitcher(walletClient, connector) {
 }
 /**
  * Execute a bridge transaction (framework-agnostic)
- * Supports EVM, Solana, and Bitcoin transactions
+ * Supports EVM, Solana, Bitcoin, and Tron transactions
  */
-export async function executeBridgeTransaction(quote, walletClient, connector, setStep, solanaExecutor, bitcoinExecutor) {
-    const executeTransaction = createTransactionExecutor(walletClient, connector, solanaExecutor, bitcoinExecutor);
+export async function executeBridgeTransaction(quote, walletClient, connector, setStep, solanaExecutor, bitcoinExecutor, tronExecutor) {
+    const executeTransaction = createTransactionExecutor(walletClient, connector, solanaExecutor, bitcoinExecutor, tronExecutor);
     const switchChain = createChainSwitcher(walletClient, connector);
     switch (quote.provider) {
         case 'relay':

package/dist/types/core.d.ts

@@ -14,14 +14,16 @@ export type Caip2NsCosmos = 'cosmos';
 export type Caip2NsSolana = 'solana';
 export type Caip2NsSui = 'sui';
 export type Caip2NsStellar = 'stellar';
-export type Caip2Ns = Caip2NsBip122 | Caip2NsEip155 | Caip2NsCosmos | Caip2NsSolana | Caip2NsSui | Caip2NsStellar;
+export type Caip2NsTron = 'tron';
+export type Caip2Ns = Caip2NsBip122 | Caip2NsEip155 | Caip2NsCosmos | Caip2NsSolana | Caip2NsSui | Caip2NsStellar | Caip2NsTron;
 export type Caip2Bip122 = `${Caip2NsBip122}:${string}`;
 export type Caip2Eip155 = `${Caip2NsEip155}:${IntStr}`;
 export type Caip2Cosmos = `${Caip2NsCosmos}:${string}`;
 export type Caip2Solana = `${Caip2NsSolana}:${string}`;
 export type Caip2Sui = `${Caip2NsSui}:${'mainnet' | 'testnet' | 'devnet'}`;
 export type Caip2Stellar = `${Caip2NsStellar}:${string}`;
-export type Caip2 = Caip2Bip122 | Caip2Eip155 | Caip2Cosmos | Caip2Solana | Caip2Sui | Caip2Stellar;
+export type Caip2Tron = `${Caip2NsTron}:${string}`;
+export type Caip2 = Caip2Bip122 | Caip2Eip155 | Caip2Cosmos | Caip2Solana | Caip2Sui | Caip2Stellar | Caip2Tron;
 export type Caip19NsEip155 = `erc${bigint}:${Hex}`;
 export type Caip19NsIcs20 = `ics20:${string}`;
 export type Caip19NsSolana = `solana:${Base58}/token:${Base58}`;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@silentswap/sdk",
   "type": "module",
-  "version": "0.1.50",
+  "version": "0.1.52",
   "license": "MIT",
   "main": "dist/index.js",
   "files": [

package/src/data/filtered.json

@@ -485,6 +485,18 @@
 			"nativeCoinId": "ethereum",
 			"name": "Soneium"
 		},
+		"tron:0x2b6653dc": {
+			"coingeckoPlatformId": "tron",
+			"coingeckoId": "tron",
+			"native": {
+				"slip44": 195,
+				"decimals": 6,
+				"symbol": "TRX"
+			},
+			"caip2": "tron:0x2b6653dc",
+			"nativeCoinId": "tron",
+			"name": "TRON"
+		},
 		"bip122:000000000019d6689c085ae165831e93": {
 			"coingeckoPlatformId": "bitcoin",
 			"coingeckoId": "bitcoin",
@@ -3590,6 +3602,28 @@
 				"1C0E00"
 			]
 		},
+		"tron:0x2b6653dc/slip44:195": {
+			"caip19": "tron:0x2b6653dc/slip44:195",
+			"coingeckoId": "tron",
+			"name": "TRON",
+			"symbol": "TRX",
+			"decimals": 6,
+			"gradient": [
+				"000000",
+				"1C0E00"
+			]
+		},
+		"tron:0x2b6653dc/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t": {
+			"caip19": "tron:0x2b6653dc/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+			"coingeckoId": "tether",
+			"name": "Tether USD (Tron)",
+			"symbol": "USDT",
+			"decimals": 6,
+			"gradient": [
+				"26A17B",
+				"125C48"
+			]
+		},
 		"eip155:56/erc20:0x000Ae314E2A2172a039B26378814C252734f556A": {
 			"caip19": "eip155:56/erc20:0x000Ae314E2A2172a039B26378814C252734f556A",
 			"coingeckoId": "aster-2",