@shapeshiftoss/unchained-client 10.14.10 → 10.15.0

package/dist/cjs/generated/thorchain/apis/V1Api.d.ts

@@ -10,21 +10,13 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { Account, AffiliateFees, AffiliateRevenue, EstimateGasRequest, Info, Tx, TxHistory } from '../models';
+import type { Account, EstimateGasRequest, Info, Tx, TxHistory } from '../models';
 export interface EstimateGasOperationRequest {
     body?: EstimateGasRequest;
 }
 export interface GetAccountRequest {
     pubkey: string;
 }
-export interface GetAffiliateFeesRequest {
-    start?: string;
-    end?: string;
-}
-export interface GetAffiliateRevenueRequest {
-    start?: string;
-    end?: string;
-}
 export interface GetTxRequest {
     txid: string;
 }
@@ -56,22 +48,6 @@ export declare class V1Api extends runtime.BaseAPI {
      * Get account details.
      */
     getAccount(requestParameters: GetAccountRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Account>;
-    /**
-     * Get ss affiliate fee history.
-     */
-    getAffiliateFeesRaw(requestParameters: GetAffiliateFeesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AffiliateFees>>;
-    /**
-     * Get ss affiliate fee history.
-     */
-    getAffiliateFees(requestParameters?: GetAffiliateFeesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AffiliateFees>;
-    /**
-     * Get total ss affiliate revenue earned.
-     */
-    getAffiliateRevenueRaw(requestParameters: GetAffiliateRevenueRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AffiliateRevenue>>;
-    /**
-     * Get total ss affiliate revenue earned.
-     */
-    getAffiliateRevenue(requestParameters?: GetAffiliateRevenueRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AffiliateRevenue>;
     /**
      * Get information about the running coinstack.
      */

package/dist/cjs/generated/thorchain/apis/V1Api.js

@@ -91,60 +91,6 @@ class V1Api extends runtime.BaseAPI {
         const response = await this.getAccountRaw(requestParameters, initOverrides);
         return await response.value();
     }
-    /**
-     * Get ss affiliate fee history.
-     */
-    async getAffiliateFeesRaw(requestParameters, initOverrides) {
-        const queryParameters = {};
-        if (requestParameters.start !== undefined) {
-            queryParameters['start'] = requestParameters.start;
-        }
-        if (requestParameters.end !== undefined) {
-            queryParameters['end'] = requestParameters.end;
-        }
-        const headerParameters = {};
-        const response = await this.request({
-            path: `/api/v1/affiliate/fees`,
-            method: 'GET',
-            headers: headerParameters,
-            query: queryParameters,
-        }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, models_1.AffiliateFeesFromJSON)(jsonValue));
-    }
-    /**
-     * Get ss affiliate fee history.
-     */
-    async getAffiliateFees(requestParameters = {}, initOverrides) {
-        const response = await this.getAffiliateFeesRaw(requestParameters, initOverrides);
-        return await response.value();
-    }
-    /**
-     * Get total ss affiliate revenue earned.
-     */
-    async getAffiliateRevenueRaw(requestParameters, initOverrides) {
-        const queryParameters = {};
-        if (requestParameters.start !== undefined) {
-            queryParameters['start'] = requestParameters.start;
-        }
-        if (requestParameters.end !== undefined) {
-            queryParameters['end'] = requestParameters.end;
-        }
-        const headerParameters = {};
-        const response = await this.request({
-            path: `/api/v1/affiliate/revenue`,
-            method: 'GET',
-            headers: headerParameters,
-            query: queryParameters,
-        }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, models_1.AffiliateRevenueFromJSON)(jsonValue));
-    }
-    /**
-     * Get total ss affiliate revenue earned.
-     */
-    async getAffiliateRevenue(requestParameters = {}, initOverrides) {
-        const response = await this.getAffiliateRevenueRaw(requestParameters, initOverrides);
-        return await response.value();
-    }
     /**
      * Get information about the running coinstack.
      */

package/dist/cjs/generated/thorchain/models/index.d.ts

@@ -1,7 +1,4 @@
 export * from './Account';
-export * from './AffiliateFee';
-export * from './AffiliateFees';
-export * from './AffiliateRevenue';
 export * from './ApiError';
 export * from './Attribute';
 export * from './BadRequestError';

package/dist/cjs/generated/thorchain/models/index.js

@@ -18,9 +18,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 /* tslint:disable */
 /* eslint-disable */
 __exportStar(require("./Account"), exports);
-__exportStar(require("./AffiliateFee"), exports);
-__exportStar(require("./AffiliateFees"), exports);
-__exportStar(require("./AffiliateRevenue"), exports);
 __exportStar(require("./ApiError"), exports);
 __exportStar(require("./Attribute"), exports);
 __exportStar(require("./BadRequestError"), exports);

package/dist/cjs/generated/zcash/models/Address.d.ts

@@ -27,6 +27,13 @@ export interface Address {
      * @memberof Address
      */
     pubkey: string;
+    /**
+     * BIP44 derivation path for the address (e.g. `m/84'/0'/0'/0/3`).
+     * Present only for xpub-derived addresses.
+     * @type {string}
+     * @memberof Address
+     */
+    path?: string;
 }
 /**
  * Check if a given object implements the Address interface.

package/dist/cjs/generated/zcash/models/Address.js

@@ -15,6 +15,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AddressToJSON = exports.AddressFromJSONTyped = exports.AddressFromJSON = exports.instanceOfAddress = void 0;
+const runtime_1 = require("../runtime");
 /**
  * Check if a given object implements the Address interface.
  */
@@ -36,6 +37,7 @@ function AddressFromJSONTyped(json, ignoreDiscriminator) {
     return {
         'balance': json['balance'],
         'pubkey': json['pubkey'],
+        'path': !(0, runtime_1.exists)(json, 'path') ? undefined : json['path'],
     };
 }
 exports.AddressFromJSONTyped = AddressFromJSONTyped;
@@ -49,6 +51,7 @@ function AddressToJSON(value) {
     return {
         'balance': value.balance,
         'pubkey': value.pubkey,
+        'path': value.path,
     };
 }
 exports.AddressToJSON = AddressToJSON;

package/dist/cjs/solana/parser/__tests__/solana.test.js

@@ -19,9 +19,11 @@ vitest_1.vi.mock('../../../generated/solana', async (importActual) => {
     const actual = await importActual();
     return {
         ...actual,
-        V1Api: vitest_1.vi.fn().mockImplementation(() => ({
-            getToken: getTokenMock,
-        })),
+        V1Api: vitest_1.vi.fn().mockImplementation(function () {
+            return {
+                getToken: getTokenMock,
+            };
+        }),
     };
 });
 const txParser = new index_1.TransactionParser({

package/dist/cjs/solana/parser/index.js

@@ -57,6 +57,7 @@ class TransactionParser {
             chainId: this.chainId,
             // all transactions from unchained are finalized with at least 1 confirmation (unused throughout web)
             confirmations: 1,
+            data: parserResult?.data,
             status: this.getStatus(tx),
             trade: parserResult?.trade,
             transfers: parserResult?.transfers ?? [],

package/dist/cjs/solana/parser/thorchain.d.ts

@@ -0,0 +1,9 @@
+import type { SubParser, Tx, TxSpecific } from './types';
+export type ParserArgs = {
+    midgardUrl: string;
+};
+export declare class Parser implements SubParser<Tx> {
+    private readonly parser;
+    constructor(args: ParserArgs);
+    parse(tx: Tx): Promise<TxSpecific | undefined>;
+}

package/dist/cjs/solana/parser/thorchain.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+const bs58_1 = __importDefault(require("bs58"));
+const thorchain = __importStar(require("../../parser/thorchain"));
+const MEMO_PROGRAM_ID = 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr';
+class Parser {
+    parser;
+    constructor(args) {
+        this.parser = new thorchain.Parser({ midgardUrl: args.midgardUrl });
+    }
+    async parse(tx) {
+        const memoInstruction = tx.instructions.find(ix => ix.programId === MEMO_PROGRAM_ID);
+        if (!memoInstruction)
+            return;
+        try {
+            const memo = Buffer.from(bs58_1.default.decode(memoInstruction.data)).toString('utf8');
+            if (!memo)
+                return;
+            return await this.parser.parse(memo, tx.txid);
+        }
+        catch (err) {
+            console.error('Failed to decode or parse Solana THORChain memo', err);
+            return undefined;
+        }
+    }
+}
+exports.Parser = Parser;

package/dist/cjs/solana/parser/types.d.ts

@@ -1,10 +1,13 @@
 import type * as solana from '../../generated/solana';
+import type * as thorchain from '../../parser/thorchain';
 import type { StandardTx } from '../../types';
 export * from '../../generated/solana';
 export type Tx = solana.Tx;
+export type TxMetadata = thorchain.TxMetadata;
 export interface ParsedTx extends StandardTx {
+    data?: TxMetadata;
 }
-export type TxSpecific = Partial<Pick<ParsedTx, 'trade' | 'transfers'>>;
+export type TxSpecific = Partial<Pick<ParsedTx, 'data' | 'trade' | 'transfers'>>;
 export interface SubParser<T extends Tx, U = TxSpecific> {
     parse(tx: T, address: string): Promise<U | undefined>;
 }

package/dist/cjs/tron/__tests__/api.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/tron/__tests__/api.test.js

@@ -0,0 +1,300 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const api_1 = require("../api");
+const successResponse = {
+    result: { result: true },
+    energy_used: 64285,
+    energy_penalty: 49635,
+    constant_result: ['0000000000000000000000000000000000000000000000000000000000000000'],
+    transaction: { ret: [{}] },
+};
+// A reverted simulation still reports result.result: true - the failure is only visible on
+// transaction.ret and the message
+const revertResponse = {
+    result: { result: true, message: 'REVERT opcode executed' },
+    energy_used: 7896,
+    energy_penalty: 6079,
+    constant_result: [''],
+    transaction: { ret: [{ ret: 'FAILED' }] },
+};
+(0, vitest_1.describe)('TronApi', () => {
+    const api = new api_1.TronApi({ rpcUrl: 'https://tron.example' });
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.spyOn(api, 'getChainPrices').mockResolvedValue({
+            bandwidthPrice: 1000,
+            energyPrice: 100,
+            memoFee: 1_000_000,
+        });
+        vitest_1.vi.spyOn(api, 'getContractEnergyShare').mockResolvedValue({
+            callerPercent: 100,
+            originEnergyLimit: 0,
+            originEnergyAvailable: 0,
+        });
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.restoreAllMocks();
+        vitest_1.vi.unstubAllGlobals();
+    });
+    (0, vitest_1.describe)('estimateContractCallFee', () => {
+        const params = {
+            contractAddress: 'TAfbit1ENsRmtZbPQfYU3srURpfYuWYS7K',
+            from: 'TT2T17KZhoDu47i2E4FWxfG79zdkEWkU9N',
+            data: '0x2213bc0b',
+        };
+        (0, vitest_1.it)('prices a successful simulation at energy_used * energyPrice', async () => {
+            vitest_1.vi.stubGlobal('fetch', vitest_1.vi.fn().mockResolvedValue({ ok: true, json: () => successResponse }));
+            (0, vitest_1.expect)(await api.estimateContractCallFee(params)).toBe('6428500');
+        });
+        (0, vitest_1.it)('prices the caller in full when the share lookup fails', async () => {
+            vitest_1.vi.stubGlobal('fetch', vitest_1.vi.fn().mockResolvedValue({ ok: true, json: () => successResponse }));
+            vitest_1.vi.mocked(api.getContractEnergyShare).mockRejectedValue(new Error('429'));
+            (0, vitest_1.expect)(await api.estimateContractCallFee(params)).toBe('6428500');
+        });
+        (0, vitest_1.it)('fails instead when the caller requires the share', async () => {
+            vitest_1.vi.stubGlobal('fetch', vitest_1.vi.fn().mockResolvedValue({ ok: true, json: () => successResponse }));
+            vitest_1.vi.mocked(api.getContractEnergyShare).mockRejectedValue(new Error('429'));
+            await (0, vitest_1.expect)(api.estimateContractCallFee({ ...params, requireEnergyShare: true })).rejects.toThrow('429');
+        });
+        (0, vitest_1.it)('bills the caller only their share when the deployer covers the rest', async () => {
+            vitest_1.vi.stubGlobal('fetch', vitest_1.vi.fn().mockResolvedValue({ ok: true, json: () => successResponse }));
+            vitest_1.vi.mocked(api.getContractEnergyShare).mockResolvedValue({
+                callerPercent: 5,
+                originEnergyLimit: 10_000_000,
+                originEnergyAvailable: 5_000_000,
+            });
+            // 64285 - floor(64285 * 0.95) = 3215
+            (0, vitest_1.expect)(await api.estimateContractCallFee(params)).toBe('321500');
+        });
+        (0, vitest_1.it)('throws on a reverted simulation rather than trusting the partial energy', async () => {
+            vitest_1.vi.stubGlobal('fetch', vitest_1.vi.fn().mockResolvedValue({ ok: true, json: () => revertResponse }));
+            await (0, vitest_1.expect)(api.estimateContractCallFee(params)).rejects.toThrow('REVERT opcode executed');
+        });
+        (0, vitest_1.it)('reports a failed request as such rather than as a revert', async () => {
+            vitest_1.vi.stubGlobal('fetch', vitest_1.vi.fn().mockResolvedValue({ ok: false, status: 429, json: () => ({}) }));
+            await (0, vitest_1.expect)(api.estimateContractCallFee(params)).rejects.toThrow('request failed: 429');
+        });
+    });
+    (0, vitest_1.describe)('getCallerEnergy', () => {
+        (0, vitest_1.it)('charges the caller in full when the contract sets no deployer share', () => {
+            const share = {
+                callerPercent: 100,
+                originEnergyLimit: 0,
+                originEnergyAvailable: 0,
+            };
+            (0, vitest_1.expect)((0, api_1.getCallerEnergy)(901_682, share)).toBe(901_682);
+        });
+        (0, vitest_1.it)('charges the caller their percent when the deployer has the energy staked', () => {
+            const share = {
+                callerPercent: 5,
+                originEnergyLimit: 10_000_000,
+                originEnergyAvailable: 5_000_000,
+            };
+            (0, vitest_1.expect)((0, api_1.getCallerEnergy)(901_682, share)).toBe(45_085);
+        });
+        (0, vitest_1.it)('charges the caller in full when the deployer has nothing staked', () => {
+            const share = {
+                callerPercent: 30,
+                originEnergyLimit: 10_000_000,
+                originEnergyAvailable: 0,
+            };
+            (0, vitest_1.expect)((0, api_1.getCallerEnergy)(130_285, share)).toBe(130_285);
+        });
+        (0, vitest_1.it)('caps the deployer share at their per-call limit', () => {
+            const share = {
+                callerPercent: 0,
+                originEnergyLimit: 100_000,
+                originEnergyAvailable: 5_000_000,
+            };
+            (0, vitest_1.expect)((0, api_1.getCallerEnergy)(300_000, share)).toBe(200_000);
+        });
+        (0, vitest_1.it)('caps the deployer share at what they have left', () => {
+            const share = {
+                callerPercent: 0,
+                originEnergyLimit: 10_000_000,
+                originEnergyAvailable: 40_000,
+            };
+            (0, vitest_1.expect)((0, api_1.getCallerEnergy)(300_000, share)).toBe(260_000);
+        });
+    });
+    (0, vitest_1.describe)('getContractEnergyShare', () => {
+        const contractResponse = {
+            consume_user_resource_percent: 5,
+            origin_energy_limit: 10_000_000,
+            origin_address: 'TDeployer',
+        };
+        const resourceResponse = { EnergyLimit: 6_000_000, EnergyUsed: 1_000_000 };
+        const respond = (...bodies) => {
+            const fetchMock = vitest_1.vi.fn();
+            bodies.forEach(body => fetchMock.mockResolvedValueOnce({ ok: true, json: () => body }));
+            vitest_1.vi.stubGlobal('fetch', fetchMock);
+            return fetchMock;
+        };
+        // the contract record is cached per instance, so each case gets its own
+        const freshApi = () => new api_1.TronApi({ rpcUrl: 'https://tron.example' });
+        (0, vitest_1.it)('reads the caller percent, per-call limit and the unspent deployer energy', async () => {
+            respond(contractResponse, resourceResponse);
+            (0, vitest_1.expect)(await freshApi().getContractEnergyShare('TRouter')).toEqual({
+                callerPercent: 5,
+                originEnergyLimit: 10_000_000,
+                originEnergyAvailable: 5_000_000,
+            });
+        });
+        (0, vitest_1.it)('reads an omitted percent as the deployer paying everything', async () => {
+            respond({ origin_energy_limit: 10_000_000, origin_address: 'TDeployer' }, resourceResponse);
+            (0, vitest_1.expect)(await freshApi().getContractEnergyShare('TRouter')).toMatchObject({ callerPercent: 0 });
+        });
+        (0, vitest_1.it)('reads an omitted per-call limit as the creator default', async () => {
+            respond({ consume_user_resource_percent: 5, origin_address: 'TDeployer' }, resourceResponse);
+            (0, vitest_1.expect)(await freshApi().getContractEnergyShare('TRouter')).toMatchObject({
+                originEnergyLimit: 10_000_000,
+            });
+        });
+        (0, vitest_1.it)('reads a plain address as a call the caller pays in full without a resource lookup', async () => {
+            const fetchMock = respond({});
+            (0, vitest_1.expect)(await freshApi().getContractEnergyShare('TPlain')).toEqual({
+                callerPercent: 100,
+                originEnergyLimit: 0,
+                originEnergyAvailable: 0,
+            });
+            (0, vitest_1.expect)(fetchMock).toHaveBeenCalledTimes(1);
+        });
+        (0, vitest_1.it)('re-reads an empty body rather than caching it as a plain address', async () => {
+            const fetchMock = respond({}, contractResponse, resourceResponse);
+            const api = freshApi();
+            await api.getContractEnergyShare('TRouter');
+            (0, vitest_1.expect)(await api.getContractEnergyShare('TRouter')).toMatchObject({ callerPercent: 5 });
+            (0, vitest_1.expect)(fetchMock).toHaveBeenCalledTimes(3);
+        });
+        (0, vitest_1.it)('rejects a failed lookup rather than guessing the split', async () => {
+            vitest_1.vi.stubGlobal('fetch', vitest_1.vi.fn().mockResolvedValue({ ok: false, status: 429 }));
+            await (0, vitest_1.expect)(freshApi().getContractEnergyShare('TRouter')).rejects.toThrow('429');
+        });
+        (0, vitest_1.it)('does not cache an error body the node returns with a 200', async () => {
+            const fetchMock = respond({ Error: 'class org.tron.core.exception' }, contractResponse, resourceResponse);
+            const api = freshApi();
+            await (0, vitest_1.expect)(api.getContractEnergyShare('TRouter')).rejects.toThrow('getcontract failed');
+            (0, vitest_1.expect)(await api.getContractEnergyShare('TRouter')).toMatchObject({ callerPercent: 5 });
+            (0, vitest_1.expect)(fetchMock).toHaveBeenCalledTimes(3);
+        });
+        (0, vitest_1.it)('reads the contract once and the deployer energy once per refresh window', async () => {
+            vitest_1.vi.useFakeTimers();
+            const fetchMock = respond(contractResponse, resourceResponse, resourceResponse);
+            const api = freshApi();
+            await api.getContractEnergyShare('TRouter');
+            await api.getContractEnergyShare('TRouter');
+            (0, vitest_1.expect)(fetchMock).toHaveBeenCalledTimes(2);
+            vitest_1.vi.advanceTimersByTime(16_000);
+            await api.getContractEnergyShare('TRouter');
+            (0, vitest_1.expect)(fetchMock).toHaveBeenCalledTimes(3);
+            const contractReads = fetchMock.mock.calls.filter(([url]) => String(url).endsWith('/wallet/getcontract'));
+            (0, vitest_1.expect)(contractReads).toHaveLength(1);
+            vitest_1.vi.useRealTimers();
+        });
+        (0, vitest_1.it)('re-reads the contract after a minute, since its split can change', async () => {
+            vitest_1.vi.useFakeTimers();
+            const fetchMock = respond(contractResponse, resourceResponse, contractResponse, resourceResponse);
+            const api = freshApi();
+            await api.getContractEnergyShare('TRouter');
+            vitest_1.vi.advanceTimersByTime(61_000);
+            await api.getContractEnergyShare('TRouter');
+            const contractReads = fetchMock.mock.calls.filter(([url]) => String(url).endsWith('/wallet/getcontract'));
+            (0, vitest_1.expect)(contractReads).toHaveLength(2);
+            vitest_1.vi.useRealTimers();
+        });
+    });
+    (0, vitest_1.describe)('getChainPrices', () => {
+        (0, vitest_1.it)('reads the energy, bandwidth and memo parameters', async () => {
+            vitest_1.vi.restoreAllMocks();
+            const tronWeb = api.getTronWeb();
+            vitest_1.vi.spyOn(tronWeb.trx, 'getChainParameters').mockResolvedValue([
+                { key: 'getTransactionFee', value: 1000 },
+                { key: 'getEnergyFee', value: 100 },
+                { key: 'getMemoFee', value: 1_000_000 },
+            ]);
+            (0, vitest_1.expect)(await api.getChainPrices()).toEqual({
+                bandwidthPrice: 1000,
+                energyPrice: 100,
+                memoFee: 1_000_000,
+            });
+        });
+        (0, vitest_1.it)('throws rather than defaulting when the node is unreachable', async () => {
+            vitest_1.vi.restoreAllMocks();
+            const tronWeb = api.getTronWeb();
+            vitest_1.vi.spyOn(tronWeb.trx, 'getChainParameters').mockRejectedValue(new Error('ECONNREFUSED'));
+            await (0, vitest_1.expect)(api.getChainPrices()).rejects.toThrow('ECONNREFUSED');
+        });
+    });
+    (0, vitest_1.describe)('getTrc20Balance', () => {
+        (0, vitest_1.it)('reads balanceOf(address) with a single constant call', async () => {
+            const tronWeb = api.getTronWeb();
+            const trigger = vitest_1.vi
+                .spyOn(tronWeb.transactionBuilder, 'triggerConstantContract')
+                .mockResolvedValue({
+                result: { result: true },
+                constant_result: ['00000000000000000000000000000000000000000000000000000000028e6fb0'],
+            });
+            const actual = await api.getTrc20Balance({
+                contractAddress: 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t',
+                address: 'TE6oHVdTbcp1Q9XBYx5VzjWbZEg3t3Jrnc',
+            });
+            (0, vitest_1.expect)(actual).toBe('42889136');
+            (0, vitest_1.expect)(trigger).toHaveBeenCalledWith('TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t', 'balanceOf(address)', {}, [{ type: 'address', value: 'TE6oHVdTbcp1Q9XBYx5VzjWbZEg3t3Jrnc' }], 'TE6oHVdTbcp1Q9XBYx5VzjWbZEg3t3Jrnc');
+        });
+    });
+    (0, vitest_1.describe)('getTrc20Allowance', () => {
+        (0, vitest_1.it)('reads allowance(owner, spender) with a single constant call', async () => {
+            const tronWeb = api.getTronWeb();
+            const trigger = vitest_1.vi
+                .spyOn(tronWeb.transactionBuilder, 'triggerConstantContract')
+                .mockResolvedValue({
+                result: { result: true },
+                constant_result: ['000000000000000000000000000000000000000000000000000000000000007b'],
+            });
+            const actual = await api.getTrc20Allowance({
+                contractAddress: 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t',
+                owner: 'TT2T17KZhoDu47i2E4FWxfG79zdkEWkU9N',
+                spender: 'TAfbit1ENsRmtZbPQfYU3srURpfYuWYS7K',
+            });
+            (0, vitest_1.expect)(actual).toBe('123');
+            (0, vitest_1.expect)(trigger).toHaveBeenCalledWith('TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t', 'allowance(address,address)', {}, [
+                { type: 'address', value: 'TT2T17KZhoDu47i2E4FWxfG79zdkEWkU9N' },
+                { type: 'address', value: 'TAfbit1ENsRmtZbPQfYU3srURpfYuWYS7K' },
+            ], 'TT2T17KZhoDu47i2E4FWxfG79zdkEWkU9N');
+        });
+    });
+    (0, vitest_1.describe)('isAccountActivated', () => {
+        (0, vitest_1.it)('is true for an account the node knows', async () => {
+            vitest_1.vi.stubGlobal('fetch', vitest_1.vi.fn().mockResolvedValue({ ok: true, json: () => ({ address: '41abc', balance: 1 }) }));
+            (0, vitest_1.expect)(await api.isAccountActivated('TT2T17KZhoDu47i2E4FWxfG79zdkEWkU9N')).toBe(true);
+        });
+        (0, vitest_1.it)('is false for a fresh address', async () => {
+            vitest_1.vi.stubGlobal('fetch', vitest_1.vi.fn().mockResolvedValue({ ok: true, json: () => ({}) }));
+            (0, vitest_1.expect)(await api.isAccountActivated('TT2T17KZhoDu47i2E4FWxfG79zdkEWkU9N')).toBe(false);
+        });
+        (0, vitest_1.it)('throws on an error response rather than reading it as not activated', async () => {
+            vitest_1.vi.stubGlobal('fetch', vitest_1.vi.fn().mockResolvedValue({ ok: false, status: 429, json: () => ({ Error: 'throttled' }) }));
+            await (0, vitest_1.expect)(api.isAccountActivated('TT2T17KZhoDu47i2E4FWxfG79zdkEWkU9N')).rejects.toThrow('429');
+        });
+    });
+    (0, vitest_1.describe)('estimateTrc20TransferFee', () => {
+        const params = {
+            contractAddress: 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t',
+            from: 'TT2T17KZhoDu47i2E4FWxfG79zdkEWkU9N',
+            to: 'TT2T17KZhoDu47i2E4FWxfG79zdkEWkU9N',
+            amount: '1',
+        };
+        const stubTriggerConstantContract = (response) => {
+            const tronWeb = api.getTronWeb();
+            vitest_1.vi.spyOn(tronWeb.transactionBuilder, 'triggerConstantContract').mockResolvedValue(response);
+        };
+        (0, vitest_1.it)('prices a successful simulation at energy_used * energyPrice', async () => {
+            stubTriggerConstantContract(successResponse);
+            (0, vitest_1.expect)(await api.estimateTrc20TransferFee(params)).toBe('6428500');
+        });
+        (0, vitest_1.it)('throws on a reverted simulation rather than trusting the partial energy', async () => {
+            stubTriggerConstantContract(revertResponse);
+            await (0, vitest_1.expect)(api.estimateTrc20TransferFee(params)).rejects.toThrow('REVERT opcode executed');
+        });
+    });
+});

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

@@ -1,14 +1,25 @@
 import type { TronBlock, TronTx } from './types';
 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;
 }