fix(xrp listoperations): 🐛 add fees operation for transactions that are not payment

Author: qperrot

.changeset/flat-eagles-applaud.md

@@ -0,0 +1,5 @@
+---
+"@ledgerhq/coin-xrp": minor
+---
+
+Fix: listOperations output is missing some token related transactions

libs/coin-modules/coin-xrp/src/api/index.integ.test.ts

@@ -218,6 +218,7 @@ describe("Xrp Api (testnet)", () => {
 
 describe("Xrp Api (mainnet)", () => {
   const SENDER = "rn5BQvhksnPfbo277LtFks4iyYStPKGrnJ";
+  const SENDER_WITH_FEES = "r4aYLkMk2yzULLpLfXtJyznFPnHKZozKip";
   const api = createApi({ node: "https://xrp.coin.ledger.com" });
 
   describe("estimateFees", () => {
@@ -307,6 +308,29 @@ describe("Xrp Api (mainnet)", () => {
       expect(op.type).toEqual(outTx.type);
       expect(op.tx.fees).toEqual(BigInt(outTx.fees * 1e6));
     });
+
+    it("returns FEES operation", async () => {
+      const resp = await api.listOperations(SENDER_WITH_FEES, { minHeight: 0 });
+      const feesOps = resp.items;
+
+      // https://xrpscan.com/tx/BEA8B9E4D2A8351417E862D41C8BE1F0013DEFBF6A8893771FE6991E6B20E19C
+      const outTx = {
+        hash: "BEA8B9E4D2A8351417E862D41C8BE1F0013DEFBF6A8893771FE6991E6B20E19C",
+        amount: 0,
+        recipient: [],
+        sender: SENDER_WITH_FEES,
+        type: "FEES",
+        fees: 0.00001,
+      };
+      const op = feesOps.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).toEqual([]);
+      expect(op.senders).toContain(outTx.sender);
+      expect(op.type).toEqual(outTx.type);
+      expect(op.tx.fees).toEqual(BigInt(outTx.fees * 1e6));
+    });
   });
 
   describe("lastBlock", () => {

libs/coin-modules/coin-xrp/src/api/index.test.ts

@@ -123,6 +123,71 @@ describe("listOperations", () => {
     ];
   }
 
+  function givenNonPaymentTx(
+    fee: bigint,
+    sender: string,
+    transactionType = "OfferCreate",
+  ): unknown {
+    return {
+      ledger_hash: "HASH_VALUE_BLOCK",
+      hash: "NON_PAYMENT_HASH",
+      close_time_iso: "2000-01-01T00:00:01Z",
+      meta: { TransactionResult: "tesSUCCESS" },
+      tx_json: {
+        TransactionType: transactionType,
+        Fee: fee.toString(),
+        ledger_index: 1,
+        date: 1000,
+        Account: sender,
+        Sequence: 42,
+        SigningPubKey: "PUBKEY",
+      },
+    };
+  }
+
+  it("should return a FEES operation for a non-Payment tx sent by the queried address", async () => {
+    const fee = BigInt(10);
+    const address = "sender_address";
+    mockGetTransactions.mockResolvedValue(
+      mockNetworkTxs([givenNonPaymentTx(fee, address)], undefined),
+    );
+
+    const { items: results } = await api.listOperations(address, { minHeight: 0, order: "asc" });
+
+    expect(results).toHaveLength(1);
+    expect(results[0]).toMatchObject<Partial<Operation>>({
+      id: "NON_PAYMENT_HASH",
+      type: "FEES",
+      value: BigInt(0),
+      senders: [address],
+      recipients: [],
+      tx: expect.objectContaining({
+        hash: "NON_PAYMENT_HASH",
+        fees: fee,
+        failed: false,
+      }),
+      details: {
+        xrpTxType: "OfferCreate",
+        sequence: 42,
+        signingPubKey: "PUBKEY",
+      },
+    });
+  });
+
+  it("should not return FEES operation for non-Payment tx sent by another address", async () => {
+    const fee = BigInt(10);
+    mockGetTransactions.mockResolvedValue(
+      mockNetworkTxs([givenNonPaymentTx(fee, "other_address")], undefined),
+    );
+
+    const { items: results } = await api.listOperations("queried_address", {
+      minHeight: 0,
+      order: "asc",
+    });
+
+    expect(results).toHaveLength(0);
+  });
+
   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

libs/coin-modules/coin-xrp/src/logic/listOperations.test.ts

@@ -81,8 +81,27 @@ describe("listOperations", () => {
       SigningPubKey: "DEADBEEF",
     },
   };
+  // Non-Payment tx whose Account does NOT match the queried address ("any address")
   const otherTx = { ...paymentTx, tx_json: { ...paymentTx.tx_json, TransactionType: "Other" } };
 
+  // Non-Payment tx sent by "sender" — used to verify FEES operation generation
+  const offerCreateTx = {
+    ledger_hash: "HASH_VALUE_BLOCK",
+    hash: "OFFER_HASH",
+    validated: true,
+    close_time_iso: "2000-01-01T00:00:01Z",
+    meta: { TransactionResult: "tesSUCCESS" },
+    tx_json: {
+      TransactionType: "OfferCreate",
+      Fee: "5",
+      ledger_index: 2,
+      date: 1000,
+      Account: "sender",
+      Sequence: 2,
+      SigningPubKey: "DEADBEEF",
+    },
+  };
+
   it("should only list operations of type payment", async () => {
     // Given
     const lastTransaction = paymentTx;
@@ -171,6 +190,84 @@ describe("listOperations", () => {
     expect(JSON.parse(token)).toEqual(someMarker);
   });
 
+  it("should include a FEES operation for a non-Payment tx sent by the queried address", async () => {
+    // Given
+    mockNetworkGetTransactions.mockResolvedValue(mockNetworkTxs([offerCreateTx]));
+
+    // When
+    const [results] = await listOperations("sender", { minHeight: 0, order: "asc" });
+
+    // Then
+    expect(results).toHaveLength(1);
+    expect(results[0]).toMatchObject<Partial<Operation>>({
+      id: "OFFER_HASH",
+      type: "FEES",
+      value: BigInt(0),
+      senders: ["sender"],
+      recipients: [],
+      tx: expect.objectContaining({
+        hash: "OFFER_HASH",
+        fees: BigInt(5),
+        failed: false,
+        block: {
+          hash: "HASH_VALUE_BLOCK",
+          height: 2,
+          time: new Date("2000-01-01T00:00:01Z"),
+        },
+      }),
+      details: {
+        xrpTxType: "OfferCreate",
+        sequence: 2,
+        signingPubKey: "DEADBEEF",
+      },
+    });
+  });
+
+  it("should exclude non-Payment txs sent by other accounts from FEES operations", async () => {
+    // Given — offerCreateTx has Account: "sender", but we query "other_address"
+    mockNetworkGetTransactions.mockResolvedValue(mockNetworkTxs([offerCreateTx]));
+
+    // When
+    const [results] = await listOperations("other_address", { minHeight: 0, order: "asc" });
+
+    // Then — no Payment and no matching Account, so nothing returned
+    expect(results).toHaveLength(0);
+  });
+
+  it("should return both Payment ops and FEES ops when txs contain both types", async () => {
+    // Given — paymentTx (Payment from "sender") + offerCreateTx (OfferCreate from "sender")
+    mockNetworkGetTransactions.mockResolvedValue(mockNetworkTxs([paymentTx, offerCreateTx]));
+
+    // When — query as "sender" to match both
+    const [results] = await listOperations("sender", { minHeight: 0, order: "asc" });
+
+    // Then
+    expect(results).toHaveLength(2);
+    expect(results.some(op => op.type === "OUT")).toBe(true);
+    expect(results.some(op => op.type === "FEES")).toBe(true);
+  });
+
+  it("should mark a failed non-Payment tx as a failed FEES operation", async () => {
+    // Given
+    const failedOfferTx = {
+      ...offerCreateTx,
+      hash: "FAILED_OFFER_HASH",
+      meta: { TransactionResult: "tecINSUF_RESERVE_OFFER" },
+    };
+    mockNetworkGetTransactions.mockResolvedValue(mockNetworkTxs([failedOfferTx]));
+
+    // When
+    const [results] = await listOperations("sender", { minHeight: 0, order: "asc" });
+
+    // Then
+    expect(results).toHaveLength(1);
+    expect(results[0]).toMatchObject({
+      id: "FAILED_OFFER_HASH",
+      type: "FEES",
+      tx: expect.objectContaining({ failed: true }),
+    });
+  });
+
   it.each([
     {
       address: "WHATEVER_ADDRESS",

libs/coin-modules/coin-xrp/src/logic/listOperations.ts

@@ -60,44 +60,64 @@ export async function listOperations(
     };
   }
 
-  async function getPaymentTransactions(
+  /**
+   * Fetches one page of account_tx and splits results into:
+   * - Payment transactions (OUT/IN)
+   * - Non-Payment transactions sent by this account (fee-only, no XRP transferred)
+   *
+   * tx_type node RPC filter is unreliable (see LIVE-16705), so we filter client-side.
+   */
+  async function getAccountTransactions(
     address: string,
-    options: GetTransactionsOptions,
-  ): Promise<[boolean, GetTransactionsOptions, XrplOperation[]]> {
-    const response = await getTransactions(address, options);
+    opts: GetTransactionsOptions,
+  ): Promise<[boolean, GetTransactionsOptions, XrplOperation[], XrplOperation[]]> {
+    const response = await getTransactions(address, opts);
     const txs = response.transactions;
     const responseMarker = 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 { marker, ...nextOptions } = options;
+    // Non-Payment transactions sent by this account: the account paid fees but transferred no XRP.
+    const feeOnlyTxs = txs.filter(
+      tx => tx.tx_json.TransactionType !== "Payment" && tx.tx_json.Account === address,
+    );
+
+    const shortage = (opts.limit && txs.length < opts.limit) || false;
+    const { marker: _marker, ...restOpts } = opts;
+    const nextOpts: GetTransactionsOptions = { ...restOpts };
 
     if (responseMarker) {
-      (nextOptions as GetTransactionsOptions).marker = responseMarker;
-      if (nextOptions.limit) nextOptions.limit -= paymentTxs.length;
+      nextOpts.marker = responseMarker;
+      if (nextOpts.limit) nextOpts.limit -= paymentTxs.length;
     }
-    return [shortage, nextOptions, paymentTxs];
+    return [shortage, nextOpts, paymentTxs, feeOnlyTxs];
   }
 
-  let [txShortage, nextOptions, transactions] = await getPaymentTransactions(address, options);
+  let [txShortage, nextOptions, transactions, feeOnlyTxs] = await getAccountTransactions(
+    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.
   while (nextOptions.limit && !isEnough()) {
-    const [newTxShortage, newNextOptions, newTransactions] = await getPaymentTransactions(
-      address,
-      nextOptions,
-    );
+    const [newTxShortage, newNextOptions, newTransactions, newFeeOnlyTxs] =
+      await getAccountTransactions(address, nextOptions);
     txShortage = newTxShortage;
     nextOptions = newNextOptions;
     transactions = transactions.concat(newTransactions);
+    feeOnlyTxs = feeOnlyTxs.concat(newFeeOnlyTxs);
   }
 
   // the order is reversed so that the results are always sorted by newest tx first element of the list
-  if (order === "asc") transactions.reverse();
+  if (order === "asc") {
+    transactions.reverse();
+    feeOnlyTxs.reverse();
+  }
 
   // the next index to start the pagination from
   const next = nextOptions.marker ? JSON.stringify(nextOptions.marker) : "";
-  return [transactions.map(convertToCoreOperation(address)), next];
+  const paymentOps = transactions.map(convertToCoreOperation(address));
+  const feeOps = feeOnlyTxs.map(convertFeeToCoreOperation);
+  return [[...paymentOps, ...feeOps], next];
 }
 
 const convertToCoreOperation =
@@ -198,3 +218,45 @@ const convertToCoreOperation =
 
     return op;
   };
+
+/**
+ * Converts a non-Payment transaction sent by this account into a FEES-type Operation.
+ * These transactions (OfferCreate, OfferCancel, TrustSet, AccountSet, etc.) do not
+ * transfer XRP to a recipient — they only consume the network fee paid by the sender.
+ */
+const convertFeeToCoreOperation = (operation: XrplOperation): Operation => {
+  const {
+    ledger_hash,
+    hash,
+    close_time_iso,
+    tx_json: { TransactionType, Fee, date, Account, ledger_index, Sequence, SigningPubKey },
+  } = operation;
+
+  const toEpochDate = (RIPPLE_EPOCH + date) * 1000;
+  const failed = operation.meta.TransactionResult !== "tesSUCCESS";
+
+  return {
+    id: hash,
+    asset: { type: "native" },
+    tx: {
+      hash,
+      fees: BigInt(Fee),
+      date: new Date(toEpochDate),
+      block: {
+        time: new Date(close_time_iso),
+        hash: ledger_hash,
+        height: ledger_index,
+      },
+      failed,
+    },
+    type: "FEES",
+    value: BigInt(0),
+    senders: [Account],
+    recipients: [],
+    details: {
+      xrpTxType: TransactionType,
+      sequence: Sequence,
+      signingPubKey: SigningPubKey,
+    },
+  };
+};