@ledgerhq/coin-sui 0.12.0-nightly.3 → 0.12.0

package/src/network/sdk.ts

@@ -24,7 +24,6 @@ import type {
   BlockTransaction,
   BlockOperation,
   Operation as Op,
-  Page,
   Stake,
   StakeState,
   AssetInfo,
@@ -319,7 +318,6 @@ export function transactionToOperation(
   return {
     id: encodeOperationId(accountId, hash, type),
     accountId,
-    // warning this is false:
     blockHash: hash,
     blockHeight: BLOCK_HEIGHT,
     date: getOperationDate(transaction),
@@ -349,6 +347,7 @@ export function transactionToOp(address: string, transaction: SuiTransactionBloc
       block: {
         // agreed to return bigint
         height: BigInt(transaction.checkpoint || "") as unknown as number,
+        hash,
         time: getOperationDate(transaction),
       },
     },
@@ -450,22 +449,14 @@ export const getOperations = async (
   accountId: string,
   addr: string,
   cursor?: QueryTransactionBlocksParams["cursor"],
-  order?: "asc" | "desc",
 ): Promise<Operation[]> =>
   withApi(async api => {
-    let rpcOrder: "ascending" | "descending";
-    if (order) {
-      rpcOrder = order === "asc" ? "ascending" : "descending";
-    } else {
-      rpcOrder = cursor ? "ascending" : "descending";
-    }
-
-    const sendOps = await loadOperations({
+    const sentOps = await loadOperations({
       api,
       addr,
       type: "OUT",
       cursor,
-      order: rpcOrder,
+      order: cursor ? "ascending" : "descending",
       operations: [],
     });
     const receivedOps = await loadOperations({
@@ -473,51 +464,38 @@ export const getOperations = async (
       addr,
       type: "IN",
       cursor,
-      order: rpcOrder,
+      order: cursor ? "ascending" : "descending",
       operations: [],
     });
-    // When restoring state (no cursor provided) we filter out extra operations to maintain correct chronological order
-    const rawTransactions = filterOperations(sendOps, receivedOps, rpcOrder, !cursor);
+    const rawTransactions = filterOperations(sentOps, receivedOps, cursor);
 
-    return rawTransactions.operations.map(transaction =>
-      transactionToOperation(accountId, addr, transaction),
-    );
+    return rawTransactions.map(transaction => transactionToOperation(accountId, addr, transaction));
   });
 
 export const filterOperations = (
-  sendOps: LoadOperationResponse,
-  receiveOps: LoadOperationResponse,
-  order: "ascending" | "descending",
-  shouldFilter: boolean = true,
-): LoadOperationResponse => {
-  let filterTimestamp: number = 0;
-  let nextCursor: string | null | undefined = undefined;
-  // When we've reached the limit for either sent or received operations,
+  operationList1: SuiTransactionBlockResponse[],
+  operationList2: SuiTransactionBlockResponse[],
+  cursor: string | null | undefined,
+) => {
+  let filterTimestamp = 0;
+
+  // When restoring state (no cursor provided) and we've reached the limit for either sent or received operations,
   // we filter out extra operations to maintain correct chronological order
   if (
-    shouldFilter &&
-    sendOps.operations.length &&
-    receiveOps.operations.length &&
-    (sendOps.operations.length === TRANSACTIONS_LIMIT ||
-      receiveOps.operations.length === TRANSACTIONS_LIMIT)
+    !cursor &&
+    operationList1.length &&
+    operationList2.length &&
+    (operationList1.length === TRANSACTIONS_LIMIT || operationList2.length === TRANSACTIONS_LIMIT)
   ) {
-    const sendTime = Number(sendOps.operations[sendOps.operations.length - 1].timestampMs ?? 0);
-    const receiveTime = Number(
-      receiveOps.operations[receiveOps.operations.length - 1].timestampMs ?? 0,
-    );
-    if (sendTime >= receiveTime) {
-      nextCursor = sendOps.cursor;
-      filterTimestamp = sendTime;
-    } else {
-      nextCursor = receiveOps.cursor;
-      filterTimestamp = receiveTime;
-    }
+    const aTime = operationList1[operationList1.length - 1].timestampMs ?? 0;
+    const bTime = operationList2[operationList2.length - 1].timestampMs ?? 0;
+    filterTimestamp = Math.max(Number(aTime), Number(bTime));
   }
-  const result = [...sendOps.operations, ...receiveOps.operations]
+  const result = [...operationList1, ...operationList2]
     .sort((a, b) => Number(b.timestampMs) - Number(a.timestampMs))
     .filter(op => Number(op.timestampMs) >= filterTimestamp);
 
-  return { operations: uniqBy(result, tx => tx.digest), cursor: nextCursor };
+  return uniqBy(result, tx => tx.digest);
 };
 
 /**
@@ -527,22 +505,14 @@ export const getListOperations = async (
   addr: string,
   cursor: QueryTransactionBlocksParams["cursor"] = null,
   withApiImpl: typeof withApi = withApi,
-  order?: "asc" | "desc",
-): Promise<Page<Op>> =>
+): Promise<Op[]> =>
   withApiImpl(async api => {
-    let rpcOrder: "ascending" | "descending";
-    if (order) {
-      rpcOrder = order === "asc" ? "ascending" : "descending";
-    } else {
-      rpcOrder = cursor ? "ascending" : "descending";
-    }
-
     const opsOut = await loadOperations({
       api,
       addr,
       type: "OUT",
       cursor,
-      order: rpcOrder,
+      order: cursor ? "ascending" : "descending",
       operations: [],
     });
     const opsIn = await loadOperations({
@@ -550,15 +520,12 @@ export const getListOperations = async (
       addr,
       type: "IN",
       cursor,
-      order: rpcOrder,
+      order: cursor ? "ascending" : "descending",
       operations: [],
     });
-    const list = filterOperations(opsIn, opsOut, rpcOrder, true);
+    const list = filterOperations(opsIn, opsOut, cursor);
 
-    return {
-      items: list.operations.map(t => transactionToOp(addr, t)),
-      next: list.cursor ?? undefined,
-    };
+    return list.map(t => transactionToOp(addr, t));
   });
 
 /**
@@ -748,11 +715,6 @@ export const executeTransactionBlock = async (params: ExecuteTransactionBlockPar
     return api.executeTransactionBlock(params);
   });
 
-type LoadOperationResponse = {
-  operations: SuiTransactionBlockResponse[];
-  cursor?: QueryTransactionBlocksParams["cursor"];
-};
-
 /**
  * Fetch operations for a specific address and type until the limit is reached
  */
@@ -768,10 +730,10 @@ export const loadOperations = async ({
   operations: PaginatedTransactionResponse["data"];
   order: "ascending" | "descending";
   cursor?: QueryTransactionBlocksParams["cursor"];
-}): Promise<LoadOperationResponse> => {
+}): Promise<PaginatedTransactionResponse["data"]> => {
   try {
     if (order === "descending" && operations.length >= TRANSACTIONS_LIMIT) {
-      return { operations, cursor };
+      return operations;
     }
 
     const { data, nextCursor, hasNextPage } = await queryTransactions({
@@ -782,7 +744,7 @@ export const loadOperations = async ({
 
     operations.push(...data);
     if (!hasNextPage) {
-      return { operations: operations, cursor: nextCursor };
+      return operations;
     }
 
     await loadOperations({ ...params, cursor: nextCursor, operations, order });
@@ -797,7 +759,7 @@ export const loadOperations = async ({
     }
   }
 
-  return { operations: operations, cursor: cursor };
+  return operations;
 };
 
 /**