@shapeshiftoss/unchained-client 10.14.10 → 10.15.0

package/dist/esm/tron/api.d.ts

@@ -1,14 +1,25 @@
 import type { TronBlock, TronTx } from './types.js';
 export interface TronApiConfig {
     rpcUrl: string;
+    apiKey?: string;
 }
+export type TronContractEnergyShare = {
+    callerPercent: number;
+    originEnergyLimit: number;
+    originEnergyAvailable: number;
+};
+export declare const getCallerEnergy: (energyUsed: number, share: TronContractEnergyShare) => number;
 export declare class TronApi {
     private readonly rpcUrl;
+    private readonly apiKey;
     private tronWeb;
+    private readonly contracts;
+    private readonly originEnergy;
     private requestQueue;
     private readonly minRequestInterval;
     constructor(config: TronApiConfig);
     getRpcUrl(): string;
+    private get tronGridHeaders();
     private throttle;
     private getTronWeb;
     getAccount(params: {
@@ -21,10 +32,16 @@ export declare class TronApi {
             balance: string;
         }[];
     }>;
-    getTRC20Balance(params: {
+    getTrc20Balance(params: {
+        contractAddress: string;
         address: string;
+    }): Promise<string>;
+    getTrc20Allowance(params: {
         contractAddress: string;
+        owner: string;
+        spender: string;
     }): Promise<string>;
+    isAccountActivated(address: string): Promise<boolean>;
     getTxHistory(_params: {
         pubkey: string;
         pageSize?: number;
@@ -44,23 +61,29 @@ export declare class TronApi {
             hex: string;
         };
     }): Promise<string>;
-    private getChainPrices;
-    estimateFees(params: {
-        estimateFeesBody: {
-            serializedTx: string;
-        };
-    }): Promise<string>;
-    estimateTRC20TransferFee(params: {
+    getChainPrices(): Promise<{
+        bandwidthPrice: number;
+        energyPrice: number;
+        memoFee: number;
+    }>;
+    getContractEnergyShare(contractAddress: string): Promise<TronContractEnergyShare>;
+    private getContract;
+    private getPricingContext;
+    private getOriginEnergyAvailable;
+    private post;
+    estimateTrc20TransferFee(params: {
         contractAddress: string;
         from: string;
         to: string;
         amount: string;
+        requireEnergyShare?: boolean;
     }): Promise<string>;
-    getPriorityFees(): Promise<{
-        baseFee: string;
-        fast: string;
-        average: string;
-        slow: string;
-        estimatedBandwidth: string;
-    }>;
+    estimateContractCallFee(params: {
+        contractAddress: string;
+        from: string;
+        data: string;
+        callValue?: string;
+        requireEnergyShare?: boolean;
+    }): Promise<string>;
+    private getSimulatedEnergy;
 }

package/dist/esm/tron/api.js

@@ -1,15 +1,42 @@
 import { TronWeb } from 'tronweb';
+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
+export 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;
+};
 export class TronApi {
     rpcUrl;
+    apiKey;
     tronWeb = null;
+    contracts = new Map();
+    originEnergy = new Map();
     requestQueue = Promise.resolve();
     minRequestInterval = 1_500;
     constructor(config) {
         this.rpcUrl = config.rpcUrl;
+        this.apiKey = config.apiKey ?? '';
     }
     getRpcUrl() {
         return this.rpcUrl;
     }
+    get tronGridHeaders() {
+        return {
+            'Content-Type': 'application/json',
+            ...(this.apiKey ? { 'TRON-PRO-API-KEY': this.apiKey } : {}),
+        };
+    }
     async throttle() {
         // Queue the request and wait for all previous requests to complete
         const currentRequest = this.requestQueue.then(async () => {
@@ -20,7 +47,10 @@ export class TronApi {
     }
     getTronWeb() {
         if (!this.tronWeb) {
-            this.tronWeb = new TronWeb({ fullHost: this.rpcUrl });
+            this.tronWeb = new TronWeb({
+                fullHost: this.rpcUrl,
+                headers: this.apiKey ? { 'TRON-PRO-API-KEY': this.apiKey } : {},
+            });
         }
         return this.tronWeb;
     }
@@ -28,7 +58,7 @@ export class TronApi {
         await this.throttle();
         const response = await fetch(`${this.rpcUrl}/wallet/getaccount`, {
             method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
+            headers: this.tronGridHeaders,
             body: JSON.stringify({ address: params.pubkey, visible: true }),
         });
         const data = await response.json();
@@ -45,7 +75,9 @@ export class TronApi {
         // Get TRC20 tokens from TronGrid API
         try {
             await this.throttle();
-            const trc20Response = await fetch(`${this.rpcUrl}/v1/accounts/${params.pubkey}`);
+            const trc20Response = await fetch(`${this.rpcUrl}/v1/accounts/${params.pubkey}`, {
+                headers: this.tronGridHeaders,
+            });
             const trc20Data = await trc20Response.json();
             if (trc20Data.data?.[0]?.trc20 && Array.isArray(trc20Data.data[0].trc20)) {
                 // trc20 is an array of objects like [{contractAddress: balance}, ...]
@@ -58,6 +90,45 @@ export class TronApi {
                     }
                 });
             }
+            else if (!trc20Data.data || trc20Data.data.length === 0) {
+                // Non-activated account: /v1/accounts returns data:[] for addresses that have never sent TRX.
+                // Fall back to discovering TRC20 balances via received transactions + hardcoded top tokens.
+                try {
+                    await this.throttle();
+                    const HARDCODED_TOP_TOKENS = [
+                        'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t',
+                        'TEkxiTehnzSmSe2XqrBj4w32RUN966rdz8', // USDC
+                    ];
+                    const MAX_FALLBACK_CONTRACTS = 20;
+                    const discoveredContracts = new Set(HARDCODED_TOP_TOKENS);
+                    const trc20TxResponse = await fetch(`${this.rpcUrl}/v1/accounts/${params.pubkey}/transactions/trc20?limit=200&only_to=true`, { headers: this.tronGridHeaders });
+                    if (trc20TxResponse.ok) {
+                        const trc20TxData = await trc20TxResponse.json();
+                        if (trc20TxData.data && Array.isArray(trc20TxData.data)) {
+                            trc20TxData.data.forEach((tx) => {
+                                const contractAddress = tx.token_info?.address;
+                                if (contractAddress)
+                                    discoveredContracts.add(contractAddress);
+                            });
+                        }
+                    }
+                    for (const contractAddress of Array.from(discoveredContracts).slice(0, MAX_FALLBACK_CONTRACTS)) {
+                        await this.throttle();
+                        await this.getTrc20Balance({ contractAddress, address: params.pubkey })
+                            .then(balance => {
+                            if (balance !== '0')
+                                tokens.push({ contractAddress, balance });
+                        })
+                            .catch(() => undefined);
+                    }
+                }
+                catch (fallbackErr) {
+                    console.error('Failed TRC20 fallback discovery for non-activated TRON account', {
+                        address: `${params.pubkey.slice(0, 6)}...${params.pubkey.slice(-4)}`,
+                        error: fallbackErr,
+                    });
+                }
+            }
         }
         catch (err) {
             // TRC20 fetch failed, continue with just TRC10 tokens
@@ -69,16 +140,36 @@ export class TronApi {
             tokens,
         };
     }
-    async getTRC20Balance(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();
-        }
-        catch (_err) {
-            return '0';
-        }
+    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');
@@ -88,22 +179,20 @@ export class TronApi {
         const [txResponse, infoResponse] = await Promise.all([
             fetch(`${this.rpcUrl}/wallet/gettransactionbyid`, {
                 method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
+                headers: this.tronGridHeaders,
                 body: JSON.stringify({ value: params.txid, visible: true }),
             }),
             fetch(`${this.rpcUrl}/wallet/gettransactioninfobyid`, {
                 method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
+                headers: this.tronGridHeaders,
                 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';
@@ -134,12 +223,11 @@ export class TronApi {
         await this.throttle();
         const response = await fetch(`${this.rpcUrl}/wallet/getblockbynum`, {
             method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
+            headers: this.tronGridHeaders,
             body: JSON.stringify({ num: params.height }),
         });
-        if (!response.ok) {
+        if (!response.ok)
             return null;
-        }
         return await response.json();
     }
     async sendTx(params) {
@@ -151,9 +239,8 @@ export 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) {
@@ -161,69 +248,138 @@ export 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(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(getCallerEnergy(energy, share) * energyPrice);
+    }
+    // A revert still reports result.result: true with the partial energy burned - trusting it would underestimate
+    getSimulatedEnergy(result, label) {
+        const isReverted = result.transaction?.ret?.some(ret => ret.ret === 'FAILED');
+        if (result.result?.result !== true || isReverted || !result.energy_used) {
+            throw new Error(`[tron] ${label} simulation failed: ${result.result?.message ?? 'unknown error'}`);
         }
+        return result.energy_used;
     }
 }

package/dist/esm/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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshiftoss/unchained-client",
-  "version": "10.14.10",
+  "version": "10.15.0",
   "repository": "https://github.com/shapeshift/web",
   "license": "MIT",
   "type": "module",
@@ -20,30 +20,29 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "yarn clean && yarn generate && yarn run -T tsc --build && yarn postbuild",
-    "build:docker": "yarn clean:dist && yarn run -T tsc --build && yarn postbuild",
-    "clean": "rm -rf dist src/generated",
-    "clean:dist": "rm -rf dist",
-    "dev": "yarn run -T tsc --build --watch",
-    "generate": "TS_POST_PROCESS_FILE=./generator/post_process.sh JAVA_OPTS='-Dlog.level=error' openapi-generator-cli generate",
-    "postbuild": "yarn postbuild:esm && yarn postbuild:cjs",
-    "postbuild:esm": "yarn run -T tsc-esm-fix --target=dist/esm --ext=.js",
-    "postbuild:cjs": "echo '{\"type\": \"commonjs\"}' > dist/cjs/package.json"
-  },
   "dependencies": {
-    "@shapeshiftoss/caip": "^8.16.8",
     "@shapeshiftoss/common-api": "^9.3.0",
-    "@shapeshiftoss/contracts": "^1.0.6",
-    "@shapeshiftoss/utils": "^1.0.6",
     "axios": "^1.13.5",
     "bignumber.js": "^9.3.1",
+    "bs58": "^5.0.0",
     "ethers": "6.11.1",
     "isomorphic-ws": "^4.0.1",
-    "viem": "2.43.5",
-    "ws": "^8.17.1"
+    "viem": "2.55.11",
+    "ws": "^8.17.1",
+    "@shapeshiftoss/caip": "^8.17.1",
+    "@shapeshiftoss/contracts": "^1.1.0",
+    "@shapeshiftoss/utils": "^1.3.1"
   },
   "devDependencies": {
     "@openapitools/openapi-generator-cli": "^2.5.1"
+  },
+  "scripts": {
+    "build": "rm -rf dist && pnpm run generate && pnpm exec tsc --build && pnpm run postbuild",
+    "clean": "rm -rf dist src/generated node_modules",
+    "dev": "pnpm exec tsc --build --watch",
+    "generate": "rm -rf src/generated && TS_POST_PROCESS_FILE=./generator/post_process.sh JAVA_OPTS='-Dlog.level=error' openapi-generator-cli generate",
+    "postbuild": "pnpm run postbuild:esm && pnpm run postbuild:cjs",
+    "postbuild:esm": "pnpm exec tsc-esm-fix --target=dist/esm --ext=.js",
+    "postbuild:cjs": "echo '{\"type\": \"commonjs\"}' > dist/cjs/package.json"
   }
 }