@shapeshiftoss/unchained-client 10.14.11 → 10.16.0

package/dist/cjs/tron/api.js

@@ -1,11 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TronApi = void 0;
+exports.TronApi = exports.getCallerEnergy = void 0;
+const utils_1 = require("@shapeshiftoss/utils");
 const tronweb_1 = require("tronweb");
+const PRECISION_READ_TIMEOUT_MS = 10_000;
+const TRON_CALLER_PAYS_ALL = {
+    callerPercent: 100,
+    originEnergyLimit: 0,
+    originEnergyAvailable: 0,
+};
+// java-tron reads a stored zero, which TronGrid omits, as this creator default
+const TRON_CREATOR_DEFAULT_ENERGY_LIMIT = 10_000_000;
+// A deployer's unspent energy moves slowly next to how often the swappers re-estimate
+const TRON_ORIGIN_ENERGY_TTL_MS = 15_000;
+// A deployer can raise the caller's share after deployment, so the split is re-read within the minute
+const TRON_CONTRACT_TTL_MS = 60_000;
+// The deployer covers the rest only out of what they have staked, so a dry deployer (Tether) leaves the caller paying in full
+const getCallerEnergy = (energyUsed, share) => {
+    const originShare = Math.floor((energyUsed * (100 - share.callerPercent)) / 100);
+    const originCovered = Math.max(0, Math.min(originShare, share.originEnergyLimit, share.originEnergyAvailable));
+    return energyUsed - originCovered;
+};
+exports.getCallerEnergy = getCallerEnergy;
 class TronApi {
     rpcUrl;
     apiKey;
     tronWeb = null;
+    contracts = new Map();
+    originEnergy = new Map();
     requestQueue = Promise.resolve();
     minRequestInterval = 1_500;
     constructor(config) {
@@ -98,9 +120,12 @@ class TronApi {
                     }
                     for (const contractAddress of Array.from(discoveredContracts).slice(0, MAX_FALLBACK_CONTRACTS)) {
                         await this.throttle();
-                        const balance = await this.getTRC20Balance({ address: params.pubkey, contractAddress });
-                        if (balance !== '0')
-                            tokens.push({ contractAddress, balance });
+                        await this.getTrc20Balance({ contractAddress, address: params.pubkey })
+                            .then(balance => {
+                            if (balance !== '0')
+                                tokens.push({ contractAddress, balance });
+                        })
+                            .catch(() => undefined);
                     }
                 }
                 catch (fallbackErr) {
@@ -121,17 +146,67 @@ class TronApi {
             tokens,
         };
     }
-    async getTRC20Balance(params) {
+    async getTrc20Decimals(params) {
         try {
-            const tronWeb = await this.getTronWeb();
-            const contract = await tronWeb.contract().at(params.contractAddress);
-            const balance = await contract.balanceOf(params.address).call();
-            return balance.toString();
+            const result = await (0, utils_1.timeout)(this.getTronWeb().transactionBuilder.triggerConstantContract(params.contractAddress, 'decimals()', {}, [], params.contractAddress), PRECISION_READ_TIMEOUT_MS, undefined);
+            if (!result)
+                return;
+            const [decimalsHex] = result.constant_result ?? [];
+            if (this.isReverted(result) || !decimalsHex)
+                return;
+            // decimals() is a uint8; anything larger is a contract answering something else
+            const decimals = Number(BigInt(`0x${decimalsHex}`));
+            return decimals > 255 ? undefined : decimals;
         }
-        catch (_err) {
-            return '0';
+        catch (err) {
+            console.error(`[tron] failed to read decimals of ${params.contractAddress}`, err);
+            return;
+        }
+    }
+    async getTrc10Precision(params) {
+        try {
+            const data = await (0, utils_1.timeout)(fetch(`${this.rpcUrl}/v1/assets/${params.id}`, {
+                headers: this.tronGridHeaders,
+                signal: AbortSignal.timeout(PRECISION_READ_TIMEOUT_MS),
+            }).then(response => response.json()), PRECISION_READ_TIMEOUT_MS, undefined);
+            return data?.data?.[0]?.precision;
+        }
+        catch (err) {
+            console.error(`[tron] failed to read precision of trc10 ${params.id}`, err);
+            return;
         }
     }
+    async getTrc20Balance(params) {
+        const result = await this.getTronWeb().transactionBuilder.triggerConstantContract(params.contractAddress, 'balanceOf(address)', {}, [{ type: 'address', value: params.address }], params.address);
+        const [balance] = result.constant_result ?? [];
+        if (!balance)
+            throw new Error('[tron] balanceOf call returned no data');
+        return BigInt(`0x${balance}`).toString();
+    }
+    // A direct selector call - contract().at() would first fetch the ABI, doubling the requests
+    async getTrc20Allowance(params) {
+        const tronWeb = this.getTronWeb();
+        const result = await tronWeb.transactionBuilder.triggerConstantContract(params.contractAddress, 'allowance(address,address)', {}, [
+            { type: 'address', value: params.owner },
+            { type: 'address', value: params.spender },
+        ], params.owner);
+        const [allowance] = result.constant_result ?? [];
+        if (!allowance)
+            throw new Error('[tron] allowance call returned no data');
+        return BigInt(`0x${allowance}`).toString();
+    }
+    // Accounts exist on-chain only once they have received TRX; a fresh address returns {}
+    async isAccountActivated(address) {
+        const response = await fetch(`${this.rpcUrl}/wallet/getaccount`, {
+            method: 'POST',
+            headers: this.tronGridHeaders,
+            body: JSON.stringify({ address, visible: true }),
+        });
+        if (!response.ok)
+            throw new Error(`[tron] getaccount failed: ${response.status}`);
+        const data = await response.json();
+        return !!data.address;
+    }
     getTxHistory(_params) {
         throw new Error('Transaction history is not supported for TRON');
     }
@@ -149,13 +224,11 @@ class TronApi {
                 body: JSON.stringify({ value: params.txid, visible: true }),
             }),
         ]);
-        if (!txResponse.ok) {
+        if (!txResponse.ok)
             return null;
-        }
         const tx = await txResponse.json();
-        if (!tx || !tx.txID) {
+        if (!tx || !tx.txID)
             return null;
-        }
         let blockNumber = 0;
         let blockTimeStamp = 0;
         let fee = '0';
@@ -189,9 +262,8 @@ class TronApi {
             headers: this.tronGridHeaders,
             body: JSON.stringify({ num: params.height }),
         });
-        if (!response.ok) {
+        if (!response.ok)
             return null;
-        }
         return await response.json();
     }
     async sendTx(params) {
@@ -203,9 +275,8 @@ class TronApi {
                 throw new Error(result.message || JSON.stringify(result) || 'Failed to broadcast transaction');
             }
             const txid = result.txid || result.transaction?.txID;
-            if (!txid) {
+            if (!txid)
                 throw new Error('Transaction ID not found in broadcast result');
-            }
             return txid;
         }
         catch (error) {
@@ -213,70 +284,143 @@ class TronApi {
         }
     }
     async getChainPrices() {
-        try {
-            const tronWeb = await this.getTronWeb();
-            const params = await tronWeb.trx.getChainParameters();
-            const bandwidthPrice = params.find(p => p.key === 'getTransactionFee')?.value ?? 1000;
-            const energyPrice = params.find(p => p.key === 'getEnergyFee')?.value ?? 420;
-            return { bandwidthPrice, energyPrice };
-        }
-        catch (_err) {
-            return { bandwidthPrice: 1000, energyPrice: 420 };
-        }
+        const params = await this.getTronWeb().trx.getChainParameters();
+        const param = (key) => {
+            const value = params.find(p => p.key === key)?.value;
+            if (value === undefined)
+                throw new Error(`[tron] chain parameter ${key} missing`);
+            return value;
+        };
+        return {
+            bandwidthPrice: param('getTransactionFee'),
+            energyPrice: param('getEnergyFee'),
+            memoFee: param('getMemoFee'),
+        };
     }
-    async estimateFees(params) {
-        try {
-            const { bandwidthPrice } = await this.getChainPrices();
-            const rawDataBytes = Buffer.from(params.estimateFeesBody.serializedTx, 'hex').length;
-            const signatureBytes = 65;
-            const totalBytes = rawDataBytes + signatureBytes;
-            const feeInSun = totalBytes * bandwidthPrice;
-            return String(feeInSun);
-        }
-        catch (err) {
-            throw new Error(`Failed to estimate fees: ${err}`);
-        }
+    // A plain address answers getcontract with {} and pays in full
+    async getContractEnergyShare(contractAddress) {
+        const contract = await this.getContract(contractAddress);
+        if (!contract.origin_address)
+            return TRON_CALLER_PAYS_ALL;
+        // TronGrid omits zero-valued fields, so a contract whose deployer pays everything carries no percent at all
+        const callerPercent = contract.consume_user_resource_percent ?? 0;
+        if (callerPercent >= 100)
+            return TRON_CALLER_PAYS_ALL;
+        return {
+            callerPercent,
+            originEnergyLimit: contract.origin_energy_limit || TRON_CREATOR_DEFAULT_ENERGY_LIMIT,
+            originEnergyAvailable: await this.getOriginEnergyAvailable(contract.origin_address),
+        };
     }
-    async estimateTRC20TransferFee(params) {
-        try {
-            const tronWeb = await this.getTronWeb();
-            const { energyPrice } = await this.getChainPrices();
-            const result = await tronWeb.transactionBuilder.triggerConstantContract(params.contractAddress, 'transfer(address,uint256)', {}, [
-                { type: 'address', value: params.to },
-                { type: 'uint256', value: params.amount },
-            ], params.from);
-            const energyUsed = result.energy_used ?? 0;
-            const feeInSun = energyUsed * energyPrice;
-            return String(feeInSun);
-        }
-        catch (_err) {
-            // Fallback: Worst case 130k energy at current 100 sun/energy
-            return '13000000'; // 13 TRX (more realistic than 31 TRX)
-        }
+    getContract(contractAddress) {
+        const cached = this.contracts.get(contractAddress);
+        if (cached && Date.now() - cached.readAt < TRON_CONTRACT_TTL_MS)
+            return cached.value;
+        const value = this.post('/wallet/getcontract', {
+            value: contractAddress,
+            visible: true,
+        })
+            .then(body => {
+            if (body.Error)
+                throw new Error(`[tron] getcontract failed: ${body.Error}`);
+            // only a contract record is worth keeping; an empty body is re-read next time
+            if (!body.origin_address && this.contracts.get(contractAddress)?.value === value) {
+                this.contracts.delete(contractAddress);
+            }
+            return body;
+        })
+            .catch(err => {
+            if (this.contracts.get(contractAddress)?.value === value) {
+                this.contracts.delete(contractAddress);
+            }
+            throw err;
+        });
+        this.contracts.set(contractAddress, { readAt: Date.now(), value });
+        return value;
     }
-    async getPriorityFees() {
-        try {
-            const { bandwidthPrice } = await this.getChainPrices();
-            const estimatedBytes = 268;
-            const baseFee = String(estimatedBytes * bandwidthPrice);
-            return {
-                baseFee,
-                fast: baseFee,
-                average: baseFee,
-                slow: baseFee,
-                estimatedBandwidth: String(estimatedBytes),
-            };
+    // A failed share lookup prices the simulation as if the caller paid in full, unless the caller must not guess
+    async getPricingContext(contractAddress, requireEnergyShare = false) {
+        const [{ energyPrice }, share] = await Promise.all([
+            this.getChainPrices(),
+            this.getContractEnergyShare(contractAddress).catch((error) => {
+                if (requireEnergyShare)
+                    throw error;
+                console.warn(`[tron] energy share lookup failed for ${contractAddress}, pricing in full`, error);
+                return TRON_CALLER_PAYS_ALL;
+            }),
+        ]);
+        return { energyPrice, share };
+    }
+    getOriginEnergyAvailable(originAddress) {
+        const cached = this.originEnergy.get(originAddress);
+        if (cached && Date.now() - cached.readAt < TRON_ORIGIN_ENERGY_TTL_MS)
+            return cached.value;
+        const value = this.post('/wallet/getaccountresource', { address: originAddress, visible: true })
+            .then(body => {
+            if (body.Error)
+                throw new Error(`[tron] getaccountresource failed: ${body.Error}`);
+            return Math.max(0, (body.EnergyLimit ?? 0) - (body.EnergyUsed ?? 0));
+        })
+            .catch(err => {
+            if (this.originEnergy.get(originAddress)?.value === value) {
+                this.originEnergy.delete(originAddress);
+            }
+            throw err;
+        });
+        this.originEnergy.set(originAddress, { readAt: Date.now(), value });
+        return value;
+    }
+    async post(path, body) {
+        const response = await fetch(`${this.rpcUrl}${path}`, {
+            method: 'POST',
+            headers: this.tronGridHeaders,
+            body: JSON.stringify(body),
+        });
+        if (!response.ok)
+            throw new Error(`[tron] ${path} failed: ${response.status}`);
+        return response.json();
+    }
+    async estimateTrc20TransferFee(params) {
+        const tronWeb = this.getTronWeb();
+        const { energyPrice, share } = await this.getPricingContext(params.contractAddress, params.requireEnergyShare);
+        const result = await tronWeb.transactionBuilder.triggerConstantContract(params.contractAddress, 'transfer(address,uint256)', {}, [
+            { type: 'address', value: params.to },
+            { type: 'uint256', value: params.amount },
+        ], params.from);
+        const energy = this.getSimulatedEnergy(result, 'trc20 transfer');
+        return String((0, exports.getCallerEnergy)(energy, share) * energyPrice);
+    }
+    async estimateContractCallFee(params) {
+        const { energyPrice, share } = await this.getPricingContext(params.contractAddress, params.requireEnergyShare);
+        const response = await fetch(`${this.rpcUrl}/wallet/triggerconstantcontract`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', ...this.tronGridHeaders },
+            body: JSON.stringify({
+                owner_address: params.from,
+                contract_address: params.contractAddress,
+                data: params.data.startsWith('0x') ? params.data.slice(2) : params.data,
+                call_value: Number(params.callValue) || 0,
+                visible: true,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`[tron] contract call simulation request failed: ${response.status}`);
         }
-        catch (_err) {
-            const defaultFee = '268000';
-            return {
-                baseFee: defaultFee,
-                fast: defaultFee,
-                average: defaultFee,
-                slow: defaultFee,
-                estimatedBandwidth: '268',
-            };
+        const result = await response.json();
+        const energy = this.getSimulatedEnergy(result, 'contract call');
+        return String((0, exports.getCallerEnergy)(energy, share) * energyPrice);
+    }
+    // A revert still reports result.result: true - the failure is only visible on the transaction's ret
+    isReverted(result) {
+        const failed = result.transaction?.ret?.some(ret => ret.ret === 'FAILED');
+        return result.result?.result !== true || Boolean(failed);
+    }
+    // Trusting a revert's partial energy would underestimate
+    getSimulatedEnergy(result, label) {
+        if (this.isReverted(result) || !result.energy_used) {
+            throw new Error(`[tron] ${label} simulation failed: ${result.result?.message ?? 'unknown error'}`);
         }
+        return result.energy_used;
     }
 }
 exports.TronApi = TronApi;

package/dist/cjs/tron/types.d.ts

@@ -29,6 +29,9 @@ export interface TronTx {
                     amount?: number;
                     owner_address?: string;
                     to_address?: string;
+                    contract_address?: string;
+                    call_value?: number;
+                    data?: string;
                 };
                 type_url: string;
             };
@@ -38,6 +41,7 @@ export interface TronTx {
         ref_block_hash: string;
         expiration: number;
         timestamp: number;
+        fee_limit?: number;
     };
     raw_data_hex: string;
     txID: string;