@shapeshiftoss/unchained-client 10.15.0 → 10.16.0

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

@@ -20,6 +20,9 @@ export interface EstimateGasRequest {
 export interface GetAccountRequest {
     pubkey: string;
 }
+export interface GetRfoxStakingDurationRequest {
+    address: string;
+}
 export interface GetTransactionRequest {
     txid: string;
 }
@@ -77,6 +80,18 @@ export declare class V1Api extends runtime.BaseAPI {
      * Get information about the running coinstack
      */
     getInfo(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BaseInfo>;
+    /**
+     * Get rFOX staking duration by contract address
+     */
+    getRfoxStakingDurationRaw(requestParameters: GetRfoxStakingDurationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<{
+        [key: string]: number;
+    }>>;
+    /**
+     * Get rFOX staking duration by contract address
+     */
+    getRfoxStakingDuration(requestParameters: GetRfoxStakingDurationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<{
+        [key: string]: number;
+    }>;
     /**
      * Get transaction details
      */

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

@@ -162,6 +162,30 @@ class V1Api extends runtime.BaseAPI {
         const response = await this.getInfoRaw(initOverrides);
         return await response.value();
     }
+    /**
+     * Get rFOX staking duration by contract address
+     */
+    async getRfoxStakingDurationRaw(requestParameters, initOverrides) {
+        if (requestParameters.address === null || requestParameters.address === undefined) {
+            throw new runtime.RequiredError('address', 'Required parameter requestParameters.address was null or undefined when calling getRfoxStakingDuration.');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        const response = await this.request({
+            path: `/api/v1/rfox/staking-duration/{address}`.replace(`{${"address"}}`, encodeURIComponent(String(requestParameters.address))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response);
+    }
+    /**
+     * Get rFOX staking duration by contract address
+     */
+    async getRfoxStakingDuration(requestParameters, initOverrides) {
+        const response = await this.getRfoxStakingDurationRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
     /**
      * Get transaction details
      */

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

@@ -242,6 +242,131 @@ const revertResponse = {
             (0, vitest_1.expect)(trigger).toHaveBeenCalledWith('TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t', 'balanceOf(address)', {}, [{ type: 'address', value: 'TE6oHVdTbcp1Q9XBYx5VzjWbZEg3t3Jrnc' }], 'TE6oHVdTbcp1Q9XBYx5VzjWbZEg3t3Jrnc');
         });
     });
+    (0, vitest_1.describe)('getTrc20Decimals', () => {
+        const USDT = 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t';
+        const eighteen = '0000000000000000000000000000000000000000000000000000000000000012';
+        (0, vitest_1.it)('reads decimals() with a single constant call', async () => {
+            const freshApi = new api_1.TronApi({ rpcUrl: 'https://tron.example' });
+            const tronWeb = freshApi.getTronWeb();
+            const trigger = vitest_1.vi
+                .spyOn(tronWeb.transactionBuilder, 'triggerConstantContract')
+                .mockResolvedValue({ result: { result: true }, constant_result: [eighteen] });
+            (0, vitest_1.expect)(await freshApi.getTrc20Decimals({ contractAddress: USDT })).toBe(18);
+            (0, vitest_1.expect)(trigger).toHaveBeenCalledWith(USDT, 'decimals()', {}, [], USDT);
+        });
+        (0, vitest_1.it)('reads a reverted decimals() as unknown', async () => {
+            const freshApi = new api_1.TronApi({ rpcUrl: 'https://tron.example' });
+            const tronWeb = freshApi.getTronWeb();
+            const trigger = vitest_1.vi
+                .spyOn(tronWeb.transactionBuilder, 'triggerConstantContract')
+                .mockResolvedValueOnce({
+                result: { result: true, message: 'REVERT opcode executed' },
+                constant_result: ['08c379a0' + '0'.repeat(56)],
+                transaction: { ret: [{ ret: 'FAILED' }] },
+            })
+                .mockResolvedValue({ result: { result: true }, constant_result: [eighteen] });
+            (0, vitest_1.expect)(await freshApi.getTrc20Decimals({ contractAddress: USDT })).toBeUndefined();
+            (0, vitest_1.expect)(await freshApi.getTrc20Decimals({ contractAddress: USDT })).toBe(18);
+            (0, vitest_1.expect)(trigger).toHaveBeenCalledTimes(2);
+        });
+        (0, vitest_1.it)('reads a value outside a uint8 as unknown', async () => {
+            const freshApi = new api_1.TronApi({ rpcUrl: 'https://tron.example' });
+            const tronWeb = freshApi.getTronWeb();
+            vitest_1.vi.spyOn(tronWeb.transactionBuilder, 'triggerConstantContract').mockResolvedValue({
+                result: { result: true },
+                constant_result: ['0'.repeat(61) + '100'],
+            });
+            (0, vitest_1.expect)(await freshApi.getTrc20Decimals({ contractAddress: USDT })).toBeUndefined();
+        });
+        (0, vitest_1.it)('gives up on a call that hangs', async () => {
+            vitest_1.vi.useFakeTimers();
+            try {
+                const freshApi = new api_1.TronApi({ rpcUrl: 'https://tron.example' });
+                const tronWeb = freshApi.getTronWeb();
+                vitest_1.vi.spyOn(tronWeb.transactionBuilder, 'triggerConstantContract').mockReturnValue(new Promise(() => undefined));
+                const pending = freshApi.getTrc20Decimals({ contractAddress: USDT });
+                await vitest_1.vi.runAllTimersAsync();
+                (0, vitest_1.expect)(await pending).toBeUndefined();
+            }
+            finally {
+                vitest_1.vi.useRealTimers();
+            }
+        });
+        (0, vitest_1.it)('reads a failed call as unknown', async () => {
+            const freshApi = new api_1.TronApi({ rpcUrl: 'https://tron.example' });
+            const tronWeb = freshApi.getTronWeb();
+            const trigger = vitest_1.vi
+                .spyOn(tronWeb.transactionBuilder, 'triggerConstantContract')
+                .mockRejectedValueOnce(new Error('429'))
+                .mockResolvedValue({ result: { result: true }, constant_result: [eighteen] });
+            (0, vitest_1.expect)(await freshApi.getTrc20Decimals({ contractAddress: USDT })).toBeUndefined();
+            (0, vitest_1.expect)(await freshApi.getTrc20Decimals({ contractAddress: USDT })).toBe(18);
+            (0, vitest_1.expect)(trigger).toHaveBeenCalledTimes(2);
+        });
+    });
+    (0, vitest_1.describe)('getTrc10Precision', () => {
+        const respond = (body) => {
+            const fetchMock = vitest_1.vi.fn().mockResolvedValue({ ok: true, json: () => body });
+            vitest_1.vi.stubGlobal('fetch', fetchMock);
+            return fetchMock;
+        };
+        (0, vitest_1.it)('reads the precision of an issued token', async () => {
+            const freshApi = new api_1.TronApi({ rpcUrl: 'https://tron.example' });
+            const fetchMock = respond({ success: true, data: [{ id: '1002000', precision: 6 }] });
+            (0, vitest_1.expect)(await freshApi.getTrc10Precision({ id: '1002000' })).toBe(6);
+            (0, vitest_1.expect)(fetchMock).toHaveBeenCalledWith('https://tron.example/v1/assets/1002000', vitest_1.expect.objectContaining({ headers: vitest_1.expect.anything() }));
+        });
+        (0, vitest_1.it)('reads a zero precision as issued', async () => {
+            const freshApi = new api_1.TronApi({ rpcUrl: 'https://tron.example' });
+            respond({ success: true, data: [{ id: '1000001', precision: 0 }] });
+            (0, vitest_1.expect)(await freshApi.getTrc10Precision({ id: '1000001' })).toBe(0);
+        });
+        (0, vitest_1.it)('reads an unknown id as unknown', async () => {
+            const freshApi = new api_1.TronApi({ rpcUrl: 'https://tron.example' });
+            respond({ success: false, error: 'A valid account address or asset id is required.' });
+            (0, vitest_1.expect)(await freshApi.getTrc10Precision({ id: '9999999' })).toBeUndefined();
+        });
+        (0, vitest_1.it)('reads an empty listing as unknown', async () => {
+            const freshApi = new api_1.TronApi({ rpcUrl: 'https://tron.example' });
+            respond({ success: true, data: [] });
+            (0, vitest_1.expect)(await freshApi.getTrc10Precision({ id: '1009999' })).toBeUndefined();
+        });
+        (0, vitest_1.it)('gives up on a request that hangs', async () => {
+            vitest_1.vi.useFakeTimers();
+            try {
+                const freshApi = new api_1.TronApi({ rpcUrl: 'https://tron.example' });
+                vitest_1.vi.stubGlobal('fetch', vitest_1.vi.fn().mockReturnValue(new Promise(() => undefined)));
+                const pending = freshApi.getTrc10Precision({ id: '1002000' });
+                await vitest_1.vi.runAllTimersAsync();
+                (0, vitest_1.expect)(await pending).toBeUndefined();
+            }
+            finally {
+                vitest_1.vi.useRealTimers();
+            }
+        });
+        (0, vitest_1.it)('gives up on a response whose body stalls', async () => {
+            vitest_1.vi.useFakeTimers();
+            try {
+                const freshApi = new api_1.TronApi({ rpcUrl: 'https://tron.example' });
+                const fetchMock = vitest_1.vi
+                    .fn()
+                    .mockResolvedValue({ ok: true, json: () => new Promise(() => undefined) });
+                vitest_1.vi.stubGlobal('fetch', fetchMock);
+                const pending = freshApi.getTrc10Precision({ id: '1002000' });
+                await vitest_1.vi.runAllTimersAsync();
+                (0, vitest_1.expect)(await pending).toBeUndefined();
+                (0, vitest_1.expect)(fetchMock).toHaveBeenCalledWith('https://tron.example/v1/assets/1002000', vitest_1.expect.objectContaining({ signal: vitest_1.expect.any(AbortSignal) }));
+            }
+            finally {
+                vitest_1.vi.useRealTimers();
+            }
+        });
+        (0, vitest_1.it)('reads a failed request as unknown', async () => {
+            const freshApi = new api_1.TronApi({ rpcUrl: 'https://tron.example' });
+            vitest_1.vi.stubGlobal('fetch', vitest_1.vi.fn().mockRejectedValue(new Error('429')));
+            (0, vitest_1.expect)(await freshApi.getTrc10Precision({ id: '1002000' })).toBeUndefined();
+        });
+    });
     (0, vitest_1.describe)('getTrc20Allowance', () => {
         (0, vitest_1.it)('reads allowance(owner, spender) with a single constant call', async () => {
             const tronWeb = api.getTronWeb();

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

@@ -32,6 +32,12 @@ export declare class TronApi {
             balance: string;
         }[];
     }>;
+    getTrc20Decimals(params: {
+        contractAddress: string;
+    }): Promise<number | undefined>;
+    getTrc10Precision(params: {
+        id: string;
+    }): Promise<number | undefined>;
     getTrc20Balance(params: {
         contractAddress: string;
         address: string;
@@ -85,5 +91,6 @@ export declare class TronApi {
         callValue?: string;
         requireEnergyShare?: boolean;
     }): Promise<string>;
+    private isReverted;
     private getSimulatedEnergy;
 }

package/dist/cjs/tron/api.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 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,
@@ -144,6 +146,36 @@ class TronApi {
             tokens,
         };
     }
+    async getTrc20Decimals(params) {
+        try {
+            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) {
+            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 ?? [];
@@ -378,10 +410,14 @@ class TronApi {
         const energy = this.getSimulatedEnergy(result, 'contract call');
         return String((0, exports.getCallerEnergy)(energy, share) * energyPrice);
     }
-    // A revert still reports result.result: true with the partial energy burned - trusting it would underestimate
+    // 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) {
-        const isReverted = result.transaction?.ret?.some(ret => ret.ret === 'FAILED');
-        if (result.result?.result !== true || isReverted || !result.energy_used) {
+        if (this.isReverted(result) || !result.energy_used) {
             throw new Error(`[tron] ${label} simulation failed: ${result.result?.message ?? 'unknown error'}`);
         }
         return result.energy_used;