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

package/src/logic/listOperations.test.ts

@@ -1,6 +1,7 @@
 import { assert } from "console";
 import { listOperations } from "./listOperations";
 import { RIPPLE_EPOCH } from "./utils";
+import { Marker } from "../network/types";
 
 const maxHeight = 2;
 const minHeight = 1;
@@ -9,45 +10,60 @@ const mockGetServerInfos = jest.fn().mockResolvedValue({
     complete_ledgers: `${minHeight}-${maxHeight}`,
   },
 });
-const mockGetTransactions = jest.fn();
+const mockNetworkGetTransactions = jest.fn();
 jest.mock("../network", () => ({
   getServerInfos: () => mockGetServerInfos(),
-  getTransactions: () => mockGetTransactions(),
+  getTransactions: () => mockNetworkGetTransactions(),
 }));
 
 describe("listOperations", () => {
   afterEach(() => {
     mockGetServerInfos.mockClear();
-    mockGetTransactions.mockClear();
+    mockNetworkGetTransactions.mockClear();
   });
 
+  const someMarker: Marker = { 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("when there are no transactions then the result is empty", async () => {
     // Given
-    mockGetTransactions.mockResolvedValue([]);
+    mockNetworkGetTransactions.mockResolvedValue(mockNetworkTxs([]));
     // When
     const [results, token] = await listOperations("any address", { minHeight: 0 });
     // Then
     expect(mockGetServerInfos).toHaveBeenCalledTimes(1);
-    expect(mockGetTransactions).toHaveBeenCalledTimes(1);
+    expect(mockNetworkGetTransactions).toHaveBeenCalledTimes(1);
     expect(results).toEqual([]);
-    expect(token).toEqual(minHeight);
+    expect(JSON.parse(token)).toEqual(someMarker);
   });
 
   it("when there are no transactions and a limit then the result is empty", async () => {
     // Given
-    mockGetTransactions.mockResolvedValue([]);
+    mockNetworkGetTransactions.mockResolvedValue(mockNetworkTxs([]));
     // When
     const [results, token] = await listOperations("any address", { minHeight: 0, limit: 1 });
     // Then
     expect(mockGetServerInfos).toHaveBeenCalledTimes(1);
-    expect(mockGetTransactions).toHaveBeenCalledTimes(1);
+    expect(mockNetworkGetTransactions).toHaveBeenCalledTimes(1);
     expect(results).toEqual([]);
-    expect(token).toEqual(minHeight);
+    expect(JSON.parse(token)).toEqual(someMarker);
   });
 
   const paymentTx = {
     ledger_hash: "HASH_VALUE_BLOCK",
     hash: "HASH_VALUE",
+    validated: true,
     close_time_iso: "2000-01-01T00:00:01Z",
     meta: { delivered_amount: "100" },
     tx_json: {
@@ -65,8 +81,9 @@ describe("listOperations", () => {
   it("should only list operations of type payment", async () => {
     // Given
     const lastTransaction = paymentTx;
-    mockGetTransactions.mockResolvedValueOnce([paymentTx, otherTx, lastTransaction]);
-    mockGetTransactions.mockResolvedValue([]); // subsequent calls
+    const txs = [paymentTx, otherTx, lastTransaction];
+    mockNetworkGetTransactions.mockResolvedValueOnce(mockNetworkTxs(txs));
+    mockNetworkGetTransactions.mockResolvedValue(mockNetworkTxs([])); // subsequent calls
 
     // When
     const [results, token] = await listOperations("any address", { minHeight: 0, limit: 3 });
@@ -74,39 +91,39 @@ describe("listOperations", () => {
     // Then
     expect(mockGetServerInfos).toHaveBeenCalledTimes(1);
     // it's called twice because first call yields only 2 transactions, and 3 are asked
-    expect(mockGetTransactions).toHaveBeenCalledTimes(2);
+    expect(mockNetworkGetTransactions).toHaveBeenCalledTimes(2);
     expect(results.length).toEqual(2);
-    expect(token).toEqual(lastTransaction.tx_json.ledger_index - 1);
+    expect(JSON.parse(token)).toEqual(someMarker);
   });
 
   it("should make enough calls so that the limit requested is satified", async () => {
-    const lastTransaction = otherTx;
     const txs = [paymentTx, paymentTx, otherTx, otherTx, otherTx, otherTx, otherTx, otherTx];
     assert(txs.length === 8);
-    mockGetTransactions.mockResolvedValue(txs);
+    mockNetworkGetTransactions.mockResolvedValue(mockNetworkTxs(txs));
 
     const [results, token] = await listOperations("any address", { minHeight: 0, limit: 8 });
 
     expect(mockGetServerInfos).toHaveBeenCalledTimes(1);
     // it's called 4 times because each call yields only 2 transactions, and 8 are asked
-    expect(mockGetTransactions).toHaveBeenCalledTimes(4);
+    expect(mockNetworkGetTransactions).toHaveBeenCalledTimes(4);
     expect(results.length).toEqual(8);
-    expect(token).toEqual(lastTransaction.tx_json.ledger_index - 1);
+    expect(JSON.parse(token)).toEqual(someMarker);
   });
 
   it("should make enough calls, even if there is not enough txs to satisfy the limit", async () => {
-    mockGetTransactions.mockResolvedValueOnce([otherTx, otherTx, otherTx, otherTx]);
-    mockGetTransactions.mockResolvedValueOnce([paymentTx, paymentTx]);
-    mockGetTransactions.mockResolvedValue([]); // subsequent calls
-    const lastTransaction = paymentTx;
+    mockNetworkGetTransactions.mockResolvedValueOnce(
+      mockNetworkTxs([otherTx, otherTx, otherTx, otherTx]),
+    );
+    mockNetworkGetTransactions.mockResolvedValueOnce(mockNetworkTxs([paymentTx, paymentTx]));
+    mockNetworkGetTransactions.mockResolvedValue([]); // subsequent calls
 
     const [results, token] = await listOperations("any address", { minHeight: 0, limit: 4 });
 
     expect(mockGetServerInfos).toHaveBeenCalledTimes(1);
     // it's called 2 times because the second call is a shortage of txs
-    expect(mockGetTransactions).toHaveBeenCalledTimes(2);
+    expect(mockNetworkGetTransactions).toHaveBeenCalledTimes(2);
     expect(results.length).toEqual(2);
-    expect(token).toEqual(lastTransaction.tx_json.ledger_index - 1);
+    expect(JSON.parse(token)).toEqual(someMarker);
   });
 
   it.each([
@@ -128,69 +145,71 @@ describe("listOperations", () => {
       // Given
       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,
+      mockNetworkGetTransactions.mockResolvedValue(
+        mockNetworkTxs([
+          {
+            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,
+              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",
+          {
+            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,
+              ],
+              Sequence: 1,
+            },
           },
-        },
-      ]);
+        ]),
+      );
 
       // When
-      const [results, _] = await listOperations(address, { minHeight: 0 });
+      const [results, _] = await listOperations(address, { minHeight: 0, order: "asc" });
 
       // Then
       expect(mockGetServerInfos).toHaveBeenCalledTimes(1);
-      expect(mockGetTransactions).toHaveBeenCalledTimes(1);
+      expect(mockNetworkGetTransactions).toHaveBeenCalledTimes(1);
       // if expectedType is "OUT", compute value with fees (i.e. delivered_amount + Fee)
       const expectedValue =
         expectedType === "IN" ? BigInt(deliveredAmount) : BigInt(deliveredAmount + fee);
@@ -209,6 +228,14 @@ describe("listOperations", () => {
           recipients: [opDestination],
           date: new Date(1000000 + RIPPLE_EPOCH * 1000),
           transactionSequenceNumber: 1,
+          details: {
+            memos: [
+              {
+                type: "687474703a2f2f6578616d706c652e636f6d2f6d656d6f2f67656e65726963",
+                data: "72656e74",
+              },
+            ],
+          },
         },
         {
           hash: "HASH_VALUE",
@@ -242,14 +269,6 @@ describe("listOperations", () => {
           recipients: [opDestination],
           date: new Date(1000000 + RIPPLE_EPOCH * 1000),
           transactionSequenceNumber: 1,
-          details: {
-            memos: [
-              {
-                type: "687474703a2f2f6578616d706c652e636f6d2f6d656d6f2f67656e65726963",
-                data: "72656e74",
-              },
-            ],
-          },
         },
       ]);
     },

package/src/logic/listOperations.ts

@@ -1,41 +1,50 @@
-import { getServerInfos, getTransactions } from "../network";
+import { getServerInfos, getTransactions, GetTransactionsOptions } from "../network";
 import type { XrplOperation } from "../network/types";
 import { XrpMemo, XrpOperation } from "../types";
 import { RIPPLE_EPOCH } from "./utils";
 
+type Order = "asc" | "desc";
 /**
  * Returns list of "Payment" Operations associated to an account.
  * @param address Account address
- * @param blockHeight Height to start searching for operations
- * @returns
+ * @param minHeight retrieve operations from a specific block height until top most (inclusive)
+ *  if not provided, it will start from the oldest possible history.
+ * The result is not guaranteed to contain all operations until top height (it depends of the underlying explorer),
+ * so you might need to call this function multiple times to get all operations.
+ * @param order whether to return operations from the top block or from the oldest block
+ *   it defaults to "desc" (newest first)
+ *   it doesn't control the order of the operations in the result list.
+ *   this parameter is added as a workaround for the issue LIVE-16705
+ * @returns a list of operations is descending order and a token to be used for pagination
  */
 export async function listOperations(
   address: string,
   {
     limit,
-    maxHeight,
     minHeight,
+    token,
+    order,
   }: {
+    // pagination:
     limit?: number;
-    maxHeight?: number | undefined; // used for pagination
-    minHeight?: number; // used to retrieve operations from a specific block height until top most
+    token?: string;
+    order?: Order;
+    // filters:
+    minHeight?: number;
   },
-): Promise<[XrpOperation[], number]> {
+): Promise<[XrpOperation[], string]> {
   const serverInfo = await getServerInfos();
   const ledgers = serverInfo.info.complete_ledgers.split("-");
   const minLedgerVersion = Number(ledgers[0]);
-  const maxLedgerVersion = Number(ledgers[1]);
 
-  type Options = {
-    ledger_index_min?: number;
-    ledger_index_max?: number;
-    limit?: number;
-    tx_type?: string;
-  };
+  // by default the explorer queries the transactions in descending order (newest first)
+  let forward = false;
+  if (order && order === "asc") {
+    forward = true;
+  }
 
-  let options: Options = {
-    ledger_index_max: maxHeight ?? maxLedgerVersion,
-    tx_type: "Payment",
+  let options: GetTransactionsOptions = {
+    forward: forward,
   };
 
   if (limit) {
@@ -44,7 +53,15 @@ export async function listOperations(
       limit,
     };
   }
-  if (minHeight) {
+
+  if (token) {
+    options = {
+      ...options,
+      marker: JSON.parse(token),
+    };
+  }
+
+  if (minHeight !== undefined) {
     options = {
       ...options,
       // if there is no ops, it might be after a clear and we prefer to pull from the oldest possible history
@@ -54,25 +71,22 @@ export async function listOperations(
 
   async function getPaymentTransactions(
     address: string,
-    options: Options,
-  ): Promise<[boolean, Options, XrplOperation[]]> {
-    const txs = await getTransactions(address, options);
+    options: GetTransactionsOptions,
+  ): Promise<[boolean, GetTransactionsOptions, XrplOperation[]]> {
+    const response = await getTransactions(address, options);
+    const txs = response.transactions;
+    const marker = response.marker;
     // Filter out the transactions that are not "Payment" type because the filter on "tx_type" of the node RPC is not working as expected.
     const paymentTxs = txs.filter(tx => tx.tx_json.TransactionType === "Payment");
     const shortage = (options.limit && txs.length < options.limit) || false;
-    const lastTransaction = txs.slice(-1)[0];
     const nextOptions = { ...options };
-    if (lastTransaction) {
-      nextOptions.ledger_index_max = lastTransaction.tx_json.ledger_index - 1;
+    if (marker) {
+      nextOptions.marker = marker;
       if (nextOptions.limit) nextOptions.limit -= paymentTxs.length;
     }
     return [shortage, nextOptions, paymentTxs];
   }
 
-  // TODO BUG: given the number of txs belonging to the SAME block > limit
-  //           when user loop over pages using the provided token
-  //           then user misses some txs that doesn't fit the page size limit
-  //           because the "next token" is a block height (solution is to use an opaque token instead)
   let [txShortage, nextOptions, transactions] = await getPaymentTransactions(address, options);
   const isEnough = () => txShortage || (limit && transactions.length >= limit);
   // We need to call the node RPC multiple times to get the desired number of transactions by the limiter.
@@ -86,13 +100,12 @@ export async function listOperations(
     transactions = transactions.concat(newTransactions);
   }
 
-  const lastTransaction = transactions.slice(-1)[0];
-  // the next index to start the pagination from
-  const nextIndex = lastTransaction
-    ? Math.max(lastTransaction.tx_json.ledger_index - 1, minLedgerVersion)
-    : minLedgerVersion;
+  // the order is reversed so that the results are always sorted by newest tx first element of the list
+  if (order === "asc") transactions.reverse();
 
-  return [transactions.map(convertToCoreOperation(address)), nextIndex];
+  // the next index to start the pagination from
+  const next = nextOptions.marker ? JSON.stringify(nextOptions.marker) : "";
+  return [transactions.map(convertToCoreOperation(address)), next];
 }
 
 const convertToCoreOperation =

package/src/network/index.ts

@@ -4,13 +4,13 @@ import type { AccountInfo } from "../types/model";
 import {
   isErrorResponse,
   isResponseStatus,
+  Marker,
   type AccountInfoResponse,
   type AccountTxResponse,
   type ErrorResponse,
   type LedgerResponse,
   type ServerInfoResponse,
   type SubmitReponse,
-  type XrplOperation,
 } from "./types";
 
 const getNodeUrl = () => coinConfig.getCoinConfig().node;
@@ -66,19 +66,32 @@ export const getServerInfos = async (): Promise<ServerInfoResponse> => {
   return rpcCall<ServerInfoResponse>("server_info", { ledger_index: "validated" });
 };
 
+// https://xrpl.org/docs/references/http-websocket-apis/public-api-methods/account-methods/account_tx
+export type GetTransactionsOptions = {
+  ledger_index_min?: number;
+  ledger_index_max?: number;
+  limit?: number;
+  marker?: Marker;
+  // this property controls the order of the transactions
+  // true: oldest first
+  // false: newest first
+  forward: boolean;
+};
+
 export const getTransactions = async (
   address: string,
-  options: { ledger_index_min?: number; ledger_index_max?: number; limit?: number } | undefined,
-): Promise<XrplOperation[]> => {
+  options: GetTransactionsOptions | undefined,
+): Promise<AccountTxResponse> => {
   const result = await rpcCall<AccountTxResponse>("account_tx", {
     account: address,
-    // newest first
-    // note that order within the results is not guaranteed (see documentation of account_tx)
-    forward: false,
+    // this property controls the order of the transactions
+    // looks like there is a bug in LL (https://ledgerhq.atlassian.net/browse/LIVE-16705)
+    // so we need to set it to false (newest first) to get the transactions in the right order
+    // for lama-adapter we need to set it to true (oldest first)
     ...options,
     api_version: 2,
   });
-  return result.transactions;
+  return result;
 };
 
 export async function getLedger(): Promise<LedgerResponse> {
@@ -93,7 +106,7 @@ export async function getLedgerIndex(): Promise<number> {
 
 async function rpcCall<T extends object>(
   method: string,
-  params: Record<string, string | number | boolean> = {},
+  params: Record<string, unknown> = {},
 ): Promise<T> {
   const {
     data: { result },

package/src/network/types.ts

@@ -168,6 +168,11 @@ export type ServerInfoResponse = {
   };
 } & ResponseStatus;
 
+export type Marker = {
+  ledger: number;
+  seq: number;
+};
+
 export type AccountTxResponse = {
   account: string;
   ledger_index_max: number;
@@ -175,6 +180,7 @@ export type AccountTxResponse = {
   limit: number;
   transactions: XrplOperation[];
   validated: boolean;
+  marker?: Marker;
 } & ResponseStatus;
 
 export type LedgerResponse = {

package/tsconfig.json

@@ -3,7 +3,6 @@
   "compilerOptions": {
     "declaration": true,
     "declarationMap": true,
-    "module": "commonjs",
     "downlevelIteration": true,
     "lib": ["es2020", "dom"],
     "outDir": "lib",