@dynamic-labs/tron 4.33.0 → 4.35.0

package/src/utils/TronUiTransaction/TronUiTransaction.cjs

@@ -0,0 +1,113 @@
+'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');
+
+// 1 TRX = 1,000,000 SUN (atomic units)
+const SUN_PER_TRX = 1000000;
+class TronUiTransaction {
+    constructor({ onSubmit, from, provider }) {
+        this.chain = 'TRON';
+        this.data = undefined;
+        this.fee = { gas: undefined };
+        this.from = from;
+        this.onSubmit = onSubmit;
+        this.provider = provider;
+    }
+    fetchFee() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (this.fee.gas)
+                return;
+            this.fee.gas = this.nonNativeAddress ? BigInt(500000) : BigInt(270000);
+        });
+    }
+    parse(input) {
+        const numericValue = parseFloat(input);
+        if (isNaN(numericValue))
+            return BigInt(0);
+        return BigInt(Math.floor(numericValue * SUN_PER_TRX));
+    }
+    parseNonNativeToken(input, decimals) {
+        const numericValue = parseFloat(input);
+        if (isNaN(numericValue))
+            return BigInt(0);
+        return BigInt(Math.floor(numericValue * Math.pow(10, decimals)));
+    }
+    format(value, options) {
+        var _a;
+        const trxValue = Number(value) / SUN_PER_TRX;
+        return utils.formatNumberText(String(trxValue), {
+            precision: (_a = options === null || options === void 0 ? void 0 : options.precision) !== null && _a !== void 0 ? _a : 6,
+        });
+    }
+    formatNonNativeToken(value, decimals) {
+        const tokenValue = Number(value) / Math.pow(10, decimals);
+        return utils.formatNumberText(String(tokenValue), {
+            precision: decimals > 6 ? 6 : decimals,
+        });
+    }
+    submit() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!this.to) {
+                throw new Error('Destination address is required');
+            }
+            if (!this.value && !this.nonNativeValue) {
+                throw new Error('Transaction value is required');
+            }
+            return this.onSubmit(this);
+        });
+    }
+    getBalance() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const { tronWeb } = this.provider;
+                if (!tronWeb)
+                    return BigInt(0);
+                if (this.nonNativeAddress) {
+                    // Get TRC20 token balance
+                    const contract = yield tronWeb.contract().at(this.nonNativeAddress);
+                    const balance = yield contract.balanceOf(String(this.from)).call();
+                    return BigInt(typeof balance === 'string' ? balance : balance.toString());
+                }
+                else {
+                    // Get native TRX balance
+                    const balance = yield tronWeb.trx.getBalance(String(this.from));
+                    return BigInt(String(balance));
+                }
+            }
+            catch (error) {
+                walletConnectorCore.logger.error('Error occurred while fetching TRON balance. Please try again or contact support.');
+                return BigInt(0);
+            }
+        });
+    }
+    validateAddressFormat(address) {
+        if (address === 'dyn_send_transaction.multiple_recipients') {
+            return true;
+        }
+        try {
+            const { tronWeb } = this.provider;
+            if (!tronWeb)
+                return false;
+            // TRON addresses start with 'T' and are 34 characters long
+            if (!address.startsWith('T') || address.length !== 34) {
+                return false;
+            }
+            // Use TronWeb's built-in address validation
+            return tronWeb.isAddress(address);
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    isGasSponsored() {
+        return false;
+    }
+}
+
+exports.SUN_PER_TRX = SUN_PER_TRX;
+exports.TronUiTransaction = TronUiTransaction;

package/src/utils/TronUiTransaction/TronUiTransaction.d.ts

@@ -0,0 +1,39 @@
+import { IUITransaction, IUITransactionFormatOptions } from '@dynamic-labs/types';
+import type { ITronProvider } from '../../types';
+export declare const SUN_PER_TRX = 1000000;
+type TronUiTransactionProps = {
+    /** TRON Address of the sender */
+    from: string;
+    /** The TRON provider instance, needed to interact with TronWeb */
+    provider: ITronProvider;
+    /** The function to call when the transaction is submitted */
+    onSubmit: (transaction: TronUiTransaction) => Promise<string>;
+};
+export declare class TronUiTransaction implements IUITransaction {
+    to: string | undefined;
+    from: string;
+    value: bigint | undefined;
+    chain: string;
+    receipt: string | undefined;
+    data: undefined;
+    fee: {
+        gas: bigint | undefined;
+    };
+    nonNativeAddress?: string;
+    nonNativeDecimal?: number;
+    nonNativeValue?: bigint;
+    nativePrice?: number;
+    private onSubmit;
+    private provider;
+    constructor({ onSubmit, from, provider }: TronUiTransactionProps);
+    fetchFee(): Promise<void>;
+    parse(input: string): bigint;
+    parseNonNativeToken(input: string, decimals: number): bigint;
+    format(value: bigint, options?: IUITransactionFormatOptions): string;
+    formatNonNativeToken(value: bigint, decimals: number): string;
+    submit(): Promise<string>;
+    getBalance(): Promise<bigint>;
+    validateAddressFormat(address: string): boolean;
+    isGasSponsored(): boolean;
+}
+export {};

package/src/utils/TronUiTransaction/TronUiTransaction.js

@@ -0,0 +1,108 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { formatNumberText } from '@dynamic-labs/utils';
+import { logger } from '@dynamic-labs/wallet-connector-core';
+
+// 1 TRX = 1,000,000 SUN (atomic units)
+const SUN_PER_TRX = 1000000;
+class TronUiTransaction {
+    constructor({ onSubmit, from, provider }) {
+        this.chain = 'TRON';
+        this.data = undefined;
+        this.fee = { gas: undefined };
+        this.from = from;
+        this.onSubmit = onSubmit;
+        this.provider = provider;
+    }
+    fetchFee() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.fee.gas)
+                return;
+            this.fee.gas = this.nonNativeAddress ? BigInt(500000) : BigInt(270000);
+        });
+    }
+    parse(input) {
+        const numericValue = parseFloat(input);
+        if (isNaN(numericValue))
+            return BigInt(0);
+        return BigInt(Math.floor(numericValue * SUN_PER_TRX));
+    }
+    parseNonNativeToken(input, decimals) {
+        const numericValue = parseFloat(input);
+        if (isNaN(numericValue))
+            return BigInt(0);
+        return BigInt(Math.floor(numericValue * Math.pow(10, decimals)));
+    }
+    format(value, options) {
+        var _a;
+        const trxValue = Number(value) / SUN_PER_TRX;
+        return formatNumberText(String(trxValue), {
+            precision: (_a = options === null || options === void 0 ? void 0 : options.precision) !== null && _a !== void 0 ? _a : 6,
+        });
+    }
+    formatNonNativeToken(value, decimals) {
+        const tokenValue = Number(value) / Math.pow(10, decimals);
+        return formatNumberText(String(tokenValue), {
+            precision: decimals > 6 ? 6 : decimals,
+        });
+    }
+    submit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.to) {
+                throw new Error('Destination address is required');
+            }
+            if (!this.value && !this.nonNativeValue) {
+                throw new Error('Transaction value is required');
+            }
+            return this.onSubmit(this);
+        });
+    }
+    getBalance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { tronWeb } = this.provider;
+                if (!tronWeb)
+                    return BigInt(0);
+                if (this.nonNativeAddress) {
+                    // Get TRC20 token balance
+                    const contract = yield tronWeb.contract().at(this.nonNativeAddress);
+                    const balance = yield contract.balanceOf(String(this.from)).call();
+                    return BigInt(typeof balance === 'string' ? balance : balance.toString());
+                }
+                else {
+                    // Get native TRX balance
+                    const balance = yield tronWeb.trx.getBalance(String(this.from));
+                    return BigInt(String(balance));
+                }
+            }
+            catch (error) {
+                logger.error('Error occurred while fetching TRON balance. Please try again or contact support.');
+                return BigInt(0);
+            }
+        });
+    }
+    validateAddressFormat(address) {
+        if (address === 'dyn_send_transaction.multiple_recipients') {
+            return true;
+        }
+        try {
+            const { tronWeb } = this.provider;
+            if (!tronWeb)
+                return false;
+            // TRON addresses start with 'T' and are 34 characters long
+            if (!address.startsWith('T') || address.length !== 34) {
+                return false;
+            }
+            // Use TronWeb's built-in address validation
+            return tronWeb.isAddress(address);
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    isGasSponsored() {
+        return false;
+    }
+}
+
+export { SUN_PER_TRX, TronUiTransaction };

package/src/utils/TronUiTransaction/index.d.ts

@@ -0,0 +1 @@
+export { TronUiTransaction, SUN_PER_TRX } from './TronUiTransaction';

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.d.ts

@@ -0,0 +1,9 @@
+import type { GenericNetwork } from '@dynamic-labs/types';
+export declare const TRON_MAINNET_NETWORK: GenericNetwork;
+export declare const TRON_NILE_TESTNET_NETWORK: GenericNetwork;
+export declare const TRON_SHASTA_TESTNET_NETWORK: GenericNetwork;
+/**
+ * Gets the default Tron networks configuration
+ * @returns Array of default Tron networks
+ */
+export declare const getDefaultTronNetworks: () => GenericNetwork[];

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/index.d.ts

@@ -0,0 +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.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Utility functions for Tron provider validation and error handling
+ */
+import type { ITronProvider } from '../types';
+/**
+ * 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
+ */
+export declare const assertProvider: <T>(provider: T | undefined, providerName: string) => T;
+/**
+ * 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
+ */
+export declare const getCurrentAddress: (provider: ITronProvider) => string | undefined;
+/**
+ * Checks if a Tron provider is ready and connected
+ * @param provider - The Tron provider
+ * @returns True if the provider is ready and connected
+ */
+export declare const isProviderReady: (provider: ITronProvider) => boolean;

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;
+    }>;
+}