@dynamic-labs/tron 4.40.1 → 4.41.0

package/src/connectors/TronWalletAdapterConnector/TronWalletAdapterConnector.js

@@ -1,58 +1,123 @@
 'use client'
 import { __awaiter } from '../../../_virtual/_tslib.js';
+import { TronLinkAdapter, BitKeepAdapter, OkxWalletAdapter, TokenPocketAdapter, TrustAdapter } from '@tronweb3/tronwallet-adapters';
 import { WalletConnectorBase, logger } from '@dynamic-labs/wallet-connector-core';
 import { DynamicError } from '@dynamic-labs/utils';
 import { TronWallet } from '../../wallet/TronWallet/TronWallet.js';
 import { TronUiTransaction } from '../../utils/TronUiTransaction/TronUiTransaction.js';
 import { convertChainIdToDecimal } from '../../utils/convertChainIdToDecimal/convertChainIdToDecimal.js';
 
+/**
+ * Registry mapping wallet keys to their adapter classes
+ */
+const ADAPTER_REGISTRY = {
+    bitgettron: BitKeepAdapter,
+    okxtron: OkxWalletAdapter,
+    tokenpockettron: TokenPocketAdapter,
+    tronlinkwallet: TronLinkAdapter,
+    trusttron: TrustAdapter,
+};
 class TronWalletAdapterConnector extends WalletConnectorBase {
+    /**
+     * Create the TronWallet Adapter instance for this connector
+     * Uses the adapter registry to create the appropriate adapter
+     */
+    createAdapter() {
+        const AdapterClass = ADAPTER_REGISTRY[this.overrideKey];
+        if (!AdapterClass) {
+            logger.warn(`[${this.name}] Unknown adapter for overrideKey: ${this.overrideKey}. Falling back to TronLink.`);
+            return new TronLinkAdapter();
+        }
+        const adapter = new AdapterClass();
+        return adapter;
+    }
     constructor(opts) {
         super(opts);
         this.ChainWallet = TronWallet;
-        this.name = 'Tron';
-        this.overrideKey = 'tron';
+        this.name = 'Tron Wallet';
+        this.overrideKey = 'tronwallet';
         this.connectedChain = 'TRON';
         this.supportedChains = ['TRON'];
         this.switchNetworkOnlyFromWallet = true;
+        this.adapter = undefined;
+        this.balanceCache = new Map();
+        this.networkCache = null;
         this.tronNetworks = opts.tronNetworks;
-        // Initialize adapter immediately so it can start detecting the wallet
-        this.adapter = this.createAdapter();
+        this.overrideKey = opts.overrideKey || 'tronwallet';
     }
     confirmTransactionStatus() {
         throw new Error('Method not implemented.');
     }
     /**
      * Get the TronWallet Adapter instance
+     * Adapter is created lazily only when connect() is called to avoid multiple adapters
+     * polling simultaneously at startup.
      */
     getAdapter() {
+        if (!this.adapter) {
+            throw new Error('Adapter not initialized. Call connect() first.');
+        }
         return this.adapter;
     }
     /**
-     * Check if the wallet is installed
+     * Check if the specific wallet is installed on the browser
+     * Each wallet adapter checks for its own specific browser injection
      */
     isInstalledOnBrowser() {
-        const adapter = this.getAdapter();
-        return adapter.readyState === 'Found';
+        try {
+            // Create the adapter to check if the wallet is installed
+            if (!this.adapter) {
+                const AdapterClass = ADAPTER_REGISTRY[this.overrideKey];
+                if (!AdapterClass) {
+                    return false;
+                }
+                this.adapter = new AdapterClass();
+            }
+            // The adapter's readyState indicates if the wallet is installed:
+            // NotFound = wallet not installed
+            // Loading/Found = wallet is installed
+            return this.adapter.readyState !== 'NotFound';
+        }
+        catch (_a) {
+            return false;
+        }
     }
     /**
      * Connect to the wallet
      */
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
-            const adapter = this.getAdapter();
+            // Create adapter NOW (first time connect is called)
+            if (!this.adapter) {
+                this.adapter = this.createAdapter();
+            }
+            const { adapter } = { adapter: this.adapter };
+            // If already connected, return early
             if (adapter.connected) {
                 return;
             }
-            if (adapter.readyState !== 'Found') {
-                throw new DynamicError(`${this.name} wallet not found. Please install the extension.`);
-            }
+            // Connect to the adapter
             try {
                 yield adapter.connect();
             }
             catch (error) {
                 throw new DynamicError(`Failed to connect to ${this.name}: ${error}`);
             }
+            // Some wallets (Trust, Bitget) populate the address asynchronously after connect()
+            // Wait briefly for the address to be populated by the wallet
+            const initialAddress = adapter.address;
+            const hasNoAddress = !initialAddress ||
+                (typeof initialAddress === 'string' && initialAddress.length === 0);
+            if (hasNoAddress) {
+                // Give the wallet 1000ms to populate the address
+                const startTime = Date.now();
+                while ((!adapter.address ||
+                    (typeof adapter.address === 'string' &&
+                        adapter.address.length === 0)) &&
+                    Date.now() - startTime < 1000) {
+                    yield new Promise((resolve) => setTimeout(resolve, 50));
+                }
+            }
         });
     }
     /**
@@ -60,12 +125,41 @@ class TronWalletAdapterConnector extends WalletConnectorBase {
      */
     getAddress() {
         return __awaiter(this, void 0, void 0, function* () {
-            const adapter = this.getAdapter();
-            // If not connected, trigger the connection flow
+            // Create adapter if it doesn't exist yet (defensive against SDK calling getAddress before connect)
+            if (!this.adapter) {
+                this.adapter = this.createAdapter();
+            }
+            const { adapter } = { adapter: this.adapter };
+            // If adapter exists but isn't connected yet, connect it first
             if (!adapter.connected) {
-                yield this.connect();
+                try {
+                    yield adapter.connect();
+                    // Some wallets (Trust, Bitget) populate the address asynchronously after connect()
+                    // Wait briefly for the address to be populated by the wallet
+                    const initialAddress = adapter.address;
+                    const hasNoAddress = !initialAddress ||
+                        (typeof initialAddress === 'string' && initialAddress.length === 0);
+                    if (hasNoAddress) {
+                        // Give the wallet 1000ms to populate the address
+                        const startTime = Date.now();
+                        while ((!adapter.address ||
+                            (typeof adapter.address === 'string' &&
+                                adapter.address.length === 0)) &&
+                            Date.now() - startTime < 1000) {
+                            yield new Promise((resolve) => setTimeout(resolve, 50));
+                        }
+                    }
+                }
+                catch (error) {
+                    throw new DynamicError(`Failed to connect to ${this.name}: ${error}`);
+                }
+            }
+            const { address } = adapter;
+            // Handle null, undefined, and empty string
+            if (!address || address.length === 0) {
+                return undefined;
             }
-            return adapter.address || undefined;
+            return address;
         });
     }
     /**
@@ -78,15 +172,35 @@ class TronWalletAdapterConnector extends WalletConnectorBase {
         });
     }
     /**
-     * Get the current network
+     * Get the current network with caching to prevent rate limiting
      */
     getNetwork() {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // Don't create adapter if it doesn't exist yet (prevents initialization crashes)
+            if (!this.adapter) {
+                return '728126428'; // Mainnet fallback
+            }
+            // Check cache first (10 second cache for network info)
+            if (this.networkCache && Date.now() - this.networkCache.timestamp < 10000) {
+                return this.networkCache.network;
+            }
             try {
                 const networkInfo = yield this.adapter.network();
-                return convertChainIdToDecimal(networkInfo.chainId);
+                const networkStr = convertChainIdToDecimal(networkInfo.chainId);
+                // Cache the result
+                this.networkCache = {
+                    network: networkStr,
+                    timestamp: Date.now(),
+                };
+                return networkStr;
             }
             catch (error) {
+                // Handle rate limiting gracefully
+                if (error instanceof Error && error.message.includes('429')) {
+                    logger.warn(`[${this.name}] Rate limited, returning cached network or mainnet`);
+                    return ((_a = this.networkCache) === null || _a === void 0 ? void 0 : _a.network) || '728126428'; // Mainnet in decimal format
+                }
                 // If adapter is not connected, fall back to mainnet
                 return '728126428'; // Mainnet in decimal format
             }
@@ -97,6 +211,10 @@ class TronWalletAdapterConnector extends WalletConnectorBase {
      */
     isTestnet() {
         return __awaiter(this, void 0, void 0, function* () {
+            // Don't create adapter if it doesn't exist yet (prevents initialization crashes)
+            if (!this.adapter) {
+                return false; // Assume mainnet if not connected
+            }
             try {
                 const networkInfo = yield this.adapter.network();
                 // Testnet networkTypes: Shasta, Nile
@@ -104,6 +222,11 @@ class TronWalletAdapterConnector extends WalletConnectorBase {
                     networkInfo.networkType === 'Nile');
             }
             catch (error) {
+                // Handle rate limiting gracefully - assume mainnet (not testnet)
+                if (error instanceof Error && error.message.includes('429')) {
+                    logger.warn(`[${this.name}] Rate limited, assuming mainnet (not testnet)`);
+                    return false;
+                }
                 // If adapter is not connected, assume mainnet (not testnet)
                 return false;
             }
@@ -114,7 +237,10 @@ class TronWalletAdapterConnector extends WalletConnectorBase {
      */
     signMessage(messageToSign) {
         return __awaiter(this, void 0, void 0, function* () {
-            const adapter = this.getAdapter();
+            if (!this.adapter) {
+                throw new DynamicError('Wallet not connected');
+            }
+            const { adapter } = { adapter: this.adapter };
             if (!adapter.connected) {
                 throw new DynamicError('Wallet not connected');
             }
@@ -130,36 +256,70 @@ class TronWalletAdapterConnector extends WalletConnectorBase {
     }
     /**
      * Get the TronWeb instance from the adapter
-     * The adapters store TronWeb in their internal _wallet property
+     *
+     * CRITICAL: Each adapter maintains its own _wallet.tronWeb reference
+     * to avoid collision. We access it through the adapter's internal state,
+     * NOT through global window objects.
+     *
+     * This is the key insight from the tronwallet-adapter implementation:
+     * - TronLink stores in _wallet (can be window.tronLink or window.tron.tronWeb)
+     * - TokenPocket stores in _wallet (from window.tokenpocket.tronWeb)
+     * - BitKeep stores in _wallet (from window.bitkeep.tronWeb)
+     * - Each adapter handles its own detection and isolation
      */
     getWalletTronWeb() {
-        var _a;
-        const adapter = this.adapter;
-        // Try to access adapter's internal tronWeb directly
-        if (adapter.tronWeb) {
-            return adapter.tronWeb;
+        var _a, _b, _c;
+        if (!this.adapter) {
+            return undefined;
         }
-        // Most adapters store it in _wallet.tronWeb
+        const adapter = this.adapter;
+        // The adapter's internal wallet contains the wallet-specific TronWeb
+        // This is the safe way to access it without collisions
         if ((_a = adapter._wallet) === null || _a === void 0 ? void 0 : _a.tronWeb) {
             return adapter._wallet.tronWeb;
         }
+        // Some adapters nest it under _wallet.tron.tronWeb
+        if ((_c = (_b = adapter._wallet) === null || _b === void 0 ? void 0 : _b.tron) === null || _c === void 0 ? void 0 : _c.tronWeb) {
+            return adapter._wallet.tron.tronWeb;
+        }
         return undefined;
     }
     /**
-     * Get balance of an address
+     * Get balance of an address with caching to prevent rate limiting
      */
     getBalance(address) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
+            if (!this.adapter) {
+                return '0';
+            }
+            // Check cache first (5 second cache)
+            const cached = this.balanceCache.get(address);
+            if (cached && Date.now() - cached.timestamp < 5000) {
+                return cached.balance;
+            }
+            // Get TronWeb from the adapter's internal wallet state
             const tronWeb = this.getWalletTronWeb();
             if (!((_a = tronWeb === null || tronWeb === void 0 ? void 0 : tronWeb.trx) === null || _a === void 0 ? void 0 : _a.getBalance)) {
+                logger.debug(`[${this.name}] TronWeb not available for balance check`);
                 return '0';
             }
             try {
                 const balance = yield tronWeb.trx.getBalance(address);
-                return (balance / 1000000).toFixed(6); // SUN → TRX
+                const balanceStr = (balance / 1000000).toFixed(6); // SUN → TRX
+                // Cache the result
+                this.balanceCache.set(address, {
+                    balance: balanceStr,
+                    timestamp: Date.now(),
+                });
+                return balanceStr;
             }
             catch (error) {
+                // Handle rate limiting gracefully
+                if (error instanceof Error && error.message.includes('429')) {
+                    logger.warn(`[${this.name}] Rate limited, returning cached balance or 0`);
+                    return (cached === null || cached === void 0 ? void 0 : cached.balance) || '0';
+                }
                 logger.error(`[${this.name}] Failed to get balance:`, error);
                 return '0';
             }
@@ -184,15 +344,19 @@ class TronWalletAdapterConnector extends WalletConnectorBase {
      */
     getBlockExplorerUrlsForCurrentNetwork() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
+            var _a, _b, _c, _d, _e, _f;
+            if (!this.adapter) {
+                // If adapter is not connected, return mainnet block explorer URLs
+                return ((_b = (_a = this.tronNetworks.find((n) => String(n.chainId) === '728126428')) === null || _a === void 0 ? void 0 : _a.blockExplorerUrls) !== null && _b !== void 0 ? _b : []);
+            }
             try {
                 const networkInfo = yield this.adapter.network();
                 const decimalChainId = convertChainIdToDecimal(networkInfo.chainId);
-                return ((_b = (_a = this.tronNetworks.find((n) => String(n.chainId) === decimalChainId)) === null || _a === void 0 ? void 0 : _a.blockExplorerUrls) !== null && _b !== void 0 ? _b : []);
+                return ((_d = (_c = this.tronNetworks.find((n) => String(n.chainId) === decimalChainId)) === null || _c === void 0 ? void 0 : _c.blockExplorerUrls) !== null && _d !== void 0 ? _d : []);
             }
             catch (error) {
                 // If adapter is not connected, return mainnet block explorer URLs
-                return ((_d = (_c = this.tronNetworks.find((n) => String(n.chainId) === '728126428')) === null || _c === void 0 ? void 0 : _c.blockExplorerUrls) !== null && _d !== void 0 ? _d : []);
+                return ((_f = (_e = this.tronNetworks.find((n) => String(n.chainId) === '728126428')) === null || _e === void 0 ? void 0 : _e.blockExplorerUrls) !== null && _f !== void 0 ? _f : []);
             }
         });
     }
@@ -201,52 +365,20 @@ class TronWalletAdapterConnector extends WalletConnectorBase {
      */
     endSession() {
         return __awaiter(this, void 0, void 0, function* () {
-            const adapter = this.getAdapter();
-            if (adapter.connected) {
+            var _a;
+            if ((_a = this.adapter) === null || _a === void 0 ? void 0 : _a.connected) {
                 try {
-                    yield adapter.disconnect();
+                    yield this.adapter.disconnect();
                 }
                 catch (error) {
                     logger.debug(`[${this.name}] Error during disconnect:`, error);
                 }
             }
+            // Clear caches on disconnect
+            this.balanceCache.clear();
+            this.networkCache = null;
         });
     }
-    /**
-     * Setup event listeners - called by Dynamic's initEventListener()
-     */
-    setupEventListeners() {
-        const { adapter } = this;
-        // Connect event
-        adapter.on('connect', (address) => {
-            this.emit('accountChange', {
-                accounts: [address],
-            });
-        });
-        // Disconnect event
-        adapter.on('disconnect', () => {
-            this.emit('disconnect');
-        });
-        // Account change event
-        adapter.on('accountsChanged', (address) => {
-            this.emit('accountChange', {
-                accounts: [address],
-            });
-        });
-        // Chain change event
-        adapter.on('chainChanged', (chainData) => {
-            const data = chainData;
-            this.emit('chainChange', {
-                chain: data.chainId,
-            });
-        });
-    }
-    /**
-     * Cleanup event listeners
-     */
-    teardownEventListeners() {
-        this.adapter.removeAllListeners();
-    }
     /**
      * Create a UI transaction for the send balance flow
      *
@@ -256,7 +388,7 @@ class TronWalletAdapterConnector extends WalletConnectorBase {
     createUiTransaction(from) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.validateActiveWallet(from);
-            // Get TronWeb from the wallet-specific window location
+            // Get TronWeb from the adapter's internal wallet state
             const tronWeb = this.getWalletTronWeb();
             if (!tronWeb) {
                 throw new DynamicError('TronWeb not available');

package/src/index.cjs

@@ -5,20 +5,12 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var assertPackageVersion = require('@dynamic-labs/assert-package-version');
 var _package = require('../package.cjs');
-var BitgetTronConnector = require('./connectors/BitgetTronConnector/BitgetTronConnector.cjs');
-var OKXTronConnector = require('./connectors/OKXTronConnector/OKXTronConnector.cjs');
-var TokenPocketTronConnector = require('./connectors/TokenPocketTronConnector/TokenPocketTronConnector.cjs');
-var TrustTronConnector = require('./connectors/TrustTronConnector/TrustTronConnector.cjs');
+var fetchTronWalletAdapterConnectors = require('./utils/fetchTronWalletAdapterConnectors/fetchTronWalletAdapterConnectors.cjs');
 var TronWallet = require('./wallet/TronWallet/TronWallet.cjs');
 var isTronWallet = require('./wallet/isTronWallet/isTronWallet.cjs');
 
 assertPackageVersion.assertPackageVersion('@dynamic-labs/tron', _package.version);
-const TronWalletConnectors = () => [
-    BitgetTronConnector.BitgetTronConnector,
-    OKXTronConnector.OKXTronConnector,
-    TokenPocketTronConnector.TokenPocketTronConnector,
-    TrustTronConnector.TrustTronConnector,
-];
+const TronWalletConnectors = (props) => [...fetchTronWalletAdapterConnectors.fetchTronWalletAdapterConnectors(props)];
 
 exports.TronWallet = TronWallet.TronWallet;
 exports.isTronWallet = isTronWallet.isTronWallet;

package/src/index.d.ts

@@ -1,7 +1,6 @@
-import { BitgetTronConnector } from './connectors/BitgetTronConnector';
-import { OKXTronConnector } from './connectors/OKXTronConnector';
-import { TokenPocketTronConnector } from './connectors/TokenPocketTronConnector';
-import { TrustTronConnector } from './connectors/TrustTronConnector';
 export { TronWallet } from './wallet/TronWallet';
 export { isTronWallet } from './wallet/isTronWallet';
-export declare const TronWalletConnectors: () => (typeof BitgetTronConnector | typeof OKXTronConnector | typeof TokenPocketTronConnector | typeof TrustTronConnector)[];
+export declare const TronWalletConnectors: (props: {
+    walletBook: any;
+    tronNetworks: any[];
+}) => import("dist/packages/wallet-connector-core/src").WalletConnectorConstructor[];

package/src/index.js

@@ -1,19 +1,11 @@
 'use client'
 import { assertPackageVersion } from '@dynamic-labs/assert-package-version';
 import { version } from '../package.js';
-import { BitgetTronConnector } from './connectors/BitgetTronConnector/BitgetTronConnector.js';
-import { OKXTronConnector } from './connectors/OKXTronConnector/OKXTronConnector.js';
-import { TokenPocketTronConnector } from './connectors/TokenPocketTronConnector/TokenPocketTronConnector.js';
-import { TrustTronConnector } from './connectors/TrustTronConnector/TrustTronConnector.js';
+import { fetchTronWalletAdapterConnectors } from './utils/fetchTronWalletAdapterConnectors/fetchTronWalletAdapterConnectors.js';
 export { TronWallet } from './wallet/TronWallet/TronWallet.js';
 export { isTronWallet } from './wallet/isTronWallet/isTronWallet.js';
 
 assertPackageVersion('@dynamic-labs/tron', version);
-const TronWalletConnectors = () => [
-    BitgetTronConnector,
-    OKXTronConnector,
-    TokenPocketTronConnector,
-    TrustTronConnector,
-];
+const TronWalletConnectors = (props) => [...fetchTronWalletAdapterConnectors(props)];
 
 export { TronWalletConnectors };

package/src/utils/fetchTronWalletAdapterConnectors/fetchTronWalletAdapterConnectors.cjs

@@ -0,0 +1,80 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var walletBook = require('@dynamic-labs/wallet-book');
+var TronWalletAdapterConnector = require('../../connectors/TronWalletAdapterConnector/TronWalletAdapterConnector.cjs');
+
+/**
+ * Checks if a wallet configuration supports TronWallet Adapters.
+ *
+ * A wallet is considered valid if it has:
+ * - An injected config for the 'tron' chain
+ * - The tronwallet-adapters feature included in wallet standard features
+ * - A valid provider ID
+ *
+ * @param wallet - The wallet configuration to check
+ * @returns true if the wallet supports TronWallet Adapters, false otherwise
+ */
+const isValidTronWalletAdapterWallet = (wallet) => {
+    var _a;
+    return Boolean((_a = wallet.injectedConfig) === null || _a === void 0 ? void 0 : _a.find((config) => {
+        var _a, _b;
+        return config.chain === 'tron' &&
+            Array.isArray((_a = config.walletStandard) === null || _a === void 0 ? void 0 : _a.features) &&
+            config.walletStandard.features.includes('tronwallet-adapters:') &&
+            ((_b = config.walletStandard) === null || _b === void 0 ? void 0 : _b.providerId);
+    }));
+};
+/**
+ * Fetches all Tron wallet connectors that support TronWallet Adapters from the wallet book.
+ *
+ * This function scans the wallet book for wallets with Tron chain configuration
+ * and creates connector classes for each matching wallet.
+ *
+ * @param walletBook - The wallet book schema containing all wallet configurations
+ * @param tronNetworks - The Tron networks configuration
+ * @returns Array of wallet connector constructors for TronWallet Adapter enabled wallets
+ *
+ * @example
+ * ```typescript
+ * const tronConnectors = fetchTronWalletAdapterConnectors({ walletBook, tronNetworks });
+ * // Returns connectors for wallets like TronLink, TokenPocket, OKX, etc.
+ * ```
+ */
+const fetchTronWalletAdapterConnectors = ({ walletBook: walletBook$1, tronNetworks, }) => {
+    var _a;
+    return Object.entries((_a = walletBook$1 === null || walletBook$1 === void 0 ? void 0 : walletBook$1.wallets) !== null && _a !== void 0 ? _a : {})
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        .filter(([_, wallet]) => isValidTronWalletAdapterWallet(wallet))
+        .map(([key, wallet]) => {
+        const { shortName } = wallet;
+        const name = shortName || wallet.name;
+        return class extends TronWalletAdapterConnector.TronWalletAdapterConnector {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            constructor(props) {
+                var _a;
+                super(Object.assign(Object.assign({}, props), { metadata: {
+                        brandColor: undefined,
+                        deepLinks: undefined,
+                        downloadLinks: undefined,
+                        groupKey: undefined,
+                        icon: ((_a = wallet === null || wallet === void 0 ? void 0 : wallet.brand) === null || _a === void 0 ? void 0 : _a.spriteId)
+                            ? walletBook.renderTemplate('iconicUrl', wallet.brand.spriteId)
+                            : '',
+                        id: key,
+                        name: name,
+                        rdns: undefined,
+                        supportedHardwareWallets: undefined,
+                        walletLimitations: undefined,
+                    }, overrideKey: key, tronNetworks, walletData: wallet }));
+                this.name = name;
+                this.overrideKey = key;
+            }
+        };
+    });
+};
+
+exports.fetchTronWalletAdapterConnectors = fetchTronWalletAdapterConnectors;
+exports.isValidTronWalletAdapterWallet = isValidTronWalletAdapterWallet;

package/src/utils/fetchTronWalletAdapterConnectors/fetchTronWalletAdapterConnectors.d.ts

@@ -0,0 +1,35 @@
+import { WalletBookSchema } from '@dynamic-labs/wallet-book';
+import { WalletConnectorConstructor } from '@dynamic-labs/wallet-connector-core';
+import type { GenericNetwork } from '@dynamic-labs/types';
+/**
+ * Checks if a wallet configuration supports TronWallet Adapters.
+ *
+ * A wallet is considered valid if it has:
+ * - An injected config for the 'tron' chain
+ * - The tronwallet-adapters feature included in wallet standard features
+ * - A valid provider ID
+ *
+ * @param wallet - The wallet configuration to check
+ * @returns true if the wallet supports TronWallet Adapters, false otherwise
+ */
+export declare const isValidTronWalletAdapterWallet: (wallet: WalletBookSchema['wallets'][string]) => boolean;
+/**
+ * Fetches all Tron wallet connectors that support TronWallet Adapters from the wallet book.
+ *
+ * This function scans the wallet book for wallets with Tron chain configuration
+ * and creates connector classes for each matching wallet.
+ *
+ * @param walletBook - The wallet book schema containing all wallet configurations
+ * @param tronNetworks - The Tron networks configuration
+ * @returns Array of wallet connector constructors for TronWallet Adapter enabled wallets
+ *
+ * @example
+ * ```typescript
+ * const tronConnectors = fetchTronWalletAdapterConnectors({ walletBook, tronNetworks });
+ * // Returns connectors for wallets like TronLink, TokenPocket, OKX, etc.
+ * ```
+ */
+export declare const fetchTronWalletAdapterConnectors: ({ walletBook, tronNetworks, }: {
+    walletBook: WalletBookSchema;
+    tronNetworks: GenericNetwork[];
+}) => WalletConnectorConstructor[];