@ledgerhq/coin-xrp 7.3.0-nightly.1 → 7.3.0-nightly.3

package/src/api/index.integ.test.ts

@@ -1,9 +1,10 @@
 import { decode } from "ripple-binary-codec";
 import { createApi } from ".";
+import { Operation } from "@ledgerhq/coin-framework/api/types";
 //import { decode, encodeForSigning } from "ripple-binary-codec";
 //import { sign } from "ripple-keypairs";
 
-describe("Xrp Api", () => {
+describe("Xrp Api (testnet)", () => {
   const SENDER = "rh1HPuRVsYYvThxG2Bs1MfjmrVC73S16Fb";
   const api = createApi({ node: "https://s.altnet.rippletest.net:51234" });
 
@@ -70,8 +71,12 @@ describe("Xrp Api", () => {
 
     it("returns operations from latest, but in asc order", async () => {
       // When
-      const [txDesc] = await api.listOperations(SENDER, { minHeight: 0, order: "desc" });
-
+      const SENDER_WITH_TRANSACTIONS = "rUxSkt6hQpWxXQwTNRUCYYRQ7BC2yRA3F8";
+      const [txDesc] = await api.listOperations(SENDER_WITH_TRANSACTIONS, {
+        minHeight: 200,
+        order: "desc",
+      });
+      expect(txDesc.length).toBeGreaterThanOrEqual(200);
       // Then
       // Check if the result is sorted in ascending order
       expect(txDesc[0].tx.block.height).toBeGreaterThanOrEqual(
@@ -96,13 +101,13 @@ describe("Xrp Api", () => {
     // Account with no transaction (at the time of this writing)
     const SENDER_WITH_NO_TRANSACTION = "rKtXXTVno77jhu6tto1MAXjepyuaKaLcqB";
 
-    it("returns an amount above 0 when address has transactions", async () => {
+    it("returns a balance", async () => {
       // When
       const result = await api.getBalance(SENDER);
 
       // Then
       expect(result[0].asset).toEqual({ type: "native" });
-      expect(result[0].value).toBeGreaterThan(BigInt(0));
+      expect(result[0].value).toBeGreaterThanOrEqual(BigInt(0));
     });
 
     it("returns 0 when address has no transaction", async () => {
@@ -176,6 +181,169 @@ describe("Xrp Api", () => {
   });
 });
 
+describe("Xrp Api (mainnet)", () => {
+  const SENDER = "rn5BQvhksnPfbo277LtFks4iyYStPKGrnJ";
+  const api = createApi({ node: "https://xrp.coin.ledger.com" });
+
+  describe("estimateFees", () => {
+    it("returns a default value", async () => {
+      // Given
+      const amount = BigInt(100);
+
+      // When
+      const result = await api.estimateFees({
+        asset: { type: "native" },
+        type: "send",
+        sender: SENDER,
+        amount,
+        recipient: "r9m6MwViR4GnUNqoGXGa8eroBrZ9FAPHFS",
+        memo: {
+          type: "map",
+          memos: new Map(),
+        },
+      });
+
+      // Then
+      expect(result.value).toEqual(BigInt(10));
+    });
+  });
+
+  describe("listOperations", () => {
+    let ops: Operation[];
+
+    beforeAll(async () => {
+      const resp = await api.listOperations(SENDER, { minHeight: 0 });
+      ops = resp[0];
+    });
+
+    it("returns operations", async () => {
+      // https://xrpscan.com/account/rn5BQvhksnPfbo277LtFks4iyYStPKGrnJ
+      expect(ops.length).toBeGreaterThanOrEqual(200);
+      const checkSet = new Set(ops.map(elt => elt.tx.hash));
+      expect(checkSet.size).toEqual(ops.length);
+      ops.forEach(operation => {
+        const isSenderOrReceipt =
+          operation.senders.includes(SENDER) || operation.recipients.includes(SENDER);
+        expect(isSenderOrReceipt).toBeTruthy();
+      });
+    });
+
+    it("returns IN operation", async () => {
+      // https://xrpscan.com/tx/805E371FDA0223E8910F831802EE93DBA1A4CA40AC8C1337F26F566CD67788F5
+      const inTx = {
+        hash: "9E5141DCAE8158E51ED612333FF3EC2D60A3D2DCD2F6DD5E4F92E4A6704C3CE9",
+        amount: 7.5,
+        recipient: SENDER,
+        sender: "rnXQmrXk9HSKdNwkut1k9dpAMVYuBsJV49",
+        type: "IN",
+        fees: 0.00001,
+      };
+      const op = ops.find(o => o.tx.hash === inTx.hash) as Operation;
+      expect(op.tx.hash).toEqual(inTx.hash);
+      expect(op.value).toEqual(BigInt(inTx.amount * 1e6));
+      expect(op.recipients).toContain(inTx.recipient);
+      expect(op.senders).toContain(inTx.sender);
+      expect(op.type).toEqual(inTx.type);
+      expect(op.tx.fees).toEqual(BigInt(inTx.fees * 1e6));
+    });
+
+    it("returns OUT operation", async () => {
+      // https://xrpscan.com/tx/8D13FD7EE0D28B615905903D033A3DC3839FBAA2F545417E3DE51A1A745C1688
+      const outTx = {
+        hash: "8D13FD7EE0D28B615905903D033A3DC3839FBAA2F545417E3DE51A1A745C1688",
+        amount: 0.1,
+        recipient: "r3XzsqzQCC6r4ZzifWnwa32sFR2H9exkew",
+        sender: SENDER,
+        type: "OUT",
+        fees: 0.00001,
+      };
+      const op = ops.find(o => o.tx.hash === outTx.hash) as Operation;
+      expect(op.tx.hash).toEqual(outTx.hash);
+      expect(op.value).toEqual(BigInt(outTx.amount * 1e6));
+      expect(op.recipients).toContain(outTx.recipient);
+      expect(op.senders).toContain(outTx.sender);
+      expect(op.type).toEqual(outTx.type);
+      expect(op.tx.fees).toEqual(BigInt(outTx.fees * 1e6));
+    });
+  });
+
+  describe("lastBlock", () => {
+    it("returns last block info", async () => {
+      const result = await api.lastBlock();
+      expect(result.hash).toBeDefined();
+      expect(result.height).toBeDefined();
+      expect(result.time).toBeInstanceOf(Date);
+    });
+  });
+
+  describe("getBalance", () => {
+    it("returns an amount", async () => {
+      const result = await api.getBalance(SENDER);
+      expect(result[0].asset).toEqual({ type: "native" });
+      expect(result[0].value).toBeGreaterThanOrEqual(BigInt(0));
+    });
+  });
+
+  describe("craftTransaction", () => {
+    const RECIPIENT = "r9m6MwViR4GnUNqoGXGa8eroBrZ9FAPHFS";
+
+    it("returns a raw transaction", async () => {
+      const result = await api.craftTransaction({
+        asset: { type: "native" },
+        type: "send",
+        sender: SENDER,
+        recipient: RECIPIENT,
+        amount: BigInt(10),
+        memo: {
+          type: "map",
+          memos: new Map([["memos", ["testdata"]]]),
+        },
+      });
+      expect(result.length).toEqual(178);
+    });
+
+    it("should use default fees when user does not provide them for crafting a transaction", async () => {
+      const result = await api.craftTransaction({
+        asset: { type: "native" },
+        type: "send",
+        sender: SENDER,
+        recipient: RECIPIENT,
+        amount: BigInt(10),
+        memo: {
+          type: "map",
+          memos: new Map(),
+        },
+      });
+
+      expect(decode(result)).toMatchObject({
+        Fee: "10",
+      });
+    });
+
+    it("should use custom user fees when user provides it for crafting a transaction", async () => {
+      const customFees = 99n;
+      const result = await api.craftTransaction(
+        {
+          asset: { type: "native" },
+          type: "send",
+          sender: SENDER,
+          recipient: RECIPIENT,
+          amount: BigInt(10),
+          memo: {
+            type: "map",
+            memos: new Map(),
+          },
+        },
+        { value: customFees },
+      );
+
+      expect(decode(result)).toMatchObject({
+        Fee: customFees.toString(),
+      });
+    });
+  });
+});
+
 // To enable this test, you need to fill an `.env` file at the root of this package. Example can be found in `.env.integ.test.example`.
 // The value hardcoded here depends on the value filled in the `.env` file.
 /*describe.skip("combine", () => {

package/src/api/index.test.ts

@@ -108,12 +108,11 @@ describe("listOperations", () => {
     mockGetTransactions.mockResolvedValue(mockNetworkTxs(txs, defaultMarker));
     const [results, _] = await api.listOperations("src", { minHeight: 0, order: "asc" });
 
-    // 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);
+    // called 1 times because the client is expected to do the pagination itself
+    expect(mockGetServerInfos).toHaveBeenCalledTimes(1);
+    expect(mockGetTransactions).toHaveBeenCalledTimes(1);
 
-    expect(results.length).toBe(txs.length * 10);
+    expect(results.length).toBe(txs.length);
   });
 
   it("should pass the token returned by previous calls", async () => {
@@ -122,11 +121,10 @@ describe("listOperations", () => {
       .mockReturnValueOnce(mockNetworkTxs(txs, defaultMarker))
       .mockReturnValueOnce(mockNetworkTxs(txs, undefined));
 
-    const [results, _] = await api.listOperations("src", { minHeight: 0, order: "asc" });
+    const [results, token] = await api.listOperations("src", { minHeight: 0, order: "asc" });
 
-    // called 2 times because the second time there is no marker
-    expect(mockGetServerInfos).toHaveBeenCalledTimes(2);
-    expect(mockGetTransactions).toHaveBeenCalledTimes(2);
+    expect(mockGetServerInfos).toHaveBeenCalledTimes(1);
+    expect(mockGetTransactions).toHaveBeenCalledTimes(1);
 
     // check tokens are passed
     const baseOptions = {
@@ -135,13 +133,14 @@ describe("listOperations", () => {
       forward: true,
     };
     expect(mockGetTransactions).toHaveBeenNthCalledWith(1, "src", baseOptions);
+    await api.listOperations("src", { minHeight: 0, order: "asc", lastPagingToken: token });
     const optionsWithToken = {
       ...baseOptions,
       marker: defaultMarker,
     };
     expect(mockGetTransactions).toHaveBeenNthCalledWith(2, "src", optionsWithToken);
 
-    expect(results.length).toBe(txs.length * 2);
+    expect(results.length).toBe(txs.length);
   });
 
   it.each([
@@ -174,12 +173,9 @@ describe("listOperations", () => {
       const [results, _] = await api.listOperations(address, { minHeight: 0, order: "asc" });
 
       // Then
-      // called twice because the marker is set the first time
-      expect(mockGetServerInfos).toHaveBeenCalledTimes(2);
-      expect(mockGetTransactions).toHaveBeenCalledTimes(2);
+      expect(mockGetServerInfos).toHaveBeenCalledTimes(1);
+      expect(mockGetTransactions).toHaveBeenCalledTimes(1);
 
-      // if expectedType is "OUT", compute value with fees (i.e. delivered_amount + 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([
         {
@@ -196,7 +192,7 @@ describe("listOperations", () => {
             },
           },
           type: expectedType,
-          value: expectedValue,
+          value: deliveredAmount,
           senders: [opSender],
           recipients: [opDestination],
           details: {
@@ -224,7 +220,7 @@ describe("listOperations", () => {
             },
           },
           type: expectedType,
-          value: expectedValue,
+          value: deliveredAmount,
           senders: [opSender],
           recipients: [opDestination],
           details: {
@@ -247,7 +243,7 @@ describe("listOperations", () => {
             },
           },
           type: expectedType,
-          value: expectedValue,
+          value: deliveredAmount,
           senders: [opSender],
           recipients: [opDestination],
           details: {

package/src/api/index.ts

@@ -27,7 +27,6 @@ import {
   MemoInput,
 } from "../logic";
 import { ListOperationsOptions, XrpMapMemo } from "../types";
-import { Order } from "../types/model";
 
 export function createApi(config: XrpConfig): Api<XrpMapMemo> {
   coinConfig.setCoinConfig(() => ({ ...config, status: { type: "active" } }));
@@ -103,76 +102,20 @@ async function estimate(): Promise<FeeEstimation> {
   return { value: estimation.fees };
 }
 
-type PaginationState = {
-  readonly pageSize: number; // must be large enough to avoid unnecessary calls to the underlying explorer
-  readonly maxIterations: number; // a security to avoid infinite loop
-  currentIteration: number;
-  readonly minHeight: number;
-  continueIterations: boolean;
-  apiNextCursor?: string;
-  accumulator: Operation[];
-};
-
-async function operationsFromHeight(
-  address: string,
-  minHeight: number,
-  order: Order = "asc",
-): Promise<[Operation[], string]> {
-  async function fetchNextPage(state: PaginationState): Promise<PaginationState> {
-    const options: ListOperationsOptions = {
-      limit: state.pageSize,
-      minHeight: state.minHeight,
-      order: order,
-    };
-    if (state.apiNextCursor) {
-      options.token = state.apiNextCursor;
-    }
-    const [operations, apiNextCursor] = await listOperations(address, options);
-    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 ?? ""];
-}
-
 // NOTE: double check
 async function operations(address: string, pagination: Pagination): Promise<[Operation[], string]> {
   const { minHeight, lastPagingToken, order } = pagination;
-  if (minHeight) {
-    return await operationsFromHeight(address, minHeight, order);
-  }
-  const isInitSync = lastPagingToken === "";
-
-  const newPagination = {
-    minHeight: isInitSync ? 0 : parseInt(lastPagingToken || "0", 10),
+  const options: ListOperationsOptions = {
+    limit: 200,
+    minHeight: minHeight,
+    order: order ?? "asc",
   };
-  // TODO token must be implemented properly (waiting ack from the design document)
-  return await operationsFromHeight(address, newPagination.minHeight, order);
+  if (lastPagingToken) {
+    const token = lastPagingToken.split("-");
+    options.token = JSON.stringify({ ledger: Number(token[0]), seq: Number(token[1]) });
+    log(options.token);
+  }
+  const [operations, apiNextCursor] = await listOperations(address, options);
+  const next = apiNextCursor ? JSON.parse(apiNextCursor) : null;
+  return [operations, next ? next.ledger + "-" + next.seq : ""];
 }

package/src/logic/listOperations.test.ts

@@ -215,9 +215,7 @@ describe("listOperations", () => {
       // Then
       expect(mockGetServerInfos).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 + fees);
+      const expectedValue = BigInt(deliveredAmount);
       expect(results).toEqual([
         {
           id: "HASH_VALUE",

package/src/logic/listOperations.ts

@@ -120,17 +120,12 @@ const convertToCoreOperation =
     } = operation;
 
     const type = Account === address ? "OUT" : "IN";
-    let value =
+    const value =
       delivered_amount && typeof delivered_amount === "string"
         ? BigInt(delivered_amount)
         : BigInt(0);
 
     const fees = BigInt(Fee);
-    if (type === "OUT") {
-      if (!Number.isNaN(fees)) {
-        value = value + fees;
-      }
-    }
 
     const toEpochDate = (RIPPLE_EPOCH + date) * 1000;