@dynamic-labs/tron 4.34.0 → 4.36.0

package/src/utils/getDefaultTronNetworks.cjs

@@ -0,0 +1,60 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const TRON_MAINNET_NETWORK = {
+    blockExplorerUrls: ['https://tronscan.org/'],
+    chainId: '728126428',
+    iconUrls: ['https://app.dynamic.xyz/assets/networks/tron.svg'],
+    name: 'Tron Mainnet',
+    nativeCurrency: {
+        decimals: 6,
+        name: 'Tron',
+        symbol: 'TRX',
+    },
+    networkId: '728126428',
+    rpcUrls: ['https://api.trongrid.io'],
+};
+const TRON_NILE_TESTNET_NETWORK = {
+    blockExplorerUrls: ['https://nile.tronscan.org/'],
+    chainId: '728126430',
+    iconUrls: ['https://app.dynamic.xyz/assets/networks/tron.svg'],
+    isTestnet: true,
+    name: 'Tron Nile Testnet',
+    nativeCurrency: {
+        decimals: 6,
+        name: 'Tron',
+        symbol: 'TRX',
+    },
+    networkId: '728126430',
+    rpcUrls: ['https://api.nileex.io'],
+};
+const TRON_SHASTA_TESTNET_NETWORK = {
+    blockExplorerUrls: ['https://shasta.tronscan.org/'],
+    chainId: '728126429',
+    iconUrls: ['https://app.dynamic.xyz/assets/networks/tron.svg'],
+    isTestnet: true,
+    name: 'Tron Shasta Testnet',
+    nativeCurrency: {
+        decimals: 6,
+        name: 'Tron',
+        symbol: 'TRX',
+    },
+    networkId: '728126429',
+    rpcUrls: ['https://api.shasta.trongrid.io'],
+};
+/**
+ * Gets the default Tron networks configuration
+ * @returns Array of default Tron networks
+ */
+const getDefaultTronNetworks = () => [
+    TRON_MAINNET_NETWORK,
+    TRON_NILE_TESTNET_NETWORK,
+    TRON_SHASTA_TESTNET_NETWORK,
+];
+
+exports.TRON_MAINNET_NETWORK = TRON_MAINNET_NETWORK;
+exports.TRON_NILE_TESTNET_NETWORK = TRON_NILE_TESTNET_NETWORK;
+exports.TRON_SHASTA_TESTNET_NETWORK = TRON_SHASTA_TESTNET_NETWORK;
+exports.getDefaultTronNetworks = getDefaultTronNetworks;

package/src/utils/getDefaultTronNetworks.js

@@ -0,0 +1,53 @@
+'use client'
+const TRON_MAINNET_NETWORK = {
+    blockExplorerUrls: ['https://tronscan.org/'],
+    chainId: '728126428',
+    iconUrls: ['https://app.dynamic.xyz/assets/networks/tron.svg'],
+    name: 'Tron Mainnet',
+    nativeCurrency: {
+        decimals: 6,
+        name: 'Tron',
+        symbol: 'TRX',
+    },
+    networkId: '728126428',
+    rpcUrls: ['https://api.trongrid.io'],
+};
+const TRON_NILE_TESTNET_NETWORK = {
+    blockExplorerUrls: ['https://nile.tronscan.org/'],
+    chainId: '728126430',
+    iconUrls: ['https://app.dynamic.xyz/assets/networks/tron.svg'],
+    isTestnet: true,
+    name: 'Tron Nile Testnet',
+    nativeCurrency: {
+        decimals: 6,
+        name: 'Tron',
+        symbol: 'TRX',
+    },
+    networkId: '728126430',
+    rpcUrls: ['https://api.nileex.io'],
+};
+const TRON_SHASTA_TESTNET_NETWORK = {
+    blockExplorerUrls: ['https://shasta.tronscan.org/'],
+    chainId: '728126429',
+    iconUrls: ['https://app.dynamic.xyz/assets/networks/tron.svg'],
+    isTestnet: true,
+    name: 'Tron Shasta Testnet',
+    nativeCurrency: {
+        decimals: 6,
+        name: 'Tron',
+        symbol: 'TRX',
+    },
+    networkId: '728126429',
+    rpcUrls: ['https://api.shasta.trongrid.io'],
+};
+/**
+ * Gets the default Tron networks configuration
+ * @returns Array of default Tron networks
+ */
+const getDefaultTronNetworks = () => [
+    TRON_MAINNET_NETWORK,
+    TRON_NILE_TESTNET_NETWORK,
+    TRON_SHASTA_TESTNET_NETWORK,
+];
+
+export { TRON_MAINNET_NETWORK, TRON_NILE_TESTNET_NETWORK, TRON_SHASTA_TESTNET_NETWORK, getDefaultTronNetworks };

package/src/utils/getTronGasEstimation.cjs

@@ -0,0 +1,136 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+
+/**
+ * Estimates gas fee for TRC20 token transfers
+ * @param params TRC20 estimation parameters
+ * @returns Estimated gas fee in SUN or null if estimation fails
+ */
+const estimateTRC20Gas = (params) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const { tronWeb, from, to, contractAddress, amount } = params;
+    try {
+        const functionSelector = 'transfer(address,uint256)';
+        const parameters = [
+            { type: 'address', value: to },
+            { type: 'uint256', value: amount.toString() },
+        ];
+        const result = yield tronWeb.transactionBuilder.estimateEnergy(contractAddress, functionSelector, {}, parameters, from);
+        if (result === null || result === void 0 ? void 0 : result.energy_required) {
+            // Convert energy to TRX (energy cost is typically ~420 SUN per unit)
+            const estimatedFee = Math.max(result.energy_required * 420, 500000);
+            return BigInt(estimatedFee);
+        }
+        return null;
+    }
+    catch (error) {
+        walletConnectorCore.logger.error('TRC20 energy estimation failed:', error);
+        return null;
+    }
+});
+/**
+ * Estimates gas fee for native TRX transfers
+ * @param params Native TRX estimation parameters
+ * @returns Estimated gas fee in SUN or null if estimation fails
+ */
+const estimateNativeTRXGas = (params) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const { tronWeb, from, to, value } = params;
+    try {
+        // Build the transaction to get accurate bandwidth cost
+        const transaction = yield tronWeb.transactionBuilder.sendTrx(to, Number(value), from);
+        // Get bandwidth cost
+        const bandwidth = transaction.raw_data_hex
+            ? transaction.raw_data_hex.length / 2
+            : 200; // fallback estimate
+        // Check account resources (free bandwidth, energy, etc.)
+        let accountResources;
+        try {
+            accountResources = yield tronWeb.trx.getAccountResources(from);
+        }
+        catch (resourceError) {
+            walletConnectorCore.logger.error('Could not fetch account resources:', resourceError);
+            accountResources = null;
+        }
+        // Calculate if transaction can use free bandwidth
+        const freeNetAvailable = accountResources
+            ? (accountResources.freeNetLimit || 0) -
+                (accountResources.freeNetUsed || 0)
+            : 0;
+        const delegatedNetAvailable = accountResources
+            ? (accountResources.NetLimit || 0) - (accountResources.NetUsed || 0)
+            : 0;
+        const totalFreeBandwidth = freeNetAvailable + delegatedNetAvailable;
+        // If we have enough free bandwidth, the fee should be 0
+        if (bandwidth <= totalFreeBandwidth) {
+            return BigInt(0);
+        }
+        // Otherwise calculate the fee for the bandwidth we need to pay for
+        const paidBandwidth = bandwidth - totalFreeBandwidth;
+        const estimatedFee = Math.max(paidBandwidth * 1000, 0);
+        return BigInt(estimatedFee);
+    }
+    catch (error) {
+        walletConnectorCore.logger.error('Native TRX estimation failed:', error);
+        return null;
+    }
+});
+/**
+ * Gets fallback gas fee based on transaction type
+ * @param isTokenTransfer Whether this is a token transfer
+ * @returns Fallback gas fee in SUN
+ */
+const getFallbackGasFee = (isTokenTransfer) => isTokenTransfer ? BigInt(500000) : BigInt(270000);
+/**
+ * Estimates gas fees for TRON transactions
+ * @param params Transaction parameters for estimation
+ * @returns Estimated gas fee in SUN
+ */
+const getTronGasEstimation = (params) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const { provider, from, to, value, nonNativeAddress, nonNativeValue } = params;
+    try {
+        const { tronWeb } = provider;
+        if (!tronWeb) {
+            return getFallbackGasFee(Boolean(nonNativeAddress));
+        }
+        // TRC20 Token Transfer Estimation
+        if (nonNativeAddress && to && nonNativeValue) {
+            const trc20Fee = yield estimateTRC20Gas({
+                amount: nonNativeValue,
+                contractAddress: nonNativeAddress,
+                from,
+                to,
+                tronWeb,
+            });
+            if (trc20Fee) {
+                return trc20Fee;
+            }
+        }
+        // Native TRX Transfer Estimation
+        if (to && value && value > 0) {
+            const nativeFee = yield estimateNativeTRXGas({
+                from,
+                to,
+                tronWeb,
+                value,
+            });
+            if (nativeFee) {
+                return nativeFee;
+            }
+        }
+        // Fallback to reasonable defaults
+        return getFallbackGasFee(Boolean(nonNativeAddress));
+    }
+    catch (error) {
+        walletConnectorCore.logger.error('Gas estimation failed:', error);
+        return getFallbackGasFee(Boolean(nonNativeAddress));
+    }
+});
+
+exports.estimateNativeTRXGas = estimateNativeTRXGas;
+exports.estimateTRC20Gas = estimateTRC20Gas;
+exports.getFallbackGasFee = getFallbackGasFee;
+exports.getTronGasEstimation = getTronGasEstimation;

package/src/utils/getTronGasEstimation.d.ts

@@ -0,0 +1,47 @@
+import type { TronWeb } from 'tronweb';
+import type { ITronProvider } from '../types';
+export interface TronGasEstimationParams {
+    provider: ITronProvider;
+    from: string;
+    to?: string;
+    value?: bigint;
+    nonNativeAddress?: string;
+    nonNativeValue?: bigint;
+}
+export interface TRC20EstimationParams {
+    tronWeb: TronWeb;
+    from: string;
+    to: string;
+    contractAddress: string;
+    amount: bigint;
+}
+export interface NativeTRXEstimationParams {
+    tronWeb: TronWeb;
+    from: string;
+    to: string;
+    value: bigint;
+}
+/**
+ * Estimates gas fee for TRC20 token transfers
+ * @param params TRC20 estimation parameters
+ * @returns Estimated gas fee in SUN or null if estimation fails
+ */
+export declare const estimateTRC20Gas: (params: TRC20EstimationParams) => Promise<bigint | null>;
+/**
+ * Estimates gas fee for native TRX transfers
+ * @param params Native TRX estimation parameters
+ * @returns Estimated gas fee in SUN or null if estimation fails
+ */
+export declare const estimateNativeTRXGas: (params: NativeTRXEstimationParams) => Promise<bigint | null>;
+/**
+ * Gets fallback gas fee based on transaction type
+ * @param isTokenTransfer Whether this is a token transfer
+ * @returns Fallback gas fee in SUN
+ */
+export declare const getFallbackGasFee: (isTokenTransfer: boolean) => bigint;
+/**
+ * Estimates gas fees for TRON transactions
+ * @param params Transaction parameters for estimation
+ * @returns Estimated gas fee in SUN
+ */
+export declare const getTronGasEstimation: (params: TronGasEstimationParams) => Promise<bigint>;

package/src/utils/getTronGasEstimation.js

@@ -0,0 +1,129 @@
+'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
+import { logger } from '@dynamic-labs/wallet-connector-core';
+
+/**
+ * Estimates gas fee for TRC20 token transfers
+ * @param params TRC20 estimation parameters
+ * @returns Estimated gas fee in SUN or null if estimation fails
+ */
+const estimateTRC20Gas = (params) => __awaiter(void 0, void 0, void 0, function* () {
+    const { tronWeb, from, to, contractAddress, amount } = params;
+    try {
+        const functionSelector = 'transfer(address,uint256)';
+        const parameters = [
+            { type: 'address', value: to },
+            { type: 'uint256', value: amount.toString() },
+        ];
+        const result = yield tronWeb.transactionBuilder.estimateEnergy(contractAddress, functionSelector, {}, parameters, from);
+        if (result === null || result === void 0 ? void 0 : result.energy_required) {
+            // Convert energy to TRX (energy cost is typically ~420 SUN per unit)
+            const estimatedFee = Math.max(result.energy_required * 420, 500000);
+            return BigInt(estimatedFee);
+        }
+        return null;
+    }
+    catch (error) {
+        logger.error('TRC20 energy estimation failed:', error);
+        return null;
+    }
+});
+/**
+ * Estimates gas fee for native TRX transfers
+ * @param params Native TRX estimation parameters
+ * @returns Estimated gas fee in SUN or null if estimation fails
+ */
+const estimateNativeTRXGas = (params) => __awaiter(void 0, void 0, void 0, function* () {
+    const { tronWeb, from, to, value } = params;
+    try {
+        // Build the transaction to get accurate bandwidth cost
+        const transaction = yield tronWeb.transactionBuilder.sendTrx(to, Number(value), from);
+        // Get bandwidth cost
+        const bandwidth = transaction.raw_data_hex
+            ? transaction.raw_data_hex.length / 2
+            : 200; // fallback estimate
+        // Check account resources (free bandwidth, energy, etc.)
+        let accountResources;
+        try {
+            accountResources = yield tronWeb.trx.getAccountResources(from);
+        }
+        catch (resourceError) {
+            logger.error('Could not fetch account resources:', resourceError);
+            accountResources = null;
+        }
+        // Calculate if transaction can use free bandwidth
+        const freeNetAvailable = accountResources
+            ? (accountResources.freeNetLimit || 0) -
+                (accountResources.freeNetUsed || 0)
+            : 0;
+        const delegatedNetAvailable = accountResources
+            ? (accountResources.NetLimit || 0) - (accountResources.NetUsed || 0)
+            : 0;
+        const totalFreeBandwidth = freeNetAvailable + delegatedNetAvailable;
+        // If we have enough free bandwidth, the fee should be 0
+        if (bandwidth <= totalFreeBandwidth) {
+            return BigInt(0);
+        }
+        // Otherwise calculate the fee for the bandwidth we need to pay for
+        const paidBandwidth = bandwidth - totalFreeBandwidth;
+        const estimatedFee = Math.max(paidBandwidth * 1000, 0);
+        return BigInt(estimatedFee);
+    }
+    catch (error) {
+        logger.error('Native TRX estimation failed:', error);
+        return null;
+    }
+});
+/**
+ * Gets fallback gas fee based on transaction type
+ * @param isTokenTransfer Whether this is a token transfer
+ * @returns Fallback gas fee in SUN
+ */
+const getFallbackGasFee = (isTokenTransfer) => isTokenTransfer ? BigInt(500000) : BigInt(270000);
+/**
+ * Estimates gas fees for TRON transactions
+ * @param params Transaction parameters for estimation
+ * @returns Estimated gas fee in SUN
+ */
+const getTronGasEstimation = (params) => __awaiter(void 0, void 0, void 0, function* () {
+    const { provider, from, to, value, nonNativeAddress, nonNativeValue } = params;
+    try {
+        const { tronWeb } = provider;
+        if (!tronWeb) {
+            return getFallbackGasFee(Boolean(nonNativeAddress));
+        }
+        // TRC20 Token Transfer Estimation
+        if (nonNativeAddress && to && nonNativeValue) {
+            const trc20Fee = yield estimateTRC20Gas({
+                amount: nonNativeValue,
+                contractAddress: nonNativeAddress,
+                from,
+                to,
+                tronWeb,
+            });
+            if (trc20Fee) {
+                return trc20Fee;
+            }
+        }
+        // Native TRX Transfer Estimation
+        if (to && value && value > 0) {
+            const nativeFee = yield estimateNativeTRXGas({
+                from,
+                to,
+                tronWeb,
+                value,
+            });
+            if (nativeFee) {
+                return nativeFee;
+            }
+        }
+        // Fallback to reasonable defaults
+        return getFallbackGasFee(Boolean(nonNativeAddress));
+    }
+    catch (error) {
+        logger.error('Gas estimation failed:', error);
+        return getFallbackGasFee(Boolean(nonNativeAddress));
+    }
+});
+
+export { estimateNativeTRXGas, estimateTRC20Gas, getFallbackGasFee, getTronGasEstimation };

package/src/utils/index.d.ts

@@ -1,2 +1,3 @@
 export { assertProvider, getCurrentAddress, isProviderReady } from './provider';
 export { getDefaultTronNetworks } from './getDefaultTronNetworks';
+export { TronUiTransaction, SUN_PER_TRX } from './TronUiTransaction';

package/src/utils/provider.cjs

@@ -0,0 +1,59 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Asserts that a provider is available and throws an error if not
+ * @param provider - The provider to validate
+ * @param providerName - Human-readable name for error messages
+ * @returns The validated provider
+ * @throws {Error} If provider is not available
+ */
+const assertProvider = (provider, providerName) => {
+    if (!provider) {
+        throw new Error(`${providerName} provider not available`);
+    }
+    return provider;
+};
+/**
+ * Gets the current address from a Tron provider using various methods
+ * @param provider - The Tron provider
+ * @returns The current address or undefined if not available
+ */
+const getCurrentAddress = (provider) => {
+    var _a, _b, _c, _d;
+    // Try different ways to get the address
+    if (provider.address) {
+        return provider.address;
+    }
+    if ((_b = (_a = provider.tronWeb) === null || _a === void 0 ? void 0 : _a.defaultAddress) === null || _b === void 0 ? void 0 : _b.base58) {
+        return provider.tronWeb.defaultAddress.base58;
+    }
+    if (typeof ((_c = provider.tronWeb) === null || _c === void 0 ? void 0 : _c.defaultAddress) === 'string') {
+        return provider.tronWeb.defaultAddress;
+    }
+    // Check global tronWeb
+    if (typeof window !== 'undefined' && ((_d = window.tronWeb) === null || _d === void 0 ? void 0 : _d.defaultAddress)) {
+        if (typeof window.tronWeb.defaultAddress === 'string') {
+            return window.tronWeb.defaultAddress;
+        }
+        if (window.tronWeb.defaultAddress.base58) {
+            return window.tronWeb.defaultAddress.base58;
+        }
+    }
+    return undefined;
+};
+/**
+ * Checks if a Tron provider is ready and connected
+ * @param provider - The Tron provider
+ * @returns True if the provider is ready and connected
+ */
+const isProviderReady = (provider) => {
+    const hasAddress = getCurrentAddress(provider);
+    return Boolean(provider.ready !== false && (provider.isConnected || hasAddress));
+};
+
+exports.assertProvider = assertProvider;
+exports.getCurrentAddress = getCurrentAddress;
+exports.isProviderReady = isProviderReady;

package/src/utils/provider.js

@@ -0,0 +1,53 @@
+'use client'
+/**
+ * Asserts that a provider is available and throws an error if not
+ * @param provider - The provider to validate
+ * @param providerName - Human-readable name for error messages
+ * @returns The validated provider
+ * @throws {Error} If provider is not available
+ */
+const assertProvider = (provider, providerName) => {
+    if (!provider) {
+        throw new Error(`${providerName} provider not available`);
+    }
+    return provider;
+};
+/**
+ * Gets the current address from a Tron provider using various methods
+ * @param provider - The Tron provider
+ * @returns The current address or undefined if not available
+ */
+const getCurrentAddress = (provider) => {
+    var _a, _b, _c, _d;
+    // Try different ways to get the address
+    if (provider.address) {
+        return provider.address;
+    }
+    if ((_b = (_a = provider.tronWeb) === null || _a === void 0 ? void 0 : _a.defaultAddress) === null || _b === void 0 ? void 0 : _b.base58) {
+        return provider.tronWeb.defaultAddress.base58;
+    }
+    if (typeof ((_c = provider.tronWeb) === null || _c === void 0 ? void 0 : _c.defaultAddress) === 'string') {
+        return provider.tronWeb.defaultAddress;
+    }
+    // Check global tronWeb
+    if (typeof window !== 'undefined' && ((_d = window.tronWeb) === null || _d === void 0 ? void 0 : _d.defaultAddress)) {
+        if (typeof window.tronWeb.defaultAddress === 'string') {
+            return window.tronWeb.defaultAddress;
+        }
+        if (window.tronWeb.defaultAddress.base58) {
+            return window.tronWeb.defaultAddress.base58;
+        }
+    }
+    return undefined;
+};
+/**
+ * Checks if a Tron provider is ready and connected
+ * @param provider - The Tron provider
+ * @returns True if the provider is ready and connected
+ */
+const isProviderReady = (provider) => {
+    const hasAddress = getCurrentAddress(provider);
+    return Boolean(provider.ready !== false && (provider.isConnected || hasAddress));
+};
+
+export { assertProvider, getCurrentAddress, isProviderReady };

package/src/wallet/TronWallet.cjs

@@ -0,0 +1,106 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var utils = require('@dynamic-labs/utils');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var provider = require('../utils/provider.cjs');
+
+class TronWallet extends walletConnectorCore.Wallet {
+    constructor(props) {
+        super(props);
+    }
+    getProvider() {
+        return this._connector.getProvider();
+    }
+    getTronWeb() {
+        var _a;
+        return (_a = this.getProvider()) === null || _a === void 0 ? void 0 : _a.tronWeb;
+    }
+    getAddress() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const provider$1 = provider.assertProvider(this.getProvider(), 'Tron');
+            const address = provider.getCurrentAddress(provider$1);
+            if (!address)
+                throw new utils.DynamicError('No address available');
+            return address;
+        });
+    }
+    getNetwork() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this._connector.getNetwork();
+        });
+    }
+    signMessage(message) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const messageString = typeof message === 'string' ? message : new TextDecoder().decode(message);
+            const signature = yield this._connector.signMessage(messageString);
+            if (!signature) {
+                throw new utils.DynamicError('Failed to sign message with signMessageV2');
+            }
+            return signature;
+        });
+    }
+    getBalance(address) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const targetAddress = address || (yield this.getAddress());
+            return this._connector.getBalance(targetAddress);
+        });
+    }
+    sendBalance() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            throw new utils.DynamicError('sendBalance not implemented. Use sendTrx or sendToken.');
+        });
+    }
+    sendTrx(to, amount, options) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const provider$1 = provider.assertProvider(this.getProvider(), 'Tron');
+            if (!((_b = (_a = provider$1.tronWeb) === null || _a === void 0 ? void 0 : _a.trx) === null || _b === void 0 ? void 0 : _b.sendTransaction)) {
+                throw new utils.DynamicError('TRX transfer not supported');
+            }
+            const fromAddress = (options === null || options === void 0 ? void 0 : options.from) || (yield this.getAddress());
+            const amountInSun = provider$1.tronWeb.toSun(amount);
+            return provider$1.tronWeb.trx.sendTransaction(to, Number(amountInSun), {
+                address: fromAddress,
+            });
+        });
+    }
+    getTokenBalance(tokenId, address) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const provider$1 = provider.assertProvider(this.getProvider(), 'Tron');
+            const targetAddress = address || (yield this.getAddress());
+            if (!((_a = provider$1.tronWeb) === null || _a === void 0 ? void 0 : _a.contract)) {
+                throw new utils.DynamicError('TRC20 token balance not supported by this wallet');
+            }
+            try {
+                const contract = yield provider$1.tronWeb.contract().at(tokenId);
+                const balance = yield contract.balanceOf(targetAddress).call();
+                return typeof balance === 'string'
+                    ? parseInt(balance, 10)
+                    : Number(balance);
+            }
+            catch (error) {
+                throw new utils.DynamicError(`TRC20 token balance query failed: ${error}`);
+            }
+        });
+    }
+    getNetworkDetails() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const provider$1 = provider.assertProvider(this.getProvider(), 'Tron');
+            if (provider$1.getNetwork) {
+                return provider$1.getNetwork();
+            }
+            const chainId = yield this._connector.getNetwork();
+            return {
+                chainId: chainId || '0x2b6653dc', // mainnet default
+                name: chainId === '0x94a9059e' ? 'Nile Testnet' : 'Mainnet',
+            };
+        });
+    }
+}
+
+exports.TronWallet = TronWallet;

package/src/wallet/TronWallet.d.ts

@@ -0,0 +1,22 @@
+import type { TronWeb, Types } from 'tronweb';
+import { Wallet, WalletProps } from '@dynamic-labs/wallet-connector-core';
+import type { ITronProvider } from '../types';
+import type { TronWalletConnector } from '../connectors/TronWalletConnector';
+export declare class TronWallet extends Wallet<TronWalletConnector> {
+    constructor(props: WalletProps<TronWalletConnector>);
+    getProvider(): ITronProvider | undefined;
+    getTronWeb(): TronWeb | undefined;
+    getAddress(): Promise<string>;
+    getNetwork(): Promise<string | number | undefined>;
+    signMessage(message: string | Uint8Array): Promise<string>;
+    getBalance(address?: string): Promise<string | undefined>;
+    sendBalance(): Promise<string | undefined>;
+    sendTrx(to: string, amount: number, options?: {
+        from?: string;
+    }): Promise<Types.BroadcastReturn<Types.SignedTransaction>>;
+    getTokenBalance(tokenId: string, address?: string): Promise<number>;
+    getNetworkDetails(): Promise<{
+        chainId: string;
+        name: string;
+    }>;
+}