@dynamic-labs/tron 4.34.0 → 4.36.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

@@ -6,9 +6,20 @@ declare global {
     interface Window {
         tronLink?: ITronProvider;
         tronWeb?: TronWeb;
-        tokenpocket?: {
+        bitkeep?: {
+            tron?: ITronProvider;
+        };
+        bybitWallet?: {
+            tronLink?: ITronProvider;
+            tronWeb?: TronWeb;
+        };
+        okxwallet?: {
+            tronLink?: ITronProvider;
+            tronWeb?: TronWeb;
+        };
+        trustwallet?: {
+            tronLink?: ITronProvider;
             tronWeb?: TronWeb;
-            tron?: unknown;
         };
     }
 }

package/src/utils/TronUiTransaction/TronUiTransaction.cjs

@@ -0,0 +1,121 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var utils = require('@dynamic-labs/utils');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var getTronGasEstimation = require('../getTronGasEstimation.cjs');
+
+// 1 TRX = 1,000,000 SUN (atomic units)
+const SUN_PER_TRX = 1000000;
+class TronUiTransaction {
+    constructor({ onSubmit, from, provider }) {
+        this.chain = 'TRON';
+        this.data = undefined;
+        this.fee = { gas: undefined };
+        this.from = from;
+        this.onSubmit = onSubmit;
+        this.provider = provider;
+    }
+    fetchFee() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (this.fee.gas)
+                return;
+            this.fee.gas = yield getTronGasEstimation.getTronGasEstimation({
+                from: this.from,
+                nonNativeAddress: this.nonNativeAddress,
+                nonNativeValue: this.nonNativeValue,
+                provider: this.provider,
+                to: this.to,
+                value: this.value,
+            });
+        });
+    }
+    parse(input) {
+        const numericValue = parseFloat(input);
+        if (isNaN(numericValue))
+            return BigInt(0);
+        return BigInt(Math.floor(numericValue * SUN_PER_TRX));
+    }
+    parseNonNativeToken(input, decimals) {
+        const numericValue = parseFloat(input);
+        if (isNaN(numericValue))
+            return BigInt(0);
+        return BigInt(Math.floor(numericValue * Math.pow(10, decimals)));
+    }
+    format(value, options) {
+        var _a;
+        const trxValue = Number(value) / SUN_PER_TRX;
+        return utils.formatNumberText(String(trxValue), {
+            precision: (_a = options === null || options === void 0 ? void 0 : options.precision) !== null && _a !== void 0 ? _a : 6,
+        });
+    }
+    formatNonNativeToken(value, decimals) {
+        const tokenValue = Number(value) / Math.pow(10, decimals);
+        return utils.formatNumberText(String(tokenValue), {
+            precision: decimals > 6 ? 6 : decimals,
+        });
+    }
+    submit() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!this.to) {
+                throw new Error('Destination address is required');
+            }
+            if (!this.value && !this.nonNativeValue) {
+                throw new Error('Transaction value is required');
+            }
+            return this.onSubmit(this);
+        });
+    }
+    getBalance() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const { tronWeb } = this.provider;
+                if (!tronWeb)
+                    return BigInt(0);
+                if (this.nonNativeAddress) {
+                    // Get TRC20 token balance
+                    const contract = yield tronWeb.contract().at(this.nonNativeAddress);
+                    const balance = yield contract.balanceOf(String(this.from)).call();
+                    return BigInt(typeof balance === 'string' ? balance : balance.toString());
+                }
+                else {
+                    // Get native TRX balance
+                    const balance = yield tronWeb.trx.getBalance(String(this.from));
+                    return BigInt(String(balance));
+                }
+            }
+            catch (error) {
+                walletConnectorCore.logger.error('Error occurred while fetching TRON balance. Please try again or contact support.');
+                return BigInt(0);
+            }
+        });
+    }
+    validateAddressFormat(address) {
+        if (address === 'dyn_send_transaction.multiple_recipients') {
+            return true;
+        }
+        try {
+            const { tronWeb } = this.provider;
+            if (!tronWeb)
+                return false;
+            // TRON addresses start with 'T' and are 34 characters long
+            if (!address.startsWith('T') || address.length !== 34) {
+                return false;
+            }
+            // Use TronWeb's built-in address validation
+            return tronWeb.isAddress(address);
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    isGasSponsored() {
+        return false;
+    }
+}
+
+exports.SUN_PER_TRX = SUN_PER_TRX;
+exports.TronUiTransaction = TronUiTransaction;

package/src/utils/TronUiTransaction/TronUiTransaction.d.ts

@@ -0,0 +1,39 @@
+import { IUITransaction, IUITransactionFormatOptions } from '@dynamic-labs/types';
+import type { ITronProvider } from '../../types';
+export declare const SUN_PER_TRX = 1000000;
+type TronUiTransactionProps = {
+    /** TRON Address of the sender */
+    from: string;
+    /** The TRON provider instance, needed to interact with TronWeb */
+    provider: ITronProvider;
+    /** The function to call when the transaction is submitted */
+    onSubmit: (transaction: TronUiTransaction) => Promise<string>;
+};
+export declare class TronUiTransaction implements IUITransaction {
+    to: string | undefined;
+    from: string;
+    value: bigint | undefined;
+    chain: string;
+    receipt: string | undefined;
+    data: undefined;
+    fee: {
+        gas: bigint | undefined;
+    };
+    nonNativeAddress?: string;
+    nonNativeDecimal?: number;
+    nonNativeValue?: bigint;
+    nativePrice?: number;
+    private onSubmit;
+    private provider;
+    constructor({ onSubmit, from, provider }: TronUiTransactionProps);
+    fetchFee(): Promise<void>;
+    parse(input: string): bigint;
+    parseNonNativeToken(input: string, decimals: number): bigint;
+    format(value: bigint, options?: IUITransactionFormatOptions): string;
+    formatNonNativeToken(value: bigint, decimals: number): string;
+    submit(): Promise<string>;
+    getBalance(): Promise<bigint>;
+    validateAddressFormat(address: string): boolean;
+    isGasSponsored(): boolean;
+}
+export {};

package/src/utils/TronUiTransaction/TronUiTransaction.js

@@ -0,0 +1,116 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { formatNumberText } from '@dynamic-labs/utils';
+import { logger } from '@dynamic-labs/wallet-connector-core';
+import { getTronGasEstimation } from '../getTronGasEstimation.js';
+
+// 1 TRX = 1,000,000 SUN (atomic units)
+const SUN_PER_TRX = 1000000;
+class TronUiTransaction {
+    constructor({ onSubmit, from, provider }) {
+        this.chain = 'TRON';
+        this.data = undefined;
+        this.fee = { gas: undefined };
+        this.from = from;
+        this.onSubmit = onSubmit;
+        this.provider = provider;
+    }
+    fetchFee() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.fee.gas)
+                return;
+            this.fee.gas = yield getTronGasEstimation({
+                from: this.from,
+                nonNativeAddress: this.nonNativeAddress,
+                nonNativeValue: this.nonNativeValue,
+                provider: this.provider,
+                to: this.to,
+                value: this.value,
+            });
+        });
+    }
+    parse(input) {
+        const numericValue = parseFloat(input);
+        if (isNaN(numericValue))
+            return BigInt(0);
+        return BigInt(Math.floor(numericValue * SUN_PER_TRX));
+    }
+    parseNonNativeToken(input, decimals) {
+        const numericValue = parseFloat(input);
+        if (isNaN(numericValue))
+            return BigInt(0);
+        return BigInt(Math.floor(numericValue * Math.pow(10, decimals)));
+    }
+    format(value, options) {
+        var _a;
+        const trxValue = Number(value) / SUN_PER_TRX;
+        return formatNumberText(String(trxValue), {
+            precision: (_a = options === null || options === void 0 ? void 0 : options.precision) !== null && _a !== void 0 ? _a : 6,
+        });
+    }
+    formatNonNativeToken(value, decimals) {
+        const tokenValue = Number(value) / Math.pow(10, decimals);
+        return formatNumberText(String(tokenValue), {
+            precision: decimals > 6 ? 6 : decimals,
+        });
+    }
+    submit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.to) {
+                throw new Error('Destination address is required');
+            }
+            if (!this.value && !this.nonNativeValue) {
+                throw new Error('Transaction value is required');
+            }
+            return this.onSubmit(this);
+        });
+    }
+    getBalance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { tronWeb } = this.provider;
+                if (!tronWeb)
+                    return BigInt(0);
+                if (this.nonNativeAddress) {
+                    // Get TRC20 token balance
+                    const contract = yield tronWeb.contract().at(this.nonNativeAddress);
+                    const balance = yield contract.balanceOf(String(this.from)).call();
+                    return BigInt(typeof balance === 'string' ? balance : balance.toString());
+                }
+                else {
+                    // Get native TRX balance
+                    const balance = yield tronWeb.trx.getBalance(String(this.from));
+                    return BigInt(String(balance));
+                }
+            }
+            catch (error) {
+                logger.error('Error occurred while fetching TRON balance. Please try again or contact support.');
+                return BigInt(0);
+            }
+        });
+    }
+    validateAddressFormat(address) {
+        if (address === 'dyn_send_transaction.multiple_recipients') {
+            return true;
+        }
+        try {
+            const { tronWeb } = this.provider;
+            if (!tronWeb)
+                return false;
+            // TRON addresses start with 'T' and are 34 characters long
+            if (!address.startsWith('T') || address.length !== 34) {
+                return false;
+            }
+            // Use TronWeb's built-in address validation
+            return tronWeb.isAddress(address);
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    isGasSponsored() {
+        return false;
+    }
+}
+
+export { SUN_PER_TRX, TronUiTransaction };

package/src/utils/TronUiTransaction/index.d.ts

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