@dynamic-labs/tron 4.40.0 → 4.40.2

package/src/connectors/TronWalletAdapterConnector/TronWalletAdapterConnector.js

@@ -0,0 +1,432 @@
+'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 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;
+        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 specific wallet is installed on the browser
+     * Each wallet adapter checks for its own specific browser injection
+     */
+    isInstalledOnBrowser() {
+        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* () {
+            // 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;
+            }
+            // 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));
+                }
+            }
+        });
+    }
+    /**
+     * Get the current address
+     */
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 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) {
+                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 address;
+        });
+    }
+    /**
+     * Get connected accounts
+     */
+    getConnectedAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = yield this.getAddress();
+            return address ? [address] : [];
+        });
+    }
+    /**
+     * 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();
+                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
+            }
+        });
+    }
+    /**
+     * Check if current network is testnet
+     */
+    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
+                return (networkInfo.networkType === 'Shasta' ||
+                    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;
+            }
+        });
+    }
+    /**
+     * Sign a message using the adapter
+     */
+    signMessage(messageToSign) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.adapter) {
+                throw new DynamicError('Wallet not connected');
+            }
+            const { adapter } = { adapter: this.adapter };
+            if (!adapter.connected) {
+                throw new DynamicError('Wallet not connected');
+            }
+            try {
+                const signature = yield adapter.signMessage(messageToSign);
+                return signature;
+            }
+            catch (error) {
+                logger.error(`[${this.name}] Sign message failed:`, error);
+                throw new DynamicError(`Failed to sign message: ${error}`);
+            }
+        });
+    }
+    /**
+     * Get the TronWeb instance from the adapter
+     *
+     * 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, _b, _c;
+        if (!this.adapter) {
+            return undefined;
+        }
+        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 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);
+                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';
+            }
+        });
+    }
+    /**
+     * Get enabled networks
+     */
+    getEnabledNetworks() {
+        return this.tronNetworks;
+    }
+    /**
+     * Switch network (must be done in wallet UI)
+     */
+    switchNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new DynamicError('Network switching must be done manually in the Tron wallet UI');
+        });
+    }
+    /**
+     * Get block explorer URLs for current network
+     */
+    getBlockExplorerUrlsForCurrentNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 ((_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 ((_f = (_e = this.tronNetworks.find((n) => String(n.chainId) === '728126428')) === null || _e === void 0 ? void 0 : _e.blockExplorerUrls) !== null && _f !== void 0 ? _f : []);
+            }
+        });
+    }
+    /**
+     * Disconnect and cleanup
+     */
+    endSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if ((_a = this.adapter) === null || _a === void 0 ? void 0 : _a.connected) {
+                try {
+                    yield this.adapter.disconnect();
+                }
+                catch (error) {
+                    logger.debug(`[${this.name}] Error during disconnect:`, error);
+                }
+            }
+            // Clear caches on disconnect
+            this.balanceCache.clear();
+            this.networkCache = null;
+        });
+    }
+    /**
+     * Create a UI transaction for the send balance flow
+     *
+     * @param from - The address sending the transaction
+     * @returns A TronUiTransaction instance
+     */
+    createUiTransaction(from) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.validateActiveWallet(from);
+            // Get TronWeb from the adapter's internal wallet state
+            const tronWeb = this.getWalletTronWeb();
+            if (!tronWeb) {
+                throw new DynamicError('TronWeb not available');
+            }
+            return new TronUiTransaction({
+                from,
+                onSubmit: (transaction) => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    if (!transaction.to) {
+                        throw new DynamicError('Destination address is required');
+                    }
+                    // Create a minimal wallet instance for sending
+                    const wallet = new TronWallet({
+                        address: from,
+                        chain: 'TRON',
+                        connector: this,
+                        id: 'temp-id',
+                        isAuthenticated: false,
+                        key: 'temp-key',
+                    });
+                    if (transaction.nonNativeAddress && transaction.nonNativeValue) {
+                        // Handle TRC20 token transfers - not yet implemented
+                        throw new DynamicError('TRC20 token transfers not yet implemented');
+                    }
+                    else if (transaction.value) {
+                        // Handle native TRX transfers
+                        const trxAmount = Number(transaction.value) / 1000000; // Convert SUN to TRX
+                        const result = yield wallet.sendTrx(transaction.to, trxAmount, {
+                            from,
+                        });
+                        return result.txid || ((_a = result.transaction) === null || _a === void 0 ? void 0 : _a.txID);
+                    }
+                    throw new DynamicError('Invalid transaction parameters');
+                }),
+                tronWeb,
+            });
+        });
+    }
+}
+
+export { TronWalletAdapterConnector };

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

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

package/src/index.cjs

@@ -5,22 +5,13 @@ 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');
-var TronWallet = require('./wallet/TronWallet.cjs');
 
 assertPackageVersion.assertPackageVersion('@dynamic-labs/tron', _package.version);
-const TronWalletConnectors = () => [
-    // BybitTronConnector, // Currently Bybit can't sign messages
-    BitgetTronConnector.BitgetTronConnector,
-    OKXTronConnector.OKXTronConnector,
-    TokenPocketTronConnector.TokenPocketTronConnector,
-    TrustTronConnector.TrustTronConnector,
-];
+const TronWalletConnectors = (props) => [...fetchTronWalletAdapterConnectors.fetchTronWalletAdapterConnectors(props)];
 
-exports.isTronWallet = isTronWallet.isTronWallet;
 exports.TronWallet = TronWallet.TronWallet;
+exports.isTronWallet = isTronWallet.isTronWallet;
 exports.TronWalletConnectors = TronWalletConnectors;

package/src/index.d.ts

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

package/src/index.js

@@ -1,20 +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';
-export { TronWallet } from './wallet/TronWallet.js';
 
 assertPackageVersion('@dynamic-labs/tron', version);
-const TronWalletConnectors = () => [
-    // BybitTronConnector, // Currently Bybit can't sign messages
-    BitgetTronConnector,
-    OKXTronConnector,
-    TokenPocketTronConnector,
-    TrustTronConnector,
-];
+const TronWalletConnectors = (props) => [...fetchTronWalletAdapterConnectors(props)];
 
 export { TronWalletConnectors };