@ledgerhq/coin-xrp 0.7.1 → 0.8.0-next.0

package/src/logic/listOperations.ts

@@ -11,42 +11,89 @@ import { RIPPLE_EPOCH } from "./utils";
  */
 export async function listOperations(
   address: string,
-  blockHeight: number,
-): Promise<XrpOperation[]> {
+  {
+    limit,
+    mostRecentIndex,
+    startAt,
+  }: {
+    limit?: number;
+    mostRecentIndex?: number | undefined;
+    startAt?: number;
+  },
+): Promise<[XrpOperation[], number]> {
   const serverInfo = await getServerInfos();
   const ledgers = serverInfo.info.complete_ledgers.split("-");
   const minLedgerVersion = Number(ledgers[0]);
   const maxLedgerVersion = Number(ledgers[1]);
 
-  // if there is no ops, it might be after a clear and we prefer to pull from the oldest possible history
-  const startAt = Math.max(blockHeight, minLedgerVersion);
+  let options: {
+    ledger_index_min?: number;
+    ledger_index_max?: number;
+    limit?: number;
+    tx_type?: string;
+  } = {
+    ledger_index_max: mostRecentIndex ?? maxLedgerVersion,
+    tx_type: "Payment",
+  };
+
+  if (limit) {
+    options = {
+      ...options,
+      limit,
+    };
+  }
+  if (startAt) {
+    options = {
+      ...options,
+      // if there is no ops, it might be after a clear and we prefer to pull from the oldest possible history
+      ledger_index_min: Math.max(startAt, minLedgerVersion),
+    };
+  }
 
-  const transactions = await getTransactions(address, {
-    ledger_index_min: startAt,
-    ledger_index_max: maxLedgerVersion,
-  });
+  // We need to filter out the transactions that are not "Payment" type because the filter on "tx_type" of the node RPC
+  // is not working as expected. It returns all the transactions. We need to call the node RPC multiple times to get the
+  // desired number of transactions by the limiter.
+  let transactions: XrplOperation[] = [];
+  let needToStop = true;
+  do {
+    const newTransactions = await getTransactions(address, options);
+    const newPaymentsTxs = newTransactions.filter(tx => tx.tx_json.TransactionType === "Payment");
+    if (options.limit) {
+      needToStop = newTransactions.length < options.limit;
+      options.ledger_index_max = newTransactions.slice(-1)[0].tx_json.ledger_index - 1;
+    }
+    transactions = transactions.concat(newPaymentsTxs);
+  } while (
+    options.limit &&
+    !needToStop &&
+    transactions.length < options.limit &&
+    (options.limit -= transactions.length)
+  );
 
-  return transactions
-    .filter(op => op.tx.TransactionType === "Payment")
-    .map(convertToCoreOperation(address));
+  return [
+    transactions.map(convertToCoreOperation(address)),
+    transactions.slice(-1)[0].tx_json.ledger_index - 1, // Returns the next index to start from for pagination
+  ];
 }
 
 const convertToCoreOperation =
   (address: string) =>
   (operation: XrplOperation): XrpOperation => {
     const {
+      ledger_hash,
+      hash,
+      close_time_iso,
       meta: { delivered_amount },
-      tx: {
+      tx_json: {
         TransactionType,
         Fee,
-        hash,
-        inLedger,
         date,
         Account,
         Destination,
         DestinationTag,
         Sequence,
         Memos,
+        ledger_index,
       },
     } = operation;
 
@@ -90,13 +137,15 @@ const convertToCoreOperation =
     }
 
     let op: XrpOperation = {
+      blockTime: new Date(close_time_iso),
+      blockHash: ledger_hash,
       hash,
       address,
       type: TransactionType,
       simpleType: type,
       value,
       fee,
-      blockHeight: inLedger,
+      blockHeight: ledger_index,
       senders: [Account],
       recipients: [Destination],
       date: new Date(toEpochDate),

package/src/network/index.ts

@@ -68,12 +68,12 @@ export const getServerInfos = async (): Promise<ServerInfoResponse> => {
 
 export const getTransactions = async (
   address: string,
-  options: { ledger_index_min?: number; ledger_index_max?: number } | undefined,
+  options: { ledger_index_min?: number; ledger_index_max?: number; limit?: number } | undefined,
 ): Promise<XrplOperation[]> => {
   const result = await rpcCall<AccountTxResponse>("account_tx", {
     account: address,
-    ledger_index: "validated",
     ...options,
+    api_version: 2,
   });
 
   return result.transactions;
@@ -109,7 +109,7 @@ async function rpcCall<T extends object>(
   });
 
   if (isResponseStatus(result) && result.status !== "success") {
-    throw new Error(`couldn't fetch ${method} with params ${params}`);
+    throw new Error(`couldn't fetch ${method} with params ${JSON.stringify(params)}`);
   }
 
   return result;

package/src/network/types.ts

@@ -1,4 +1,7 @@
 export type XrplOperation = {
+  ledger_hash: string;
+  hash: string;
+  close_time_iso: string;
   meta: {
     AffectedNodes: {
       ModifiedNode: {
@@ -22,7 +25,7 @@ export type XrplOperation = {
     TransactionResult: string;
     delivered_amount: string;
   };
-  tx: {
+  tx_json: {
     Account: string;
     Amount: string;
     DeliverMax: string;
@@ -44,8 +47,6 @@ export type XrplOperation = {
     TransactionType: string;
     TxnSignature: string;
     date: number;
-    hash: string;
-    inLedger: number;
     ledger_index: number;
   };
   validated: boolean;

package/src/types/model.ts

@@ -11,6 +11,8 @@ export type XrpMemo = {
   type?: string;
 };
 export type XrpOperation = {
+  blockTime: Date;
+  blockHash: string;
   hash: string;
   address: string;
   type: string;