@dynamic-labs/tron 4.39.0 → 4.40.1

package/src/connectors/TronWalletAdapterConnector/TronWalletAdapterConnector.js

@@ -0,0 +1,300 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+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';
+
+class TronWalletAdapterConnector extends WalletConnectorBase {
+    constructor(opts) {
+        super(opts);
+        this.ChainWallet = TronWallet;
+        this.name = 'Tron';
+        this.overrideKey = 'tron';
+        this.connectedChain = 'TRON';
+        this.supportedChains = ['TRON'];
+        this.switchNetworkOnlyFromWallet = true;
+        this.tronNetworks = opts.tronNetworks;
+        // Initialize adapter immediately so it can start detecting the wallet
+        this.adapter = this.createAdapter();
+    }
+    confirmTransactionStatus() {
+        throw new Error('Method not implemented.');
+    }
+    /**
+     * Get the TronWallet Adapter instance
+     */
+    getAdapter() {
+        return this.adapter;
+    }
+    /**
+     * Check if the wallet is installed
+     */
+    isInstalledOnBrowser() {
+        const adapter = this.getAdapter();
+        return adapter.readyState === 'Found';
+    }
+    /**
+     * Connect to the wallet
+     */
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adapter = this.getAdapter();
+            if (adapter.connected) {
+                return;
+            }
+            if (adapter.readyState !== 'Found') {
+                throw new DynamicError(`${this.name} wallet not found. Please install the extension.`);
+            }
+            try {
+                yield adapter.connect();
+            }
+            catch (error) {
+                throw new DynamicError(`Failed to connect to ${this.name}: ${error}`);
+            }
+        });
+    }
+    /**
+     * Get the current address
+     */
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adapter = this.getAdapter();
+            // If not connected, trigger the connection flow
+            if (!adapter.connected) {
+                yield this.connect();
+            }
+            return adapter.address || undefined;
+        });
+    }
+    /**
+     * Get connected accounts
+     */
+    getConnectedAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = yield this.getAddress();
+            return address ? [address] : [];
+        });
+    }
+    /**
+     * Get the current network
+     */
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const networkInfo = yield this.adapter.network();
+                return convertChainIdToDecimal(networkInfo.chainId);
+            }
+            catch (error) {
+                // 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* () {
+            try {
+                const networkInfo = yield this.adapter.network();
+                // Testnet networkTypes: Shasta, Nile
+                return (networkInfo.networkType === 'Shasta' ||
+                    networkInfo.networkType === 'Nile');
+            }
+            catch (error) {
+                // 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* () {
+            const adapter = this.getAdapter();
+            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
+     * The adapters store TronWeb in their internal _wallet property
+     */
+    getWalletTronWeb() {
+        var _a;
+        const adapter = this.adapter;
+        // Try to access adapter's internal tronWeb directly
+        if (adapter.tronWeb) {
+            return adapter.tronWeb;
+        }
+        // Most adapters store it in _wallet.tronWeb
+        if ((_a = adapter._wallet) === null || _a === void 0 ? void 0 : _a.tronWeb) {
+            return adapter._wallet.tronWeb;
+        }
+        return undefined;
+    }
+    /**
+     * Get balance of an address
+     */
+    getBalance(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const tronWeb = this.getWalletTronWeb();
+            if (!((_a = tronWeb === null || tronWeb === void 0 ? void 0 : tronWeb.trx) === null || _a === void 0 ? void 0 : _a.getBalance)) {
+                return '0';
+            }
+            try {
+                const balance = yield tronWeb.trx.getBalance(address);
+                return (balance / 1000000).toFixed(6); // SUN → TRX
+            }
+            catch (error) {
+                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;
+            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 : []);
+            }
+            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 : []);
+            }
+        });
+    }
+    /**
+     * Disconnect and cleanup
+     */
+    endSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adapter = this.getAdapter();
+            if (adapter.connected) {
+                try {
+                    yield adapter.disconnect();
+                }
+                catch (error) {
+                    logger.debug(`[${this.name}] Error during disconnect:`, error);
+                }
+            }
+        });
+    }
+    /**
+     * 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
+     *
+     * @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 wallet-specific window location
+            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/connectors/TrustTronConnector/TrustTronConnector.cjs

@@ -3,28 +3,17 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var TronWalletConnector = require('../TronWalletConnector/TronWalletConnector.cjs');
+var tronwalletAdapters = require('@tronweb3/tronwallet-adapters');
+var TronWalletAdapterConnector = require('../TronWalletAdapterConnector/TronWalletAdapterConnector.cjs');
 
-class TrustTronConnector extends TronWalletConnector.TronWalletConnector {
+class TrustTronConnector extends TronWalletAdapterConnector.TronWalletAdapterConnector {
     constructor() {
         super(...arguments);
         this.name = 'Trust Wallet';
         this.overrideKey = 'trusttron';
     }
-    getProvider() {
-        var _a, _b, _c;
-        const provider = (_a = window.trustwallet) === null || _a === void 0 ? void 0 : _a.tronLink;
-        if (provider && provider.ready && !provider.chainId) {
-            // Trust Wallet doesn't expose chainId/network, set them manually
-            const host = (_c = (_b = provider.tronWeb) === null || _b === void 0 ? void 0 : _b.fullNode) === null || _c === void 0 ? void 0 : _c.host;
-            if (host === null || host === void 0 ? void 0 : host.includes('tron.twnodes.com')) {
-                Object.assign(provider, {
-                    chainId: '728126428',
-                    network: 'mainnet',
-                });
-            }
-        }
-        return provider;
+    createAdapter() {
+        return new tronwalletAdapters.TrustAdapter();
     }
 }
 

package/src/connectors/TrustTronConnector/TrustTronConnector.d.ts

@@ -1,7 +1,7 @@
-import type { ITronProvider } from '../../types';
-import { TronWalletConnector } from '../TronWalletConnector';
-export declare class TrustTronConnector extends TronWalletConnector {
+import { TrustAdapter } from '@tronweb3/tronwallet-adapters';
+import { TronWalletAdapterConnector } from '../TronWalletAdapterConnector';
+export declare class TrustTronConnector extends TronWalletAdapterConnector {
     name: string;
     overrideKey: string;
-    getProvider(): ITronProvider | undefined;
+    protected createAdapter(): TrustAdapter;
 }

package/src/connectors/TrustTronConnector/TrustTronConnector.js

@@ -1,26 +1,15 @@
 'use client'
-import { TronWalletConnector } from '../TronWalletConnector/TronWalletConnector.js';
+import { TrustAdapter } from '@tronweb3/tronwallet-adapters';
+import { TronWalletAdapterConnector } from '../TronWalletAdapterConnector/TronWalletAdapterConnector.js';
 
-class TrustTronConnector extends TronWalletConnector {
+class TrustTronConnector extends TronWalletAdapterConnector {
     constructor() {
         super(...arguments);
         this.name = 'Trust Wallet';
         this.overrideKey = 'trusttron';
     }
-    getProvider() {
-        var _a, _b, _c;
-        const provider = (_a = window.trustwallet) === null || _a === void 0 ? void 0 : _a.tronLink;
-        if (provider && provider.ready && !provider.chainId) {
-            // Trust Wallet doesn't expose chainId/network, set them manually
-            const host = (_c = (_b = provider.tronWeb) === null || _b === void 0 ? void 0 : _b.fullNode) === null || _c === void 0 ? void 0 : _c.host;
-            if (host === null || host === void 0 ? void 0 : host.includes('tron.twnodes.com')) {
-                Object.assign(provider, {
-                    chainId: '728126428',
-                    network: 'mainnet',
-                });
-            }
-        }
-        return provider;
+    createAdapter() {
+        return new TrustAdapter();
     }
 }
 

package/src/index.cjs

@@ -9,18 +9,17 @@ var BitgetTronConnector = require('./connectors/BitgetTronConnector/BitgetTronCo
 var OKXTronConnector = require('./connectors/OKXTronConnector/OKXTronConnector.cjs');
 var TokenPocketTronConnector = require('./connectors/TokenPocketTronConnector/TokenPocketTronConnector.cjs');
 var TrustTronConnector = require('./connectors/TrustTronConnector/TrustTronConnector.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,
 ];
 
-exports.isTronWallet = isTronWallet.isTronWallet;
 exports.TronWallet = TronWallet.TronWallet;
+exports.isTronWallet = isTronWallet.isTronWallet;
 exports.TronWalletConnectors = TronWalletConnectors;

package/src/index.d.ts

@@ -1,6 +1,7 @@
 import { BitgetTronConnector } from './connectors/BitgetTronConnector';
-export { type ITronProvider, type TronConnectionResult } from './types';
-export { type TronWalletConnector } from './connectors/TronWalletConnector';
-export { isTronWallet } from './wallet/isTronWallet';
+import { OKXTronConnector } from './connectors/OKXTronConnector';
+import { TokenPocketTronConnector } from './connectors/TokenPocketTronConnector';
+import { TrustTronConnector } from './connectors/TrustTronConnector';
 export { TronWallet } from './wallet/TronWallet';
-export declare const TronWalletConnectors: () => (typeof BitgetTronConnector)[];
+export { isTronWallet } from './wallet/isTronWallet';
+export declare const TronWalletConnectors: () => (typeof BitgetTronConnector | typeof OKXTronConnector | typeof TokenPocketTronConnector | typeof TrustTronConnector)[];

package/src/index.js

@@ -5,12 +5,11 @@ import { BitgetTronConnector } from './connectors/BitgetTronConnector/BitgetTron
 import { OKXTronConnector } from './connectors/OKXTronConnector/OKXTronConnector.js';
 import { TokenPocketTronConnector } from './connectors/TokenPocketTronConnector/TokenPocketTronConnector.js';
 import { TrustTronConnector } from './connectors/TrustTronConnector/TrustTronConnector.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,

package/src/types.d.ts

@@ -1,182 +1,12 @@
-import type { TronWeb, Types } from 'tronweb';
-/**
- * Global window interface extension for Tron wallet providers
- */
-declare global {
-    interface Window {
-        tronLink?: ITronProvider;
-        tronWeb?: TronWeb;
-        bitkeep?: {
-            tron?: ITronProvider;
-        };
-        bybitWallet?: {
-            tronLink?: ITronProvider;
-            tronWeb?: TronWeb;
-        };
-        okxwallet?: {
-            tronLink?: ITronProvider;
-            tronWeb?: TronWeb;
-        };
-        trustwallet?: {
-            tronLink?: ITronProvider;
-            tronWeb?: TronWeb;
-        };
-        tokenpocket?: {
-            tron?: ITronProvider;
-            tronWeb?: TronWeb;
-        };
-    }
-}
-/**
- * Interface that all Tron wallet providers must implement.
- *
- * This interface is designed to be flexible and work with different
- * Tron wallet implementations like TronLink, TokenPocket, etc.
- */
-export interface ITronProvider {
-    /** Whether the wallet is currently connected */
-    isConnected?: boolean;
-    /** Whether the wallet is ready */
-    ready?: boolean;
-    /** The current network chain ID */
-    chainId?: string;
-    /** The current network name */
-    network?: string;
-    /** The current wallet address */
-    address?: string;
-    /** TronWeb instance */
-    tronWeb?: TronWeb;
-    /** TronLink specific flag */
-    isTronLink?: boolean;
-    /**
-     * Request connection to the wallet
-     * @returns Promise that resolves to connection result
-     */
-    request?(params: {
-        method: string;
-        params?: unknown;
-    }): Promise<unknown>;
-    /**
-     * Connect to the wallet (TronLink style)
-     * @returns Promise that resolves to connection result
-     */
-    connect?(): Promise<TronConnectionResult>;
-    /**
-     * Disconnect from the wallet
-     * @returns Promise that resolves when disconnected
-     */
-    disconnect?(): Promise<void>;
-    /**
-     * Sign a message
-     * @param message - Message to sign
-     * @returns Promise that resolves to the signature
-     */
-    signMessage?(message: string): Promise<string>;
-    /**
-     * Sign a transaction
-     * @param transaction - Transaction to sign
-     * @returns Promise that resolves to the signed transaction
-     */
-    signTransaction?(transaction: Types.Transaction): Promise<Types.SignedTransaction>;
-    /**
-     * Send a transaction
-     * @param transaction - Transaction to send
-     * @returns Promise that resolves to transaction result
-     */
-    sendTransaction?(transaction: Types.SignedTransaction): Promise<Types.BroadcastReturn<Types.SignedTransaction>>;
-    /**
-     * Send TRX to an address
-     * @param to - Recipient address
-     * @param amount - Amount in TRX
-     * @param options - Optional parameters
-     * @returns Promise that resolves to transaction result
-     */
-    sendTrx?(to: string, amount: number, options?: {
-        from?: string;
-    }): Promise<Types.BroadcastReturn<Types.SignedTransaction>>;
-    /**
-     * Send tokens to an address
-     * @param to - Recipient address
-     * @param amount - Amount of tokens
-     * @param tokenId - Token ID
-     * @param options - Optional parameters
-     * @returns Promise that resolves to transaction result
-     */
-    sendToken?(to: string, amount: number, tokenId: string | number, options?: {
-        from?: string;
-    }): Promise<Types.BroadcastReturn<Types.SignedTransaction>>;
-    /**
-     * Get account balance
-     * @param address - Optional address (defaults to current account)
-     * @returns Promise that resolves to balance in SUN
-     */
-    getBalance?(address?: string): Promise<number>;
-    /**
-     * Get token balance
-     * @param tokenId - Token ID
-     * @param address - Optional address (defaults to current account)
-     * @returns Promise that resolves to token balance
-     */
-    getTokenBalance?(tokenId: string, address?: string): Promise<number>;
-    /**
-     * Get current network information
-     * @returns Promise that resolves to network info
-     */
-    getNetwork?(): Promise<{
+import type { Adapter, AdapterState, WalletReadyState } from '@tronweb3/tronwallet-abstract-adapter';
+export type { Adapter, AdapterState, WalletReadyState };
+export type TronAdapterEvents = {
+    connect: (address: string) => void;
+    disconnect: () => void;
+    accountsChanged: (address: string, preAddress?: string) => void;
+    chainChanged: (chainData: {
         chainId: string;
-        name: string;
-    }>;
-    /**
-     * Switch network
-     * @param networkId - Network ID to switch to
-     * @returns Promise that resolves when network is switched
-     */
-    switchNetwork?(networkId: string): Promise<void>;
-    /**
-     * Add network
-     * @param network - Network configuration to add
-     * @returns Promise that resolves when network is added
-     */
-    addNetwork?(network: {
-        networkId: string;
-        name: string;
-        rpcUrl: string;
-        chainId?: string;
-    }): Promise<void>;
-    /**
-     * Listen for account changes
-     * @param callback - Callback function for account changes
-     */
-    onAccountChange?(callback: (address: string) => void): void;
-    /**
-     * Listen for network changes
-     * @param callback - Callback function for network changes
-     */
-    onNetworkChange?(callback: (network: {
-        chainId: string;
-        name: string;
-    }) => void): void;
-    /**
-     * Remove account change listener
-     * @param callback - Callback function to remove
-     */
-    removeAccountChangeListener?(callback: (address: string) => void): void;
-    /**
-     * Remove network change listener
-     * @param callback - Callback function to remove
-     */
-    removeNetworkChangeListener?(callback: (network: {
-        chainId: string;
-        name: string;
-    }) => void): void;
-    /** Additional properties that providers may implement */
-    [key: string]: unknown;
-}
-/**
- * Result from wallet connection
- */
-export type TronConnectionResult = {
-    address: string;
-    chainId?: string;
-    network?: string;
-} | string | boolean;
+    }) => void;
+    readyStateChanged: (state: WalletReadyState) => void;
+    error: (error: Error) => void;
+};