pwc-sdk-wallet 0.7.8 → 0.7.9

package/README.md

@@ -31,6 +31,7 @@ A comprehensive, secure, and user-friendly wallet SDK for React Native applicati
 - [Account Management](#account-management)
    - [Add New HD Account](#add-new-hd-account)
    - [Add New Solana Account](#add-new-solana-account)
+   - [Add New TRON Account](#add-new-tron-account)
    - [Import Account](#import-account)
    - [Get Accounts](#get-accounts)
 - [Balance & Token Functions](#balance--token-functions)
@@ -45,6 +46,9 @@ A comprehensive, secure, and user-friendly wallet SDK for React Native applicati
    - [Send Native Token](#send-native-token)
    - [Send Token](#send-token)
    - [Send SPL Token (Solana)](#send-spl-token-solana)
+   - [Send TRX (TRON)](#send-trx-tron)
+   - [Send TRC-20 Token (TRON)](#send-trc-20-token-tron)
+   - [Popular TRON TRC-20 Tokens](#popular-tron-trc-20-tokens)
    - [Export Mnemonic](#export-mnemonic)
 
 ### 🔄 Multi-Transfer Operations
@@ -1469,7 +1473,7 @@ console.log('ERC-1155 transfer gas:', erc1155TransferGas.toString());
 
 - 🔐 **Secure HD Wallet Management**: BIP-44 compliant hierarchical deterministic wallets
 - 🎯 **Vanity Address Generation**: Generate wallets with custom address prefixes
-- 🔗 **Multi-Chain Support**: Ethereum, BSC, Polygon, Arbitrum, Optimism, Base, and Solana
+- 🔗 **Multi-Chain Support**: Ethereum, BSC, Polygon, Arbitrum, Optimism, Base, Solana, and TRON
 - 🚀 **Multi-Transfer Operations**: Batch send tokens to multiple recipients
 - 🔧 **Custom Chain Support**: Add custom chains and override built-in configurations
 - 📱 **React Native Optimized**: Designed specifically for mobile applications
@@ -1536,6 +1540,13 @@ const { vault, encryptedVault } = await Vault.createFromMnemonic(
   'solana'
 );
 
+// For TRON
+const { vault, encryptedVault } = await Vault.createFromMnemonic(
+  existingMnemonic, 
+  'your-secure-password', 
+  'tron'
+);
+
 // Get wallet accounts
 const accounts = vault.getAccounts();
 console.log('Imported wallet addresses:', accounts.map(acc => acc.address));
@@ -1788,6 +1799,13 @@ const newSolanaAccount = vault.addSolanaAccount();
 console.log('New Solana account:', newSolanaAccount.address);
 ```
 
+#### Add New TRON Account
+```typescript
+// Add a new TRON account
+const newTronAccount = vault.addNewTronAccount();
+console.log('New TRON account:', newTronAccount.address);
+```
+
 #### Import Account
 ```typescript
 // Import an existing account with private key
@@ -1917,6 +1935,96 @@ const USDC_DEVNET = '4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU';
 const USDT_DEVNET = 'Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB';
 ```
 
+#### Send TRX (TRON)
+```typescript
+// Send native TRX
+const tx = await vault.sendTRX(from, to, '1.5');
+console.log('Transaction hash:', tx.hash);
+
+// Get TRX balance
+const balance = await vault.getTRXBalance(address);
+console.log('TRX Balance:', TronChainService.sunToTrx(balance.toString()));
+```
+
+#### Send TRC-20 Token (TRON)
+```typescript
+// Send USDT on TRON
+const usdtTx = await vault.sendTRC20Token(
+  'TYourAddress...',
+  'TRecipient...',
+  '100', // 100 USDT
+  'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t' // USDT contract address
+);
+
+// Send USDC on TRON
+const usdcTx = await vault.sendTRC20Token(
+  'TYourAddress...',
+  'TRecipient...',
+  '50', // 50 USDC
+  'TEkxiTehnzSmSe2XqrBj4w32RUN966rdz8' // USDC contract address
+);
+
+// Get TRC-20 token balance
+const usdtBalance = await vault.getTRC20TokenBalance(
+  'TYourAddress...',
+  'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t'
+);
+console.log('USDT Balance:', usdtBalance.toString());
+
+// Get TRC-20 token information
+const tokenInfo = await vault.getTRC20TokenInfo(
+  'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t'
+);
+console.log('Token:', tokenInfo.name, '(', tokenInfo.symbol, ')');
+console.log('Decimals:', tokenInfo.decimals);
+
+// Estimate TRX transfer fee
+const trxFee = await vault.estimateTRXTransferFee(
+  'TYourAddress...',
+  'TRecipient...',
+  '1.5'
+);
+console.log('Estimated TRX fee:', TronChainService.sunToTrx(trxFee.toString()), 'TRX');
+
+// Estimate TRC-20 transfer fee
+const tokenFee = await vault.estimateTRC20TransferFee(
+  'TYourAddress...',
+  'TRecipient...',
+  '100',
+  'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t'
+);
+console.log('Estimated token fee:', TronChainService.sunToTrx(tokenFee.toString()), 'TRX');
+```
+
+#### Popular TRON TRC-20 Tokens
+
+**Mainnet Token Addresses:**
+```typescript
+// USDT (Tether USD)
+const USDT_TRC20 = 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t';
+
+// USDC (USD Coin)
+const USDC_TRC20 = 'TEkxiTehnzSmSe2XqrBj4w32RUN966rdz8';
+
+// USDD (Decentralized USD)
+const USDD_TRC20 = 'TPYmHEhy5n8TCEfYGqW2rPxsghSfzghPDn';
+
+// JST (JUST)
+const JST_TRC20 = 'TCFLL5dx5ZJdKnWuesXxi1VPwjLVmWZZy9';
+
+// WIN (WINkLink)
+const WIN_TRC20 = 'TLa2f6VPqDgRE67v1736s7bJ8Ray5wYjU7';
+```
+
+**Shasta Testnet Token Addresses (for testing):**
+```typescript
+// USDT Shasta
+const USDT_SHASTA = 'TG3XXyExBkPp9nzdajDZsozEu1kkaAzc3X';
+
+// USDC Shasta
+const USDC_SHASTA = 'TXYZopYRdj2D9XRtbG411XZZ3kM5VkAeBZ';
+```
+
 #### Export Mnemonic
 ```typescript
 // Export the mnemonic phrase (requires password)

package/dist/Vault.d.ts

@@ -4,7 +4,7 @@ import { Recipient, MultiTransferResult } from './types/multiTransfer';
 import { NFTDetailExtended, NFTBalance, NFTOptions } from './types/nft';
 export interface Account {
     address: string;
-    type: 'HD' | 'Simple' | 'Solana';
+    type: 'HD' | 'Simple' | 'Solana' | 'Tron';
     name: string;
 }
 export interface TransactionResponse {
@@ -51,11 +51,11 @@ export declare class Vault {
     /**
      * Creates a new Vault with a fresh mnemonic.
      * @param password - The password used to encrypt the vault data
-     * @param chainType - The type of blockchain to support ('evm' for Ethereum-compatible chains or 'solana' for Solana). Defaults to 'evm'
+     * @param chainType - The type of blockchain to support ('evm' for Ethereum-compatible chains, 'solana' for Solana, or 'tron' for TRON). Defaults to 'evm'
      * @returns Promise resolving to an object containing the created vault instance and its encrypted data
      * @throws Error if mnemonic generation or keyring initialization fails
      */
-    static createNew(password: string, chainType?: 'evm' | 'solana', config?: VaultConfig): Promise<{
+    static createNew(password: string, chainType?: 'evm' | 'solana' | 'tron', config?: VaultConfig): Promise<{
         vault: Vault;
         encryptedVault: EncryptedData;
     }>;
@@ -63,11 +63,11 @@ export declare class Vault {
      * Creates a new Vault from an existing mnemonic phrase.
      * @param mnemonic - The existing mnemonic phrase (12, 15, 18, 21, or 24 words)
      * @param password - The password used to encrypt the vault data
-     * @param chainType - The type of blockchain to support ('evm' for Ethereum-compatible chains or 'solana' for Solana). Defaults to 'evm'
+     * @param chainType - The type of blockchain to support ('evm' for Ethereum-compatible chains, 'solana' for Solana, or 'tron' for TRON). Defaults to 'evm'
      * @returns Promise resolving to an object containing the created vault instance and its encrypted data
      * @throws Error if mnemonic is invalid or keyring initialization fails
      */
-    static createFromMnemonic(mnemonic: string, password: string, chainType?: 'evm' | 'solana', config?: VaultConfig): Promise<{
+    static createFromMnemonic(mnemonic: string, password: string, chainType?: 'evm' | 'solana' | 'tron', config?: VaultConfig): Promise<{
         vault: Vault;
         encryptedVault: EncryptedData;
     }>;
@@ -91,6 +91,12 @@ export declare class Vault {
      * @throws Error if no Solana keyring is available in the vault
      */
     addNewSolanaAccount(): Promise<Account>;
+    /**
+     * Adds a new TRON account derived from the TRON keyring.
+     * @returns Promise resolving to the newly created TRON account information
+     * @throws Error if no TRON keyring is available in the vault
+     */
+    addNewTronAccount(): Promise<Account>;
     /**
      * Imports an account from a private key and adds it to the vault.
      * @param privateKey - The private key to import (hex string without '0x' prefix for EVM, base58 for Solana)
@@ -580,4 +586,82 @@ export declare class Vault {
      * ```
      */
     sendNativeToken(fromAddress: string, to: string, amount: string, chainId: ChainId): Promise<TransactionResponse>;
+    /**
+     * Sends TRX (native TRON token) to another address.
+     * @param fromAddress - The sender's TRON address
+     * @param to - The recipient's TRON address
+     * @param amount - The amount of TRX to send as a string (e.g., "1.5")
+     * @returns Promise resolving to the transaction response with hash and details
+     * @throws Error if the transaction fails or recipient address is invalid
+     *
+     * @example
+     * ```typescript
+     * // Send 1.5 TRX
+     * const tx = await vault.sendTRX(from, to, '1.5');
+     * console.log('Transaction hash:', tx.hash);
+     * ```
+     */
+    sendTRX(fromAddress: string, to: string, amount: string): Promise<TransactionResponse>;
+    /**
+     * Sends TRC-20 tokens on TRON blockchain.
+     * @param fromAddress - The sender's TRON address
+     * @param to - The recipient's TRON address
+     * @param amount - The amount of tokens to send as a string
+     * @param tokenAddress - The TRC-20 token contract address
+     * @returns Promise resolving to the transaction response with hash and details
+     * @throws Error if insufficient balance, invalid addresses, or transaction fails
+     *
+     * @example
+     * ```typescript
+     * // Send USDT on TRON
+     * const tx = await vault.sendTRC20Token(
+     *   'TYourAddress...',
+     *   'TRecipient...',
+     *   '100', // 100 USDT
+     *   'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t' // USDT contract address
+     * );
+     * ```
+     */
+    sendTRC20Token(fromAddress: string, to: string, amount: string, tokenAddress: string): Promise<TransactionResponse>;
+    /**
+     * Gets TRX balance for a specific address on TRON.
+     * @param address - The TRON address to check balance for
+     * @returns Promise resolving to the TRX balance as a bigint in SUN
+     * @throws Error if the balance query fails
+     */
+    getTRXBalance(address: string): Promise<bigint>;
+    /**
+     * Gets TRC-20 token balance for a specific address on TRON.
+     * @param address - The TRON address to check balance for
+     * @param tokenAddress - The TRC-20 token contract address
+     * @returns Promise resolving to the token balance as a bigint
+     * @throws Error if the balance query fails
+     */
+    getTRC20TokenBalance(address: string, tokenAddress: string): Promise<bigint>;
+    /**
+     * Gets TRC-20 token information.
+     * @param tokenAddress - The TRC-20 token contract address
+     * @returns Promise resolving to the token information
+     * @throws Error if the token query fails
+     */
+    getTRC20TokenInfo(tokenAddress: string): Promise<Token>;
+    /**
+     * Estimates the transaction fee for a TRX transfer.
+     * @param fromAddress - The sender's TRON address
+     * @param to - The recipient's TRON address
+     * @param amount - The amount of TRX to send
+     * @returns Promise resolving to the estimated fee in SUN
+     * @throws Error if the estimation fails
+     */
+    estimateTRXTransferFee(fromAddress: string, to: string, amount: string): Promise<bigint>;
+    /**
+     * Estimates the transaction fee for a TRC-20 token transfer.
+     * @param fromAddress - The sender's TRON address
+     * @param to - The recipient's TRON address
+     * @param amount - The amount of tokens to send
+     * @param tokenAddress - The TRC-20 token contract address
+     * @returns Promise resolving to the estimated fee in SUN
+     * @throws Error if the estimation fails
+     */
+    estimateTRC20TransferFee(fromAddress: string, to: string, amount: string, tokenAddress: string): Promise<bigint>;
 }

package/dist/Vault.js

@@ -4,8 +4,10 @@ exports.Vault = void 0;
 const HDKeyring_1 = require("./keyrings/HDKeyring");
 const SimpleKeyring_1 = require("./keyrings/SimpleKeyring");
 const SolanaKeyring_1 = require("./keyrings/SolanaKeyring");
+const TronKeyring_1 = require("./keyrings/TronKeyring");
 const ChainService_1 = require("./chain/ChainService");
 const SolanaChainService_1 = require("./chain/SolanaChainService");
+const TronChainService_1 = require("./chain/TronChainService");
 const EncryptionService_1 = require("./crypto/EncryptionService");
 const chains_1 = require("./config/chains");
 const constants_1 = require("./config/constants");
@@ -43,7 +45,7 @@ class Vault {
     /**
      * Creates a new Vault with a fresh mnemonic.
      * @param password - The password used to encrypt the vault data
-     * @param chainType - The type of blockchain to support ('evm' for Ethereum-compatible chains or 'solana' for Solana). Defaults to 'evm'
+     * @param chainType - The type of blockchain to support ('evm' for Ethereum-compatible chains, 'solana' for Solana, or 'tron' for TRON). Defaults to 'evm'
      * @returns Promise resolving to an object containing the created vault instance and its encrypted data
      * @throws Error if mnemonic generation or keyring initialization fails
      */
@@ -56,6 +58,13 @@ class Vault {
             const encryptedVault = await vault.encrypt(password);
             return { vault, encryptedVault };
         }
+        else if (chainType === 'tron') {
+            const tronKeyring = new TronKeyring_1.TronKeyring(mnemonic);
+            const vault = new Vault([tronKeyring], config);
+            vault.chainId = 'tron'; // Set TRON chain ID
+            const encryptedVault = await vault.encrypt(password);
+            return { vault, encryptedVault };
+        }
         else {
             const hdKeyring = new HDKeyring_1.HDKeyring(mnemonic);
             await hdKeyring.initialize();
@@ -69,7 +78,7 @@ class Vault {
      * Creates a new Vault from an existing mnemonic phrase.
      * @param mnemonic - The existing mnemonic phrase (12, 15, 18, 21, or 24 words)
      * @param password - The password used to encrypt the vault data
-     * @param chainType - The type of blockchain to support ('evm' for Ethereum-compatible chains or 'solana' for Solana). Defaults to 'evm'
+     * @param chainType - The type of blockchain to support ('evm' for Ethereum-compatible chains, 'solana' for Solana, or 'tron' for TRON). Defaults to 'evm'
      * @returns Promise resolving to an object containing the created vault instance and its encrypted data
      * @throws Error if mnemonic is invalid or keyring initialization fails
      */
@@ -81,6 +90,13 @@ class Vault {
             const encryptedVault = await vault.encrypt(password);
             return { vault, encryptedVault };
         }
+        else if (chainType === 'tron') {
+            const tronKeyring = new TronKeyring_1.TronKeyring(mnemonic);
+            const vault = new Vault([tronKeyring], config);
+            vault.chainId = 'tron'; // Set TRON chain ID
+            const encryptedVault = await vault.encrypt(password);
+            return { vault, encryptedVault };
+        }
         else {
             const hdKeyring = new HDKeyring_1.HDKeyring(mnemonic);
             await hdKeyring.initialize();
@@ -171,6 +187,23 @@ class Vault {
             name: `Solana ${solanaKeyring.accounts.length}`
         };
     }
+    /**
+     * Adds a new TRON account derived from the TRON keyring.
+     * @returns Promise resolving to the newly created TRON account information
+     * @throws Error if no TRON keyring is available in the vault
+     */
+    async addNewTronAccount() {
+        const tronKeyring = this.keyrings.find(k => k instanceof TronKeyring_1.TronKeyring);
+        if (!tronKeyring) {
+            throw new Error('No TRON keyring available to create new accounts.');
+        }
+        const newAddress = await tronKeyring.addNewAccount();
+        return {
+            address: newAddress,
+            type: 'Tron',
+            name: `Tron ${tronKeyring.getAllAccounts().length}`
+        };
+    }
     /**
      * Imports an account from a private key and adds it to the vault.
      * @param privateKey - The private key to import (hex string without '0x' prefix for EVM, base58 for Solana)
@@ -204,6 +237,7 @@ class Vault {
         let hdAccountCount = 1;
         let importedAccountCount = 1;
         let solanaAccountCount = 1;
+        let tronAccountCount = 1;
         for (const keyring of this.keyrings) {
             if (keyring instanceof HDKeyring_1.HDKeyring) {
                 for (const address of keyring.accounts) {
@@ -230,6 +264,15 @@ class Vault {
                     });
                 }
             }
+            else if (keyring instanceof TronKeyring_1.TronKeyring) {
+                for (const address of keyring.getAllAccounts()) {
+                    accounts.push({
+                        address,
+                        type: 'Tron',
+                        name: `Tron ${tronAccountCount++}`,
+                    });
+                }
+            }
         }
         return accounts;
     }
@@ -1300,6 +1343,16 @@ class Vault {
                 blockNumber: result.blockNumber || undefined
             };
         }
+        else if (chainInfo.type === 'tron') {
+            const chainService = new TronChainService_1.TronChainService(privateKey, chainInfo);
+            const result = await chainService.sendTransaction(to, amount);
+            return {
+                hash: result.hash,
+                from: result.from,
+                to: result.to,
+                blockNumber: result.blockNumber || undefined
+            };
+        }
         else {
             const chainService = new ChainService_1.ChainService(privateKey, chainInfo);
             // Create transaction request for native token transfer
@@ -1316,6 +1369,161 @@ class Vault {
             };
         }
     }
+    // --- TRON Operations ---
+    /**
+     * Sends TRX (native TRON token) to another address.
+     * @param fromAddress - The sender's TRON address
+     * @param to - The recipient's TRON address
+     * @param amount - The amount of TRX to send as a string (e.g., "1.5")
+     * @returns Promise resolving to the transaction response with hash and details
+     * @throws Error if the transaction fails or recipient address is invalid
+     *
+     * @example
+     * ```typescript
+     * // Send 1.5 TRX
+     * const tx = await vault.sendTRX(from, to, '1.5');
+     * console.log('Transaction hash:', tx.hash);
+     * ```
+     */
+    async sendTRX(fromAddress, to, amount) {
+        const chainInfo = (0, chains_1.getChainConfig)('tron');
+        if (chainInfo.type !== 'tron') {
+            throw new Error('TRON chain configuration not found');
+        }
+        const privateKey = await this.getPrivateKeyFor(fromAddress);
+        const chainService = new TronChainService_1.TronChainService(privateKey, chainInfo);
+        const result = await chainService.sendTransaction(to, amount);
+        return {
+            hash: result.hash,
+            from: result.from,
+            to: result.to,
+            blockNumber: result.blockNumber
+        };
+    }
+    /**
+     * Sends TRC-20 tokens on TRON blockchain.
+     * @param fromAddress - The sender's TRON address
+     * @param to - The recipient's TRON address
+     * @param amount - The amount of tokens to send as a string
+     * @param tokenAddress - The TRC-20 token contract address
+     * @returns Promise resolving to the transaction response with hash and details
+     * @throws Error if insufficient balance, invalid addresses, or transaction fails
+     *
+     * @example
+     * ```typescript
+     * // Send USDT on TRON
+     * const tx = await vault.sendTRC20Token(
+     *   'TYourAddress...',
+     *   'TRecipient...',
+     *   '100', // 100 USDT
+     *   'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t' // USDT contract address
+     * );
+     * ```
+     */
+    async sendTRC20Token(fromAddress, to, amount, tokenAddress) {
+        const chainInfo = (0, chains_1.getChainConfig)('tron');
+        if (chainInfo.type !== 'tron') {
+            throw new Error('TRON chain configuration not found');
+        }
+        const privateKey = await this.getPrivateKeyFor(fromAddress);
+        const chainService = new TronChainService_1.TronChainService(privateKey, chainInfo);
+        const result = await chainService.sendToken(to, amount, tokenAddress);
+        return {
+            hash: result.hash,
+            from: result.from,
+            to: result.to,
+            blockNumber: result.blockNumber
+        };
+    }
+    /**
+     * Gets TRX balance for a specific address on TRON.
+     * @param address - The TRON address to check balance for
+     * @returns Promise resolving to the TRX balance as a bigint in SUN
+     * @throws Error if the balance query fails
+     */
+    async getTRXBalance(address) {
+        const chainInfo = (0, chains_1.getChainConfig)('tron');
+        if (chainInfo.type !== 'tron') {
+            throw new Error('TRON chain configuration not found');
+        }
+        const privateKey = await this.getPrivateKeyFor(address);
+        const chainService = new TronChainService_1.TronChainService(privateKey, chainInfo);
+        return await chainService.getNativeBalance();
+    }
+    /**
+     * Gets TRC-20 token balance for a specific address on TRON.
+     * @param address - The TRON address to check balance for
+     * @param tokenAddress - The TRC-20 token contract address
+     * @returns Promise resolving to the token balance as a bigint
+     * @throws Error if the balance query fails
+     */
+    async getTRC20TokenBalance(address, tokenAddress) {
+        const chainInfo = (0, chains_1.getChainConfig)('tron');
+        if (chainInfo.type !== 'tron') {
+            throw new Error('TRON chain configuration not found');
+        }
+        const privateKey = await this.getPrivateKeyFor(address);
+        const chainService = new TronChainService_1.TronChainService(privateKey, chainInfo);
+        return await chainService.getTokenBalance(tokenAddress);
+    }
+    /**
+     * Gets TRC-20 token information.
+     * @param tokenAddress - The TRC-20 token contract address
+     * @returns Promise resolving to the token information
+     * @throws Error if the token query fails
+     */
+    async getTRC20TokenInfo(tokenAddress) {
+        const chainInfo = (0, chains_1.getChainConfig)('tron');
+        if (chainInfo.type !== 'tron') {
+            throw new Error('TRON chain configuration not found');
+        }
+        // Use a dummy private key for read-only operations
+        const dummyPrivateKey = '0000000000000000000000000000000000000000000000000000000000000001';
+        const chainService = new TronChainService_1.TronChainService(dummyPrivateKey, chainInfo);
+        const tokenInfo = await chainService.getTokenInfo(tokenAddress);
+        return {
+            address: tokenInfo.address,
+            name: tokenInfo.name,
+            symbol: tokenInfo.symbol,
+            decimals: tokenInfo.decimals,
+            totalSupply: tokenInfo.totalSupply
+        };
+    }
+    /**
+     * Estimates the transaction fee for a TRX transfer.
+     * @param fromAddress - The sender's TRON address
+     * @param to - The recipient's TRON address
+     * @param amount - The amount of TRX to send
+     * @returns Promise resolving to the estimated fee in SUN
+     * @throws Error if the estimation fails
+     */
+    async estimateTRXTransferFee(fromAddress, to, amount) {
+        const chainInfo = (0, chains_1.getChainConfig)('tron');
+        if (chainInfo.type !== 'tron') {
+            throw new Error('TRON chain configuration not found');
+        }
+        const privateKey = await this.getPrivateKeyFor(fromAddress);
+        const chainService = new TronChainService_1.TronChainService(privateKey, chainInfo);
+        return await chainService.estimateTransactionFee(to, amount);
+    }
+    /**
+     * Estimates the transaction fee for a TRC-20 token transfer.
+     * @param fromAddress - The sender's TRON address
+     * @param to - The recipient's TRON address
+     * @param amount - The amount of tokens to send
+     * @param tokenAddress - The TRC-20 token contract address
+     * @returns Promise resolving to the estimated fee in SUN
+     * @throws Error if the estimation fails
+     */
+    async estimateTRC20TransferFee(fromAddress, to, amount, tokenAddress) {
+        const chainInfo = (0, chains_1.getChainConfig)('tron');
+        if (chainInfo.type !== 'tron') {
+            throw new Error('TRON chain configuration not found');
+        }
+        const privateKey = await this.getPrivateKeyFor(fromAddress);
+        const chainService = new TronChainService_1.TronChainService(privateKey, chainInfo);
+        return await chainService.estimateTokenTransferFee(to, amount, tokenAddress);
+    }
 }
 exports.Vault = Vault;
 // Rate limiting for export attempts