@dynamic-labs/tron 4.40.0 → 4.40.2

package/src/connectors/TronWalletAdapterConnector/TronWalletAdapterConnector.cjs

@@ -0,0 +1,436 @@
+'use client'
+'use strict';
+
+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 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 _tslib.__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 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));
+                }
+            }
+        });
+    }
+    /**
+     * Get the current address
+     */
+    getAddress() {
+        return _tslib.__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 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 address;
+        });
+    }
+    /**
+     * Get connected accounts
+     */
+    getConnectedAccounts() {
+        return _tslib.__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 _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();
+                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
+            }
+        });
+    }
+    /**
+     * Check if current network is testnet
+     */
+    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
+                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')) {
+                    walletConnectorCore.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 _tslib.__awaiter(this, void 0, void 0, function* () {
+            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');
+            }
+            try {
+                const signature = yield adapter.signMessage(messageToSign);
+                return signature;
+            }
+            catch (error) {
+                walletConnectorCore.logger.error(`[${this.name}] Sign message failed:`, error);
+                throw new utils.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 _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);
+                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';
+            }
+        });
+    }
+    /**
+     * Get enabled networks
+     */
+    getEnabledNetworks() {
+        return this.tronNetworks;
+    }
+    /**
+     * Switch network (must be done in wallet UI)
+     */
+    switchNetwork() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            throw new utils.DynamicError('Network switching must be done manually in the Tron wallet UI');
+        });
+    }
+    /**
+     * Get block explorer URLs for current network
+     */
+    getBlockExplorerUrlsForCurrentNetwork() {
+        return _tslib.__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.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 _tslib.__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) {
+                    walletConnectorCore.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 _tslib.__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 utils.DynamicError('TronWeb not available');
+            }
+            return new TronUiTransaction.TronUiTransaction({
+                from,
+                onSubmit: (transaction) => _tslib.__awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    if (!transaction.to) {
+                        throw new utils.DynamicError('Destination address is required');
+                    }
+                    // Create a minimal wallet instance for sending
+                    const wallet = new TronWallet.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 utils.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 utils.DynamicError('Invalid transaction parameters');
+                }),
+                tronWeb,
+            });
+        });
+    }
+}
+
+exports.TronWalletAdapterConnector = TronWalletAdapterConnector;

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

@@ -0,0 +1,115 @@
+import type { Adapter, Network, TronWeb } from '@tronweb3/tronwallet-abstract-adapter';
+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
+ * All TronWallet adapters support this method
+ */
+interface TronAdapterWithNetwork extends Adapter {
+    network(): Promise<Network>;
+}
+export declare abstract class TronWalletAdapterConnector extends WalletConnectorBase<typeof TronWallet> implements ISendBalanceWalletConnector {
+    ChainWallet: typeof TronWallet;
+    name: string;
+    overrideKey: string;
+    connectedChain: Chain;
+    supportedChains: Chain[];
+    switchNetworkOnlyFromWallet: boolean;
+    protected tronNetworks: GenericNetwork[];
+    protected adapter?: TronAdapterWithNetwork;
+    private balanceCache;
+    private networkCache;
+    /**
+     * Create the TronWallet Adapter instance for this connector
+     * Uses the adapter registry to create the appropriate adapter
+     */
+    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(): TronAdapterWithNetwork;
+    /**
+     * Check if the specific wallet is installed on the browser
+     * Each wallet adapter checks for its own specific browser injection
+     */
+    isInstalledOnBrowser(): boolean;
+    /**
+     * Connect to the wallet
+     */
+    connect(): Promise<void>;
+    /**
+     * Get the current address
+     */
+    getAddress(): Promise<string | undefined>;
+    /**
+     * Get connected accounts
+     */
+    getConnectedAccounts(): Promise<string[]>;
+    /**
+     * Get the current network with caching to prevent rate limiting
+     */
+    getNetwork(): Promise<string | undefined>;
+    /**
+     * Check if current network is testnet
+     */
+    isTestnet(): Promise<boolean>;
+    /**
+     * Sign a message using the adapter
+     */
+    signMessage(messageToSign: string): Promise<string>;
+    /**
+     * 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(): TronWeb | undefined;
+    /**
+     * Get balance of an address with caching to prevent rate limiting
+     */
+    getBalance(address: string): Promise<string | undefined>;
+    /**
+     * Get enabled networks
+     */
+    getEnabledNetworks(): GenericNetwork[];
+    /**
+     * Switch network (must be done in wallet UI)
+     */
+    switchNetwork(): Promise<void>;
+    /**
+     * Get block explorer URLs for current network
+     */
+    getBlockExplorerUrlsForCurrentNetwork(): Promise<string[]>;
+    /**
+     * Disconnect and cleanup
+     */
+    endSession(): Promise<void>;
+    /**
+     * Create a UI transaction for the send balance flow
+     *
+     * @param from - The address sending the transaction
+     * @returns A TronUiTransaction instance
+     */
+    createUiTransaction(from: string): Promise<IUITransaction>;
+}
+export {};