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

package/lib-es/network/sdk.test.js

@@ -987,8 +987,8 @@ describe("loadOperations", () => {
             order: "ascending",
             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}`,
         ]);
@@ -1010,7 +1010,7 @@ describe("loadOperations", () => {
             order: "ascending",
             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);
     });
     it("should not exceed TRANSACTIONS_LIMIT", async () => {
@@ -1034,7 +1034,7 @@ describe("loadOperations", () => {
             order: "ascending",
             operations: [],
         });
-        expect(result).toHaveLength(sdk.TRANSACTIONS_LIMIT);
+        expect(result.operations).toHaveLength(sdk.TRANSACTIONS_LIMIT);
         expect(mockApi.queryTransactionBlocks).toHaveBeenCalledTimes(expectedCalls);
     });
     it("should retry without cursor when InvalidParams error occurs", async () => {
@@ -1058,7 +1058,7 @@ describe("loadOperations", () => {
             cursor: "some-cursor",
         }));
         // 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 () => {
         mockApi.queryTransactionBlocks.mockRejectedValueOnce(new Error("unexpected"));
@@ -1069,7 +1069,7 @@ describe("loadOperations", () => {
             order: "ascending",
             operations: [],
         });
-        expect(result).toEqual([]);
+        expect(result.operations).toEqual([]);
         expect(mockApi.queryTransactionBlocks).toHaveBeenCalledTimes(1);
     });
 });
@@ -1140,18 +1140,24 @@ 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 };
         });
     });
     afterEach(() => {
@@ -1174,15 +1180,21 @@ 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);
         // Filter timestamp should be the maximum of the last timestamps from both arrays
@@ -1197,15 +1209,23 @@ 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);
         // Filter timestamp should be the maximum of the last timestamps from both arrays
@@ -1220,12 +1240,20 @@ 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);
         // Filter timestamp should be the maximum of the last timestamps from both arrays
@@ -1240,21 +1268,27 @@ 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);
         // Filter timestamp should be the timestamp of the last sent operation (4000 + 296*100 = 33600)
@@ -1266,12 +1300,18 @@ 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);
         // Should be sorted by timestamp in descending order
@@ -1281,7 +1321,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);
         expect(operations).toHaveLength(0);
@@ -1290,15 +1330,18 @@ 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);
         expect(operations).toHaveLength(2);
@@ -1308,15 +1351,21 @@ 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, []));
+                return {
+                    operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) => createMockTransaction(`sent${i + 1}`, "1000", mockAddr, [])),
+                    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);
         // Filter timestamp should be 1000 (the common timestamp)
@@ -1372,189 +1421,239 @@ 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 result = sdk.filterOperations(operationList1, operationList2, null);
+            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 undefined cursor", () => {
-            const operationList1 = [
-                createMockTransaction("tx1", "1000"),
-                createMockTransaction("tx2", "2000"),
-            ];
-            const operationList2 = [
-                createMockTransaction("tx3", "1500"),
-                createMockTransaction("tx4", "2500"),
-            ];
-            const result = sdk.filterOperations(operationList1, operationList2, undefined);
+            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"]);
         });
     });
     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 result = sdk.filterOperations(operationList1, operationList2, null);
+            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, "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 result = sdk.filterOperations(operationList1, operationList2, null);
+            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, "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 result = sdk.filterOperations(operationList1, operationList2, null);
+            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, "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");
         });
     });
     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 result = sdk.filterOperations(operationList1, operationList2, null);
+            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, "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 result = sdk.filterOperations(operationList1, operationList2, null);
+            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, "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");
         });
     });
     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 result = sdk.filterOperations(operationList1, operationList2, null);
+            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, "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 = [];
-            const result = sdk.filterOperations(operationList1, operationList2, null);
-            expect(result).toHaveLength(2);
-            expect(result.map(tx => tx.digest)).toEqual(["tx1_2", "tx1_1"]);
+            const operationList1 = {
+                operations: [
+                    createMockTransaction("tx1_1", "1000"),
+                    createMockTransaction("tx1_2", "2000"),
+                ],
+                cursor: null,
+            };
+            const operationList2 = {
+                operations: [],
+                cursor: null,
+            };
+            const result = sdk.filterOperations(operationList1, operationList2, "ascending");
+            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 result = sdk.filterOperations(operationList1, operationList2, null);
+            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, "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 result = sdk.filterOperations(operationList1, operationList2, null);
+            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, "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"));
-            const operationList2 = [
-                createMockTransaction("tx2_1", "1000"),
-                createMockTransaction("tx2_2", "1000"),
-            ];
-            const result = sdk.filterOperations(operationList1, operationList2, null);
+            const operationList1 = {
+                operations: Array.from({ length: sdk.TRANSACTIONS_LIMIT }, (_, i) => createMockTransaction(`tx1_${i + 1}`, "1000")),
+                cursor: null,
+            };
+            const operationList2 = {
+                operations: [
+                    createMockTransaction("tx2_1", "1000"),
+                    createMockTransaction("tx2_2", "1000"),
+                ],
+                cursor: 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);
         });
     });
     describe("conversion methods", () => {