@dynamic-labs/tron 4.39.0 → 4.40.1

package/src/connectors/TronWalletAdapterConnector/TronWalletAdapterConnector.cjs

@@ -0,0 +1,304 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+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');
+
+class TronWalletAdapterConnector extends walletConnectorCore.WalletConnectorBase {
+    constructor(opts) {
+        super(opts);
+        this.ChainWallet = TronWallet.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 _tslib.__awaiter(this, void 0, void 0, function* () {
+            const adapter = this.getAdapter();
+            if (adapter.connected) {
+                return;
+            }
+            if (adapter.readyState !== 'Found') {
+                throw new utils.DynamicError(`${this.name} wallet not found. Please install the extension.`);
+            }
+            try {
+                yield adapter.connect();
+            }
+            catch (error) {
+                throw new utils.DynamicError(`Failed to connect to ${this.name}: ${error}`);
+            }
+        });
+    }
+    /**
+     * Get the current address
+     */
+    getAddress() {
+        return _tslib.__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 _tslib.__awaiter(this, void 0, void 0, function* () {
+            const address = yield this.getAddress();
+            return address ? [address] : [];
+        });
+    }
+    /**
+     * Get the current network
+     */
+    getNetwork() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const networkInfo = yield this.adapter.network();
+                return convertChainIdToDecimal.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 _tslib.__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 _tslib.__awaiter(this, void 0, void 0, function* () {
+            const adapter = this.getAdapter();
+            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
+     * 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 _tslib.__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) {
+                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;
+            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 : []);
+            }
+            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 _tslib.__awaiter(this, void 0, void 0, function* () {
+            const adapter = this.getAdapter();
+            if (adapter.connected) {
+                try {
+                    yield adapter.disconnect();
+                }
+                catch (error) {
+                    walletConnectorCore.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 _tslib.__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 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,107 @@
+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 { GenericNetwork, IUITransaction, TransactionReceipt } from '@dynamic-labs/types';
+import { TronWallet } from '../../wallet/TronWallet';
+export type TronWalletAdapterConnectorOpts = {
+    walletBook: WalletBookSchema;
+    tronNetworks: GenericNetwork[];
+    metadata?: WalletMetadata;
+};
+/**
+ * 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;
+    /**
+     * Create the TronWallet Adapter instance for this connector
+     * Each connector must implement this to return the appropriate adapter
+     */
+    protected abstract createAdapter(): TronAdapterWithNetwork;
+    constructor(opts: TronWalletAdapterConnectorOpts);
+    confirmTransactionStatus?(): Promise<TransactionReceipt>;
+    /**
+     * Get the TronWallet Adapter instance
+     */
+    getAdapter(): Adapter;
+    /**
+     * Check if the wallet is installed
+     */
+    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
+     */
+    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
+     * The adapters store TronWeb in their internal _wallet property
+     */
+    getWalletTronWeb(): TronWeb | undefined;
+    /**
+     * Get balance of an address
+     */
+    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>;
+    /**
+     * Setup event listeners - called by Dynamic's initEventListener()
+     */
+    setupEventListeners(): void;
+    /**
+     * Cleanup event listeners
+     */
+    teardownEventListeners(): 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 {};