@ledgerhq/coin-sui 0.12.0 → 0.13.0-nightly.1

package/src/network/sdk.test.ts

@@ -490,6 +490,7 @@ describe("SDK Functions", () => {
     expect(operation.asset).toEqual({ type: "token", assetReference: "0x123::test::TOKEN" });
     expect(operation.memo).toBeUndefined();
     expect(operation.details).toBeUndefined();
+    expect(operation.tx.block.hash).toBeUndefined();
     expect(operation.tx).toMatchObject({
       hash: "DhKLpX5kwuKuyRa71RGqpX5EY2M8Efw535ZVXYXsRiDt",
       block: {},
@@ -991,6 +992,7 @@ describe("Staking Operations", () => {
       expect(operation.recipients).toEqual([]);
       expect(operation.value).toEqual(1000000000n); // The function returns minus of the balance change
       expect(operation.asset).toEqual({ type: "native" });
+      expect(operation.tx.block.hash).toBeUndefined();
     });
 
     test("transactionToOp should map unstaking transaction correctly", () => {
@@ -1041,6 +1043,7 @@ describe("Staking Operations", () => {
       expect(operation.recipients).toEqual([]);
       expect(operation.value).toEqual(0n);
       expect(operation.asset).toEqual({ type: "native" });
+      expect(operation.tx.block.hash).toBeUndefined();
     });
   });
 
@@ -1124,8 +1127,8 @@ describe("loadOperations", () => {
       operations: [],
     });
 
-    expect(result).toHaveLength(pageSize + 1);
-    expect(result.map(tx => tx.digest)).toEqual([
+    expect(result.operations).toHaveLength(pageSize + 1);
+    expect(result.operations.map(tx => tx.digest)).toEqual([
       ...firstPage.map(tx => tx.digest),
       `tx${pageSize + 1}`,
     ]);
@@ -1151,7 +1154,7 @@ describe("loadOperations", () => {
       operations: [],
     });
 
-    expect(result).toHaveLength(sdk.TRANSACTIONS_LIMIT_PER_QUERY - 1);
+    expect(result.operations).toHaveLength(sdk.TRANSACTIONS_LIMIT_PER_QUERY - 1);
     expect(mockApi.queryTransactionBlocks).toHaveBeenCalledTimes(1);
   });
 
@@ -1178,7 +1181,7 @@ describe("loadOperations", () => {
       operations: [],
     });
 
-    expect(result).toHaveLength(sdk.TRANSACTIONS_LIMIT);
+    expect(result.operations).toHaveLength(sdk.TRANSACTIONS_LIMIT);
     expect(mockApi.queryTransactionBlocks).toHaveBeenCalledTimes(expectedCalls);
   });
 
@@ -1209,7 +1212,7 @@ describe("loadOperations", () => {
     );
 
     // Result should be empty array (no retry, just return operations)
-    expect(result).toHaveLength(0);
+    expect(result.operations).toHaveLength(0);
   });
 
   it("should should not retry after unexpected errors and return empty data", async () => {
@@ -1223,7 +1226,7 @@ describe("loadOperations", () => {
       operations: [],
     });
 
-    expect(result).toEqual([]);
+    expect(result.operations).toEqual([]);
     expect(mockApi.queryTransactionBlocks).toHaveBeenCalledTimes(1);
   });
 });
@@ -1306,17 +1309,23 @@ describe("getOperations filtering logic", () => {
     // Mock loadOperations to return different data based on operation type
     mockLoadOperations.mockImplementation(async ({ type, ..._params }) => {
       if (type === "OUT") {
-        return [
-          createMockTransaction("sent1", "1000", mockAddr, []),
-          createMockTransaction("sent2", "2000", mockAddr, []),
-        ];
+        return {
+          operations: [
+            createMockTransaction("sent1", "1000", mockAddr, []),
+            createMockTransaction("sent2", "2000", mockAddr, []),
+          ],
+          cursor: null,
+        };
       } else if (type === "IN") {
-        return [
-          createMockTransaction("received1", "1500", otherAddr, [mockAddr]),
-          createMockTransaction("received2", "2500", otherAddr, [mockAddr]),
-        ];
+        return {
+          operations: [
+            createMockTransaction("received1", "1500", otherAddr, [mockAddr]),
+            createMockTransaction("received2", "2500", otherAddr, [mockAddr]),
+          ],
+          cursor: null,
+        };
       }
-      return [];
+      return { operations: [], cursor: null };
     });
   });
 
@@ -1346,16 +1355,22 @@ describe("getOperations filtering logic", () => {
     // Mock to return enough sent operations to reach limit
     mockLoadOperations.mockImplementation(async ({ type, ..._params }) => {
       if (type === "OUT") {
-        return Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
-          createMockTransaction(`sent${i + 1}`, String(1000 + i * 100), mockAddr, []),
-        );
+        return {
+          operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
+            createMockTransaction(`sent${i + 1}`, String(1000 + i * 100), mockAddr, []),
+          ),
+          cursor: null,
+        };
       } else if (type === "IN") {
-        return [
-          createMockTransaction("received1", "500", otherAddr, [mockAddr]),
-          createMockTransaction("received2", "1500", otherAddr, [mockAddr]),
-        ];
+        return {
+          operations: [
+            createMockTransaction("received1", "500", otherAddr, [mockAddr]),
+            createMockTransaction("received2", "1500", otherAddr, [mockAddr]),
+          ],
+          cursor: null,
+        };
       }
-      return [];
+      return { operations: [], cursor: null };
     });
 
     const operations = await sdk.getOperations(mockAccountId, mockAddr);
@@ -1373,16 +1388,24 @@ describe("getOperations filtering logic", () => {
     // Mock to return enough received operations to reach limit
     mockLoadOperations.mockImplementation(async ({ type, ..._params }) => {
       if (type === "OUT") {
-        return [
-          createMockTransaction("sent1", "500", mockAddr, []),
-          createMockTransaction("sent2", "1500", mockAddr, []),
-        ];
+        return {
+          operations: [
+            createMockTransaction("sent1", "500", mockAddr, []),
+            createMockTransaction("sent2", "1500", mockAddr, []),
+          ],
+          cursor: null,
+        };
       } else if (type === "IN") {
-        return Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
-          createMockTransaction(`received${i + 1}`, String(1000 + i * 100), otherAddr, [mockAddr]),
-        );
+        return {
+          operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
+            createMockTransaction(`received${i + 1}`, String(1000 + i * 100), otherAddr, [
+              mockAddr,
+            ]),
+          ),
+          cursor: null,
+        };
       }
-      return [];
+      return { operations: [], cursor: null };
     });
 
     const operations = await sdk.getOperations(mockAccountId, mockAddr);
@@ -1400,15 +1423,23 @@ describe("getOperations filtering logic", () => {
     // Mock to return enough operations to reach limit for both types
     mockLoadOperations.mockImplementation(async ({ type, ..._params }) => {
       if (type === "OUT") {
-        return Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
-          createMockTransaction(`sent${i + 1}`, String(1000 + i * 100), mockAddr, []),
-        );
+        return {
+          operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
+            createMockTransaction(`sent${i + 1}`, String(1000 + i * 100), mockAddr, []),
+          ),
+          cursor: null,
+        };
       } else if (type === "IN") {
-        return Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
-          createMockTransaction(`received${i + 1}`, String(2000 + i * 100), otherAddr, [mockAddr]),
-        );
+        return {
+          operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
+            createMockTransaction(`received${i + 1}`, String(2000 + i * 100), otherAddr, [
+              mockAddr,
+            ]),
+          ),
+          cursor: null,
+        };
       }
-      return [];
+      return { operations: [], cursor: null };
     });
 
     const operations = await sdk.getOperations(mockAccountId, mockAddr);
@@ -1426,22 +1457,28 @@ describe("getOperations filtering logic", () => {
     // Mock to return operations with null timestamps and reach limit
     mockLoadOperations.mockImplementation(async ({ type, ..._params }) => {
       if (type === "OUT") {
-        return [
-          createMockTransaction("sent1", "1000", mockAddr, []),
-          createMockTransaction("sent2", null, mockAddr, []),
-          createMockTransaction("sent3", "3000", mockAddr, []),
-          ...Array.from({ length: sdk.TRANSACTIONS_LIMIT - 3 }, (_, i) =>
-            createMockTransaction(`sent${i + 4}`, String(4000 + i * 100), mockAddr, []),
-          ),
-        ];
+        return {
+          operations: [
+            createMockTransaction("sent1", "1000", mockAddr, []),
+            createMockTransaction("sent2", null, mockAddr, []),
+            createMockTransaction("sent3", "3000", mockAddr, []),
+            ...Array.from({ length: sdk.TRANSACTIONS_LIMIT - 3 }, (_, i) =>
+              createMockTransaction(`sent${i + 4}`, String(4000 + i * 100), mockAddr, []),
+            ),
+          ],
+          cursor: null,
+        };
       } else if (type === "IN") {
-        return [
-          createMockTransaction("received1", null, otherAddr, [mockAddr]),
-          createMockTransaction("received2", "2000", otherAddr, [mockAddr]),
-          createMockTransaction("received3", "4000", otherAddr, [mockAddr]),
-        ];
+        return {
+          operations: [
+            createMockTransaction("received1", null, otherAddr, [mockAddr]),
+            createMockTransaction("received2", "2000", otherAddr, [mockAddr]),
+            createMockTransaction("received3", "4000", otherAddr, [mockAddr]),
+          ],
+          cursor: null,
+        };
       }
-      return [];
+      return { operations: [], cursor: null };
     });
 
     const operations = await sdk.getOperations(mockAccountId, mockAddr);
@@ -1456,15 +1493,21 @@ describe("getOperations filtering logic", () => {
     // Mock to return operations that reach limit
     mockLoadOperations.mockImplementation(async ({ type, ..._params }) => {
       if (type === "OUT") {
-        return Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
-          createMockTransaction(`sent${i + 1}`, String(1000 + i * 10), mockAddr, []),
-        );
+        return {
+          operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
+            createMockTransaction(`sent${i + 1}`, String(1000 + i * 10), mockAddr, []),
+          ),
+          cursor: null,
+        };
       } else if (type === "IN") {
-        return Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
-          createMockTransaction(`received${i + 1}`, String(500 + i * 10), otherAddr, [mockAddr]),
-        );
+        return {
+          operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
+            createMockTransaction(`received${i + 1}`, String(500 + i * 10), otherAddr, [mockAddr]),
+          ),
+          cursor: null,
+        };
       }
-      return [];
+      return { operations: [], cursor: null };
     });
 
     const operations = await sdk.getOperations(mockAccountId, mockAddr);
@@ -1477,7 +1520,7 @@ describe("getOperations filtering logic", () => {
   test("should handle empty operations arrays", async () => {
     // Mock to return empty arrays
     mockLoadOperations.mockImplementation(async ({ type, ..._params }) => {
-      return [];
+      return { operations: [], cursor: null };
     });
 
     const operations = await sdk.getOperations(mockAccountId, mockAddr);
@@ -1489,14 +1532,17 @@ describe("getOperations filtering logic", () => {
     // Mock to return only OUT operations
     mockLoadOperations.mockImplementation(async ({ type, ..._params }) => {
       if (type === "OUT") {
-        return [
-          createMockTransaction("sent1", "1000", mockAddr, []),
-          createMockTransaction("sent2", "2000", mockAddr, []),
-        ];
+        return {
+          operations: [
+            createMockTransaction("sent1", "1000", mockAddr, []),
+            createMockTransaction("sent2", "2000", mockAddr, []),
+          ],
+          cursor: null,
+        };
       } else if (type === "IN") {
-        return [];
+        return { operations: [], cursor: null };
       }
-      return [];
+      return { operations: [], cursor: null };
     });
 
     const operations = await sdk.getOperations(mockAccountId, mockAddr);
@@ -1509,17 +1555,23 @@ describe("getOperations filtering logic", () => {
     // Mock to return operations with same timestamps and reach limit
     mockLoadOperations.mockImplementation(async ({ type, ..._params }) => {
       if (type === "OUT") {
-        return Array.from(
-          { length: sdk.TRANSACTIONS_LIMIT },
-          (_, i) => createMockTransaction(`sent${i + 1}`, "1000", mockAddr, []), // All same timestamp
-        );
+        return {
+          operations: Array.from(
+            { length: sdk.TRANSACTIONS_LIMIT },
+            (_, i) => createMockTransaction(`sent${i + 1}`, "1000", mockAddr, []), // All same timestamp
+          ),
+          cursor: null,
+        };
       } else if (type === "IN") {
-        return [
-          createMockTransaction("received1", "1000", otherAddr, [mockAddr]),
-          createMockTransaction("received2", "1000", otherAddr, [mockAddr]),
-        ];
+        return {
+          operations: [
+            createMockTransaction("received1", "1000", otherAddr, [mockAddr]),
+            createMockTransaction("received2", "1000", otherAddr, [mockAddr]),
+          ],
+          cursor: null,
+        };
       }
-      return [];
+      return { operations: [], cursor: null };
     });
 
     const operations = await sdk.getOperations(mockAccountId, mockAddr);
@@ -1582,117 +1634,127 @@ describe("filterOperations", () => {
 
   describe("when cursor is provided", () => {
     test("should not apply timestamp filtering", () => {
-      const operationList1 = [
-        createMockTransaction("tx1", "1000"),
-        createMockTransaction("tx2", "2000"),
-      ];
-      const operationList2 = [
-        createMockTransaction("tx3", "1500"),
-        createMockTransaction("tx4", "2500"),
-      ];
-      const cursor = "test-cursor";
-
-      const result = sdk.filterOperations(operationList1, operationList2, cursor);
+      const operationList1 = {
+        operations: [createMockTransaction("tx1", "1000"), createMockTransaction("tx2", "2000")],
+        cursor: null,
+      };
+      const operationList2 = {
+        operations: [createMockTransaction("tx3", "1500"), createMockTransaction("tx4", "2500")],
+        cursor: null,
+      };
+      const result = sdk.filterOperations(operationList1, operationList2, "ascending");
 
       // Should return all operations sorted by timestamp in descending order
-      expect(result).toHaveLength(4);
-      expect(result.map(tx => tx.digest)).toEqual(["tx4", "tx2", "tx3", "tx1"]);
+      expect(result.operations).toHaveLength(4);
+      expect(result.operations.map(tx => tx.digest)).toEqual(["tx4", "tx2", "tx3", "tx1"]);
     });
 
     test("should handle null cursor", () => {
-      const operationList1 = [
-        createMockTransaction("tx1", "1000"),
-        createMockTransaction("tx2", "2000"),
-      ];
-      const operationList2 = [
-        createMockTransaction("tx3", "1500"),
-        createMockTransaction("tx4", "2500"),
-      ];
+      const operationList1 = {
+        operations: [createMockTransaction("tx1", "1000"), createMockTransaction("tx2", "2000")],
+        cursor: null,
+      };
+      const operationList2 = {
+        operations: [createMockTransaction("tx3", "1500"), createMockTransaction("tx4", "2500")],
+        cursor: null,
+      };
 
-      const result = sdk.filterOperations(operationList1, operationList2, null);
+      const result = sdk.filterOperations(operationList1, operationList2, "ascending");
 
       // Should return all operations sorted by timestamp in descending order
-      expect(result).toHaveLength(4);
-      expect(result.map(tx => tx.digest)).toEqual(["tx4", "tx2", "tx3", "tx1"]);
+      expect(result.operations).toHaveLength(4);
+      expect(result.operations.map(tx => tx.digest)).toEqual(["tx4", "tx2", "tx3", "tx1"]);
     });
 
     test("should handle undefined cursor", () => {
-      const operationList1 = [
-        createMockTransaction("tx1", "1000"),
-        createMockTransaction("tx2", "2000"),
-      ];
-      const operationList2 = [
-        createMockTransaction("tx3", "1500"),
-        createMockTransaction("tx4", "2500"),
-      ];
+      const operationList1 = {
+        operations: [createMockTransaction("tx1", "1000"), createMockTransaction("tx2", "2000")],
+        cursor: null,
+      };
+      const operationList2 = {
+        operations: [createMockTransaction("tx3", "1500"), createMockTransaction("tx4", "2500")],
+        cursor: null,
+      };
 
-      const result = sdk.filterOperations(operationList1, operationList2, undefined);
+      const result = sdk.filterOperations(operationList1, operationList2, "ascending");
 
       // Should return all operations sorted by timestamp in descending order
-      expect(result).toHaveLength(4);
-      expect(result.map(tx => tx.digest)).toEqual(["tx4", "tx2", "tx3", "tx1"]);
+      expect(result.operations).toHaveLength(4);
+      expect(result.operations.map(tx => tx.digest)).toEqual(["tx4", "tx2", "tx3", "tx1"]);
     });
   });
 
   describe("when cursor is not provided and operations reach limits", () => {
     test("should apply timestamp filtering when both lists reach limit", () => {
-      const operationList1 = Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
-        createMockTransaction(`tx1_${i + 1}`, String(1000 + i * 100)),
-      );
-      const operationList2 = Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
-        createMockTransaction(`tx2_${i + 1}`, String(2000 + i * 100)),
-      );
+      const operationList1 = {
+        operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
+          createMockTransaction(`tx1_${i + 1}`, String(1000 + i * 100)),
+        ),
+        cursor: null,
+      };
+      const operationList2 = {
+        operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
+          createMockTransaction(`tx2_${i + 1}`, String(2000 + i * 100)),
+        ),
+        cursor: null,
+      };
 
-      const result = sdk.filterOperations(operationList1, operationList2, null);
+      const result = sdk.filterOperations(operationList1, operationList2, "ascending");
 
       // Filter timestamp should be max of last timestamps:
       // operationList1: 1000 + 299*100 = 30900
       // operationList2: 2000 + 299*100 = 31900
       // filter = max(30900, 31900) = 31900
       // Only operations with timestamp >= 31900 should remain
-      const filteredOperations = result.filter(tx => Number(tx.timestampMs) >= 31900);
+      const filteredOperations = result.operations.filter(tx => Number(tx.timestampMs) >= 31900);
       expect(filteredOperations).toHaveLength(1);
       expect(filteredOperations[0].digest).toBe("tx2_300");
     });
 
     test("should apply timestamp filtering when only first list reaches limit", () => {
-      const operationList1 = Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
-        createMockTransaction(`tx1_${i + 1}`, String(1000 + i * 100)),
-      );
-      const operationList2 = [
-        createMockTransaction("tx2_1", "500"),
-        createMockTransaction("tx2_2", "1500"),
-      ];
+      const operationList1 = {
+        operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
+          createMockTransaction(`tx1_${i + 1}`, String(1000 + i * 100)),
+        ),
+        cursor: null,
+      };
+      const operationList2 = {
+        operations: [createMockTransaction("tx2_1", "500"), createMockTransaction("tx2_2", "1500")],
+        cursor: null,
+      };
 
-      const result = sdk.filterOperations(operationList1, operationList2, null);
+      const result = sdk.filterOperations(operationList1, operationList2, "ascending");
 
       // Filter timestamp should be max of last timestamps:
       // operationList1: 1000 + 299*100 = 30900
       // operationList2: 1500
       // filter = max(30900, 1500) = 30900
       // Only operations with timestamp >= 30900 should remain
-      const filteredOperations = result.filter(tx => Number(tx.timestampMs) >= 30900);
+      const filteredOperations = result.operations.filter(tx => Number(tx.timestampMs) >= 30900);
       expect(filteredOperations).toHaveLength(1);
       expect(filteredOperations[0].digest).toBe("tx1_300");
     });
 
     test("should apply timestamp filtering when only second list reaches limit", () => {
-      const operationList1 = [
-        createMockTransaction("tx1_1", "500"),
-        createMockTransaction("tx1_2", "1500"),
-      ];
-      const operationList2 = Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
-        createMockTransaction(`tx2_${i + 1}`, String(2000 + i * 100)),
-      );
+      const operationList1 = {
+        operations: [createMockTransaction("tx1_1", "500"), createMockTransaction("tx1_2", "1500")],
+        cursor: null,
+      };
+      const operationList2 = {
+        operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
+          createMockTransaction(`tx2_${i + 1}`, String(2000 + i * 100)),
+        ),
+        cursor: null,
+      };
 
-      const result = sdk.filterOperations(operationList1, operationList2, null);
+      const result = sdk.filterOperations(operationList1, operationList2, "ascending");
 
       // Filter timestamp should be max of last timestamps:
       // operationList1: 1500
       // operationList2: 2000 + 299*100 = 31900
       // filter = max(1500, 31900) = 31900
       // Only operations with timestamp >= 31900 should remain
-      const filteredOperations = result.filter(tx => Number(tx.timestampMs) >= 31900);
+      const filteredOperations = result.operations.filter(tx => Number(tx.timestampMs) >= 31900);
       expect(filteredOperations).toHaveLength(1);
       expect(filteredOperations[0].digest).toBe("tx2_300");
     });
@@ -1700,34 +1762,46 @@ describe("filterOperations", () => {
 
   describe("when cursor is not provided and operations don't reach limits", () => {
     test("should not apply timestamp filtering when neither list reaches limit", () => {
-      const operationList1 = [
-        createMockTransaction("tx1_1", "1000"),
-        createMockTransaction("tx1_2", "2000"),
-      ];
-      const operationList2 = [
-        createMockTransaction("tx2_1", "1500"),
-        createMockTransaction("tx2_2", "2500"),
-      ];
+      const operationList1 = {
+        operations: [
+          createMockTransaction("tx1_1", "1000"),
+          createMockTransaction("tx1_2", "2000"),
+        ],
+        cursor: null,
+      };
+      const operationList2 = {
+        operations: [
+          createMockTransaction("tx2_1", "1500"),
+          createMockTransaction("tx2_2", "2500"),
+        ],
+        cursor: null,
+      };
 
-      const result = sdk.filterOperations(operationList1, operationList2, null);
+      const result = sdk.filterOperations(operationList1, operationList2, "ascending");
 
       // Should return all operations sorted by timestamp in descending order
-      expect(result).toHaveLength(4);
-      expect(result.map(tx => tx.digest)).toEqual(["tx2_2", "tx1_2", "tx2_1", "tx1_1"]);
+      expect(result.operations).toHaveLength(4);
+      expect(result.operations.map(tx => tx.digest)).toEqual(["tx2_2", "tx1_2", "tx2_1", "tx1_1"]);
     });
 
     test("should apply timestamp filtering when only one list reaches limit", () => {
-      const operationList1 = Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
-        createMockTransaction(`tx1_${i + 1}`, String(1000 + i * 100)),
-      );
-      const operationList2 = [createMockTransaction("tx2_1", "1500")];
+      const operationList1 = {
+        operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
+          createMockTransaction(`tx1_${i + 1}`, String(1000 + i * 100)),
+        ),
+        cursor: null,
+      };
+      const operationList2 = {
+        operations: [createMockTransaction("tx2_1", "1500")],
+        cursor: null,
+      };
 
-      const result = sdk.filterOperations(operationList1, operationList2, null);
+      const result = sdk.filterOperations(operationList1, operationList2, "ascending");
 
       // Should apply timestamp filtering since one list reaches limit
       // Filter timestamp should be the timestamp of the last operation in list1 (1000 + 299*100 = 30900)
       // Only operations with timestamp >= 30900 should remain
-      const filteredOperations = result.filter(tx => Number(tx.timestampMs) >= 30900);
+      const filteredOperations = result.operations.filter(tx => Number(tx.timestampMs) >= 30900);
       expect(filteredOperations).toHaveLength(1);
       expect(filteredOperations[0].digest).toBe("tx1_300");
     });
@@ -1735,94 +1809,125 @@ describe("filterOperations", () => {
 
   describe("edge cases", () => {
     test("should handle null/undefined timestampMs values", () => {
-      const operationList1 = [
-        createMockTransaction("tx1_1", "1000"),
-        createMockTransaction("tx1_2", null),
-        createMockTransaction("tx1_3", "3000"),
-        ...Array.from({ length: sdk.TRANSACTIONS_LIMIT - 3 }, (_, i) =>
-          createMockTransaction(`tx1_${i + 4}`, String(4000 + i * 100)),
-        ),
-      ];
-      const operationList2 = [
-        createMockTransaction("tx2_1", null),
-        createMockTransaction("tx2_2", "2000"),
-        createMockTransaction("tx2_3", "4000"),
-      ];
+      const operationList1 = {
+        operations: [
+          createMockTransaction("tx1_1", "1000"),
+          createMockTransaction("tx1_2", null),
+          createMockTransaction("tx1_3", "3000"),
+          ...Array.from({ length: sdk.TRANSACTIONS_LIMIT - 3 }, (_, i) =>
+            createMockTransaction(`tx1_${i + 4}`, String(4000 + i * 100)),
+          ),
+        ],
+        cursor: null,
+      };
+      const operationList2 = {
+        operations: [
+          createMockTransaction("tx2_1", null),
+          createMockTransaction("tx2_2", "2000"),
+          createMockTransaction("tx2_3", "4000"),
+        ],
+        cursor: null,
+      };
 
-      const result = sdk.filterOperations(operationList1, operationList2, null);
+      const result = sdk.filterOperations(operationList1, operationList2, "ascending");
 
       // Filter timestamp should be the timestamp of the last operation in list1 (4000 + 296*100 = 33600)
       // Only operations with timestamp >= 33600 should remain
-      const filteredOperations = result.filter(tx => Number(tx.timestampMs) >= 33600);
+      const filteredOperations = result.operations.filter(tx => Number(tx.timestampMs) >= 33600);
       expect(filteredOperations).toHaveLength(1);
       expect(filteredOperations[0].digest).toBe("tx1_300");
     });
 
     test("should handle empty arrays", () => {
-      const result = sdk.filterOperations([], [], null);
-      expect(result).toHaveLength(0);
+      const result = sdk.filterOperations(
+        { operations: [], cursor: null },
+        { operations: [], cursor: null },
+        "ascending",
+      );
+      expect(result.operations).toHaveLength(0);
     });
 
     test("should handle one empty array", () => {
-      const operationList1 = [
-        createMockTransaction("tx1_1", "1000"),
-        createMockTransaction("tx1_2", "2000"),
-      ];
-      const operationList2: SuiTransactionBlockResponse[] = [];
+      const operationList1 = {
+        operations: [
+          createMockTransaction("tx1_1", "1000"),
+          createMockTransaction("tx1_2", "2000"),
+        ],
+        cursor: null,
+      };
+      const operationList2 = {
+        operations: [],
+        cursor: null,
+      };
 
-      const result = sdk.filterOperations(operationList1, operationList2, null);
+      const result = sdk.filterOperations(operationList1, operationList2, "ascending");
 
-      expect(result).toHaveLength(2);
-      expect(result.map(tx => tx.digest)).toEqual(["tx1_2", "tx1_1"]);
+      expect(result.operations).toHaveLength(2);
+      expect(result.operations.map(tx => tx.digest)).toEqual(["tx1_2", "tx1_1"]);
     });
 
     test("should remove duplicate transactions by digest", () => {
-      const operationList1 = [
-        createMockTransaction("tx1", "1000"),
-        createMockTransaction("tx2", "2000"),
-      ];
-      const operationList2 = [
-        createMockTransaction("tx2", "2000"), // Duplicate digest
-        createMockTransaction("tx3", "3000"),
-      ];
+      const operationList1 = {
+        operations: [createMockTransaction("tx1", "1000"), createMockTransaction("tx2", "2000")],
+        cursor: null,
+      };
+      const operationList2 = {
+        operations: [
+          createMockTransaction("tx2", "2000"), // Duplicate digest
+          createMockTransaction("tx3", "3000"),
+        ],
+        cursor: null,
+      };
 
-      const result = sdk.filterOperations(operationList1, operationList2, null);
+      const result = sdk.filterOperations(operationList1, operationList2, "ascending");
 
       // Should remove duplicate tx2
-      expect(result).toHaveLength(3);
-      expect(result.map(tx => tx.digest)).toEqual(["tx3", "tx2", "tx1"]);
+      expect(result.operations).toHaveLength(3);
+      expect(result.operations.map(tx => tx.digest)).toEqual(["tx3", "tx2", "tx1"]);
     });
 
     test("should maintain chronological order after filtering", () => {
-      const operationList1 = Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
-        createMockTransaction(`tx1_${i + 1}`, String(1000 + i * 10)),
-      );
-      const operationList2 = Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
-        createMockTransaction(`tx2_${i + 1}`, String(500 + i * 10)),
-      );
+      const operationList1 = {
+        operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
+          createMockTransaction(`tx1_${i + 1}`, String(1000 + i * 10)),
+        ),
+        cursor: null,
+      };
+      const operationList2 = {
+        operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) =>
+          createMockTransaction(`tx2_${i + 1}`, String(500 + i * 10)),
+        ),
+        cursor: null,
+      };
 
-      const result = sdk.filterOperations(operationList1, operationList2, null);
+      const result = sdk.filterOperations(operationList1, operationList2, "ascending");
 
       // Should be sorted by timestamp in descending order
-      const timestamps = result.map(tx => Number(tx.timestampMs));
+      const timestamps = result.operations.map(tx => Number(tx.timestampMs));
       expect(timestamps).toEqual(timestamps.slice().sort((a, b) => b - a));
     });
 
     test("should handle operations with same timestamps", () => {
-      const operationList1 = Array.from(
-        { length: sdk.TRANSACTIONS_LIMIT },
-        (_, i) => createMockTransaction(`tx1_${i + 1}`, "1000"), // All same timestamp
-      );
-      const operationList2 = [
-        createMockTransaction("tx2_1", "1000"),
-        createMockTransaction("tx2_2", "1000"),
-      ];
+      const operationList1 = {
+        operations: Array.from(
+          { length: sdk.TRANSACTIONS_LIMIT },
+          (_, i) => createMockTransaction(`tx1_${i + 1}`, "1000"), // All same timestamp
+        ),
+        cursor: null,
+      };
+      const operationList2 = {
+        operations: [
+          createMockTransaction("tx2_1", "1000"),
+          createMockTransaction("tx2_2", "1000"),
+        ],
+        cursor: null,
+      };
 
-      const result = sdk.filterOperations(operationList1, operationList2, null);
+      const result = sdk.filterOperations(operationList1, operationList2, "ascending");
 
       // Filter timestamp should be 1000 (the common timestamp)
       // All operations have timestamp 1000, so all should pass the filter
-      expect(result).toHaveLength(sdk.TRANSACTIONS_LIMIT + 2);
+      expect(result.operations).toHaveLength(sdk.TRANSACTIONS_LIMIT + 2);
     });
   });