@ledgerhq/coin-xrp 0.9.2 → 1.0.0-nightly.1

package/src/api/index.test.ts

@@ -20,6 +20,98 @@ describe("listOperations", () => {
     mockGetTransactions.mockClear();
   });
 
+  const defaultMarker = { ledger: 1, seq: 1 };
+  function mockNetworkTxs(txs: unknown, marker: undefined | unknown): unknown {
+    return {
+      account: "account",
+      ledger_index_max: 1,
+      ledger_index_min: 1,
+      limit: 1,
+      validated: false,
+      transactions: txs,
+      marker: marker,
+      error: "",
+    };
+  }
+
+  function givenTxs(
+    fee: bigint,
+    deliveredAmount: bigint,
+    opSender: string,
+    opDestination: string,
+  ): unknown[] {
+    return [
+      {
+        ledger_hash: "HASH_VALUE_BLOCK",
+        hash: "HASH_VALUE",
+        close_time_iso: "2000-01-01T00:00:01Z",
+        meta: { delivered_amount: deliveredAmount.toString() },
+        tx_json: {
+          TransactionType: "Payment",
+          Fee: fee.toString(),
+          ledger_index: 1,
+          date: 1000,
+          Account: opSender,
+          Destination: opDestination,
+          Sequence: 1,
+        },
+      },
+      {
+        ledger_hash: "HASH_VALUE_BLOCK",
+        hash: "HASH_VALUE",
+        close_time_iso: "2000-01-01T00:00:01Z",
+        meta: { delivered_amount: deliveredAmount.toString() },
+        tx_json: {
+          TransactionType: "Payment",
+          Fee: fee.toString(),
+          ledger_index: 1,
+          date: 1000,
+          Account: opSender,
+          Destination: opDestination,
+          DestinationTag: 509555,
+          Sequence: 1,
+        },
+      },
+      {
+        ledger_hash: "HASH_VALUE_BLOCK",
+        hash: "HASH_VALUE",
+        close_time_iso: "2000-01-01T00:00:01Z",
+        meta: { delivered_amount: deliveredAmount.toString() },
+        tx_json: {
+          TransactionType: "Payment",
+          Fee: fee.toString(),
+          ledger_index: 1,
+          date: 1000,
+          Account: opSender,
+          Destination: opDestination,
+          Memos: [
+            {
+              Memo: {
+                MemoType: "687474703a2f2f6578616d706c652e636f6d2f6d656d6f2f67656e65726963",
+                MemoData: "72656e74",
+              },
+            },
+          ],
+          Sequence: 1,
+        },
+      },
+    ];
+  }
+
+  it("should kill the loop after 10 iterations", async () => {
+    const txs = givenTxs(BigInt(10), BigInt(10), "src", "dest");
+    // each time it's called it returns a marker, so in theory it would loop forever
+    mockGetTransactions.mockResolvedValue(mockNetworkTxs(txs, defaultMarker));
+    const [results, _] = await api.listOperations("src", { minHeight: 0 });
+
+    // called 10 times because there is a hard limit of 10 iterations in case something goes wrong
+    // with interpretation of the token (bug / explorer api changed ...)
+    expect(mockGetServerInfos).toHaveBeenCalledTimes(10);
+    expect(mockGetTransactions).toHaveBeenCalledTimes(10);
+
+    expect(results.length).toBe(txs.length * 10);
+  });
+
   it.each([
     {
       address: "WHATEVER_ADDRESS",
@@ -34,84 +126,36 @@ describe("listOperations", () => {
       expectedType: "OUT",
     },
   ])(
-    "should return the list of operations associated to an account",
+    `should return the list of operations associated to an account when expected type is %s`,
     async ({ address, opSender, opDestination, expectedType }) => {
       // Givem
-      const deliveredAmount = 100;
-      const fee = 10;
-      mockGetTransactions.mockResolvedValue([
-        {
-          ledger_hash: "HASH_VALUE_BLOCK",
-          hash: "HASH_VALUE",
-          close_time_iso: "2000-01-01T00:00:01Z",
-          meta: { delivered_amount: deliveredAmount.toString() },
-          tx_json: {
-            TransactionType: "Payment",
-            Fee: fee.toString(),
-            ledger_index: 1,
-            date: 1000,
-            Account: opSender,
-            Destination: opDestination,
-            Sequence: 1,
-          },
-        },
-        {
-          ledger_hash: "HASH_VALUE_BLOCK",
-          hash: "HASH_VALUE",
-          close_time_iso: "2000-01-01T00:00:01Z",
-          meta: { delivered_amount: deliveredAmount.toString() },
-          tx_json: {
-            TransactionType: "Payment",
-            Fee: fee.toString(),
-            ledger_index: 1,
-            date: 1000,
-            Account: opSender,
-            Destination: opDestination,
-            DestinationTag: 509555,
-            Sequence: 1,
-          },
-        },
-        {
-          ledger_hash: "HASH_VALUE_BLOCK",
-          hash: "HASH_VALUE",
-          close_time_iso: "2000-01-01T00:00:01Z",
-          meta: { delivered_amount: deliveredAmount.toString() },
-          tx_json: {
-            TransactionType: "Payment",
-            Fee: fee.toString(),
-            ledger_index: 1,
-            date: 1000,
-            Account: opSender,
-            Destination: opDestination,
-            Memos: [
-              {
-                Memo: {
-                  MemoType: "687474703a2f2f6578616d706c652e636f6d2f6d656d6f2f67656e65726963",
-                  MemoData: "72656e74",
-                },
-              },
-            ],
-            Sequence: 1,
-          },
-        },
-      ]);
+      const deliveredAmount = BigInt(100);
+      const fee = BigInt(10);
+      mockGetTransactions.mockResolvedValueOnce(
+        mockNetworkTxs(givenTxs(fee, deliveredAmount, opSender, opDestination), defaultMarker),
+      );
+
+      // second call to kill the loop
+      mockGetTransactions.mockResolvedValue(mockNetworkTxs([], undefined));
 
       // When
-      const [results, _] = await api.listOperations(address, { limit: 100 });
+      const [results, _] = await api.listOperations(address, { minHeight: 0 });
 
       // Then
-      expect(mockGetServerInfos).toHaveBeenCalledTimes(1);
-      expect(mockGetTransactions).toHaveBeenCalledTimes(1);
+      // called twice because the marker is set the first time
+      expect(mockGetServerInfos).toHaveBeenCalledTimes(2);
+      expect(mockGetTransactions).toHaveBeenCalledTimes(2);
+
       // if expectedType is "OUT", compute value with fees (i.e. delivered_amount + Fee)
-      const expectedValue =
-        expectedType === "IN" ? BigInt(deliveredAmount) : BigInt(deliveredAmount + fee);
+      const expectedValue = expectedType === "IN" ? deliveredAmount : deliveredAmount + fee;
+      // the order is reversed so that the result is always sorted by newest tx first element of the list
       expect(results).toEqual([
         {
           hash: "HASH_VALUE",
           address,
           type: "Payment",
           value: expectedValue,
-          fee: BigInt(10),
+          fee: fee,
           block: {
             hash: "HASH_VALUE_BLOCK",
             height: 1,
@@ -121,13 +165,21 @@ describe("listOperations", () => {
           recipients: [opDestination],
           date: new Date(1000000 + RIPPLE_EPOCH * 1000),
           transactionSequenceNumber: 1,
+          details: {
+            memos: [
+              {
+                type: "687474703a2f2f6578616d706c652e636f6d2f6d656d6f2f67656e65726963",
+                data: "72656e74",
+              },
+            ],
+          },
         },
         {
           hash: "HASH_VALUE",
           address,
           type: "Payment",
           value: expectedValue,
-          fee: BigInt(10),
+          fee: fee,
           block: {
             hash: "HASH_VALUE_BLOCK",
             height: 1,
@@ -146,7 +198,7 @@ describe("listOperations", () => {
           address,
           type: "Payment",
           value: expectedValue,
-          fee: BigInt(10),
+          fee: fee,
           block: {
             hash: "HASH_VALUE_BLOCK",
             height: 1,
@@ -156,14 +208,6 @@ describe("listOperations", () => {
           recipients: [opDestination],
           date: new Date(1000000 + RIPPLE_EPOCH * 1000),
           transactionSequenceNumber: 1,
-          details: {
-            memos: [
-              {
-                type: "687474703a2f2f6578616d706c652e636f6d2f6d656d6f2f67656e65726963",
-                data: "72656e74",
-              },
-            ],
-          },
         },
       ]);
     },

package/src/api/index.ts

@@ -4,6 +4,7 @@ import type {
   Transaction as ApiTransaction,
   Pagination,
 } from "@ledgerhq/coin-framework/api/index";
+import { log } from "@ledgerhq/logs";
 import coinConfig, { type XrpConfig } from "../config";
 import {
   broadcast,
@@ -15,6 +16,7 @@ import {
   lastBlock,
   listOperations,
 } from "../logic";
+import { XrpOperation } from "../types";
 
 export function createApi(config: XrpConfig): Api {
   coinConfig.setCoinConfig(() => ({ ...config, status: { type: "active" } }));
@@ -41,16 +43,66 @@ async function estimate(_addr: string, _amount: bigint): Promise<bigint> {
   return fees.fee;
 }
 
+type PaginationState = {
+  pageSize: number; // must be large enough to avoid unnecessary calls to the underlying explorer
+  maxIterations: number; // a security to avoid infinite loop
+  currentIteration: number;
+  minHeight: number;
+  continueIterations: boolean;
+  apiNextCursor?: string;
+  accumulator: XrpOperation[];
+};
+
+async function operationsFromHeight(
+  address: string,
+  minHeight: number,
+): Promise<[XrpOperation[], string]> {
+  async function fetchNextPage(state: PaginationState): Promise<PaginationState> {
+    const [operations, apiNextCursor] = await listOperations(address, {
+      limit: state.pageSize,
+      minHeight: state.minHeight,
+      order: "asc",
+    });
+    const newCurrentIteration = state.currentIteration + 1;
+    let continueIteration = true;
+    if (apiNextCursor === "") {
+      continueIteration = false;
+    } else if (newCurrentIteration >= state.maxIterations) {
+      log("coin:xrp", "(api/operations): max iterations reached", state.maxIterations);
+      continueIteration = false;
+    }
+    const accumulated = state.accumulator.concat(operations);
+    return {
+      ...state,
+      currentIteration: newCurrentIteration,
+      continueIterations: continueIteration,
+      apiNextCursor: apiNextCursor,
+      accumulator: accumulated,
+    };
+  }
+
+  const firstState: PaginationState = {
+    pageSize: 200,
+    maxIterations: 10,
+    currentIteration: 0,
+    minHeight: minHeight,
+    continueIterations: true,
+    accumulator: [],
+  };
+
+  let state = await fetchNextPage(firstState);
+  while (state.continueIterations) {
+    state = await fetchNextPage(state);
+  }
+  return [state.accumulator, state.apiNextCursor ?? ""];
+}
+
 async function operations(
   address: string,
-  { limit, start }: Pagination,
-): Promise<[Operation[], number]> {
-  const options: {
-    limit?: number;
-    minHeight?: number;
-  } = { limit: limit };
-  if (start) options.minHeight = start;
-  const [ops, index] = await listOperations(address, options);
+  { minHeight }: Pagination,
+): Promise<[Operation[], string]> {
+  const [ops, token] = await operationsFromHeight(address, minHeight);
+  // TODO token must be implemented properly (waiting ack from the design document)
   return [
     ops.map(op => {
       const { simpleType, blockHash, blockTime, blockHeight, ...rest } = op;
@@ -61,8 +113,8 @@ async function operations(
           hash: blockHash,
           time: blockTime,
         },
-      } satisfies Operation;
+      };
     }),
-    index,
+    token,
   ];
 }

package/src/bridge/synchronization.test.ts

@@ -68,6 +68,20 @@ describe("getAccountShape", () => {
     });
   });
 
+  const someMarker = { ledger: 1, seq: 1 };
+  function mockNetworkTxs(txs: unknown): unknown {
+    return {
+      account: "account",
+      ledger_index_max: 1,
+      ledger_index_min: 1,
+      limit: 1,
+      validated: false,
+      transactions: txs,
+      marker: someMarker,
+      error: "",
+    };
+  }
+
   it("convert correctly operations", async () => {
     // Given
     mockGetAccountInfo.mockResolvedValue({
@@ -76,22 +90,24 @@ describe("getAccountShape", () => {
       ownerCount: 0,
       sequence: 0,
     });
-    mockGetTransactions.mockResolvedValue([
-      {
-        ledger_hash: "HASH_VALUE_BLOCK",
-        hash: "HASH_VALUE",
-        meta: { delivered_amount: "100" },
-        tx_json: {
-          TransactionType: "Payment",
-          Fee: "10",
-          ledger_index: 1,
-          date: 1000,
-          Account: "account_addr",
-          Destination: "destination_addr",
-          Sequence: 1,
+    mockGetTransactions.mockResolvedValue(
+      mockNetworkTxs([
+        {
+          ledger_hash: "HASH_VALUE_BLOCK",
+          hash: "HASH_VALUE",
+          meta: { delivered_amount: "100" },
+          tx_json: {
+            TransactionType: "Payment",
+            Fee: "10",
+            ledger_index: 1,
+            date: 1000,
+            Account: "account_addr",
+            Destination: "destination_addr",
+            Sequence: 1,
+          },
         },
-      },
-    ]);
+      ]),
+    );
 
     // When
     const account = await getAccountShape(