@ledgerhq/coin-xrp 7.3.0-nightly.2 → 7.3.0

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

@@ -1,10 +1,9 @@
 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 (testnet)", () => {
+describe("Xrp Api", () => {
   const SENDER = "rh1HPuRVsYYvThxG2Bs1MfjmrVC73S16Fb";
   const api = createApi({ node: "https://s.altnet.rippletest.net:51234" });
 
@@ -34,7 +33,7 @@ describe("Xrp Api (testnet)", () => {
   describe("listOperations", () => {
     it.skip("returns a list regarding address parameter", async () => {
       // When
-      const [tx, _] = await api.listOperations(SENDER, { minHeight: 200, order: "asc" });
+      const [tx, _] = await api.listOperations(SENDER, { minHeight: 200 });
 
       // https://blockexplorer.one/xrp/testnet/address/rh1HPuRVsYYvThxG2Bs1MfjmrVC73S16Fb
       // as of 2025-03-18, the address has 287 transactions
@@ -52,10 +51,7 @@ describe("Xrp Api (testnet)", () => {
       const SENDER_WITH_TRANSACTIONS = "rUxSkt6hQpWxXQwTNRUCYYRQ7BC2yRA3F8";
 
       // When
-      const [ops, _] = await api.listOperations(SENDER_WITH_TRANSACTIONS, {
-        minHeight: 0,
-        order: "asc",
-      });
+      const [ops, _] = await api.listOperations(SENDER_WITH_TRANSACTIONS, { minHeight: 0 });
       // Then
       const checkSet = new Set(ops.map(elt => elt.tx.hash));
       expect(checkSet.size).toEqual(ops.length);
@@ -68,17 +64,6 @@ describe("Xrp Api (testnet)", () => {
       // so here we are checking that this limit is bypassed
       expect(ops.length).toBeGreaterThan(200);
     });
-
-    it("returns operations from latest, but in asc order", async () => {
-      // When
-      const [txDesc] = await api.listOperations(SENDER, { minHeight: 0, order: "desc" });
-
-      // Then
-      // Check if the result is sorted in ascending order
-      expect(txDesc[0].tx.block.height).toBeGreaterThanOrEqual(
-        txDesc[txDesc.length - 1].tx.block.height,
-      );
-    });
   });
 
   describe("lastBlock", () => {
@@ -97,13 +82,13 @@ describe("Xrp Api (testnet)", () => {
     // Account with no transaction (at the time of this writing)
     const SENDER_WITH_NO_TRANSACTION = "rKtXXTVno77jhu6tto1MAXjepyuaKaLcqB";
 
-    it("returns a balance", async () => {
+    it("returns an amount above 0 when address has transactions", async () => {
       // When
       const result = await api.getBalance(SENDER);
 
       // Then
       expect(result[0].asset).toEqual({ type: "native" });
-      expect(result[0].value).toBeGreaterThanOrEqual(BigInt(0));
+      expect(result[0].value).toBeGreaterThan(BigInt(0));
     });
 
     it("returns 0 when address has no transaction", async () => {
@@ -177,170 +162,6 @@ describe("Xrp Api (testnet)", () => {
   });
 });
 
-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
-      // as of 2025-08-29, the address has 398 transactions, 1 op per tx
-      expect(ops.length).toBeGreaterThanOrEqual(398);
-      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/8116AC2E4C6FE35C7C2AADA1FE88C32E1FFD0DA8D348855BAC3903B7153F1EFF
-      const inTx = {
-        hash: "8116AC2E4C6FE35C7C2AADA1FE88C32E1FFD0DA8D348855BAC3903B7153F1EFF",
-        amount: 6.713757,
-        recipient: SENDER,
-        sender: "r9m6MwViR4GnUNqoGXGa8eroBrZ9FAPHFS",
-        type: "IN",
-        fees: 0.000012,
-      };
-      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/F9B0E5CC0A303C6099AFCE3C1DD9D8D80034F8C33041BF1E792C8236D2DF3F79
-      const outTx = {
-        hash: "F9B0E5CC0A303C6099AFCE3C1DD9D8D80034F8C33041BF1E792C8236D2DF3F79",
-        amount: 7.8,
-        recipient: "r9m6MwViR4GnUNqoGXGa8eroBrZ9FAPHFS",
-        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

@@ -106,7 +106,7 @@ describe("listOperations", () => {
     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, order: "asc" });
+    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 ...)
@@ -122,7 +122,7 @@ describe("listOperations", () => {
       .mockReturnValueOnce(mockNetworkTxs(txs, defaultMarker))
       .mockReturnValueOnce(mockNetworkTxs(txs, undefined));
 
-    const [results, _] = await api.listOperations("src", { minHeight: 0, order: "asc" });
+    const [results, _] = await api.listOperations("src", { minHeight: 0 });
 
     // called 2 times because the second time there is no marker
     expect(mockGetServerInfos).toHaveBeenCalledTimes(2);
@@ -171,13 +171,15 @@ describe("listOperations", () => {
       mockGetTransactions.mockResolvedValue(mockNetworkTxs([], undefined));
 
       // When
-      const [results, _] = await api.listOperations(address, { minHeight: 0, order: "asc" });
+      const [results, _] = await api.listOperations(address, { minHeight: 0 });
 
       // Then
       // 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" ? 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([
         {
@@ -194,7 +196,7 @@ describe("listOperations", () => {
             },
           },
           type: expectedType,
-          value: deliveredAmount,
+          value: expectedValue,
           senders: [opSender],
           recipients: [opDestination],
           details: {
@@ -222,7 +224,7 @@ describe("listOperations", () => {
             },
           },
           type: expectedType,
-          value: deliveredAmount,
+          value: expectedValue,
           senders: [opSender],
           recipients: [opDestination],
           details: {
@@ -245,7 +247,7 @@ describe("listOperations", () => {
             },
           },
           type: expectedType,
-          value: deliveredAmount,
+          value: expectedValue,
           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" } }));
@@ -116,13 +115,12 @@ type PaginationState = {
 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,
+      order: "asc",
     };
     if (state.apiNextCursor) {
       options.token = state.apiNextCursor;
@@ -164,9 +162,9 @@ async function operationsFromHeight(
 
 // NOTE: double check
 async function operations(address: string, pagination: Pagination): Promise<[Operation[], string]> {
-  const { minHeight, lastPagingToken, order } = pagination;
+  const { minHeight, lastPagingToken } = pagination;
   if (minHeight) {
-    return await operationsFromHeight(address, minHeight, order);
+    return await operationsFromHeight(address, minHeight);
   }
   const isInitSync = lastPagingToken === "";
 
@@ -174,5 +172,5 @@ async function operations(address: string, pagination: Pagination): Promise<[Ope
     minHeight: isInitSync ? 0 : parseInt(lastPagingToken || "0", 10),
   };
   // TODO token must be implemented properly (waiting ack from the design document)
-  return await operationsFromHeight(address, newPagination.minHeight, order);
+  return await operationsFromHeight(address, newPagination.minHeight);
 }

package/src/logic/listOperations.test.ts

@@ -41,7 +41,7 @@ describe("listOperations", () => {
     // Given
     mockNetworkGetTransactions.mockResolvedValue(mockNetworkTxs([]));
     // When
-    const [results, token] = await listOperations("any address", { minHeight: 0, order: "asc" });
+    const [results, token] = await listOperations("any address", { minHeight: 0 });
     // Then
     expect(mockGetServerInfos).toHaveBeenCalledTimes(1);
     expect(mockNetworkGetTransactions).toHaveBeenCalledTimes(1);
@@ -215,7 +215,9 @@ describe("listOperations", () => {
       // Then
       expect(mockGetServerInfos).toHaveBeenCalledTimes(1);
       expect(mockNetworkGetTransactions).toHaveBeenCalledTimes(1);
-      const expectedValue = BigInt(deliveredAmount);
+      // if expectedType is "OUT", compute value with fees (i.e. delivered_amount + Fee)
+      const expectedValue =
+        expectedType === "IN" ? BigInt(deliveredAmount) : BigInt(deliveredAmount + fees);
       expect(results).toEqual([
         {
           id: "HASH_VALUE",

package/src/logic/listOperations.ts

@@ -120,12 +120,17 @@ const convertToCoreOperation =
     } = operation;
 
     const type = Account === address ? "OUT" : "IN";
-    const value =
+    let 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;
 

package/src/types/model.ts

@@ -21,7 +21,7 @@ export type XrpMemoValueMap = {
 };
 export type XrpMapMemo = TypedMapMemo<XrpMemoValueMap>;
 
-export type Order = "asc" | "desc";
+type Order = "asc" | "desc";
 
 export type ListOperationsOptions = {
   // pagination: