@ledgerhq/coin-tron 4.0.0-next.0 → 4.1.0-next.0

package/src/network/index.test.ts

@@ -1,33 +1,33 @@
 import { HttpResponse, http } from "msw";
-import { setupServer } from "msw/node";
+import { setupServer, SetupServerApi } from "msw/node";
 import { TRANSACTION_DETAIL_FIXTURE, TRANSACTION_FIXTURE, TRC20_FIXTURE } from "./types.fixture";
 import coinConfig from "../config";
 import { defaultFetchParams, fetchTronAccountTxs } from ".";
+import { assert } from "console";
 
 const TRON_BASE_URL_TEST = "https://httpbin.org";
 
-const handlers = [
-  http.get(`${TRON_BASE_URL_TEST}/v1/accounts/:addr/transactions`, () => {
-    // const url = new URL(request.url);
-    // const _ = url.searchParams.get("get_detail");
-    return HttpResponse.json(TRANSACTION_FIXTURE);
-  }),
-  http.get(`${TRON_BASE_URL_TEST}/v1/accounts/:addr/transactions/trc20`, () => {
-    // const url = new URL(request.url);
-    // const _ = url.searchParams.get("get_detail");
-    return HttpResponse.json(TRC20_FIXTURE);
-  }),
-  http.get(`${TRON_BASE_URL_TEST}/wallet/gettransactioninfobyid`, ({ request }) => {
+const defaultGetTransactionsH = http.get(
+  `${TRON_BASE_URL_TEST}/v1/accounts/:addr/transactions`,
+  () => HttpResponse.json(TRANSACTION_FIXTURE),
+);
+
+const defaultGetTrc20TransactionsH = http.get(
+  `${TRON_BASE_URL_TEST}/v1/accounts/:addr/transactions/trc20`,
+  () => HttpResponse.json(TRC20_FIXTURE),
+);
+
+const defaultGetTxInfo = http.get(
+  `${TRON_BASE_URL_TEST}/wallet/gettransactioninfobyid`,
+  ({ request }) => {
     const url = new URL(request.url);
     const value = url.searchParams.get("value") ?? "UNKNOWN";
     return HttpResponse.json(TRANSACTION_DETAIL_FIXTURE(value));
-  }),
-];
+  },
+);
 
-const mockServer = setupServer(...handlers);
-
-describe("fetchTronAccountTxs", () => {
-  beforeAll(() => {
+function doBeforeAll(server: SetupServerApi): () => void {
+  return () => {
     coinConfig.setCoinConfig(() => ({
       status: {
         type: "active",
@@ -37,16 +37,26 @@ describe("fetchTronAccountTxs", () => {
       },
     }));
 
-    mockServer.listen();
-  });
+    server.listen();
+  };
+}
 
-  beforeEach(() => {
-    mockServer.resetHandlers();
-  });
+function doBeforeEach(server: SetupServerApi): () => void {
+  return () => server.resetHandlers();
+}
 
-  afterAll(() => {
-    mockServer.close();
-  });
+function doAfterAll(server: SetupServerApi): () => void {
+  return () => server.close();
+}
+
+describe("fetchTronAccountTxs", () => {
+  const handlers = [defaultGetTransactionsH, defaultGetTrc20TransactionsH, defaultGetTxInfo];
+
+  const mockServer = setupServer(...handlers);
+
+  beforeAll(doBeforeAll(mockServer));
+  beforeEach(doBeforeEach(mockServer));
+  afterAll(doAfterAll(mockServer));
 
   it("convert correctly operations from the blockchain", async () => {
     // WHEN
@@ -64,3 +74,86 @@ describe("fetchTronAccountTxs", () => {
     expect(tx!.to).toEqual("TAVrrARNdnjHgCGMQYeQV7hv4PSu7mVsMj");
   });
 });
+
+describe("fetchTronAccountTxs with invalid TRC20 (see LIVE-18992)", () => {
+  const tx1Hash = "1237889e91c0ebbe389436c341865df09921f8f0c029d9286102372cbaadc585";
+  const tx2Hash = "154164dd04482ae78f930033d0ad95730b8b19fde171a33c3920d18c228426ab";
+  let counterGetTrc20 = 0;
+  const invalidTrc20Handler = http.get(
+    `${TRON_BASE_URL_TEST}/v1/accounts/:addr/transactions/trc20`,
+    () => {
+      const ret: any = JSON.parse(JSON.stringify(TRC20_FIXTURE));
+      switch (counterGetTrc20) {
+        case 0: {
+          const tx1 = ret.data[0];
+          assert(tx1.transaction_id == tx1Hash);
+          ret.data[0].detail.ret = undefined;
+          break;
+        }
+        case 1: {
+          const tx2 = ret.data[1];
+          assert(tx2.transaction_id == tx2Hash);
+          ret.data[1].detail.ret = undefined;
+          break;
+        }
+        default:
+          // the 3rd call should not happen
+          // because merging the 1st and 2nd results is enough to have a full set, perfectly well formed
+          throw "results should be merged after 2 calls";
+      }
+      counterGetTrc20++;
+      return HttpResponse.json(ret);
+    },
+  );
+  const handlers = [defaultGetTransactionsH, invalidTrc20Handler, defaultGetTxInfo];
+  const mockServer = setupServer(...handlers);
+
+  beforeAll(doBeforeAll(mockServer));
+  beforeEach(doBeforeEach(mockServer));
+  afterAll(doAfterAll(mockServer));
+
+  it("retry several times until result is correct", async () => {
+    // WHEN
+    const results = await fetchTronAccountTxs("ADDRESS", () => true, {}, defaultFetchParams);
+
+    // THEN
+    const tx1 = results.find(tx => tx.txID === tx1Hash);
+    expect(tx1).toBeDefined();
+    const tx2 = results.find(tx => tx.txID === tx2Hash);
+    expect(tx2).toBeDefined();
+  });
+});
+
+describe("fetchTronAccountTxs with invalid TRC20 (see LIVE-18992): after 3 tries it throws an exception", () => {
+  const tx1Hash = "1237889e91c0ebbe389436c341865df09921f8f0c029d9286102372cbaadc585";
+  const alwaysInvalidTrc20Handler = http.get(
+    `${TRON_BASE_URL_TEST}/v1/accounts/:addr/transactions/trc20`,
+    () => {
+      const ret: any = JSON.parse(JSON.stringify(TRC20_FIXTURE));
+      const tx1 = ret.data[0];
+      assert(tx1.transaction_id == tx1Hash);
+      ret.data[0].detail.ret = undefined;
+      return HttpResponse.json(ret);
+    },
+  );
+
+  const handlers = [defaultGetTransactionsH, alwaysInvalidTrc20Handler, defaultGetTxInfo];
+  const mockServer = setupServer(...handlers);
+
+  beforeAll(doBeforeAll(mockServer));
+  beforeEach(doBeforeEach(mockServer));
+  afterAll(doAfterAll(mockServer));
+
+  it("after several retry, it gives up on retry", async () => {
+    try {
+      await fetchTronAccountTxs("ADDRESS", () => true, {}, defaultFetchParams);
+    } catch (e) {
+      expect(e).toBeDefined();
+      expect((e as Error).message).toBe(
+        "getTrc20TxsWithRetry: couldn't fetch trc20 transactions after several attempts",
+      );
+      return;
+    }
+    fail("should have thrown an error");
+  });
+});

package/src/network/index.ts

@@ -483,13 +483,18 @@ export type FetchTxsStopPredicate = (
 ) => boolean;
 
 export type FetchParams = {
-  limit: number;
+  /** The maximum number of transactions to fetch per call. */
+  limitPerCall: number;
+  /** Hint about the number of transactions to be fetched in total (hint to optimize `limitPerCall`) */
+  hintGlobalLimit?: number;
   minTimestamp: number;
+  order: "asc" | "desc";
 };
 
 export const defaultFetchParams: FetchParams = {
-  limit: 100,
+  limitPerCall: 100,
   minTimestamp: 0,
+  order: "desc",
 } as const;
 
 export async function fetchTronAccountTxs(
@@ -498,12 +503,15 @@ export async function fetchTronAccountTxs(
   cacheTransactionInfoById: Record<string, TronTransactionInfo>,
   params: FetchParams,
 ): Promise<TrongridTxInfo[]> {
-  const queryParamsNativeTxs = `limit=${params.limit}&min_timestamp=${params.minTimestamp}`;
+  const adjustedLimitPerCall = params.hintGlobalLimit
+    ? Math.min(params.limitPerCall, params.hintGlobalLimit)
+    : params.limitPerCall;
+  const queryParams = `limit=${adjustedLimitPerCall}&min_timestamp=${params.minTimestamp}&order_by=block_timestamp,${params.order}`;
   const nativeTxs = (
     await getAllTransactions<
       (TransactionTronAPI & { detail?: TronTransactionInfo }) | MalformedTransactionTronAPI
     >(
-      `${getBaseApiUrl()}/v1/accounts/${addr}/transactions?${queryParamsNativeTxs}`,
+      `${getBaseApiUrl()}/v1/accounts/${addr}/transactions?${queryParams}`,
       shouldFetchMoreTxs,
       getTransactions(cacheTransactionInfoById),
     )
@@ -528,14 +536,77 @@ export async function fetchTronAccountTxs(
 
   // we need to fetch and filter trc20 transactions from another endpoint
   // doc https://developers.tron.network/reference/get-trc20-transaction-info-by-account-address
-  const queryParamsTrc20Txs = `limit=${params.limit}&min_timestamp=${params.minTimestamp}`;
-  const trc20Txs = (
+
+  const callTrc20Endpoint = async () =>
     await getAllTransactions<Trc20API>(
-      `${getBaseApiUrl()}/v1/accounts/${addr}/transactions/trc20?${queryParamsTrc20Txs}&get_detail=true`,
+      `${getBaseApiUrl()}/v1/accounts/${addr}/transactions/trc20?${queryParams}&get_detail=true`,
       shouldFetchMoreTxs,
       getTrc20,
-    )
-  ).map(tx => formatTrongridTrc20TxResponse(tx));
+    );
+
+  type Acc = {
+    txs: Trc20API[];
+    invalids: number[];
+  };
+
+  function isValid(tx: Trc20API): boolean {
+    const ret = tx?.detail?.ret;
+    return Array.isArray(ret) && ret.length > 0;
+  }
+
+  function getInvalidTxIndexes(txs: Trc20API[]): number[] {
+    const invalids: number[] = [];
+    for (let i = 0; i < txs.length; i++) {
+      if (!isValid(txs[i])) {
+        invalids.push(i);
+      }
+    }
+    txs.filter(tx => !isValid(tx)).map((tx, index) => index);
+    return invalids;
+  }
+
+  function assert(predicate: boolean, message: string) {
+    if (!predicate) {
+      throw new Error(message);
+    }
+  }
+
+  // Merge the two results
+  function mergeAccs(acc1: Acc, acc2: Acc): Acc {
+    assert(acc1.txs.length == acc2.txs.length, "accs should have the same length");
+    const accRet: Acc = { txs: acc1.txs, invalids: [] };
+    acc1.invalids.forEach(invalidIndex => {
+      acc2.invalids.includes(invalidIndex)
+        ? accRet.invalids.push(invalidIndex)
+        : (accRet.txs[invalidIndex] = acc2.txs[invalidIndex]);
+    });
+    return accRet;
+  }
+
+  // see LIVE-18992 for an explanation to why we need this
+  async function getTrc20TxsWithRetry(acc: Acc | null, times: number): Promise<Trc20API[]> {
+    assert(
+      times > 0,
+      "getTrc20TxsWithRetry: couldn't fetch trc20 transactions after several attempts",
+    );
+    const ret = await callTrc20Endpoint();
+    const thisAcc: Acc = {
+      txs: ret,
+      invalids: getInvalidTxIndexes(ret),
+    };
+    const newAcc = acc ? mergeAccs(acc, thisAcc) : thisAcc;
+    if (newAcc.invalids.length == 0) {
+      return newAcc.txs;
+    } else {
+      log(
+        "coin-tron",
+        `getTrc20TxsWithRetry: got ${newAcc.invalids.length} invalid trc20 transactions, retrying...`,
+      );
+      return await getTrc20TxsWithRetry(newAcc, times - 1);
+    }
+  }
+
+  const trc20Txs = (await getTrc20TxsWithRetry(null, 3)).map(formatTrongridTrc20TxResponse);
 
   const txInfos: TrongridTxInfo[] = compact(nativeTxs.concat(trc20Txs)).sort(
     (a, b) => b.date.getTime() - a.date.getTime(),

package/src/network/types.fixture.ts

@@ -4434,7 +4434,7 @@ export const TRC20_FIXTURE = {
     at: 1718032314555,
     page_size: 8,
   },
-};
+} as const;
 
 export const TRANSACTION_DETAIL_FIXTURE = (id: string) => ({
   id,