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

package/src/network/sdk.test.ts

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