@getomnichain/omnichain 0.5.1 → 0.6.1

package/dist/esm/tron/tron_chain.js

@@ -0,0 +1,801 @@
+import { Decimal } from 'decimal.js';
+import { isAbstractGasPricing } from "../abstract_gas_pricing.js";
+import { Chain, resolveTransferAmount, } from "../chain.base.js";
+import { CHAIN_ID_TRON_MAINNET } from "../chain_ids.js";
+import { ChainType } from "../chain_type.js";
+import { ChainError, ChainErrorKinds, isChainError } from "../errors.js";
+import { isPyInt, pyDecodeUtf8, pyEncodeUtf8, pyInt, pyItem, pyTruthy } from "../python_builtins.js";
+import { pyRepr, pyTypeRepr } from "../python_repr.js";
+import { NetworkType } from "../network_type.js";
+import { FeePriority } from "../priority.js";
+import { coerceJsonDict, JSON_TRANSACTION_TYPE_KEY } from "../transaction_json.js";
+import { UnsignedTransactionWithPrerequisites } from "../transaction_prerequisite.js";
+import { TransactionSimulationStatusTypes } from "../transaction_simulation.js";
+import { AssetBalanceChange, hrDecimalToMinorUnits, minorUnitsToHrString, } from "../transaction_status.js";
+import { AbstractSignedMessage } from "../wallet.base.js";
+import { TronAddress } from "./tron_address.js";
+import { TronAsset } from "./tron_asset.js";
+import { TronAddressNotFoundError, TronApiError, TronClient, TronTransactionNotFoundError, } from "./tron_client.js";
+import { TronContract } from "./tron_contract.js";
+import { TronGasPricing } from "./tron_gas_pricing.js";
+import { TronPublicKey, TronSignature, isBase58CheckAddress, toBase58CheckAddress, } from "./tron_keys.js";
+import { TronTrx } from "./tron_transaction_builder.js";
+import { TronTransactionFees, TronTransactionStatus } from "./tron_transaction_status.js";
+import { TronBroadcastTransactionResponse, TronSignedTransaction, TronTransactionSimulationResult, TronUnsignedTransaction, assertJsonSafeIntegers, tronTransactionFromJson, } from "./tron_transactions.js";
+export const TRC20_ABI = [
+    {
+        constant: true,
+        inputs: [],
+        name: 'decimals',
+        outputs: [{ name: '', type: 'uint8' }],
+        stateMutability: 'view',
+        type: 'function',
+    },
+    {
+        constant: true,
+        inputs: [],
+        name: 'symbol',
+        outputs: [{ name: '', type: 'string' }],
+        stateMutability: 'view',
+        type: 'function',
+    },
+    {
+        constant: true,
+        inputs: [{ name: '_owner', type: 'address' }],
+        name: 'balanceOf',
+        outputs: [{ name: 'balance', type: 'uint256' }],
+        stateMutability: 'view',
+        type: 'function',
+    },
+    {
+        constant: false,
+        inputs: [
+            { name: '_to', type: 'address' },
+            { name: '_value', type: 'uint256' },
+        ],
+        name: 'transfer',
+        outputs: [{ name: '', type: 'bool' }],
+        stateMutability: 'nonpayable',
+        type: 'function',
+    },
+    {
+        constant: false,
+        inputs: [
+            { name: '_spender', type: 'address' },
+            { name: '_value', type: 'uint256' },
+        ],
+        name: 'approve',
+        outputs: [{ name: '', type: 'bool' }],
+        stateMutability: 'nonpayable',
+        type: 'function',
+    },
+    {
+        constant: true,
+        inputs: [
+            { name: '_owner', type: 'address' },
+            { name: '_spender', type: 'address' },
+        ],
+        name: 'allowance',
+        outputs: [{ name: '', type: 'uint256' }],
+        stateMutability: 'view',
+        type: 'function',
+    },
+];
+export const TRC20_TRANSFER_TOPIC = 'ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef';
+export const DEFAULT_TRX_FEE_LIMIT_SUN = 300_000;
+export const DEFAULT_TRC20_TRANSFER_FEE_LIMIT_SUN = 15_000_000;
+export const DEFAULT_TRC20_APPROVE_FEE_LIMIT_SUN = 25_000_000;
+export function zeroResetApprovalKey(chainId, contractAddress) {
+    return `${chainId}:${contractAddress}`;
+}
+export const ZERO_RESET_APPROVAL_TRC20_ADDRESSES = new Set([
+    zeroResetApprovalKey(CHAIN_ID_TRON_MAINNET, 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t'),
+]);
+export class TronAddressUtils {
+    static isHex(value) {
+        return isPyInt(value, 16);
+    }
+    static hexToVisible(hexAddress) {
+        if (hexAddress.startsWith('T')) {
+            throw new ChainError(ChainErrorKinds.InvalidAddress, `Tron hex address must not start with "T", got ${hexAddress}`, { address: hexAddress });
+        }
+        if (!TronAddressUtils.isHex(hexAddress)) {
+            throw new ChainError(ChainErrorKinds.InvalidAddress, `Invalid hex address: ${hexAddress}`, { address: hexAddress });
+        }
+        if (!hexAddress.startsWith('41')) {
+            throw new ChainError(ChainErrorKinds.InvalidAddress, `Tron hex address must start with 41, got ${hexAddress}`, { address: hexAddress });
+        }
+        return toBase58CheckAddress(hexAddress);
+    }
+}
+export class TronSignedMessage extends AbstractSignedMessage {
+    constructor(signature) {
+        super(signature);
+    }
+}
+export class TronChain extends Chain {
+    chainAgnosticNamespace = null;
+    defaultRpcUrl;
+    rpcUrl;
+    #trongridApiKey;
+    _client = null;
+    _chainParameters = null;
+    _nativeAsset;
+    assetDecimalsByIdentifier = new Map();
+    constructor(init) {
+        super(init.chainId, init.name, NetworkType.TRON, 3.0, 'TRX', init.explorerUrl);
+        this.defaultRpcUrl = init.defaultRpcUrl;
+        this.rpcUrl = init.rpcUrl ?? null;
+        this.#trongridApiKey = init.trongridApiKey ?? null;
+        this._nativeAsset = new TronAsset(init.chainId, 'TRX', null, TronAsset.NATIVE_DECIMALS);
+    }
+    get client() {
+        if (this._client === null) {
+            const env = readEnv();
+            if (this.#trongridApiKey === null && env?.TRONGRID_API_KEY !== undefined) {
+                this.#trongridApiKey = env.TRONGRID_API_KEY;
+            }
+            this.rpcUrl = this.rpcUrl || this._loadRpcUrl();
+            this._client = new TronClient({
+                endpointUri: this.rpcUrl,
+                apiKey: this.#trongridApiKey ?? undefined,
+            });
+        }
+        return this._client;
+    }
+    get trx() {
+        return new TronTrx(this.client);
+    }
+    static rpcUrlEnvForChainId(chainId) {
+        return `TRON_${chainId}_RPC_URL`;
+    }
+    _loadRpcUrl() {
+        const env = readEnv();
+        const candidates = [`${this.name.replace(/ /g, '_').toUpperCase()}_RPC_URL`, TronChain.rpcUrlEnvForChainId(this.chainId)];
+        for (const name of candidates) {
+            const value = env?.[name];
+            if (value)
+                return value;
+        }
+        return this.defaultRpcUrl;
+    }
+    get chainType() {
+        return ChainType.TRON;
+    }
+    get nativeAsset() {
+        return this._nativeAsset;
+    }
+    get nativeToken() {
+        return this._nativeAsset;
+    }
+    toString() {
+        return `TronChain[chain_id:${this.chainId}]`;
+    }
+    getTrc20Asset(symbol, contractAddress, decimals) {
+        return new TronAsset(this.chainId, symbol, contractAddress, decimals);
+    }
+    getAssetExplorerUrl(asset) {
+        if (!(asset instanceof TronAsset)) {
+            throw new ChainError(ChainErrorKinds.InvalidArgument, `Invalid asset ${String(asset)}, expected TronAsset`, { chainId: this.chainId });
+        }
+        if (asset.isNative())
+            return null;
+        return `${this.explorerBaseUrl}/#/token20/${asset.contractAddress}`;
+    }
+    getWalletAddressExplorerUrl(walletAddress) {
+        return `${this.explorerBaseUrl}/#/address/${walletAddress}`;
+    }
+    getTransactionExplorerUrl(txHash) {
+        return `${this.explorerBaseUrl}/#/transaction/${txHash}`;
+    }
+    getWalletExplorerUrl(address) {
+        return this.getWalletAddressExplorerUrl(address);
+    }
+    getTokenExplorerUrl(tokenIdentifier) {
+        if (!tokenIdentifier)
+            return this.explorerBaseUrl;
+        return `${this.explorerBaseUrl}/#/token20/${tokenIdentifier}`;
+    }
+    static formatAssetIdentifier(identifier) {
+        if (identifier === null || identifier === undefined)
+            return null;
+        return toBase58CheckAddress(identifier);
+    }
+    static validateAssetIdentifier(identifier) {
+        if (identifier !== null && identifier !== undefined && !isBase58CheckAddress(identifier)) {
+            throw new ChainError(ChainErrorKinds.InvalidTokenIdentifier, `Invalid Tron asset contract address ${identifier}`, { identifier });
+        }
+    }
+    static formatWalletAddress(walletAddress) {
+        return toBase58CheckAddress(walletAddress);
+    }
+    static validateWalletAddress(walletAddress) {
+        if (!isBase58CheckAddress(walletAddress)) {
+            throw new ChainError(ChainErrorKinds.InvalidAddress, `Invalid Tron wallet address ${walletAddress}`, { address: walletAddress });
+        }
+    }
+    validateAddress(raw) {
+        return typeof raw === 'string' && TronAddress.validatedBase58(raw) !== null;
+    }
+    validateTokenIdentifier(raw) {
+        if (raw === undefined)
+            return true;
+        try {
+            TronChain.validateAssetIdentifier(raw);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async resolveAsset(identifier) {
+        if (identifier === null || identifier === undefined)
+            return this._nativeAsset;
+        const contract = await this.getTrc20Contract(identifier);
+        const decimals = Number(await contract.callView('decimals'));
+        const symbol = String(await contract.callView('symbol'));
+        return new TronAsset(this.chainId, symbol, identifier, decimals);
+    }
+    createAsset(symbol, identifier, decimals) {
+        if (identifier === null || identifier === undefined) {
+            if (symbol !== 'TRX') {
+                throw new ChainError(ChainErrorKinds.InvalidArgument, `Invalid symbol ${symbol} for native TRX, expected TRX`, { chainId: this.chainId });
+            }
+            if (decimals !== TronAsset.NATIVE_DECIMALS) {
+                throw new ChainError(ChainErrorKinds.InvalidArgument, `Invalid decimals ${decimals} for native TRX, expected ${TronAsset.NATIVE_DECIMALS}`, { chainId: this.chainId });
+            }
+            return this._nativeAsset;
+        }
+        return new TronAsset(this.chainId, symbol, identifier, decimals);
+    }
+    async getTrc20Contract(contractAddress) {
+        const address = toBase58CheckAddress(contractAddress);
+        const info = await this.client.getContract(address);
+        const contract = TronContract.fromContractInfo(address, info, this.client);
+        contract.abi = TRC20_ABI;
+        return contract;
+    }
+    async getCachedAssetDecimals(symbol, identifier) {
+        if (identifier === null || identifier === undefined) {
+            if (symbol !== this._nativeAsset.symbol) {
+                throw new ChainError(ChainErrorKinds.InvalidArgument, `Invalid native asset symbol ${symbol}`, { chainId: this.chainId });
+            }
+            return this._nativeAsset.decimals;
+        }
+        let decimals = this.assetDecimalsByIdentifier.get(identifier);
+        if (decimals === undefined) {
+            decimals = await this._getAssetDecimalsInternal(symbol, identifier);
+            this.assetDecimalsByIdentifier.set(identifier, decimals);
+        }
+        return decimals;
+    }
+    async _getAssetDecimalsInternal(symbol, identifier) {
+        if (identifier === null || identifier === undefined) {
+            if (symbol !== 'TRX') {
+                throw new ChainError(ChainErrorKinds.InvalidArgument, `Invalid symbol ${symbol} for native TRX`, { chainId: this.chainId });
+            }
+            return TronAsset.NATIVE_DECIMALS;
+        }
+        const contract = await this.getTrc20Contract(identifier);
+        return Number(await contract.callView('decimals'));
+    }
+    async _getTrc20SymbolInternal(address) {
+        const contract = await this.getTrc20Contract(address);
+        return String(await contract.callView('symbol'));
+    }
+    async getAssetBalance(asset, ownerAddress) {
+        this.assertOwnAsset(asset);
+        const owner = TronChain.formatWalletAddress(ownerAddress);
+        if (asset.isNative()) {
+            try {
+                return await this.client.getAccountBalance(owner);
+            }
+            catch (err) {
+                if (err instanceof TronAddressNotFoundError)
+                    return new Decimal(0);
+                throw err;
+            }
+        }
+        const contract = await this.getTrc20Contract(asset.contractAddress);
+        const balanceMr = await contract.callView('balanceOf', owner);
+        return new Decimal(minorUnitsToHrString(BigInt(balanceMr), asset.decimals));
+    }
+    async createTransferTransaction(req) {
+        this.assertOwnAsset(req.asset);
+        const sender = TronChain.formatWalletAddress(req.senderAddress);
+        const receiver = TronChain.formatWalletAddress(req.receiverAddress);
+        const feeLimitSun = this._resolveGasPricing(req.gasPricing === undefined ? FeePriority.NORMAL : req.gasPricing);
+        let amountMr = hrDecimalToMinorUnits(new Decimal(req.amountHr.toString()), req.asset.decimals);
+        let builder;
+        if (req.asset.isNative()) {
+            if (req.isFullBalance === true) {
+                amountMr = amountMr - BigInt(DEFAULT_TRX_FEE_LIMIT_SUN);
+            }
+            builder = this.trx.transfer(sender, receiver, amountMr);
+        }
+        else {
+            const contract = await this.getTrc20Contract(req.asset.contractAddress);
+            builder = (await contract.buildCall('transfer', receiver, amountMr)).withOwner(sender).feeLimit(feeLimitSun);
+        }
+        if (req.memo !== undefined && req.memo !== null) {
+            builder = builder.memo(req.memo);
+        }
+        const transaction = await builder.build();
+        return new UnsignedTransactionWithPrerequisites({
+            transaction: new TronUnsignedTransaction({ chainId: this.chainId, transaction }),
+            prerequisites: [],
+        });
+    }
+    _resolveGasPricing(gasPricing) {
+        if (isAbstractGasPricing(gasPricing)) {
+            if (!(gasPricing instanceof TronGasPricing)) {
+                throw new ChainError(ChainErrorKinds.InvalidArgument, `Expected TronGasPricing for a Tron chain, got ${gasPricing.constructor.name}`, { chainId: this.chainId });
+            }
+            return gasPricing.feeLimitSun;
+        }
+        if (!Object.values(FeePriority).includes(gasPricing)) {
+            throw new ChainError(ChainErrorKinds.InvalidArgument, `Unsupported gas_pricing ${pyRepr(gasPricing)}`, { chainId: this.chainId });
+        }
+        return DEFAULT_TRC20_TRANSFER_FEE_LIMIT_SUN;
+    }
+    async _simulateTriggerSmartContract(ownerAddressB58, contractAddressB58, callDataHex) {
+        return this.client.makeRequest('wallet/triggerconstantcontract', {
+            owner_address: ownerAddressB58,
+            contract_address: contractAddressB58,
+            data: callDataHex,
+            visible: true,
+        });
+    }
+    static _interpretTriggerConstantResponse(response) {
+        const resultObj = response.result;
+        let apiOk;
+        let apiCode = null;
+        let apiMessage = null;
+        if (resultObj !== null && typeof resultObj === 'object' && !Array.isArray(resultObj)) {
+            const result = resultObj;
+            apiOk = pyTruthy(result.result ?? false);
+            apiCode = result.code ?? null;
+            apiMessage = result.message ?? null;
+        }
+        else {
+            apiOk = pyTruthy(resultObj);
+        }
+        const energyUsedRaw = response.energy_used;
+        const energyUsed = typeof energyUsedRaw === 'number' ? Math.trunc(energyUsedRaw) : typeof energyUsedRaw === 'boolean' ? Number(energyUsedRaw) : null;
+        const ok = apiOk && apiCode === null && apiMessage === null;
+        let error = null;
+        if (!ok) {
+            let message = apiMessage;
+            if (typeof message === 'string' && /^[0-9a-fA-F]*$/.test(message) && message.length % 2 === 0) {
+                message = pyDecodeUtf8(Buffer.from(message, 'hex'), 'replace');
+            }
+            error = new Error(`Tron constant call failed: code=${pyRepr(apiCode)} message=${pyRepr(message)}`);
+        }
+        return [ok, energyUsed, error];
+    }
+    async getChainParameters() {
+        if (this._chainParameters === null) {
+            this._chainParameters = (async () => {
+                const params = await this.client.getChainParameters();
+                const energyFee = params.filter((kv) => kv.key === 'getEnergyFee').map((kv) => kv.value);
+                if (energyFee.length === 0 || energyFee[0] === undefined || energyFee[0] === null) {
+                    throw new ChainError(ChainErrorKinds.RpcError, 'Tron chain parameters are missing getEnergyFee', { chainId: this.chainId });
+                }
+                return { energyFee: Math.trunc(Number(energyFee[0])) };
+            })();
+            this._chainParameters.catch(() => {
+                this._chainParameters = null;
+            });
+        }
+        return this._chainParameters;
+    }
+    async supportsFullTransactionSimulation(unsignedTransaction) {
+        if (!(unsignedTransaction instanceof TronUnsignedTransaction)) {
+            throw new ChainError(ChainErrorKinds.InvalidArgument, 'Expected TronUnsignedTransaction', { chainId: this.chainId });
+        }
+        return false;
+    }
+    async simulateTransaction(req) {
+        const transaction = req.transaction;
+        if (!(transaction instanceof TronUnsignedTransaction)) {
+            throw new ChainError(ChainErrorKinds.InvalidArgument, `Invalid transaction ${String(transaction)}, expected TronUnsignedTransaction`, { chainId: this.chainId });
+        }
+        const contracts = pyItem(transaction.transaction.rawData, 'contract');
+        if (!pyTruthy(contracts)) {
+            throw new ChainError(ChainErrorKinds.InvalidArgument, `Tron unsigned transaction ${transaction.txId} has no contract entries`, { chainId: this.chainId });
+        }
+        const entry = contracts[0];
+        if (pyItem(entry, 'type') === 'TriggerSmartContract') {
+            const triggerValue = pyItem(pyItem(entry, 'parameter'), 'value');
+            const rawData = String(pyItem(triggerValue, 'data') || '').toLowerCase();
+            const callDataHex = rawData.startsWith('0x') ? rawData.slice(2) : rawData;
+            let ownerB58;
+            let contractB58;
+            try {
+                ownerB58 = TronAddressUtils.hexToVisible(pyItem(triggerValue, 'owner_address'));
+                contractB58 = TronAddressUtils.hexToVisible(pyItem(triggerValue, 'contract_address'));
+            }
+            catch (err) {
+                return new TronTransactionSimulationResult({
+                    chainId: this.chainId,
+                    statusType: TransactionSimulationStatusTypes.Failed,
+                    balanceChanges: new Map(),
+                    error: new Error(`Malformed TriggerSmartContract addresses in canonical tx: ${err.message}`),
+                    energyUsed: null,
+                });
+            }
+            let response;
+            try {
+                response = await this._simulateTriggerSmartContract(ownerB58, contractB58, callDataHex);
+            }
+            catch (err) {
+                return new TronTransactionSimulationResult({
+                    chainId: this.chainId,
+                    statusType: TransactionSimulationStatusTypes.Failed,
+                    balanceChanges: new Map(),
+                    error: err instanceof Error ? err : new Error(String(err)),
+                    energyUsed: null,
+                });
+            }
+            const [ok, energyUsed, error] = TronChain._interpretTriggerConstantResponse(response);
+            return new TronTransactionSimulationResult({
+                chainId: this.chainId,
+                statusType: ok ? TransactionSimulationStatusTypes.Success : TransactionSimulationStatusTypes.Failed,
+                balanceChanges: new Map(),
+                error,
+                energyUsed,
+            });
+        }
+        throw new ChainError(ChainErrorKinds.FeatureNotSupported, `Tron does not expose a gas-reporting simulation primitive for contract type ${pyRepr(entry.type)}. Only TriggerSmartContract can be dry-run via wallet/triggerconstantcontract — every other contract type is a deterministic protocol  operation with no VM execution and no energy usage to report.`, { chainId: this.chainId });
+    }
+    static _toBase58CheckAny(addressStr) {
+        if (!addressStr) {
+            throw new ChainError(ChainErrorKinds.InvalidAddress, 'empty address');
+        }
+        try {
+            return toBase58CheckAddress(addressStr);
+        }
+        catch {
+            return toBase58CheckAddress(`41${addressStr.startsWith('0x') ? addressStr.slice(2) : addressStr}`);
+        }
+    }
+    static _parseTrc20TransferLog(log) {
+        const topics = log.topics || [];
+        if (topics.length === 0 || topics[0].toLowerCase() !== TRC20_TRANSFER_TOPIC)
+            return null;
+        if (topics.length < 3)
+            return null;
+        let from;
+        let to;
+        try {
+            from = TronChain._toBase58CheckAny(topics[1].slice(-40));
+            to = TronChain._toBase58CheckAny(topics[2].slice(-40));
+        }
+        catch {
+            return null;
+        }
+        const dataHex = String(log.data || '').replace(/^[0x]+/, '');
+        if (!dataHex)
+            return null;
+        const value = pyInt(dataHex, 16);
+        let contract;
+        try {
+            contract = TronChain._toBase58CheckAny(String(log.address || ''));
+        }
+        catch {
+            contract = null;
+        }
+        return { contract, from, to, value };
+    }
+    async _balanceChangesFromInfo(args) {
+        const balanceChanges = new Map();
+        const native = this._nativeAsset;
+        const add = (wallet, asset, change) => {
+            if (args.filteredWallets !== null && !args.filteredWallets.has(wallet))
+                return;
+            if (args.filteredAssets !== null && !args.filteredAssets.some((a) => a.strictEquals(asset)))
+                return;
+            AssetBalanceChange.upsert(balanceChanges, wallet, asset, change);
+        };
+        const rawContracts = (args.txData.raw_data || {}).contract || [];
+        for (const c of rawContracts) {
+            if (c.type !== 'TransferContract')
+                continue;
+            const value = (c.parameter || {}).value || {};
+            let owner;
+            let to;
+            try {
+                owner = TronChain._toBase58CheckAny(String(value.owner_address ?? ''));
+                to = TronChain._toBase58CheckAny(String(value.to_address ?? ''));
+            }
+            catch {
+                continue;
+            }
+            const amountMr = BigInt(String(value.amount ?? 0));
+            add(owner, native, AssetBalanceChange.fromMr(-amountMr, native.decimals));
+            add(to, native, AssetBalanceChange.fromMr(amountMr, native.decimals));
+        }
+        for (const internalTransaction of args.info.internal_transactions || []) {
+            const callValueInfo = internalTransaction.callValueInfo;
+            if (callValueInfo === undefined || callValueInfo === null)
+                continue;
+            if (callValueInfo.length === 0) {
+                throw new ChainError(ChainErrorKinds.TransactionDecodeFailed, 'Tron internal transaction has an empty callValueInfo list', { chainId: this.chainId });
+            }
+            if (callValueInfo[0].callValue === undefined || callValueInfo[0].callValue === null)
+                continue;
+            const callValue = BigInt(String(callValueInfo[0].callValue));
+            const senderAddress = TronChain._toBase58CheckAny(String(internalTransaction.caller_address));
+            const receiverAddress = TronChain._toBase58CheckAny(String(internalTransaction.transferTo_address));
+            add(senderAddress, native, AssetBalanceChange.fromMr(-callValue, native.decimals));
+            add(receiverAddress, native, AssetBalanceChange.fromMr(callValue, native.decimals));
+        }
+        for (const log of args.info.log || []) {
+            const parsed = TronChain._parseTrc20TransferLog(log);
+            if (parsed === null || parsed.contract === null)
+                continue;
+            const contractAddress = parsed.contract;
+            let asset = TronAsset.searchRegisteredAsset(this.chainId, contractAddress);
+            if (asset === null) {
+                const symbol = await this._getTrc20SymbolInternal(contractAddress);
+                asset = TronAsset.getRegisteredAsset(this.chainId, symbol, contractAddress);
+                if (asset === null) {
+                    const decimals = await this._getAssetDecimalsInternal(symbol, contractAddress);
+                    asset = this.getTrc20Asset(symbol, contractAddress, decimals);
+                }
+            }
+            add(parsed.from, asset, AssetBalanceChange.fromMr(-parsed.value, asset.decimals));
+            add(parsed.to, asset, AssetBalanceChange.fromMr(parsed.value, asset.decimals));
+        }
+        if (args.feeInSun > 0 && rawContracts.length > 0) {
+            const payerHex = ((rawContracts[0].parameter || {}).value || {}).owner_address;
+            if (payerHex) {
+                try {
+                    const payer = TronChain._toBase58CheckAny(String(payerHex));
+                    add(payer, native, AssetBalanceChange.fromMr(-BigInt(args.feeInSun), native.decimals));
+                }
+                catch {
+                    void 0;
+                }
+            }
+        }
+        return balanceChanges;
+    }
+    async getTransactionStatus(txHash, opts) {
+        if (opts?.wait || (opts?.confirmations !== undefined && opts.confirmations > 1)) {
+            throw new ChainError(ChainErrorKinds.FeatureNotSupported, 'TronChain.getTransactionStatus does not honor wait/confirmations opts (would silently return immediately). Poll consumer-side or omit the opts.', { chainId: this.chainId });
+        }
+        if (Array.isArray(txHash)) {
+            return runBatch(txHash, (hash) => this.getTransactionStatusOnce(hash, opts));
+        }
+        return this.getTransactionStatusOnce(txHash, opts);
+    }
+    async getTransactionStatusOnce(txHash, opts) {
+        let info;
+        try {
+            info = await this.client.getTransactionInfo(txHash);
+        }
+        catch (err) {
+            if (err instanceof TronTransactionNotFoundError || isChainError(err, ChainErrorKinds.InvalidArgument)) {
+                return TronTransactionStatus.notFound(this.chainId, { code: 'NOT_FOUND', reason: err.message });
+            }
+            throw err;
+        }
+        if (Object.keys(info).length === 0 || info.id === undefined || info.id === null) {
+            return TronTransactionStatus.pending(this.chainId);
+        }
+        const receipt = info.receipt || {};
+        const contractRet = receipt.result ?? null;
+        const hasFailure = info.result === 'FAILED' || (contractRet !== null && contractRet !== 'SUCCESS');
+        let txData;
+        try {
+            txData = await this.client.getTransaction(txHash);
+        }
+        catch (err) {
+            if (!(err instanceof TronTransactionNotFoundError))
+                throw err;
+            txData = {};
+        }
+        const filteredWallets = opts?.filteredWallets === undefined || opts.filteredWallets === null
+            ? null
+            : new Set([...opts.filteredWallets].map((w) => TronChain.formatWalletAddress(w)));
+        const filteredAssets = opts?.filteredAssets === undefined || opts.filteredAssets === null ? null : [...opts.filteredAssets];
+        const chainParameters = await this.getChainParameters();
+        if (info.blockTimeStamp === undefined || info.blockTimeStamp === null) {
+            throw new ChainError(ChainErrorKinds.TransactionDecodeFailed, `Tron transaction info for ${txHash} has no blockTimeStamp`, {
+                chainId: this.chainId,
+                txHash,
+            });
+        }
+        const inclusionAt = new Date(Math.trunc(Number(info.blockTimeStamp)));
+        const fees = TronTransactionFees.fromTransactionInfo(info, chainParameters.energyFee);
+        const balanceChanges = await this._balanceChangesFromInfo({
+            txData,
+            info,
+            feeInSun: fees.feeInSun,
+            filteredWallets,
+            filteredAssets,
+        });
+        if (!hasFailure) {
+            return TronTransactionStatus.successful({ chainId: this.chainId, inclusionAt, balanceChanges, fees });
+        }
+        return TronTransactionStatus.failed({
+            chainId: this.chainId,
+            inclusionAt,
+            error: {
+                code: String(contractRet ?? info.result ?? 'FAILED'),
+                reason: `Tron transaction failed: result=${pyRepr(info.result ?? null)}, contractRet=${pyRepr(contractRet)}`,
+            },
+            fees,
+        });
+    }
+    async broadcastSignedTransaction(signedTransaction) {
+        if (!(signedTransaction instanceof TronSignedTransaction)) {
+            throw new ChainError(ChainErrorKinds.InvalidArgument, `Invalid transaction ${String(signedTransaction)}, expected TronSignedTransaction`, { chainId: this.chainId });
+        }
+        if (this.chainId !== signedTransaction.chainId) {
+            throw new ChainError(ChainErrorKinds.InvalidArgument, `Invalid chain for signed transaction chain for ${String(signedTransaction)} with chain id ${signedTransaction.chainId}, expected ${this.chainId}`, { chainId: this.chainId });
+        }
+        if (signedTransaction.signedTransaction.client === null) {
+            signedTransaction.signedTransaction.client = this.client;
+        }
+        try {
+            const result = await signedTransaction.signedTransaction.broadcast();
+            const txHash = pyTruthy(result.txid) ? result.txid : signedTransaction.txHash;
+            return new TronBroadcastTransactionResponse({ chain: this, txHash });
+        }
+        catch (err) {
+            return new TronBroadcastTransactionResponse({
+                chain: this,
+                txHash: signedTransaction.txHash,
+                broadcastError: err instanceof Error ? err : new Error(String(err)),
+            });
+        }
+    }
+    static verifySignature(publicKey, message, signedMessage) {
+        if (!(signedMessage instanceof TronSignedMessage)) {
+            throw new ChainError(ChainErrorKinds.InvalidArgument, `TronChain expected a TronSignedMessage, got ${pyTypeRepr(signedMessage)}`);
+        }
+        try {
+            const resolvedPublicKey = publicKey instanceof TronPublicKey
+                ? publicKey
+                : TronPublicKey.fromHex(String(publicKey).startsWith('0x') ? String(publicKey).slice(2) : String(publicKey));
+            const signature = TronSignature.fromHex(signedMessage.signature);
+            return resolvedPublicKey.verifyMsg(pyEncodeUtf8(message), signature);
+        }
+        catch {
+            return false;
+        }
+    }
+    verifySignature(publicKey, message, signedMessage) {
+        return TronChain.verifySignature(publicKey, message, signedMessage);
+    }
+    async getBalance(owner, tokenIdentifier) {
+        const ownerAddress = TronChain.formatWalletAddress(owner);
+        if (tokenIdentifier === undefined) {
+            try {
+                const account = await this.client.getAccount(ownerAddress);
+                return BigInt(String(account.balance ?? 0));
+            }
+            catch (err) {
+                if (err instanceof TronAddressNotFoundError)
+                    return 0n;
+                throw err;
+            }
+        }
+        const contract = await this.getTrc20Contract(tokenIdentifier);
+        return BigInt(await contract.callView('balanceOf', ownerAddress));
+    }
+    async createTransferUnsignedTransaction(req) {
+        if (!req.from) {
+            throw new ChainError(ChainErrorKinds.InvalidArgument, 'Tron transfers require an explicit `from` (no implicit signer)', {
+                chainId: this.chainId,
+            });
+        }
+        const asset = await this.resolveAsset(req.tokenIdentifier);
+        const resolved = resolveTransferAmount(req, asset.decimals);
+        const amountHr = resolved.kind === 'exact'
+            ? new Decimal(minorUnitsToHrString(resolved.amountMr, asset.decimals))
+            : await this.getAssetBalance(asset, req.from);
+        const bundle = await this.createTransferTransaction({
+            asset,
+            amountHr,
+            senderAddress: req.from,
+            receiverAddress: req.to,
+            isFullBalance: resolved.kind === 'full',
+            gasPricing: req.gasPricing,
+            memo: req.memo ?? null,
+        });
+        return bundle.transaction;
+    }
+    async broadcast(signed, opts) {
+        if (opts && opts.signal !== undefined) {
+            throw new ChainError(ChainErrorKinds.FeatureNotSupported, "Tron broadcast: signal is not honored (silently ignoring would let a caller conclude 'not sent' while the tx still lands)", { chainId: this.chainId });
+        }
+        const signedTransaction = parseTronSignedInput(signed, this.chainId);
+        const response = await this.broadcastSignedTransaction(signedTransaction);
+        const error = response.broadcastError;
+        if (error === null) {
+            const signedHash = signedTransaction.txHash.toLowerCase();
+            if (typeof response.txHash !== 'string' || response.txHash.toLowerCase() !== signedHash) {
+                throw new ChainError(ChainErrorKinds.RpcError, `Tron node answered txid ${pyRepr(response.txHash)} for the signed transaction ${signedTransaction.txHash}`, { chainId: this.chainId, txHash: signedTransaction.txHash });
+            }
+            return signedHash;
+        }
+        throw new ChainError(tronBroadcastErrorKind(error), `Tron broadcast failed: ${error.message}`, { chainId: this.chainId, txHash: response.txHash }, error);
+    }
+    async getChainTipHeight() {
+        return this.client.getLatestBlockNumber();
+    }
+    async verifyMessageSignature(req) {
+        try {
+            const signature = TronSignature.fromHex(req.signature.startsWith('0x') ? req.signature.slice(2) : req.signature);
+            const recovered = signature.recoverPublicKeyFromMsg(pyEncodeUtf8(req.message));
+            return recovered.toBase58CheckAddress() === toBase58CheckAddress(req.signer);
+        }
+        catch {
+            return false;
+        }
+    }
+    assertOwnAsset(asset) {
+        if (!(asset instanceof TronAsset)) {
+            throw new ChainError(ChainErrorKinds.InvalidArgument, `Invalid asset ${String(asset)} of type ${pyTypeRepr(asset)}, expected TronAsset`, {
+                chainId: this.chainId,
+            });
+        }
+        if (asset.chainId !== this.chainId) {
+            throw new ChainError(ChainErrorKinds.InvalidArgument, `Invalid chain id ${asset.chainId} for asset ${String(asset)}, expected ${this.chainId}`, { chainId: this.chainId });
+        }
+    }
+}
+const TRON_NOT_ACCEPTED_BROADCAST_CODES = new Set(['SIGERROR', 'CONTRACT_VALIDATE_ERROR', 'CONTRACT_EXE_ERROR', 'BANDWITH_ERROR']);
+export function tronBroadcastErrorKind(error) {
+    if (!(error instanceof TronApiError) || error.code === null)
+        return ChainErrorKinds.RpcError;
+    if (error.code === 'TOO_BIG_TRANSACTION_ERROR')
+        return ChainErrorKinds.TransactionTooLarge;
+    return TRON_NOT_ACCEPTED_BROADCAST_CODES.has(error.code) ? ChainErrorKinds.BroadcastRejected : ChainErrorKinds.RpcError;
+}
+function parseTronSignedInput(signed, chainId) {
+    let payload;
+    try {
+        payload = coerceJsonDict(signed);
+    }
+    catch (err) {
+        throw new ChainError(ChainErrorKinds.InvalidArgument, 'Tron broadcast: signed must be the JSON of a TronSignedTransaction or of a signed Tron transaction ({txID, raw_data, signature})', { chainId }, err);
+    }
+    if (payload[JSON_TRANSACTION_TYPE_KEY] === TronSignedTransaction.JSON_TYPE) {
+        return TronSignedTransaction.fromJson(payload);
+    }
+    if (typeof payload.txID !== 'string' || payload.raw_data === undefined) {
+        throw new ChainError(ChainErrorKinds.InvalidArgument, 'Tron broadcast: signed transaction JSON must carry txID and raw_data', { chainId });
+    }
+    assertJsonSafeIntegers(payload);
+    return new TronSignedTransaction({ chainId, signedTransaction: tronTransactionFromJson(payload) });
+}
+async function runBatch(items, fetchOne) {
+    const results = new Array(items.length);
+    let cursor = 0;
+    let aborted = false;
+    const spawn = async () => {
+        while (!aborted) {
+            const idx = cursor++;
+            if (idx >= items.length)
+                return;
+            try {
+                results[idx] = await fetchOne(items[idx]);
+            }
+            catch (err) {
+                aborted = true;
+                throw err;
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(8, items.length) }, spawn));
+    return results;
+}
+function readEnv() {
+    return globalThis.process?.env;
+}
+export { pyTruthy };
+//# sourceMappingURL=tron_chain.js.map