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

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" });
 
@@ -33,7 +34,7 @@ describe("Xrp Api", () => {
   describe("listOperations", () => {
     it.skip("returns a list regarding address parameter", async () => {
       // When
-      const [tx, _] = await api.listOperations(SENDER, { minHeight: 200 });
+      const [tx, _] = await api.listOperations(SENDER, { minHeight: 200, order: "asc" });
 
       // https://blockexplorer.one/xrp/testnet/address/rh1HPuRVsYYvThxG2Bs1MfjmrVC73S16Fb
       // as of 2025-03-18, the address has 287 transactions
@@ -51,7 +52,10 @@ describe("Xrp Api", () => {
       const SENDER_WITH_TRANSACTIONS = "rUxSkt6hQpWxXQwTNRUCYYRQ7BC2yRA3F8";
 
       // When
-      const [ops, _] = await api.listOperations(SENDER_WITH_TRANSACTIONS, { minHeight: 0 });
+      const [ops, _] = await api.listOperations(SENDER_WITH_TRANSACTIONS, {
+        minHeight: 0,
+        order: "asc",
+      });
       // Then
       const checkSet = new Set(ops.map(elt => elt.tx.hash));
       expect(checkSet.size).toEqual(ops.length);
@@ -64,6 +68,17 @@ describe("Xrp Api", () => {
       // 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", () => {
@@ -82,13 +97,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 () => {
@@ -162,6 +177,170 @@ 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
+      // 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 });
+    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 ...)
@@ -122,7 +122,7 @@ describe("listOperations", () => {
       .mockReturnValueOnce(mockNetworkTxs(txs, defaultMarker))
       .mockReturnValueOnce(mockNetworkTxs(txs, undefined));
 
-    const [results, _] = await api.listOperations("src", { minHeight: 0 });
+    const [results, _] = await api.listOperations("src", { minHeight: 0, order: "asc" });
 
     // called 2 times because the second time there is no marker
     expect(mockGetServerInfos).toHaveBeenCalledTimes(2);
@@ -171,15 +171,13 @@ describe("listOperations", () => {
       mockGetTransactions.mockResolvedValue(mockNetworkTxs([], undefined));
 
       // When
-      const [results, _] = await api.listOperations(address, { minHeight: 0 });
+      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);
 
-      // 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 +194,7 @@ describe("listOperations", () => {
             },
           },
           type: expectedType,
-          value: expectedValue,
+          value: deliveredAmount,
           senders: [opSender],
           recipients: [opDestination],
           details: {
@@ -224,7 +222,7 @@ describe("listOperations", () => {
             },
           },
           type: expectedType,
-          value: expectedValue,
+          value: deliveredAmount,
           senders: [opSender],
           recipients: [opDestination],
           details: {
@@ -247,7 +245,7 @@ describe("listOperations", () => {
             },
           },
           type: expectedType,
-          value: expectedValue,
+          value: deliveredAmount,
           senders: [opSender],
           recipients: [opDestination],
           details: {

package/src/api/index.ts

@@ -27,6 +27,7 @@ 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" } }));
@@ -115,12 +116,13 @@ 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: "asc",
+      order: order,
     };
     if (state.apiNextCursor) {
       options.token = state.apiNextCursor;
@@ -162,9 +164,9 @@ async function operationsFromHeight(
 
 // NOTE: double check
 async function operations(address: string, pagination: Pagination): Promise<[Operation[], string]> {
-  const { minHeight, lastPagingToken } = pagination;
+  const { minHeight, lastPagingToken, order } = pagination;
   if (minHeight) {
-    return await operationsFromHeight(address, minHeight);
+    return await operationsFromHeight(address, minHeight, order);
   }
   const isInitSync = lastPagingToken === "";
 
@@ -172,5 +174,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);
+  return await operationsFromHeight(address, newPagination.minHeight, order);
 }

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 });
+    const [results, token] = await listOperations("any address", { minHeight: 0, order: "asc" });
     // Then
     expect(mockGetServerInfos).toHaveBeenCalledTimes(1);
     expect(mockNetworkGetTransactions).toHaveBeenCalledTimes(1);
@@ -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;
 

package/src/types/model.ts

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