@dynamic-labs/tron 4.40.1 → 4.40.2

package/CHANGELOG.md

@@ -1,4 +1,11 @@
 
+### [4.40.2](https://github.com/dynamic-labs/dynamic-auth/compare/v4.40.1...v4.40.2) (2025-10-28)
+
+
+### Bug Fixes
+
+* upgrade node to 20.20 in sanity-yarn-add-sdk job for compatibility ([#9743](https://github.com/dynamic-labs/dynamic-auth/issues/9743)) ([58d7e32](https://github.com/dynamic-labs/dynamic-auth/commit/58d7e32cd3965fba983c91c6345eae3bfe8dd1d5))
+
 ### [4.40.1](https://github.com/dynamic-labs/dynamic-auth/compare/v4.40.0...v4.40.1) (2025-10-24)
 
 ### Bug Fixes

package/package.cjs

@@ -3,6 +3,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var version = "4.40.1";
+var version = "4.40.2";
 
 exports.version = version;

package/package.js

@@ -1,4 +1,4 @@
 'use client'
-var version = "4.40.1";
+var version = "4.40.2";
 
 export { version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/tron",
-  "version": "4.40.1",
+  "version": "4.40.2",
   "description": "A React SDK for implementing wallet web3 authentication and authorization to your website.",
   "author": "Dynamic Labs, Inc.",
   "license": "MIT",
@@ -18,14 +18,14 @@
   },
   "homepage": "https://www.dynamic.xyz/",
   "dependencies": {
-    "@dynamic-labs/assert-package-version": "4.40.1",
+    "@dynamic-labs/assert-package-version": "4.40.2",
     "@tronweb3/tronwallet-abstract-adapter": "1.1.9",
     "@tronweb3/tronwallet-adapters": "1.2.14",
     "tronweb": "6.0.4",
-    "@dynamic-labs/types": "4.40.1",
-    "@dynamic-labs/utils": "4.40.1",
-    "@dynamic-labs/wallet-book": "4.40.1",
-    "@dynamic-labs/wallet-connector-core": "4.40.1"
+    "@dynamic-labs/types": "4.40.2",
+    "@dynamic-labs/utils": "4.40.2",
+    "@dynamic-labs/wallet-book": "4.40.2",
+    "@dynamic-labs/wallet-connector-core": "4.40.2"
   },
   "peerDependencies": {}
 }

package/src/connectors/TronWalletAdapterConnector/TronWalletAdapterConnector.cjs

@@ -4,59 +4,124 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('../../../_virtual/_tslib.cjs');
+var tronwalletAdapters = require('@tronweb3/tronwallet-adapters');
 var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
 var utils = require('@dynamic-labs/utils');
 var TronWallet = require('../../wallet/TronWallet/TronWallet.cjs');
 var TronUiTransaction = require('../../utils/TronUiTransaction/TronUiTransaction.cjs');
 var convertChainIdToDecimal = require('../../utils/convertChainIdToDecimal/convertChainIdToDecimal.cjs');
 
+/**
+ * Registry mapping wallet keys to their adapter classes
+ */
+const ADAPTER_REGISTRY = {
+    bitgettron: tronwalletAdapters.BitKeepAdapter,
+    okxtron: tronwalletAdapters.OkxWalletAdapter,
+    tokenpockettron: tronwalletAdapters.TokenPocketAdapter,
+    tronlinkwallet: tronwalletAdapters.TronLinkAdapter,
+    trusttron: tronwalletAdapters.TrustAdapter,
+};
 class TronWalletAdapterConnector extends walletConnectorCore.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) {
+            walletConnectorCore.logger.warn(`[${this.name}] Unknown adapter for overrideKey: ${this.overrideKey}. Falling back to TronLink.`);
+            return new tronwalletAdapters.TronLinkAdapter();
+        }
+        const adapter = new AdapterClass();
+        return adapter;
+    }
     constructor(opts) {
         super(opts);
         this.ChainWallet = TronWallet.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 _tslib.__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 utils.DynamicError(`${this.name} wallet not found. Please install the extension.`);
-            }
+            // Connect to the adapter
             try {
                 yield adapter.connect();
             }
             catch (error) {
                 throw new utils.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));
+                }
+            }
         });
     }
     /**
@@ -64,12 +129,41 @@ class TronWalletAdapterConnector extends walletConnectorCore.WalletConnectorBase
      */
     getAddress() {
         return _tslib.__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 utils.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;
         });
     }
     /**
@@ -82,15 +176,35 @@ class TronWalletAdapterConnector extends walletConnectorCore.WalletConnectorBase
         });
     }
     /**
-     * Get the current network
+     * Get the current network with caching to prevent rate limiting
      */
     getNetwork() {
         return _tslib.__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.convertChainIdToDecimal(networkInfo.chainId);
+                const networkStr = convertChainIdToDecimal.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')) {
+                    walletConnectorCore.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
             }
@@ -101,6 +215,10 @@ class TronWalletAdapterConnector extends walletConnectorCore.WalletConnectorBase
      */
     isTestnet() {
         return _tslib.__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
@@ -108,6 +226,11 @@ class TronWalletAdapterConnector extends walletConnectorCore.WalletConnectorBase
                     networkInfo.networkType === 'Nile');
             }
             catch (error) {
+                // Handle rate limiting gracefully - assume mainnet (not testnet)
+                if (error instanceof Error && error.message.includes('429')) {
+                    walletConnectorCore.logger.warn(`[${this.name}] Rate limited, assuming mainnet (not testnet)`);
+                    return false;
+                }
                 // If adapter is not connected, assume mainnet (not testnet)
                 return false;
             }
@@ -118,7 +241,10 @@ class TronWalletAdapterConnector extends walletConnectorCore.WalletConnectorBase
      */
     signMessage(messageToSign) {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
-            const adapter = this.getAdapter();
+            if (!this.adapter) {
+                throw new utils.DynamicError('Wallet not connected');
+            }
+            const { adapter } = { adapter: this.adapter };
             if (!adapter.connected) {
                 throw new utils.DynamicError('Wallet not connected');
             }
@@ -134,36 +260,70 @@ class TronWalletAdapterConnector extends walletConnectorCore.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 _tslib.__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)) {
+                walletConnectorCore.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')) {
+                    walletConnectorCore.logger.warn(`[${this.name}] Rate limited, returning cached balance or 0`);
+                    return (cached === null || cached === void 0 ? void 0 : cached.balance) || '0';
+                }
                 walletConnectorCore.logger.error(`[${this.name}] Failed to get balance:`, error);
                 return '0';
             }
@@ -188,15 +348,19 @@ class TronWalletAdapterConnector extends walletConnectorCore.WalletConnectorBase
      */
     getBlockExplorerUrlsForCurrentNetwork() {
         return _tslib.__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.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 : []);
             }
         });
     }
@@ -205,52 +369,20 @@ class TronWalletAdapterConnector extends walletConnectorCore.WalletConnectorBase
      */
     endSession() {
         return _tslib.__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) {
                     walletConnectorCore.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
      *
@@ -260,7 +392,7 @@ class TronWalletAdapterConnector extends walletConnectorCore.WalletConnectorBase
     createUiTransaction(from) {
         return _tslib.__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 utils.DynamicError('TronWeb not available');

package/src/connectors/TronWalletAdapterConnector/TronWalletAdapterConnector.d.ts

@@ -1,12 +1,14 @@
 import type { Adapter, Network, TronWeb } from '@tronweb3/tronwallet-abstract-adapter';
-import type { WalletBookSchema } from '@dynamic-labs/wallet-book';
 import { Chain, ISendBalanceWalletConnector, WalletConnectorBase, WalletMetadata } from '@dynamic-labs/wallet-connector-core';
+import type { WalletBookSchema } from '@dynamic-labs/wallet-book';
 import type { GenericNetwork, IUITransaction, TransactionReceipt } from '@dynamic-labs/types';
 import { TronWallet } from '../../wallet/TronWallet';
 export type TronWalletAdapterConnectorOpts = {
     walletBook: WalletBookSchema;
     tronNetworks: GenericNetwork[];
     metadata?: WalletMetadata;
+    overrideKey?: string;
+    walletData?: WalletBookSchema['wallets'][string];
 };
 /**
  * TronWallet Adapter interface that includes the network() method
@@ -23,20 +25,25 @@ export declare abstract class TronWalletAdapterConnector extends WalletConnector
     supportedChains: Chain[];
     switchNetworkOnlyFromWallet: boolean;
     protected tronNetworks: GenericNetwork[];
-    protected adapter: TronAdapterWithNetwork;
+    protected adapter?: TronAdapterWithNetwork;
+    private balanceCache;
+    private networkCache;
     /**
      * Create the TronWallet Adapter instance for this connector
-     * Each connector must implement this to return the appropriate adapter
+     * Uses the adapter registry to create the appropriate adapter
      */
-    protected abstract createAdapter(): TronAdapterWithNetwork;
+    protected createAdapter(): TronAdapterWithNetwork;
     constructor(opts: TronWalletAdapterConnectorOpts);
     confirmTransactionStatus?(): Promise<TransactionReceipt>;
     /**
      * Get the TronWallet Adapter instance
+     * Adapter is created lazily only when connect() is called to avoid multiple adapters
+     * polling simultaneously at startup.
      */
-    getAdapter(): Adapter;
+    getAdapter(): TronAdapterWithNetwork;
     /**
-     * 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(): boolean;
     /**
@@ -52,7 +59,7 @@ export declare abstract class TronWalletAdapterConnector extends WalletConnector
      */
     getConnectedAccounts(): Promise<string[]>;
     /**
-     * Get the current network
+     * Get the current network with caching to prevent rate limiting
      */
     getNetwork(): Promise<string | undefined>;
     /**
@@ -65,11 +72,20 @@ export declare abstract class TronWalletAdapterConnector extends WalletConnector
     signMessage(messageToSign: string): Promise<string>;
     /**
      * 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(): TronWeb | undefined;
     /**
-     * Get balance of an address
+     * Get balance of an address with caching to prevent rate limiting
      */
     getBalance(address: string): Promise<string | undefined>;
     /**
@@ -88,14 +104,6 @@ export declare abstract class TronWalletAdapterConnector extends WalletConnector
      * Disconnect and cleanup
      */
     endSession(): Promise<void>;
-    /**
-     * Setup event listeners - called by Dynamic's initEventListener()
-     */
-    setupEventListeners(): void;
-    /**
-     * Cleanup event listeners
-     */
-    teardownEventListeners(): void;
     /**
      * Create a UI transaction for the send balance flow
      *