@dynamic-labs/tron 4.33.0 → 4.35.0

package/src/connectors/TronWalletConnector/TronWalletConnector.js

@@ -0,0 +1,251 @@
+'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.js';
+import { assertProvider, getCurrentAddress, isProviderReady } from '../../utils/provider.js';
+import { getDefaultTronNetworks } from '../../utils/getDefaultTronNetworks.js';
+import { TronUiTransaction } from '../../utils/TronUiTransaction/TronUiTransaction.js';
+
+class TronWalletConnector extends WalletConnectorBase {
+    constructor(opts) {
+        super(opts);
+        this.ChainWallet = TronWallet;
+        this.name = 'Tron';
+        this.overrideKey = 'injectedtron';
+        this.connectedChain = 'TRON';
+        this.supportedChains = ['TRON'];
+        this.switchNetworkOnlyFromWallet = true;
+        this.tronNetworks = opts.tronNetworks || getDefaultTronNetworks();
+        this.setupNetworkChangeListener();
+    }
+    setupNetworkChangeListener() {
+        const provider = this.getProvider();
+        if (!provider)
+            return;
+        if (provider.onNetworkChange &&
+            typeof provider.onNetworkChange === 'function') {
+            provider.onNetworkChange((network) => {
+                logger.debug(`[${this.name}] Network change via provider:`, network);
+                this.emit('chainChange', {
+                    chain: network.chainId || network.name || 'unknown',
+                });
+            });
+        }
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = assertProvider(this.getProvider(), 'Tron');
+            try {
+                if (provider.request) {
+                    yield provider.request({ method: 'tron_requestAccounts' });
+                }
+                else if (provider.connect) {
+                    yield provider.connect();
+                }
+                logger.debug(`[${this.name}] Connected successfully`);
+            }
+            catch (error) {
+                logger.error(`[${this.name}] Connection failed:`, error);
+                throw new DynamicError('Failed to connect to Tron wallet');
+            }
+        });
+    }
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = this.getProvider();
+            if (!provider)
+                return undefined;
+            const address = getCurrentAddress(provider);
+            if (address)
+                return address;
+            if (!isProviderReady(provider)) {
+                yield this.connect();
+                return getCurrentAddress(provider);
+            }
+            return undefined;
+        });
+    }
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const provider = this.getProvider();
+            if (!provider)
+                return undefined;
+            if (provider.chainId)
+                return String(provider.chainId);
+            if (provider.getNetwork) {
+                try {
+                    const networkInfo = yield provider.getNetwork();
+                    return (networkInfo === null || networkInfo === void 0 ? void 0 : networkInfo.chainId) ? String(networkInfo.chainId) : undefined;
+                }
+                catch (_c) {
+                    return undefined;
+                }
+            }
+            if ((_b = (_a = provider.tronWeb) === null || _a === void 0 ? void 0 : _a.fullNode) === null || _b === void 0 ? void 0 : _b.host) {
+                const { host } = provider.tronWeb.fullNode;
+                const match = this.findNetworkByRpcUrl(host) || this.findNetworkByHostPattern(host);
+                return (match === null || match === void 0 ? void 0 : match.chainId) ? String(match.chainId) : undefined;
+            }
+            return undefined;
+        });
+    }
+    findNetworkByRpcUrl(host) {
+        return this.tronNetworks.find((network) => network.rpcUrls.some((rpcUrl) => {
+            try {
+                const rpcHostname = new URL(rpcUrl).hostname;
+                const providerHostname = new URL(host).hostname;
+                return (providerHostname.includes(rpcHostname) ||
+                    rpcHostname.includes(providerHostname));
+            }
+            catch (_a) {
+                return host.includes(rpcUrl) || rpcUrl.includes(host);
+            }
+        }));
+    }
+    findNetworkByHostPattern(host) {
+        const hostLower = host.toLowerCase();
+        return this.tronNetworks.find((network) => {
+            const networkNameLower = network.name.toLowerCase();
+            if (hostLower.includes('nile') && networkNameLower.includes('nile'))
+                return true;
+            if (hostLower.includes('shasta') && networkNameLower.includes('shasta'))
+                return true;
+            if (hostLower.includes('mainnet') && networkNameLower.includes('mainnet'))
+                return true;
+            if (hostLower.includes('trongrid') &&
+                !hostLower.includes('nile') &&
+                !hostLower.includes('shasta') &&
+                networkNameLower.includes('mainnet'))
+                return true;
+            return false;
+        });
+    }
+    getConnectedAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = yield this.getAddress();
+            return address ? [address] : [];
+        });
+    }
+    isTestnet() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const networkId = yield this.getNetwork();
+            const tronNetwork = this.tronNetworks.find((n) => n.chainId === networkId);
+            return (_a = tronNetwork === null || tronNetwork === void 0 ? void 0 : tronNetwork.isTestnet) !== null && _a !== void 0 ? _a : false;
+        });
+    }
+    /**
+     * 🔑 Enforce signMessageV2 only
+     */
+    signMessage(messageToSign) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const provider = assertProvider(this.getProvider(), 'Tron');
+            if (!isProviderReady(provider)) {
+                yield this.connect();
+            }
+            if ((_b = (_a = provider.tronWeb) === null || _a === void 0 ? void 0 : _a.trx) === null || _b === void 0 ? void 0 : _b.signMessageV2) {
+                const sig = yield provider.tronWeb.trx.signMessageV2(messageToSign);
+                if (typeof sig !== 'string') {
+                    throw new DynamicError('Invalid signature format from wallet');
+                }
+                return sig;
+            }
+            throw new DynamicError('Wallet does not support signMessageV2, which is required');
+        });
+    }
+    getBalance(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const provider = this.getProvider();
+            if (!((_b = (_a = provider === null || provider === void 0 ? void 0 : provider.tronWeb) === null || _a === void 0 ? void 0 : _a.trx) === null || _b === void 0 ? void 0 : _b.getBalance))
+                return '0';
+            try {
+                const balance = yield provider.tronWeb.trx.getBalance(address);
+                return (balance / 1000000).toFixed(6); // SUN → TRX
+            }
+            catch (error) {
+                logger.error(`[${this.name}] Failed to get balance:`, error);
+                return '0';
+            }
+        });
+    }
+    isInstalledOnBrowser() {
+        const provider = this.getProvider();
+        return Boolean(provider);
+    }
+    getEnabledNetworks() {
+        return this.tronNetworks;
+    }
+    switchNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new DynamicError('Network switching must be done manually in the Tron wallet UI');
+        });
+    }
+    getBlockExplorerUrlsForCurrentNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const currentNetwork = yield this.getNetwork();
+            return ((_b = (_a = this.tronNetworks.find((n) => n.chainId.toString() === (currentNetwork === null || currentNetwork === void 0 ? void 0 : currentNetwork.toString()))) === null || _a === void 0 ? void 0 : _a.blockExplorerUrls) !== null && _b !== void 0 ? _b : []);
+        });
+    }
+    endSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = this.getProvider();
+            if (provider === null || provider === void 0 ? void 0 : provider.disconnect) {
+                try {
+                    yield provider.disconnect();
+                }
+                catch (error) {
+                    logger.debug(`[${this.name}] Error during disconnect:`, error);
+                }
+            }
+        });
+    }
+    /** Function used to create transactions in the SDK interface */
+    createUiTransaction(from) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.validateActiveWallet(from);
+            const provider = assertProvider(this.getProvider(), 'Tron');
+            if (!provider.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 - simplified for now
+                        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');
+                }),
+                provider,
+            });
+        });
+    }
+}
+
+export { TronWalletConnector };

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

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

package/src/connectors/TrustTronConnector/TrustTronConnector.cjs

@@ -0,0 +1,20 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var TronWalletConnector = require('../TronWalletConnector/TronWalletConnector.cjs');
+
+class TrustTronConnector extends TronWalletConnector.TronWalletConnector {
+    constructor() {
+        super(...arguments);
+        this.name = 'Trust Wallet';
+        this.overrideKey = 'trusttron';
+    }
+    getProvider() {
+        var _a;
+        return (_a = window.trustwallet) === null || _a === void 0 ? void 0 : _a.tronLink;
+    }
+}
+
+exports.TrustTronConnector = TrustTronConnector;

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

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

package/src/connectors/TrustTronConnector/TrustTronConnector.js

@@ -0,0 +1,16 @@
+'use client'
+import { TronWalletConnector } from '../TronWalletConnector/TronWalletConnector.js';
+
+class TrustTronConnector extends TronWalletConnector {
+    constructor() {
+        super(...arguments);
+        this.name = 'Trust Wallet';
+        this.overrideKey = 'trusttron';
+    }
+    getProvider() {
+        var _a;
+        return (_a = window.trustwallet) === null || _a === void 0 ? void 0 : _a.tronLink;
+    }
+}
+
+export { TrustTronConnector };

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

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

package/src/index.cjs

@@ -1,7 +1,25 @@
 'use client'
 'use strict';
 
+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 BybitTronConnector = require('./connectors/BybitTronConnector/BybitTronConnector.cjs');
+var OKXTronConnector = require('./connectors/OKXTronConnector/OKXTronConnector.cjs');
+var TrustTronConnector = require('./connectors/TrustTronConnector/TrustTronConnector.cjs');
+var isTronWallet = require('./wallet/isTronWallet/isTronWallet.cjs');
+var TronWallet = require('./wallet/TronWallet.cjs');
 
 assertPackageVersion.assertPackageVersion('@dynamic-labs/tron', _package.version);
+const TronWalletConnectors = () => [
+    BitgetTronConnector.BitgetTronConnector,
+    BybitTronConnector.BybitTronConnector,
+    OKXTronConnector.OKXTronConnector,
+    TrustTronConnector.TrustTronConnector,
+];
+
+exports.isTronWallet = isTronWallet.isTronWallet;
+exports.TronWallet = TronWallet.TronWallet;
+exports.TronWalletConnectors = TronWalletConnectors;

package/src/index.d.ts

@@ -1 +1,6 @@
-export { type ITronProvider } from './types';
+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)[];

package/src/index.js

@@ -1,5 +1,19 @@
 'use client'
 import { assertPackageVersion } from '@dynamic-labs/assert-package-version';
 import { version } from '../package.js';
+import { BitgetTronConnector } from './connectors/BitgetTronConnector/BitgetTronConnector.js';
+import { BybitTronConnector } from './connectors/BybitTronConnector/BybitTronConnector.js';
+import { OKXTronConnector } from './connectors/OKXTronConnector/OKXTronConnector.js';
+import { TrustTronConnector } from './connectors/TrustTronConnector/TrustTronConnector.js';
+export { isTronWallet } from './wallet/isTronWallet/isTronWallet.js';
+export { TronWallet } from './wallet/TronWallet.js';
 
 assertPackageVersion('@dynamic-labs/tron', version);
+const TronWalletConnectors = () => [
+    BitgetTronConnector,
+    BybitTronConnector,
+    OKXTronConnector,
+    TrustTronConnector,
+];
+
+export { TronWalletConnectors };

package/src/types.d.ts

@@ -1,11 +1,39 @@
 import type { TronWeb, Types } from 'tronweb';
 /**
- * Tron wallet provider interface
- * Defines the contract that Tron wallet providers must implement
+ * 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;
+        };
+    }
+}
+/**
+ * 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;
+    isConnected?: boolean;
+    /** Whether the wallet is ready */
+    ready?: boolean;
     /** The current network chain ID */
     chainId?: string;
     /** The current network name */
@@ -14,60 +42,52 @@ export interface ITronProvider {
     address?: string;
     /** TronWeb instance */
     tronWeb?: TronWeb;
+    /** TronLink specific flag */
+    isTronLink?: boolean;
     /**
-     * Connect to the wallet
+     * Request connection to the wallet
      * @returns Promise that resolves to connection result
      */
-    connect(): Promise<{
-        address: string;
-        chainId?: string;
-        network?: string;
-    }>;
+    request?(params: {
+        method: string;
+        params?: unknown;
+    }): Promise<unknown>;
     /**
-     * Disconnect from the wallet
-     * @returns Promise that resolves when disconnected
-     */
-    disconnect(): Promise<void>;
-    /**
-     * Get the current account address
-     * @returns Promise that resolves to the address
+     * Connect to the wallet (TronLink style)
+     * @returns Promise that resolves to connection result
      */
-    getAddress(): Promise<string>;
+    connect?(): Promise<TronConnectionResult>;
     /**
-     * Get the current network information
-     * @returns Promise that resolves to network info
+     * Disconnect from the wallet
+     * @returns Promise that resolves when disconnected
      */
-    getNetwork(): Promise<{
-        chainId: string;
-        name: string;
-    }>;
+    disconnect?(): Promise<void>;
     /**
      * Sign a message
      * @param message - Message to sign
-     * @param useTronHeader - Whether to use Tron message header
      * @returns Promise that resolves to the signature
      */
-    signMessage(message: string | Uint8Array, useTronHeader?: boolean): Promise<string>;
+    signMessage?(message: string): Promise<string>;
     /**
      * Sign a transaction
      * @param transaction - Transaction to sign
-     * @param privateKey - Optional private key (if not using wallet's key)
      * @returns Promise that resolves to the signed transaction
      */
-    signTransaction(transaction: Types.Transaction, privateKey?: string): Promise<Types.SignedTransaction>;
+    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>>;
+    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?: {
+    sendTrx?(to: string, amount: number, options?: {
         from?: string;
     }): Promise<Types.BroadcastReturn<Types.SignedTransaction>>;
     /**
@@ -75,36 +95,45 @@ export interface ITronProvider {
      * @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?: {
+    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
+     * @returns Promise that resolves to balance in SUN
      */
-    getBalance(address?: string): Promise<number>;
+    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>;
+    getTokenBalance?(tokenId: string, address?: string): Promise<number>;
+    /**
+     * Get current network information
+     * @returns Promise that resolves to network info
+     */
+    getNetwork?(): Promise<{
+        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>;
+    switchNetwork?(networkId: string): Promise<void>;
     /**
      * Add network
      * @param network - Network configuration to add
      * @returns Promise that resolves when network is added
      */
-    addNetwork(network: {
+    addNetwork?(network: {
         networkId: string;
         name: string;
         rpcUrl: string;
@@ -114,12 +143,12 @@ export interface ITronProvider {
      * Listen for account changes
      * @param callback - Callback function for account changes
      */
-    onAccountChange(callback: (address: string) => void): void;
+    onAccountChange?(callback: (address: string) => void): void;
     /**
      * Listen for network changes
      * @param callback - Callback function for network changes
      */
-    onNetworkChange(callback: (network: {
+    onNetworkChange?(callback: (network: {
         chainId: string;
         name: string;
     }) => void): void;
@@ -127,13 +156,23 @@ export interface ITronProvider {
      * Remove account change listener
      * @param callback - Callback function to remove
      */
-    removeAccountChangeListener(callback: (address: string) => void): void;
+    removeAccountChangeListener?(callback: (address: string) => void): void;
     /**
      * Remove network change listener
      * @param callback - Callback function to remove
      */
-    removeNetworkChangeListener(callback: (network: {
+    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;