@shapeshiftoss/unchained-client 10.15.0 → 10.16.0

package/dist/esm/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/esm/generated/ethereum/apis/V1Api.js

@@ -136,6 +136,30 @@ export 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/esm/tron/__tests__/api.test.js

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

package/dist/esm/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/esm/tron/api.js

@@ -1,4 +1,6 @@
+import { timeout } from '@shapeshiftoss/utils';
 import { TronWeb } from 'tronweb';
+const PRECISION_READ_TIMEOUT_MS = 10_000;
 const TRON_CALLER_PAYS_ALL = {
     callerPercent: 100,
     originEnergyLimit: 0,
@@ -140,6 +142,36 @@ export class TronApi {
             tokens,
         };
     }
+    async getTrc20Decimals(params) {
+        try {
+            const result = await 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 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 ?? [];
@@ -374,10 +406,14 @@ export class TronApi {
         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
+    // 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshiftoss/unchained-client",
-  "version": "10.15.0",
+  "version": "10.16.0",
   "repository": "https://github.com/shapeshift/web",
   "license": "MIT",
   "type": "module",
@@ -29,9 +29,9 @@
     "isomorphic-ws": "^4.0.1",
     "viem": "2.55.11",
     "ws": "^8.17.1",
-    "@shapeshiftoss/caip": "^8.17.1",
     "@shapeshiftoss/contracts": "^1.1.0",
-    "@shapeshiftoss/utils": "^1.3.1"
+    "@shapeshiftoss/caip": "^8.17.2",
+    "@shapeshiftoss/utils": "^1.4.0"
   },
   "devDependencies": {
     "@openapitools/openapi-generator-cli": "^2.5.1"