@ledgerhq/coin-sui 0.12.0 → 0.12.1-nightly.0

package/lib/network/sdk.test.js

@@ -443,6 +443,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: {},
@@ -902,6 +903,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", () => {
             const address = "0x65449f57946938c84c512732f1d69405d1fce417d9c9894696ddf4522f479e24";
@@ -948,6 +950,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();
         });
     });
     describe("Operation Extra Information", () => {
@@ -1015,8 +1018,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}`,
         ]);
@@ -1038,7 +1041,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 () => {
@@ -1062,7 +1065,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 () => {
@@ -1086,7 +1089,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"));
@@ -1097,7 +1100,7 @@ describe("loadOperations", () => {
             order: "ascending",
             operations: [],
         });
-        expect(result).toEqual([]);
+        expect(result.operations).toEqual([]);
         expect(mockApi.queryTransactionBlocks).toHaveBeenCalledTimes(1);
     });
 });
@@ -1168,18 +1171,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(() => {
@@ -1202,15 +1211,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
@@ -1225,15 +1240,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
@@ -1248,12 +1271,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
@@ -1268,21 +1299,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)
@@ -1294,12 +1331,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
@@ -1309,7 +1352,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);
@@ -1318,15 +1361,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);
@@ -1336,15 +1382,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)
@@ -1400,189 +1452,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", () => {