cojson 0.19.21 → 0.20.0

package/src/tests/SyncManager.processQueues.test.ts

@@ -70,7 +70,7 @@ describe("SyncManager.processQueues", () => {
       await loadCoValueOrFail(client.node, map.id);
 
       // Restart and load from storage
-      client.restart();
+      await client.restart();
       client.connectToSyncServer();
       client.addStorage({ storage });
 

package/src/tests/SyncStateManager.test.ts

@@ -46,7 +46,7 @@ describe("SyncStateManager", () => {
     const newPeerState = client.node.syncManager.peers[peerState.id]!;
 
     expect(updateSpy).toHaveBeenCalledWith(
-      peerState.id,
+      expect.objectContaining({ id: peerState.id }),
       newPeerState.getKnownState(map.core.id)!,
       { uploaded: true },
     );

package/src/tests/WasmCrypto.test.ts

@@ -5,8 +5,9 @@ import {
   setupTestNode,
   setupTestAccount,
 } from "./testUtils";
-import { stableStringify } from "../jsonStringify";
+import { Stringified } from "../jsonStringify";
 import { WasmCrypto } from "../crypto/WasmCrypto";
+import { JsonValue } from "../jsonValue";
 
 const wasmCrypto = await WasmCrypto.create();
 setCurrentTestCryptoProvider(wasmCrypto);
@@ -109,7 +110,9 @@ describe("WasmCrypto", () => {
       [
         {
           privacy: "trusting",
-          changes: stableStringify([{ op: "set", key: "count", value: 1 }]),
+          changes: JSON.stringify([
+            { op: "set", key: "count", value: 1 },
+          ]) as Stringified<JsonValue[]>,
           madeAt: Date.now(),
         },
       ],
@@ -203,7 +206,9 @@ describe("WasmCrypto", () => {
         [
           {
             privacy: "trusting",
-            changes: stableStringify([{ op: "set", key: "count", value: 1 }]),
+            changes: JSON.stringify([
+              { op: "set", key: "count", value: 1 },
+            ]) as Stringified<JsonValue[]>,
             madeAt: Date.now(),
           },
         ],

package/src/tests/coPlainText.test.ts

@@ -355,7 +355,7 @@ test("chunks transactions when when the chars are longer than MAX_RECOMMENDED_TX
 
   await coValue.waitForSync();
 
-  client.restart();
+  await client.restart();
   client.addStorage({
     storage,
   });

package/src/tests/coValueCore.loadFromStorage.test.ts

@@ -45,10 +45,17 @@ function createMockStorage(
       callback: (unsyncedCoValueIDs: RawCoID[]) => void,
     ) => void;
     stopTrackingSyncState?: (id: RawCoID) => void;
+    onCoValueUnmounted?: (id: RawCoID) => void;
     close?: () => Promise<unknown> | undefined;
+    markDeleteAsValid?: (id: RawCoID) => void;
+    enableDeletedCoValuesErasure?: () => void;
+    eraseAllDeletedCoValues?: () => Promise<void>;
   } = {},
 ): StorageAPI {
   return {
+    markDeleteAsValid: opts.markDeleteAsValid || vi.fn(),
+    enableDeletedCoValuesErasure: opts.enableDeletedCoValuesErasure || vi.fn(),
+    eraseAllDeletedCoValues: opts.eraseAllDeletedCoValues || vi.fn(),
     load: opts.load || vi.fn(),
     store: opts.store || vi.fn(),
     getKnownState: opts.getKnownState || vi.fn(),
@@ -58,6 +65,7 @@ function createMockStorage(
     trackCoValuesSyncState: opts.trackCoValuesSyncState || vi.fn(),
     getUnsyncedCoValueIDs: opts.getUnsyncedCoValueIDs || vi.fn(),
     stopTrackingSyncState: opts.stopTrackingSyncState || vi.fn(),
+    onCoValueUnmounted: opts.onCoValueUnmounted || vi.fn(),
     close: opts.close || vi.fn().mockResolvedValue(undefined),
   };
 }

package/src/tests/coValueCore.test.ts

@@ -9,13 +9,14 @@ import {
 } from "vitest";
 import { CoValueCore, idforHeader } from "../coValueCore/coValueCore.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
-import { stableStringify } from "../jsonStringify.js";
+import { Stringified } from "../jsonStringify.js";
 import { LocalNode } from "../localNode.js";
 import {
   agentAndSessionIDFromSecret,
   createTestMetricReader,
   createTestNode,
   createTwoConnectedNodes,
+  createUnloadedCoValue,
   loadCoValueOrFail,
   nodeWithRandomAgentAndSessionID,
   randomAgentAndSessionID,
@@ -25,7 +26,7 @@ import {
   waitFor,
 } from "./testUtils.js";
 import { CO_VALUE_PRIORITY } from "../priority.js";
-import { setMaxTxSizeBytes } from "../config.js";
+import { JsonValue } from "../jsonValue.js";
 
 const Crypto = await WasmCrypto.create();
 
@@ -89,14 +90,6 @@ test("transactions with wrong signature are rejected", () => {
 });
 
 describe("transactions that exceed the byte size limit are rejected", () => {
-  beforeEach(() => {
-    setMaxTxSizeBytes(1 * 1024);
-  });
-
-  afterEach(() => {
-    setMaxTxSizeBytes(1 * 1024 * 1024);
-  });
-
   test("makeTransaction should throw error when transaction exceeds byte size limit", () => {
     const [agent, sessionID] = randomAgentAndSessionID();
     const node = new LocalNode(agent.agentSecret, sessionID, Crypto);
@@ -108,7 +101,7 @@ describe("transactions that exceed the byte size limit are rejected", () => {
       ...Crypto.createdNowUnique(),
     });
 
-    const largeBinaryData = "x".repeat(1024 + 100);
+    const largeBinaryData = "x".repeat(1024 * 1024 + 100);
 
     expect(() => {
       coValue.makeTransaction(
@@ -119,7 +112,9 @@ describe("transactions that exceed the byte size limit are rejected", () => {
         ],
         "trusting",
       );
-    }).toThrow(/Transaction is too large to be synced/);
+    }).toThrow(
+      /Transaction too large to be synced: 1048689 bytes > 1048576 bytes limit/,
+    );
   });
 
   test("makeTransaction should work for transactions under byte size limit", () => {
@@ -357,7 +352,9 @@ test("changing parent and child group trigger only one invalidation on the local
 test("correctly records transactions", async () => {
   const node = nodeWithRandomAgentAndSessionID();
 
-  const changes1 = stableStringify([{ hello: "world" }]);
+  const changes1 = JSON.stringify([{ hello: "world" }]) as Stringified<
+    JsonValue[]
+  >;
   node.syncManager.recordTransactionsSize(
     [
       {
@@ -376,7 +373,7 @@ test("correctly records transactions", async () => {
   expect(value.count).toBe(1);
   expect(value.sum).toBe(changes1.length);
 
-  const changes2 = stableStringify([{ foo: "bar" }]);
+  const changes2 = JSON.stringify([{ foo: "bar" }]) as Stringified<JsonValue[]>;
   node.syncManager.recordTransactionsSize(
     [
       {
@@ -906,3 +903,41 @@ test("knownState should return the same object until the CoValue is modified", (
   expect(knownState6).not.toBe(knownState4);
   expect(knownState6).not.toBe(knownState1);
 });
+
+describe("provideHeader uniqueness validation", () => {
+  test("should reject number uniqueness", () => {
+    const node = createTestNode();
+    const { coValue, header } = createUnloadedCoValue(node);
+
+    const invalidHeader = {
+      ...header,
+      uniqueness: 1.5 as any, // non-integer
+    };
+
+    expect(coValue.provideHeader(invalidHeader)).toBe(false);
+  });
+
+  test("should reject array uniqueness", () => {
+    const node = createTestNode();
+    const { coValue, header } = createUnloadedCoValue(node);
+
+    const invalidHeader = {
+      ...header,
+      uniqueness: [1, 2, 3] as any,
+    };
+
+    expect(coValue.provideHeader(invalidHeader)).toBe(false);
+  });
+
+  test("should reject object uniqueness with non-string values", () => {
+    const node = createTestNode();
+    const { coValue, header } = createUnloadedCoValue(node);
+
+    const invalidHeader = {
+      ...header,
+      uniqueness: { key: 123 } as any,
+    };
+
+    expect(coValue.provideHeader(invalidHeader)).toBe(false);
+  });
+});

package/src/tests/coreWasm.test.ts

@@ -1,16 +1,10 @@
 import { assert, describe, expect, it } from "vitest";
 import { WasmCrypto } from "../crypto/WasmCrypto";
-import { JsonValue, LocalNode, SessionID } from "../exports";
-import {
-  agentAndSessionIDFromSecret,
-  randomAgentAndSessionID,
-} from "./testUtils";
-import { PureJSCrypto } from "../crypto/PureJSCrypto";
-import { Encrypted } from "../crypto/crypto";
-import { PrivateTransaction } from "../coValueCore/verifiedState";
+import { LocalNode } from "../exports";
+import { agentAndSessionIDFromSecret } from "./testUtils";
+import { Transaction } from "../coValueCore/verifiedState";
 
 const wasmCrypto = await WasmCrypto.create();
-const jsCrypto = await PureJSCrypto.create();
 
 const agentSecret =
   "sealerSecret_zE3Nr7YFr1KkVbJSx4JDCzYn4ApYdm8kJ5ghNBxREHQya/signerSecret_z9fEu4eNG1eXHMak3YSzY7uLdoG8HESSJ8YW4xWdNNDSP";
@@ -20,7 +14,7 @@ function createTestNode() {
   return {
     agent,
     session,
-    node: new LocalNode(agent.agentSecret, session, jsCrypto),
+    node: new LocalNode(agent.agentSecret, session, wasmCrypto),
   };
 }
 
@@ -140,4 +134,319 @@ describe("SessionLog WASM", () => {
 
     expect(decrypted).toEqual(fixtures.decrypted);
   });
+
+  function shuffleObjectKeys<T extends object>(obj: T): T {
+    const keys = Object.keys(obj);
+    // Fisher-Yates shuffle
+    for (let i = keys.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [keys[i], keys[j]] = [keys[j]!, keys[i]!];
+    }
+    const result = {} as T;
+    for (const key of keys) {
+      (result as any)[key] = (obj as any)[key];
+    }
+    return result;
+  }
+
+  function shuffleTransactions(transactions: Transaction[]): Transaction[] {
+    return transactions.map((t) => shuffleObjectKeys(t) as Transaction);
+  }
+
+  describe("Signature validation after shuffling transaction keys", () => {
+    it("trusting transactions with 100 k/v entries", () => {
+      const { agent, session, node } = createTestNode();
+
+      const group = node.createGroup();
+      const map = group.createMap();
+
+      // Create 100 trusting transactions with explicit test data
+      for (let i = 0; i < 100; i++) {
+        map.core.makeTransaction(
+          [{ op: "set", key: `key${i}`, value: `value${i}` }],
+          "trusting",
+          undefined,
+          i * 1000,
+        );
+      }
+
+      const sessionContent =
+        map.core.newContentSince(undefined)?.[0]?.new[session];
+      assert(sessionContent);
+      expect(sessionContent.newTransactions.length).toBe(100);
+
+      const log = wasmCrypto.createSessionLog(
+        map.id,
+        session,
+        agent.currentSignerID(),
+      );
+      const logShuffled = wasmCrypto.createSessionLog(
+        map.id,
+        session,
+        agent.currentSignerID(),
+      );
+
+      const shuffledTransactions = shuffleTransactions(
+        sessionContent.newTransactions,
+      );
+
+      expect(() =>
+        log.tryAdd(
+          sessionContent.newTransactions,
+          sessionContent.lastSignature,
+          false,
+        ),
+      ).not.toThrow();
+
+      expect(() =>
+        logShuffled.tryAdd(
+          shuffledTransactions,
+          sessionContent.lastSignature,
+          false,
+        ),
+      ).not.toThrow();
+    });
+
+    it("private transactions with 100 k/v entries", () => {
+      const { agent, session, node } = createTestNode();
+
+      const group = node.createGroup();
+      const map = group.createMap();
+
+      // Create 100 private transactions with explicit test data
+      for (let i = 0; i < 100; i++) {
+        map.core.makeTransaction(
+          [{ op: "set", key: `secretKey${i}`, value: `secretValue${i}` }],
+          "private",
+          undefined,
+          i * 1000,
+        );
+      }
+
+      const sessionContent =
+        map.core.newContentSince(undefined)?.[0]?.new[session];
+      assert(sessionContent);
+      expect(sessionContent.newTransactions.length).toBe(100);
+
+      // Verify transactions are actually private (encrypted)
+      const firstTx = sessionContent.newTransactions[0];
+      assert(firstTx);
+      expect(firstTx.privacy).toBe("private");
+      expect("encryptedChanges" in firstTx).toBe(true);
+
+      const log = wasmCrypto.createSessionLog(
+        map.id,
+        session,
+        agent.currentSignerID(),
+      );
+      const logShuffled = wasmCrypto.createSessionLog(
+        map.id,
+        session,
+        agent.currentSignerID(),
+      );
+
+      const shuffledTransactions = shuffleTransactions(
+        sessionContent.newTransactions,
+      );
+
+      expect(() =>
+        log.tryAdd(
+          sessionContent.newTransactions,
+          sessionContent.lastSignature,
+          false,
+        ),
+      ).not.toThrow();
+
+      expect(() =>
+        logShuffled.tryAdd(
+          shuffledTransactions,
+          sessionContent.lastSignature,
+          false,
+        ),
+      ).not.toThrow();
+    });
+
+    it("trusting transactions with metas", () => {
+      const { agent, session, node } = createTestNode();
+
+      const group = node.createGroup();
+      const map = group.createMap();
+
+      // Create transactions with metas
+      for (let i = 0; i < 50; i++) {
+        map.core.makeTransaction(
+          [{ op: "set", key: `key${i}`, value: `value${i}` }],
+          "trusting",
+          { index: i, timestamp: i * 1000, nested: { data: `meta${i}` } },
+          i * 1000,
+        );
+      }
+
+      const sessionContent =
+        map.core.newContentSince(undefined)?.[0]?.new[session];
+      assert(sessionContent);
+      expect(sessionContent.newTransactions.length).toBe(50);
+
+      // Verify metas are present
+      const firstTx = sessionContent.newTransactions[0];
+      assert(firstTx);
+      expect(firstTx.meta).toBeDefined();
+
+      const log = wasmCrypto.createSessionLog(
+        map.id,
+        session,
+        agent.currentSignerID(),
+      );
+      const logShuffled = wasmCrypto.createSessionLog(
+        map.id,
+        session,
+        agent.currentSignerID(),
+      );
+
+      const shuffledTransactions = shuffleTransactions(
+        sessionContent.newTransactions,
+      );
+
+      expect(() =>
+        log.tryAdd(
+          sessionContent.newTransactions,
+          sessionContent.lastSignature,
+          false,
+        ),
+      ).not.toThrow();
+
+      expect(() =>
+        logShuffled.tryAdd(
+          shuffledTransactions,
+          sessionContent.lastSignature,
+          false,
+        ),
+      ).not.toThrow();
+    });
+
+    it("private transactions with metas", () => {
+      const { agent, session, node } = createTestNode();
+
+      const group = node.createGroup();
+      const map = group.createMap();
+
+      // Create private transactions with encrypted metas
+      for (let i = 0; i < 50; i++) {
+        map.core.makeTransaction(
+          [{ op: "set", key: `secretKey${i}`, value: `secretValue${i}` }],
+          "private",
+          { index: i, secret: `confidential${i}` },
+          i * 1000,
+        );
+      }
+
+      const sessionContent =
+        map.core.newContentSince(undefined)?.[0]?.new[session];
+      assert(sessionContent);
+      expect(sessionContent.newTransactions.length).toBe(50);
+
+      // Verify transactions are private with encrypted metas
+      const firstTx = sessionContent.newTransactions[0];
+      assert(firstTx);
+      expect(firstTx.privacy).toBe("private");
+      expect("encryptedChanges" in firstTx).toBe(true);
+      expect(firstTx.meta).toBeDefined();
+
+      const log = wasmCrypto.createSessionLog(
+        map.id,
+        session,
+        agent.currentSignerID(),
+      );
+      const logShuffled = wasmCrypto.createSessionLog(
+        map.id,
+        session,
+        agent.currentSignerID(),
+      );
+
+      const shuffledTransactions = shuffleTransactions(
+        sessionContent.newTransactions,
+      );
+
+      expect(() =>
+        log.tryAdd(
+          sessionContent.newTransactions,
+          sessionContent.lastSignature,
+          false,
+        ),
+      ).not.toThrow();
+
+      expect(() =>
+        logShuffled.tryAdd(
+          shuffledTransactions,
+          sessionContent.lastSignature,
+          false,
+        ),
+      ).not.toThrow();
+    });
+
+    it("mixed trusting and private transactions across multiple sessions", () => {
+      const { agent, session, node } = createTestNode();
+
+      const group = node.createGroup();
+      const map = group.createMap();
+
+      // Create alternating trusting and private transactions
+      for (let i = 0; i < 50; i++) {
+        const privacy = i % 2 === 0 ? "trusting" : "private";
+        const hasMeta = i % 3 === 0;
+        map.core.makeTransaction(
+          [{ op: "set", key: `mixedKey${i}`, value: `mixedValue${i}` }],
+          privacy,
+          hasMeta ? { iteration: i, type: privacy } : undefined,
+          i * 1000,
+        );
+      }
+
+      const sessionContent =
+        map.core.newContentSince(undefined)?.[0]?.new[session];
+      assert(sessionContent);
+      expect(sessionContent.newTransactions.length).toBe(50);
+
+      // Verify we have a mix of trusting and private transactions
+      const trustingCount = sessionContent.newTransactions.filter(
+        (t) => t.privacy === "trusting",
+      ).length;
+      const privateCount = sessionContent.newTransactions.filter(
+        (t) => t.privacy === "private",
+      ).length;
+      expect(trustingCount).toBe(25);
+      expect(privateCount).toBe(25);
+
+      const log = wasmCrypto.createSessionLog(
+        map.id,
+        session,
+        agent.currentSignerID(),
+      );
+      const logShuffled = wasmCrypto.createSessionLog(
+        map.id,
+        session,
+        agent.currentSignerID(),
+      );
+
+      const shuffledTransactions = shuffleTransactions(
+        sessionContent.newTransactions,
+      );
+
+      expect(() =>
+        log.tryAdd(
+          sessionContent.newTransactions,
+          sessionContent.lastSignature,
+          false,
+        ),
+      ).not.toThrow();
+
+      expect(() =>
+        logShuffled.tryAdd(
+          shuffledTransactions,
+          sessionContent.lastSignature,
+          false,
+        ),
+      ).not.toThrow();
+    });
+  });
 });