@xchainjs/xchain-tron 2.0.0

package/lib/index.js

@@ -0,0 +1,1045 @@
+'use strict';
+
+var bip32 = require('@scure/bip32');
+var bip39 = require('@scure/bip39');
+var TW = require('tronweb');
+var xchainClient = require('@xchainjs/xchain-client');
+var xchainUtil = require('@xchainjs/xchain-util');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var TW__default = /*#__PURE__*/_interopDefault(TW);
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+const TRX_DECIMAL = 6;
+const TRON_DERIVATION_PATH = "m/44'/195'/0'/0/";
+/**
+ * Chain identifier for Tron mainnet
+ */
+const TRONChain = 'TRON';
+const AssetTRX = {
+    chain: TRONChain,
+    symbol: 'TRX',
+    ticker: 'TRX',
+    type: xchainUtil.AssetType.NATIVE,
+};
+const AssetTRONUSDT = {
+    chain: TRONChain,
+    symbol: 'USDT-TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t',
+    ticker: 'USDT',
+    type: xchainUtil.AssetType.TOKEN,
+};
+// Explorer providers for Tron
+const TRON_MAINNET_EXPLORER = new xchainClient.ExplorerProvider('https://tronscan.org/', 'https://tronscan.org/#/address/%%ADDRESS%%', 'https://tronscan.org/#/transaction/%%TX_ID%%');
+const TRON_TESTNET_EXPLORER = new xchainClient.ExplorerProvider('https://nile.tronscan.org/', 'https://nile.tronscan.org/accounts/%%ADDRESS%%', 'https://nile.tronscan.org/transactions/%%TX_ID%%');
+const TRON_DEFAULT_RPC = 'https://tron-rpc.publicnode.com';
+const tronExplorerProviders = {
+    [xchainClient.Network.Mainnet]: TRON_MAINNET_EXPLORER,
+    [xchainClient.Network.Stagenet]: TRON_MAINNET_EXPLORER,
+    [xchainClient.Network.Testnet]: TRON_TESTNET_EXPLORER,
+};
+const TRX_TRANSFER_BANDWIDTH = 268; // Bandwidth consumed by a TRX transfer
+const TRC20_TRANSFER_ENERGY = 13000; // Average energy consumed by TRC20 transfer
+const TRC20_TRANSFER_BANDWIDTH = 345; // Bandwidth consumed by TRC20 transfer
+const TRON_USDT_CONTRACT = 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t';
+const MAX_APPROVAL = '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff';
+const TRX_FEE_LIMIT = 100000000;
+
+const validateAddress = (address) => {
+    return TW.TronWeb.isAddress(address);
+};
+const getTRC20AssetContractAddress = (asset) => {
+    try {
+        return asset.symbol.slice(asset.ticker.length + 1);
+    }
+    catch (_err) {
+        return null;
+    }
+};
+
+var trc20ABI = [
+	{
+		constant: true,
+		inputs: [
+			{
+				name: "_owner",
+				type: "address"
+			}
+		],
+		name: "balanceOf",
+		outputs: [
+			{
+				name: "balance",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		constant: false,
+		inputs: [
+			{
+				name: "_to",
+				type: "address"
+			},
+			{
+				name: "_value",
+				type: "uint256"
+			}
+		],
+		name: "transfer",
+		outputs: [
+			{
+				name: "success",
+				type: "bool"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		constant: true,
+		inputs: [
+		],
+		name: "decimals",
+		outputs: [
+			{
+				name: "",
+				type: "uint8"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		constant: true,
+		inputs: [
+		],
+		name: "symbol",
+		outputs: [
+			{
+				name: "",
+				type: "string"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		constant: true,
+		inputs: [
+		],
+		name: "name",
+		outputs: [
+			{
+				name: "",
+				type: "string"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		constant: true,
+		inputs: [
+			{
+				name: "_owner",
+				type: "address"
+			},
+			{
+				name: "_spender",
+				type: "address"
+			}
+		],
+		name: "allowance",
+		outputs: [
+			{
+				name: "remaining",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		constant: false,
+		inputs: [
+			{
+				name: "_spender",
+				type: "address"
+			},
+			{
+				name: "_value",
+				type: "uint256"
+			}
+		],
+		name: "approve",
+		outputs: [
+			{
+				name: "success",
+				type: "bool"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		constant: true,
+		inputs: [
+		],
+		name: "totalSupply",
+		outputs: [
+			{
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		constant: false,
+		inputs: [
+			{
+				name: "_from",
+				type: "address"
+			},
+			{
+				name: "_to",
+				type: "address"
+			},
+			{
+				name: "_value",
+				type: "uint256"
+			}
+		],
+		name: "transferFrom",
+		outputs: [
+			{
+				name: "success",
+				type: "bool"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				name: "_from",
+				type: "address"
+			},
+			{
+				indexed: true,
+				name: "_to",
+				type: "address"
+			},
+			{
+				indexed: false,
+				name: "_value",
+				type: "uint256"
+			}
+		],
+		name: "Transfer",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				name: "_owner",
+				type: "address"
+			},
+			{
+				indexed: true,
+				name: "_spender",
+				type: "address"
+			},
+			{
+				indexed: false,
+				name: "_value",
+				type: "uint256"
+			}
+		],
+		name: "Approval",
+		type: "event"
+	}
+];
+
+const TRONGRID_API_BASE_URL = 'https://api.trongrid.io';
+class TronGrid {
+    constructor() {
+        this.tronWeb = new TW.TronWeb({ fullHost: TRON_DEFAULT_RPC });
+    }
+    getAccount(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield fetch(`${TRONGRID_API_BASE_URL}/v1/accounts/${address}`);
+                if (!response.ok) {
+                    throw new Error(`TronGrid API error: ${response.status} ${response.statusText}`);
+                }
+                const data = (yield response.json());
+                if (!(data.success && data.data) || data.data.length === 0) {
+                    throw new Error('Invalid response from TronGrid API');
+                }
+                // Convert search address to hex format for comparison
+                let searchAddressHex;
+                try {
+                    // If address is base58, convert to hex
+                    searchAddressHex = TW.TronWeb.address.toHex(address).toLowerCase();
+                }
+                catch (_a) {
+                    // If conversion fails, assume it's already hex
+                    searchAddressHex = address.toLowerCase();
+                }
+                // Find the account that matches the requested address
+                const account = data.data.find((acc) => {
+                    return acc.address.toLowerCase() === searchAddressHex;
+                });
+                if (!account) {
+                    return;
+                }
+                return account;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    getTransactions(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { address, offset, limit } = params;
+            const url = `https://api.trongrid.io/v1/accounts/${address}/transactions?limit=${limit}&start=${offset}`;
+            const res = yield fetch(url);
+            const { data } = yield res.json();
+            const txs = [];
+            for (const tx of data) {
+                const contract = tx.raw_data.contract[0];
+                // Case 1: Native TRX transfer
+                if (contract.type === 'TransferContract') {
+                    const amount = xchainUtil.baseAmount(contract.parameter.value.amount, TRX_DECIMAL);
+                    const from = [{ from: TW.TronWeb.address.fromHex(contract.parameter.value.owner_address), amount }];
+                    const to = [{ to: TW.TronWeb.address.fromHex(contract.parameter.value.to_address), amount }];
+                    txs.push({
+                        asset: AssetTRX,
+                        type: xchainClient.TxType.Transfer,
+                        from,
+                        to,
+                        date: new Date(tx.block_timestamp),
+                        hash: tx.txID,
+                    });
+                    continue;
+                }
+                // Case 2: TRC20 transfer (TriggerSmartContract)
+                if (contract.type === 'TriggerSmartContract') {
+                    const { contract_address, data: inputData, owner_address } = contract.parameter.value;
+                    // `inputData` starts with 4-byte method selector (transfer(address,uint256))
+                    // and then encoded params
+                    try {
+                        const decoded = TW__default.default.utils.abi.decodeParams(['_to', '_value'], // parameter names
+                        ['address', 'uint256'], // parameter types
+                        inputData, // full input data (with selector)
+                        true);
+                        const toAddress = decoded._to;
+                        const fromAddress = TW.TronWeb.address.fromHex(owner_address);
+                        const rawValue = decoded._value.toString();
+                        // Get token contract instance
+                        const contractHex = TW.TronWeb.address.fromHex(contract_address);
+                        const tokenContract = yield this.tronWeb.contract().at(contractHex);
+                        // Call symbol() and decimals()
+                        const symbol = yield tokenContract.symbol().call();
+                        const decimals = yield tokenContract.decimals().call();
+                        const amount = xchainUtil.baseAmount(rawValue, decimals);
+                        const from = [{ from: fromAddress, amount }];
+                        const to = [{ to: toAddress, amount }];
+                        const asset = {
+                            chain: 'TRON',
+                            symbol: `${symbol}-${contract_address}`,
+                            ticker: symbol,
+                            type: xchainUtil.AssetType.TOKEN,
+                        };
+                        txs.push({
+                            asset,
+                            type: xchainClient.TxType.Transfer,
+                            from,
+                            to,
+                            date: new Date(tx.block_timestamp),
+                            hash: tx.txID,
+                        });
+                    }
+                    catch (_e) {
+                        // Not an ERC20 transfer (could be another contract call)
+                        continue;
+                    }
+                }
+            }
+            return {
+                total: txs.length,
+                txs,
+            };
+        });
+    }
+    getTransactionData(txId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const url = `${TRONGRID_API_BASE_URL}/walletsolidity/gettransactionbyid`;
+            const res = yield fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ value: txId }),
+            });
+            const tx = yield res.json();
+            if (!tx || !((_b = (_a = tx.raw_data) === null || _a === void 0 ? void 0 : _a.contract) === null || _b === void 0 ? void 0 : _b.length)) {
+                throw new Error('Transaction not found');
+            }
+            const contract = tx.raw_data.contract[0];
+            // Case 1: Native TRX transfer
+            if (contract.type === 'TransferContract') {
+                const amount = xchainUtil.baseAmount(contract.parameter.value.amount, TRX_DECIMAL);
+                const from = [{ from: TW.TronWeb.address.fromHex(contract.parameter.value.owner_address), amount }];
+                const to = [{ to: TW.TronWeb.address.fromHex(contract.parameter.value.to_address), amount }];
+                return {
+                    asset: AssetTRX,
+                    type: xchainClient.TxType.Transfer,
+                    from,
+                    to,
+                    date: new Date((_c = tx.raw_data.timestamp) !== null && _c !== void 0 ? _c : Date.now()),
+                    hash: tx.txID,
+                };
+            }
+            // Case 2: TRC20 transfer (must decode ABI input manually)
+            if (contract.type === 'TriggerSmartContract') {
+                const { owner_address, contract_address, data: inputData } = contract.parameter.value;
+                // ERC20 transfer selector = a9059cbb
+                if (inputData.startsWith('a9059cbb')) {
+                    const decoded = TW__default.default.utils.abi.decodeParams(['_to', '_value'], // parameter names
+                    ['address', 'uint256'], // parameter types
+                    inputData, // full input data (with selector)
+                    true);
+                    const toAddress = TW.TronWeb.address.fromHex(decoded._to);
+                    const fromAddress = TW.TronWeb.address.fromHex(owner_address);
+                    const rawValue = decoded._value.toString();
+                    // should set owner_address
+                    this.tronWeb.setAddress(fromAddress);
+                    // Get token contract instance
+                    const contract = TW.TronWeb.address.fromHex(contract_address);
+                    const tokenContract = yield this.tronWeb.contract().at(contract);
+                    // Call symbol() and decimals()
+                    const symbol = yield tokenContract.symbol().call();
+                    const decimals = yield tokenContract.decimals().call();
+                    const amount = xchainUtil.baseAmount(rawValue, decimals);
+                    const from = [{ from: fromAddress, amount }];
+                    const to = [{ to: toAddress, amount }];
+                    const asset = {
+                        chain: 'TRON',
+                        symbol: `${symbol}-${contract_address}`,
+                        ticker: symbol,
+                        type: xchainUtil.AssetType.TOKEN,
+                    };
+                    return {
+                        asset,
+                        type: xchainClient.TxType.Transfer,
+                        from,
+                        to,
+                        date: new Date(tx.raw_data.timestamp),
+                        hash: tx.txID,
+                    };
+                }
+            }
+            throw new Error(`Unsupported or non-transfer transaction: ${contract.type}`);
+        });
+    }
+}
+
+// Default parameters for the Tron client
+const defaultTRONParams = {
+    network: xchainClient.Network.Mainnet,
+    phrase: '',
+    explorerProviders: tronExplorerProviders,
+    rootDerivationPaths: {
+        [xchainClient.Network.Mainnet]: TRON_DERIVATION_PATH,
+        [xchainClient.Network.Testnet]: TRON_DERIVATION_PATH,
+        [xchainClient.Network.Stagenet]: TRON_DERIVATION_PATH,
+    },
+};
+class Client extends xchainClient.BaseXChainClient {
+    constructor(params = defaultTRONParams) {
+        const clientParams = Object.assign(Object.assign({}, defaultTRONParams), params);
+        super(TRONChain, clientParams);
+        /**
+         * Get token balance and info directly from contract
+         */
+        this.fetchTokenMetadata = (_a) => __awaiter(this, [_a], void 0, function* ({ contractAddress }) {
+            const contract = this.tronWeb.contract(trc20ABI, contractAddress);
+            const [symbolRaw, decimalsRaw] = yield Promise.all([
+                contract
+                    .symbol()
+                    .call()
+                    .catch(() => 'UNKNOWN'),
+                contract
+                    .decimals()
+                    .call()
+                    .catch(() => '18'),
+            ]);
+            return { decimals: Number(decimalsRaw !== null && decimalsRaw !== void 0 ? decimalsRaw : 18), symbol: symbolRaw !== null && symbolRaw !== void 0 ? symbolRaw : 'UNKNOWN' };
+        });
+        /**
+         * Get token balance and info directly from contract
+         */
+        this.fetchTokenBalance = (_a) => __awaiter(this, [_a], void 0, function* ({ contractAddress, address }) {
+            var _b;
+            try {
+                const contract = this.tronWeb.contract(trc20ABI, contractAddress);
+                if (!((_b = contract.methods) === null || _b === void 0 ? void 0 : _b.balanceOf)) {
+                    return BigInt(0);
+                }
+                const [balance] = yield contract.methods.balanceOf(address).call();
+                return balance ? (typeof balance === 'bigint' ? balance : BigInt(balance)) : BigInt(0);
+            }
+            catch (err) {
+                console.warn(`balanceOf() failed for ${contractAddress}:`, err);
+                return BigInt(0);
+            }
+        });
+        /**
+         * Get current chain parameters including resource prices
+         */
+        this.getChainParameters = () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const parameters = yield this.tronWeb.trx.getChainParameters();
+                const paramMap = {};
+                for (const param of parameters) {
+                    paramMap[param.key] = param.value;
+                }
+                return {
+                    bandwidthFee: paramMap.getTransactionFee || 1000, // SUN per bandwidth unit
+                    createAccountFee: paramMap.getCreateAccountFee || 100000, // 0.1 TRX in SUN
+                    energyFee: paramMap.getEnergyFee || 420, // SUN per energy unit
+                };
+            }
+            catch (_a) {
+                // Return default values if unable to fetch
+                return { bandwidthFee: 1000, createAccountFee: 100000, energyFee: 420 };
+            }
+        });
+        /**
+         * Check if an address exists on the blockchain
+         */
+        this.accountExists = (address) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const account = yield this.tronWeb.trx.getAccount(address);
+                return account && Object.keys(account).length > 0;
+            }
+            catch (_a) {
+                return false;
+            }
+        });
+        /**
+         * Get account resources (bandwidth and energy)
+         */
+        this.getAccountResources = (address) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            try {
+                const resources = yield this.tronWeb.trx.getAccountResources(address);
+                return {
+                    bandwidth: {
+                        free: ((_a = resources === null || resources === void 0 ? void 0 : resources.freeNetLimit) !== null && _a !== void 0 ? _a : 0) - ((_b = resources === null || resources === void 0 ? void 0 : resources.freeNetUsed) !== null && _b !== void 0 ? _b : 0),
+                        total: resources.NetLimit || 0,
+                        used: resources.NetUsed || 0,
+                    },
+                    energy: { total: resources.EnergyLimit || 0, used: resources.EnergyUsed || 0 },
+                };
+            }
+            catch (_c) {
+                // Return default structure if unable to fetch
+                return {
+                    bandwidth: { free: 600, total: 0, used: 0 }, // 600 free bandwidth daily
+                    energy: { total: 0, used: 0 },
+                };
+            }
+        });
+        this.createTransaction = (params) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const { asset, amount: baseValue, recipient, memo, walletIndex } = params;
+            if (!asset)
+                throw Error('Asset not provided');
+            const sender = this.getAddress(walletIndex);
+            const amount = baseValue.amount().toString();
+            if (asset.type === xchainUtil.AssetType.NATIVE) {
+                const transaction = yield this.tronWeb.transactionBuilder.sendTrx(recipient, Number(amount), sender);
+                if (memo) {
+                    return this.tronWeb.transactionBuilder.addUpdateData(transaction, memo, 'utf8');
+                }
+                return transaction;
+            }
+            const contractAddress = getTRC20AssetContractAddress(asset);
+            if (!contractAddress) {
+                throw new Error('TRC20 Asset Contract Address is not valid');
+            }
+            // Build TRC20 transfer transaction
+            const functionSelector = 'transfer(address,uint256)';
+            const parameter = [
+                { type: 'address', value: recipient },
+                { type: 'uint256', value: amount },
+            ];
+            const options = { callValue: 0, feeLimit: TRX_FEE_LIMIT };
+            const res = yield this.tronWeb.transactionBuilder.triggerSmartContract(contractAddress, functionSelector, options, parameter, sender);
+            // Some nodes don’t throw; they return result=false + message
+            if (!(((_a = res === null || res === void 0 ? void 0 : res.result) === null || _a === void 0 ? void 0 : _a.result) && (res === null || res === void 0 ? void 0 : res.transaction))) {
+                throw new Error((_b = res === null || res === void 0 ? void 0 : res.result) === null || _b === void 0 ? void 0 : _b.message);
+            }
+            // Attach memo if requested
+            const tx = memo
+                ? yield this.tronWeb.transactionBuilder.addUpdateData(res.transaction, memo, 'utf8')
+                : res.transaction;
+            return tx;
+        });
+        /**
+         * Check the current allowance for a spender on a token
+         */
+        this.getApprovedAmount = (_a) => __awaiter(this, [_a], void 0, function* ({ contractAddress, spenderAddress, from }) {
+            var _b;
+            this.tronWeb.setAddress(from);
+            const contract = this.tronWeb.contract(trc20ABI, contractAddress);
+            if (!((_b = contract.methods) === null || _b === void 0 ? void 0 : _b.allowance)) {
+                throw new Error('invalid contract');
+            }
+            const [allowance] = yield contract.methods.allowance(from, spenderAddress).call();
+            return allowance ? (typeof allowance === 'bigint' ? allowance : BigInt(allowance)) : BigInt(0);
+        });
+        this.explorerProviders = clientParams.explorerProviders;
+        this.tronWeb = new TW.TronWeb({ fullHost: TRON_DEFAULT_RPC });
+        this.tronGrid = new TronGrid();
+    }
+    /**
+     * Get TRX asset info.
+     * @returns {AssetInfo} TRX asset information.
+     */
+    getAssetInfo() {
+        const assetInfo = {
+            asset: AssetTRX,
+            decimal: TRX_DECIMAL,
+        };
+        return assetInfo;
+    }
+    /**
+     * Get the explorer URL.
+     *
+     * @returns {string} The explorer URL.
+     */
+    getExplorerUrl() {
+        return this.explorerProviders[this.getNetwork()].getExplorerUrl();
+    }
+    /**
+     * Get the explorer url for the given address.
+     *
+     * @param {Address} address
+     * @returns {string} The explorer url for the given address.
+     */
+    getExplorerAddressUrl(address) {
+        return this.explorerProviders[this.getNetwork()].getExplorerAddressUrl(address);
+    }
+    /**
+     * Get the explorer url for the given transaction id.
+     *
+     * @param {string} txID
+     * @returns {string} The explorer url for the given transaction id.
+     */
+    getExplorerTxUrl(txID) {
+        return this.explorerProviders[this.getNetwork()].getExplorerTxUrl(txID);
+    }
+    /**
+     * Validate the given Tron address.
+     * @param {string} address Tron address to validate.
+     * @returns {boolean} `true` if the address is valid, `false` otherwise.
+     */
+    validateAddress(address) {
+        return validateAddress(address);
+    }
+    /**
+     * Retrieves the balance of a given address.
+     * @param {Address} address - The address to retrieve the balance for.
+     * @param {TokenAsset[]} assets - Assets to retrieve the balance for (optional).
+     * @returns {Promise<Balance[]>} An array containing the balance of the address.
+     */
+    getBalance(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ZeroBalance = [
+                {
+                    asset: AssetTRX,
+                    amount: xchainUtil.baseAmount(0, TRX_DECIMAL),
+                },
+            ];
+            // Try get balance from TronGrid
+            try {
+                const accountData = yield this.tronGrid.getAccount(address);
+                if (!accountData)
+                    return ZeroBalance;
+                const balances = [];
+                // Add TRX balance
+                balances.push({
+                    asset: AssetTRX,
+                    amount: xchainUtil.baseAmount(accountData.balance, TRX_DECIMAL),
+                });
+                // Add TRC20 balances
+                for (const token of accountData.trc20) {
+                    const entries = Object.entries(token);
+                    if (entries.length !== 1)
+                        continue;
+                    const [contractAddress, balance] = entries[0];
+                    if (!(contractAddress && balance))
+                        continue;
+                    const tokenMetaData = yield this.fetchTokenMetadata({ contractAddress });
+                    if (!tokenMetaData)
+                        continue;
+                    balances.push({
+                        asset: {
+                            chain: TRONChain,
+                            symbol: `${tokenMetaData.symbol}-${contractAddress}`,
+                            ticker: tokenMetaData.symbol,
+                            type: xchainUtil.AssetType.TOKEN,
+                        },
+                        amount: xchainUtil.baseAmount(balance || 0, tokenMetaData.decimals),
+                    });
+                }
+                return balances;
+            }
+            catch (_error) {
+                // Fallback: get TRX and USDT Balance from TronWeb
+                const balances = [];
+                const trxBalanceInSun = yield this.tronWeb.trx.getBalance(address);
+                if (trxBalanceInSun && Number(trxBalanceInSun) > 0) {
+                    balances.push({
+                        asset: AssetTRX,
+                        amount: xchainUtil.baseAmount(trxBalanceInSun, TRX_DECIMAL),
+                    });
+                }
+                const usdtBalance = yield this.fetchTokenBalance({ address, contractAddress: TRON_USDT_CONTRACT });
+                if (usdtBalance) {
+                    balances.push({
+                        asset: {
+                            chain: TRONChain,
+                            symbol: `USDT-${TRON_USDT_CONTRACT}`,
+                            ticker: 'USDT',
+                            type: xchainUtil.AssetType.TOKEN,
+                        },
+                        amount: xchainUtil.baseAmount(usdtBalance.toString(), 6),
+                    });
+                }
+                return balances;
+            }
+        });
+    }
+    /**
+     * Get transaction fees.
+     * @param {TxParams} params - Tx param
+     * @returns {Fees} The average, fast, and fastest fees.
+     */
+    getFees(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!params)
+                throw new Error('Params need to be passed');
+            const { asset, recipient, walletIndex } = params;
+            const isNative = (asset === null || asset === void 0 ? void 0 : asset.type) === xchainUtil.AssetType.NATIVE;
+            let feeAmount;
+            // Get sender address
+            const senderAddress = this.getAddress(walletIndex);
+            if (!senderAddress) {
+                // If no signer, return default fee
+                feeAmount = isNative ? xchainUtil.baseAmount(0.1 * Math.pow(10, 6), TRX_DECIMAL) : xchainUtil.baseAmount(15 * Math.pow(10, 6), TRX_DECIMAL);
+            }
+            else {
+                // Get chain parameters for current resource prices
+                const chainParams = yield this.getChainParameters();
+                // Check if recipient account exists (new accounts require activation fee)
+                const recipientExists = yield this.accountExists(recipient);
+                const activationFee = recipientExists ? 0 : chainParams.createAccountFee;
+                // Get account resources
+                const resources = yield this.getAccountResources(senderAddress);
+                if (isNative) {
+                    // Calculate bandwidth needed for TRX transfer
+                    const bandwidthNeeded = TRX_TRANSFER_BANDWIDTH;
+                    const availableBandwidth = resources.bandwidth.free + (resources.bandwidth.total - resources.bandwidth.used);
+                    let bandwidthFee = 0;
+                    if (bandwidthNeeded > availableBandwidth) {
+                        // Need to burn TRX for bandwidth
+                        const bandwidthToBuy = bandwidthNeeded - availableBandwidth;
+                        bandwidthFee = bandwidthToBuy * chainParams.bandwidthFee;
+                    }
+                    // Total fee in SUN
+                    const totalFeeSun = activationFee + bandwidthFee;
+                    feeAmount = xchainUtil.baseAmount(totalFeeSun, TRX_DECIMAL);
+                }
+                else {
+                    // TRC20 Transfer - needs both bandwidth and energy
+                    const bandwidthNeeded = TRC20_TRANSFER_BANDWIDTH;
+                    const energyNeeded = TRC20_TRANSFER_ENERGY;
+                    const availableBandwidth = resources.bandwidth.free + (resources.bandwidth.total - resources.bandwidth.used);
+                    const availableEnergy = resources.energy.total - resources.energy.used;
+                    let bandwidthFee = 0;
+                    if (bandwidthNeeded > availableBandwidth) {
+                        const bandwidthToBuy = bandwidthNeeded - availableBandwidth;
+                        bandwidthFee = bandwidthToBuy * chainParams.bandwidthFee;
+                    }
+                    let energyFee = 0;
+                    if (energyNeeded > availableEnergy) {
+                        const energyToBuy = energyNeeded - availableEnergy;
+                        energyFee = energyToBuy * chainParams.energyFee;
+                    }
+                    // Total fee in SUN
+                    const totalFeeSun = activationFee + bandwidthFee + energyFee;
+                    feeAmount = xchainUtil.baseAmount(totalFeeSun, TRX_DECIMAL);
+                }
+            }
+            // Tron has Fixed Fee model, unlike ETH or BTC
+            return {
+                average: feeAmount,
+                fast: feeAmount,
+                fastest: feeAmount,
+                type: xchainClient.FeeType.FlatFee,
+            };
+        });
+    }
+    /**
+     * Transfer TRON Asset
+     * @param {TxParams} params The transfer options.
+     * @returns {TxHash} The transaction hash.
+     */
+    transfer(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { asset, amount: baseValue, recipient, memo, walletIndex } = params;
+            if (!asset)
+                throw Error('Asset not provided');
+            const amount = baseValue.amount().toString();
+            const sender = this.getAddress(walletIndex);
+            const isNative = asset.type === xchainUtil.AssetType.NATIVE;
+            if (isNative) {
+                const transaction = yield this.tronWeb.transactionBuilder.sendTrx(recipient, Number(amount), sender);
+                if (memo) {
+                    const transactionWithMemo = yield this.tronWeb.transactionBuilder.addUpdateData(transaction, memo, 'utf8');
+                    const signedTx = yield this.signTransaction(transactionWithMemo, walletIndex);
+                    const { txid } = yield this.tronWeb.trx.sendRawTransaction(signedTx);
+                    return txid;
+                }
+                const signedTx = yield this.signTransaction(transaction, walletIndex);
+                const { txid } = yield this.tronWeb.trx.sendRawTransaction(signedTx);
+                return txid;
+            }
+            // TRC20 Token Transfer - always use createTransaction + sign pattern
+            const transaction = yield this.createTransaction(params);
+            const signedTx = yield this.signTransaction(transaction, walletIndex);
+            const { txid } = yield this.tronWeb.trx.sendRawTransaction(signedTx);
+            if (!txid) {
+                throw new Error('TRON Transfer falied');
+            }
+            return txid;
+        });
+    }
+    /**
+     * Check TRC20 allowance.
+     * @param {Address} contractAddress The contract address.
+     * @param {Address} spenderAddress The spender address.
+     * @param {BaseAmount} amount The amount to check if it's allowed to spend or not (optional).
+     * @param {number} walletIndex (optional) HD wallet index
+     * @param {IsApprovedParams} params - Parameters for checking allowance.
+     * @returns {boolean} `true` if the allowance is approved, `false` otherwise.
+     */
+    isApproved(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ contractAddress, spenderAddress, amount, walletIndex }) {
+            const from = this.getAddress(walletIndex);
+            const allowance = yield this.getApprovedAmount({ contractAddress, from, spenderAddress });
+            if (!amount) {
+                // If no amount specified, check if there's any approval
+                return allowance > BigInt(0);
+            }
+            return allowance >= BigInt(amount.amount().toString());
+        });
+    }
+    /**
+     * Approves an allowance for spending tokens.
+     *
+     * @param {ApproveParams} params - Parameters for approving an allowance.
+     * @param {Address} contractAddress The contract address.
+     * @param {Address} spenderAddress The spender address.
+     * @param {BaseAmount} amount The amount of token. By default, it will be unlimited token allowance. (optional)
+     * @param {number} walletIndex (optional) HD wallet index
+     * @returns {TransactionResponse} The result of the approval transaction.
+     * @throws Error If gas estimation fails.
+     */
+    approve(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ contractAddress, spenderAddress, amount, walletIndex = 0 }) {
+            const fromAddress = this.getAddress(walletIndex);
+            const approvalAmount = amount !== undefined ? amount.amount().toString() : MAX_APPROVAL;
+            // Build approve transaction using triggerSmartContract
+            const functionSelector = 'approve(address,uint256)';
+            const parameter = [
+                { type: 'address', value: spenderAddress },
+                { type: 'uint256', value: approvalAmount },
+            ];
+            const feeLimit = TRX_FEE_LIMIT;
+            const options = { callValue: 0, feeLimit };
+            const { transaction } = yield this.tronWeb.transactionBuilder.triggerSmartContract(contractAddress, functionSelector, options, parameter, fromAddress);
+            if (!transaction) {
+                throw new Error('Failed to build approve transaction');
+            }
+            const signedTx = yield this.signTransaction(transaction, walletIndex);
+            const { txid } = yield this.tronWeb.trx.sendRawTransaction(signedTx);
+            if (!txid) {
+                throw new Error('TRC20 Approve Failed');
+            }
+            return txid;
+        });
+    }
+    broadcastTransaction(signedTx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { txid } = yield this.tronWeb.trx.sendRawTransaction(signedTx);
+            return txid;
+        });
+    }
+    getTransactions(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = (params === null || params === void 0 ? void 0 : params.address) || this.getAddress();
+            const offset = (params === null || params === void 0 ? void 0 : params.offset) || 0;
+            const limit = (params === null || params === void 0 ? void 0 : params.limit) || 10;
+            return this.tronGrid.getTransactions({ address, limit, offset });
+        });
+    }
+    /**
+     * Get the transaction details of a given transaction ID.
+     *
+     * @param {string} txId The transaction ID.
+     * @returns {Tx} The transaction details.
+     */
+    getTransactionData(txId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.tronGrid.getTransactionData(txId);
+        });
+    }
+    broadcastTx(_signedTx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw Error('Error: not supported');
+        });
+    }
+    prepareTx(_) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Error: raw tx string not supported');
+        });
+    }
+    getFeesWithRates() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw Error('Error: not supported');
+        });
+    }
+    getFeeRates() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw Error('Error: not supported');
+        });
+    }
+}
+
+class ClientKeystore extends Client {
+    constructor(params = defaultTRONParams) {
+        const clientParams = Object.assign(Object.assign({}, defaultTRONParams), params);
+        super(clientParams);
+    }
+    getSigner(walletIndex = 0) {
+        if (!this.phrase)
+            throw new Error('Phrase must be provided');
+        const seed = bip39.mnemonicToSeedSync(this.phrase);
+        const hdKey = bip32.HDKey.fromMasterSeed(seed);
+        const derived = hdKey.derive(this.getFullDerivationPath(walletIndex));
+        if (!derived.privateKey) {
+            throw new Error('No Tron Signer');
+        }
+        const privateKeyHex = Buffer.from(derived.privateKey).toString('hex');
+        const isolatedTronWeb = new TW.TronWeb({
+            fullHost: TRON_DEFAULT_RPC,
+            privateKey: privateKeyHex,
+        });
+        const address = isolatedTronWeb.address.fromPrivateKey(privateKeyHex);
+        return {
+            getAddress: () => (typeof address === 'string' ? address : ''),
+            signTransaction: (transaction) => __awaiter(this, void 0, void 0, function* () {
+                // Use isolated instance - no shared state
+                const signedTx = yield isolatedTronWeb.trx.sign(transaction);
+                return signedTx;
+            }),
+        };
+    }
+    /**
+     * Get the current address synchronously.
+     */
+    getAddress(walletIndex = 0) {
+        return this.getSigner(walletIndex).getAddress();
+    }
+    /**
+     * Get the current address asynchronously.
+     *
+     * @param {number} index The index of the address. Default 0
+     * @returns {Address} The TRON address related to the index provided.
+     * @throws {"Phrase must be provided"} Thrown if the phrase has not been set before.
+     */
+    getAddressAsync() {
+        return __awaiter(this, arguments, void 0, function* (walletIndex = 0) {
+            return this.getAddress(walletIndex);
+        });
+    }
+    signTransaction(transaction_1) {
+        return __awaiter(this, arguments, void 0, function* (transaction, walletIndex = 0) {
+            return this.getSigner(walletIndex).signTransaction(transaction);
+        });
+    }
+}
+
+exports.AssetTRONUSDT = AssetTRONUSDT;
+exports.AssetTRX = AssetTRX;
+exports.Client = ClientKeystore;
+exports.MAX_APPROVAL = MAX_APPROVAL;
+exports.TRC20_TRANSFER_BANDWIDTH = TRC20_TRANSFER_BANDWIDTH;
+exports.TRC20_TRANSFER_ENERGY = TRC20_TRANSFER_ENERGY;
+exports.TRONChain = TRONChain;
+exports.TRON_DEFAULT_RPC = TRON_DEFAULT_RPC;
+exports.TRON_DERIVATION_PATH = TRON_DERIVATION_PATH;
+exports.TRON_USDT_CONTRACT = TRON_USDT_CONTRACT;
+exports.TRX_DECIMAL = TRX_DECIMAL;
+exports.TRX_FEE_LIMIT = TRX_FEE_LIMIT;
+exports.TRX_TRANSFER_BANDWIDTH = TRX_TRANSFER_BANDWIDTH;
+exports.defaultTRONParams = defaultTRONParams;
+exports.tronExplorerProviders = tronExplorerProviders;
+exports.validateAddress = validateAddress;
+//# sourceMappingURL=index.js.map