@ledgerhq/coin-xrp 7.23.4 → 7.24.0

package/src/api/index.test.ts

@@ -135,13 +135,14 @@ describe('listOperations', () => {
     fee: bigint,
     sender: string,
     transactionType: NonPaymentTransactionType = 'OfferCreate',
-    destination?: string
+    destination?: string,
+    affectedNodes?: unknown[]
   ): unknown {
     return {
       ledger_hash: 'HASH_VALUE_BLOCK',
       hash: 'NON_PAYMENT_HASH',
       close_time_iso: '2000-01-01T00:00:01Z',
-      meta: { TransactionResult: 'tesSUCCESS' },
+      meta: { TransactionResult: 'tesSUCCESS', AffectedNodes: affectedNodes },
       tx_json: {
         TransactionType: transactionType,
         Fee: fee.toString(),
@@ -198,12 +199,27 @@ describe('listOperations', () => {
     expect(results).toHaveLength(0)
   })
 
-  it('should return non-Payment tx when queried address is recipient', async () => {
+  it('should return non-Payment tx when queried address receives XRP via AffectedNodes', async () => {
     const fee = BigInt(10)
     const address = 'recipient_address'
     const sender = 'sender_address'
+    // AccountDelete sends the remaining balance to the Destination.
+    // The recipient's AccountRoot is modified in AffectedNodes.
+    const affectedNodes = [
+      {
+        ModifiedNode: {
+          LedgerEntryType: 'AccountRoot',
+          LedgerIndex: 'ABC123',
+          FinalFields: { Account: address, Balance: '50000000' },
+          PreviousFields: { Balance: '10000000' },
+        },
+      },
+    ]
     mockGetTransactions.mockResolvedValue(
-      mockNetworkTxs([givenNonPaymentTx(fee, sender, 'AccountDelete', address)], undefined)
+      mockNetworkTxs(
+        [givenNonPaymentTx(fee, sender, 'AccountDelete', address, affectedNodes)],
+        undefined
+      )
     )
 
     const { items: results } = await api.listOperations(address, { minHeight: 0, order: 'asc' })
@@ -212,7 +228,7 @@ describe('listOperations', () => {
     expect(results[0]).toMatchObject<Partial<Operation>>({
       id: 'NON_PAYMENT_HASH',
       type: 'IN',
-      value: BigInt(0),
+      value: BigInt(40000000),
       senders: [sender],
       recipients: [address],
       tx: expect.objectContaining({

package/src/api/listOperations.test.ts

@@ -227,17 +227,225 @@ describe('listOperations', () => {
     })
   })
 
-  it('should exclude non-Payment txs sent by other accounts from FEES operations', async () => {
-    // Given — offerCreateTx has Account: "sender", but we query "other_address"
+  it('should exclude non-Payment txs that do not affect the queried address', async () => {
+    // Given — offerCreateTx has Account: "sender", no AffectedNodes for "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
+    // Then — not fee payer, no AffectedNodes balance change → nothing returned
     expect(results).toHaveLength(0)
   })
 
+  it('should emit an IN operation when a DEX trade fills an offer and the queried address receives XRP', async () => {
+    // Given — Account A creates an OfferCreate that fills an offer by "receiver".
+    // "receiver" gets 5000000 drops of XRP through the DEX match.
+    const dexFillTx = {
+      ledger_hash: 'HASH_VALUE_BLOCK',
+      hash: 'DEX_FILL_HASH',
+      validated: true,
+      close_time_iso: '2000-01-01T00:00:01Z',
+      meta: {
+        TransactionResult: 'tesSUCCESS',
+        AffectedNodes: [
+          {
+            ModifiedNode: {
+              LedgerEntryType: 'AccountRoot',
+              LedgerIndex: 'ABC123',
+              FinalFields: { Account: 'receiver', Balance: '15000000' },
+              PreviousFields: { Balance: '10000000' },
+            },
+          },
+          {
+            ModifiedNode: {
+              LedgerEntryType: 'AccountRoot',
+              LedgerIndex: 'DEF456',
+              FinalFields: { Account: 'trader', Balance: '4999988' },
+              PreviousFields: { Balance: '10000000' },
+            },
+          },
+        ],
+      },
+      tx_json: {
+        TransactionType: 'OfferCreate',
+        Fee: '12',
+        ledger_index: 2,
+        date: 1000,
+        Account: 'trader',
+        Sequence: 3,
+        SigningPubKey: 'DEADBEEF',
+      },
+    }
+    mockNetworkGetTransactions.mockResolvedValue(mockNetworkTxs([dexFillTx]))
+
+    // When — query as "receiver" (the address whose offer got filled)
+    const [results] = await listOperations('receiver', { minHeight: 0, order: 'asc' })
+
+    // Then — receiver gets an IN operation for 5000000 drops
+    expect(results).toHaveLength(1)
+    expect(results[0]).toMatchObject({
+      id: 'DEX_FILL_HASH',
+      type: 'IN',
+      value: BigInt(5000000),
+      asset: { type: 'native' },
+      tx: expect.objectContaining({
+        hash: 'DEX_FILL_HASH',
+        fees: BigInt(12),
+        feesPayer: 'trader',
+        failed: false,
+      }),
+    })
+  })
+
+  it('should emit an OUT operation when sender spends XRP through a DEX trade beyond fees', async () => {
+    // Given — sender's OfferCreate spends 5000000 drops XRP + 12 drops fee through the DEX
+    const dexSpendTx = {
+      ledger_hash: 'HASH_VALUE_BLOCK',
+      hash: 'DEX_SPEND_HASH',
+      validated: true,
+      close_time_iso: '2000-01-01T00:00:01Z',
+      meta: {
+        TransactionResult: 'tesSUCCESS',
+        AffectedNodes: [
+          {
+            ModifiedNode: {
+              LedgerEntryType: 'AccountRoot',
+              LedgerIndex: 'ABC123',
+              FinalFields: { Account: 'sender', Balance: '4999988' },
+              PreviousFields: { Balance: '10000000' },
+            },
+          },
+        ],
+      },
+      tx_json: {
+        TransactionType: 'OfferCreate',
+        Fee: '12',
+        ledger_index: 2,
+        date: 1000,
+        Account: 'sender',
+        Sequence: 4,
+        SigningPubKey: 'DEADBEEF',
+      },
+    }
+    mockNetworkGetTransactions.mockResolvedValue(mockNetworkTxs([dexSpendTx]))
+
+    // When
+    const [results] = await listOperations('sender', { minHeight: 0, order: 'asc' })
+
+    // Then — sender gets an OUT operation for 5000000 drops (fee excluded)
+    expect(results).toHaveLength(1)
+    expect(results[0]).toMatchObject({
+      id: 'DEX_SPEND_HASH',
+      type: 'OUT',
+      // diff = 4999988 - 10000000 = -5000012, adjustedDiff = -5000012 + 12 = -5000000
+      value: BigInt(5000000),
+      tx: expect.objectContaining({
+        fees: BigInt(12),
+        feesPayer: 'sender',
+      }),
+    })
+  })
+
+  it('should emit an IN operation when a non-Payment tx creates a new account (CreatedNode)', async () => {
+    // Given — a non-Payment tx (e.g. EscrowFinish) creates a new account with an initial balance
+    const escrowFinishTx = {
+      ledger_hash: 'HASH_VALUE_BLOCK',
+      hash: 'ESCROW_HASH',
+      validated: true,
+      close_time_iso: '2000-01-01T00:00:01Z',
+      meta: {
+        TransactionResult: 'tesSUCCESS',
+        AffectedNodes: [
+          {
+            CreatedNode: {
+              LedgerEntryType: 'AccountRoot',
+              LedgerIndex: 'ABC123',
+              NewFields: { Account: 'new_account', Balance: '50000000' },
+            },
+          },
+        ],
+      },
+      tx_json: {
+        TransactionType: 'EscrowFinish',
+        Fee: '12',
+        ledger_index: 2,
+        date: 1000,
+        Account: 'escrow_sender',
+        Destination: 'new_account',
+        Sequence: 5,
+        SigningPubKey: 'DEADBEEF',
+      },
+    }
+    mockNetworkGetTransactions.mockResolvedValue(mockNetworkTxs([escrowFinishTx]))
+
+    // When — query as the newly created account
+    const [results] = await listOperations('new_account', { minHeight: 0, order: 'asc' })
+
+    // Then — new account gets an IN operation for its initial balance
+    expect(results).toHaveLength(1)
+    expect(results[0]).toMatchObject({
+      id: 'ESCROW_HASH',
+      type: 'IN',
+      value: BigInt(50000000),
+      senders: ['escrow_sender'],
+      recipients: ['new_account'],
+    })
+  })
+
+  it('should emit an OUT operation when AccountDelete sender account is deleted (DeletedNode)', async () => {
+    // Given — sender deletes their account, remaining balance goes to destination.
+    // The sender's AccountRoot appears as a DeletedNode with FinalFields.Balance.
+    const accountDeleteTx = {
+      ledger_hash: 'HASH_VALUE_BLOCK',
+      hash: 'ACCT_DELETE_HASH',
+      validated: true,
+      close_time_iso: '2000-01-01T00:00:01Z',
+      meta: {
+        TransactionResult: 'tesSUCCESS',
+        AffectedNodes: [
+          {
+            DeletedNode: {
+              LedgerEntryType: 'AccountRoot',
+              LedgerIndex: 'ABC123',
+              FinalFields: { Account: 'deleted_sender', Balance: '30000000' },
+            },
+          },
+        ],
+      },
+      tx_json: {
+        TransactionType: 'AccountDelete',
+        Fee: '2000000',
+        ledger_index: 2,
+        date: 1000,
+        Account: 'deleted_sender',
+        Destination: 'receiver',
+        Sequence: 10,
+        SigningPubKey: 'DEADBEEF',
+      },
+    }
+    mockNetworkGetTransactions.mockResolvedValue(mockNetworkTxs([accountDeleteTx]))
+
+    // When — query as the deleted sender
+    const [results] = await listOperations('deleted_sender', { minHeight: 0, order: 'asc' })
+
+    // Then — sender gets an OUT operation for the remaining balance sent to destination.
+    // FinalFields.Balance = 30000000 (post-fee). diff = -(30000000 + 2000000) = -32000000.
+    // adjustedDiff = -32000000 + 2000000 = -30000000 → OUT with value 30000000.
+    expect(results).toHaveLength(1)
+    expect(results[0]).toMatchObject({
+      id: 'ACCT_DELETE_HASH',
+      type: 'OUT',
+      value: BigInt(30000000),
+      senders: ['deleted_sender'],
+      recipients: ['receiver'],
+      tx: expect.objectContaining({
+        fees: BigInt(2000000),
+        feesPayer: 'deleted_sender',
+      }),
+    })
+  })
+
   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]))

package/src/api/listOperations.ts

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: © 2024 LEDGER SAS
 // SPDX-License-Identifier: Apache-2.0
 
-import type { XrplOperation } from '../network/types'
+import type { AffectedNode, XrplOperation } from '../network/types'
 import { Operation } from '@ledgerhq/coin-module-framework/api/types'
 import { getServerInfos, getTransactions, GetTransactionsOptions } from '../network'
 import { ListOperationsOptions, XrpMemo } from '../types'
@@ -66,27 +66,21 @@ export async function listOperations(
   /**
    * 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)
+   * - Non-Payment transactions (balance changes extracted from AffectedNodes metadata)
    *
    * tx_type node RPC filter is unreliable (see LIVE-16705), so we filter client-side.
    */
   async function getAccountTransactions(
     address: string,
     opts: GetTransactionsOptions
-  ): Promise<[boolean, GetTransactionsOptions, XrplOperation[], XrplOperation[], XrplOperation[]]> {
+  ): Promise<[boolean, GetTransactionsOptions, XrplOperation[], XrplOperation[]]> {
     const response = await getTransactions(address, opts)
     const txs = response.transactions
     const responseMarker = response.marker
 
     const paymentTxs = txs.filter((tx) => tx.tx_json.TransactionType === 'Payment')
-    // 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
-    )
-    // Non-Payment transactions received by this account: the account received XRP but did not pay fees.
-    const receivedTxs = txs.filter(
-      (tx) => tx.tx_json.TransactionType !== 'Payment' && tx.tx_json.Destination === address
-    )
+    // Non-Payment transactions — filtered for balance impact later by convertNonPaymentToCoreOperation
+    const nonPaymentTxs = txs.filter((tx) => tx.tx_json.TransactionType !== 'Payment')
 
     const shortage = (opts.limit && txs.length < opts.limit) || false
     const { marker: _marker, ...restOpts } = opts
@@ -96,36 +90,37 @@ export async function listOperations(
       nextOpts.marker = responseMarker
       if (nextOpts.limit) nextOpts.limit -= paymentTxs.length
     }
-    return [shortage, nextOpts, paymentTxs, feeOnlyTxs, receivedTxs]
+    return [shortage, nextOpts, paymentTxs, nonPaymentTxs]
   }
 
-  let [txShortage, nextOptions, transactions, feeOnlyTxs, receivedTxs] =
-    await getAccountTransactions(address, options)
+  let [txShortage, nextOptions, transactions, nonPaymentTxs] = 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, newFeeOnlyTxs, newReceivedTxs] =
+    const [newTxShortage, newNextOptions, newTransactions, newNonPaymentTxs] =
       await getAccountTransactions(address, nextOptions)
     txShortage = newTxShortage
     nextOptions = newNextOptions
     transactions = transactions.concat(newTransactions)
-    feeOnlyTxs = feeOnlyTxs.concat(newFeeOnlyTxs)
-    receivedTxs = receivedTxs.concat(newReceivedTxs)
+    nonPaymentTxs = nonPaymentTxs.concat(newNonPaymentTxs)
   }
 
   // the order is reversed so that the results are always sorted by newest tx first element of the list
   if (order === 'asc') {
     transactions.reverse()
-    feeOnlyTxs.reverse()
-    receivedTxs.reverse()
+    nonPaymentTxs.reverse()
   }
 
   // the next index to start the pagination from
   const next = nextOptions.marker ? JSON.stringify(nextOptions.marker) : ''
   const paymentOps = transactions.map(convertToCoreOperation(address))
-  const feeOps = feeOnlyTxs.map(convertFeeToCoreOperation)
-  const receivedOps = receivedTxs.map(convertToCoreOperation(address))
-  return [[...paymentOps, ...feeOps, ...receivedOps], next]
+  const nonPaymentOps = nonPaymentTxs
+    .map(convertNonPaymentToCoreOperation(address))
+    .filter((op): op is Operation => op !== null)
+  return [[...paymentOps, ...nonPaymentOps], next]
 }
 
 const convertToCoreOperation =
@@ -230,27 +225,106 @@ const convertToCoreOperation =
   }
 
 /**
- * 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.
+ * Finds the XRP (native) balance change for a specific address in a transaction's AffectedNodes.
+ * Returns the balance diff in drops, or null if the address's AccountRoot was not affected.
+ *
+ * For ModifiedNode: diff = FinalFields.Balance - PreviousFields.Balance (includes fee deduction).
+ * For CreatedNode: diff = NewFields.Balance (initial funding amount).
+ * For DeletedNode: diff = -(FinalFields.Balance + fee). FinalFields.Balance is the post-fee balance
+ *   remaining when the account was deleted. We add the fee back so the caller's fee adjustment
+ *   (adjustedDiff = diff + fee) yields the correct transfer amount.
  */
-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: {
+function findXrpBalanceDiff(
+  address: string,
+  affectedNodes: AffectedNode[],
+  fee: bigint
+): bigint | null {
+  for (const node of affectedNodes) {
+    if ('ModifiedNode' in node) {
+      const data = node.ModifiedNode
+      if (
+        data.LedgerEntryType === 'AccountRoot' &&
+        data.FinalFields?.Account === address &&
+        typeof data.FinalFields?.Balance === 'string' &&
+        typeof data.PreviousFields?.Balance === 'string'
+      ) {
+        return (
+          BigInt(data.FinalFields.Balance as string) - BigInt(data.PreviousFields.Balance as string)
+        )
+      }
+    } else if ('CreatedNode' in node) {
+      const data = node.CreatedNode
+      if (
+        data.LedgerEntryType === 'AccountRoot' &&
+        data.NewFields?.Account === address &&
+        typeof data.NewFields?.Balance === 'string'
+      ) {
+        return BigInt(data.NewFields.Balance as string)
+      }
+    } else if ('DeletedNode' in node) {
+      const data = node.DeletedNode
+      // AccountDelete: the sender's AccountRoot is deleted. FinalFields.Balance is the post-fee balance
+      // (the fee was already deducted before deletion). We return -(Balance + fee) so that the caller's
+      // fee adjustment (diff + fee) yields the correct transfer amount (= FinalFields.Balance).
+      if (
+        data.LedgerEntryType === 'AccountRoot' &&
+        data.FinalFields?.Account === address &&
+        typeof data.FinalFields?.Balance === 'string'
+      ) {
+        const balance = BigInt(data.FinalFields.Balance as string)
+        // Include the fee in the diff so the caller's adjustedDiff = (-balance - fee) + fee = -balance
+        return -(balance + fee)
+      }
+    }
+  }
+  return null
+}
+
+/**
+ * Converts a non-Payment transaction into an Operation by inspecting AffectedNodes metadata
+ * to determine the actual XRP balance change for the queried address.
+ *
+ * This handles DEX trades (OfferCreate), TrustSet, AccountSet, etc. where the queried address
+ * may gain or lose XRP through offer matching — not just pay fees.
+ *
+ * Returns null if the transaction does not affect the address's XRP balance and the address
+ * is not the fee payer.
+ */
+const convertNonPaymentToCoreOperation =
+  (address: string) =>
+  (operation: XrplOperation): Operation | null => {
+    const {
+      ledger_hash,
       hash,
-      fees: BigInt(Fee),
+      close_time_iso,
+      meta: { AffectedNodes, TransactionResult },
+      tx_json: {
+        TransactionType,
+        Fee,
+        date,
+        Account,
+        Destination,
+        ledger_index,
+        Sequence,
+        SigningPubKey,
+      },
+    } = operation
+
+    const fee = BigInt(Fee)
+    const toEpochDate = (RIPPLE_EPOCH + date) * 1000
+    const failed = TransactionResult !== 'tesSUCCESS'
+    const isFeePayer = Account === address
+
+    // Extract actual XRP balance change from ledger metadata
+    const diff = findXrpBalanceDiff(address, AffectedNodes ?? [], fee)
+
+    // The ledger diff already includes the fee deduction, so add the fee back to isolate the transfer amount.
+    // Example: sender trades 5 XRP + 12 drops fee → diff = -5000012, adjustedDiff = -5000012 + 12 = -5000000
+    const adjustedDiff = diff !== null && isFeePayer ? diff + fee : diff
+
+    const baseTx = {
+      hash,
+      fees: fee,
       feesPayer: Account,
       date: new Date(toEpochDate),
       block: {
@@ -259,15 +333,45 @@ const convertFeeToCoreOperation = (operation: XrplOperation): Operation => {
         height: ledger_index,
       },
       failed,
-    },
-    type: 'FEES',
-    value: BigInt(0),
-    senders: [Account],
-    recipients: [],
-    details: {
+    }
+
+    const details = {
       xrpTxType: TransactionType,
       sequence: Sequence,
       signingPubKey: SigningPubKey,
-    },
+    }
+
+    // Non-zero transfer amount: emit IN or OUT operation
+    if (adjustedDiff !== null && adjustedDiff !== BigInt(0)) {
+      const type = adjustedDiff > BigInt(0) ? 'IN' : 'OUT'
+      const value = adjustedDiff > BigInt(0) ? adjustedDiff : -adjustedDiff
+
+      return {
+        id: hash,
+        asset: { type: 'native' },
+        tx: baseTx,
+        type,
+        value,
+        senders: [Account],
+        recipients: Destination ? [Destination] : [],
+        details,
+      }
+    }
+
+    // No transfer beyond fees — only emit FEES for the fee payer
+    if (isFeePayer) {
+      return {
+        id: hash,
+        asset: { type: 'native' },
+        tx: baseTx,
+        type: 'FEES',
+        value: BigInt(0),
+        senders: [Account],
+        recipients: [],
+        details,
+      }
+    }
+
+    // Not fee payer, no XRP balance change — skip
+    return null
   }
-}