cojson 0.17.9 → 0.17.11

package/src/tests/coreWasm.test.ts

@@ -0,0 +1,142 @@
+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";
+
+const wasmCrypto = await WasmCrypto.create();
+const jsCrypto = await PureJSCrypto.create();
+
+const agentSecret =
+  "sealerSecret_zE3Nr7YFr1KkVbJSx4JDCzYn4ApYdm8kJ5ghNBxREHQya/signerSecret_z9fEu4eNG1eXHMak3YSzY7uLdoG8HESSJ8YW4xWdNNDSP";
+
+function createTestNode() {
+  const [agent, session] = agentAndSessionIDFromSecret(agentSecret);
+  return {
+    agent,
+    session,
+    node: new LocalNode(agent.agentSecret, session, jsCrypto),
+  };
+}
+
+describe("SessionLog WASM", () => {
+  it("it works", () => {
+    const [agent, sessionId] = agentAndSessionIDFromSecret(agentSecret);
+
+    const session = wasmCrypto.createSessionLog(
+      "co_test1" as any,
+      sessionId,
+      agent.currentSignerID(),
+    );
+
+    expect(session).toBeDefined();
+  });
+
+  it("test_add_from_example_json", () => {
+    const { agent, session, node } = createTestNode();
+
+    const group = node.createGroup();
+    const sessionContent =
+      group.core.verified.newContentSince(undefined)?.[0]?.new[session];
+    assert(sessionContent);
+
+    let log = wasmCrypto.createSessionLog(
+      group.id,
+      session,
+      agent.currentSignerID(),
+    );
+
+    log.tryAdd(
+      sessionContent.newTransactions,
+      sessionContent.lastSignature,
+      false,
+    );
+  });
+
+  it("test_add_new_transaction", () => {
+    const { agent, session, node } = createTestNode();
+
+    const group = node.createGroup();
+    const sessionContent =
+      group.core.verified.newContentSince(undefined)?.[0]?.new[session];
+    assert(sessionContent);
+
+    let log = wasmCrypto.createSessionLog(
+      group.id,
+      session,
+      agent.currentSignerID(),
+    );
+
+    const changesJson = [
+      { after: "start", op: "app", value: "co_zMphsnYN6GU8nn2HDY5suvyGufY" },
+    ];
+    const key = group.getCurrentReadKey();
+    assert(key);
+    assert(key.secret);
+
+    const { signature, transaction } = log.addNewPrivateTransaction(
+      agent,
+      changesJson,
+      key.id,
+      key.secret,
+      0,
+    );
+
+    expect(signature).toMatch(/^signature_z[a-zA-Z0-9]+$/);
+    expect(transaction).toEqual({
+      encryptedChanges: expect.stringMatching(/^encrypted_U/),
+      keyUsed: expect.stringMatching(/^key_z/),
+      madeAt: 0,
+      privacy: "private",
+    });
+
+    const decrypted = log.decryptNextTransactionChangesJson(0, key.secret);
+
+    expect(decrypted).toEqual(
+      '[{"after":"start","op":"app","value":"co_zMphsnYN6GU8nn2HDY5suvyGufY"}]',
+    );
+  });
+
+  it("test_decrypt + clone", () => {
+    const [agent] = agentAndSessionIDFromSecret(agentSecret);
+    const fixtures = {
+      id: "co_zWwrEiushQLvbkWd6Z3L8WxTU1r",
+      signature:
+        "signature_z3ktW7wxMnW7VYExCGZv4Ug2UJSW3ag6zLDiP8GpZThzif6veJt7JipYpUgshhuGbgHtLcWywWSWysV7hChxFypDt",
+      decrypted:
+        '[{"after":"start","op":"app","value":"co_zMphsnYN6GU8nn2HDY5suvyGufY"}]',
+      key: {
+        secret: "keySecret_z3dU66SsyQkkGKpNCJW6NX74MnfVGHUyY7r85b4M8X88L",
+        id: "key_z5XUAHyoqUV9zXWvMK",
+      },
+      transaction: {
+        privacy: "private",
+        madeAt: 0,
+        encryptedChanges:
+          "encrypted_UNAxqdUSGRZ2rzuLU99AFPKCe2C0HwsTzMWQreXZqLr6RpWrSMa-5lwgwIev7xPHTgZFq5UyUgMFrO9zlHJHJGgjJcDzFihY=" as any,
+        keyUsed: "key_z5XUAHyoqUV9zXWvMK",
+      },
+      session:
+        "sealer_z5yhsCCe2XwLTZC4254mUoMASshm3Diq49JrefPpjTktp/signer_z7gVGDpNz9qUtsRxAkHMuu4DYdtVVCG4XELTKPYdoYLPr_session_z9mDP8FoonSA",
+    } as const;
+
+    let log = wasmCrypto.createSessionLog(
+      fixtures.id,
+      fixtures.session,
+      agent.currentSignerID(),
+    );
+
+    log.tryAdd([fixtures.transaction], fixtures.signature, true);
+
+    const decrypted = log
+      .clone()
+      .decryptNextTransactionChangesJson(0, fixtures.key.secret);
+
+    expect(decrypted).toEqual(fixtures.decrypted);
+  });
+});

package/src/tests/group.addMember.test.ts

@@ -2,7 +2,6 @@ import { beforeEach, describe, expect, test } from "vitest";
 import { expectMap } from "../coValue.js";
 import {
   SyncMessagesLog,
-  TEST_NODE_CONFIG,
   loadCoValueOrFail,
   setupTestAccount,
   setupTestNode,
@@ -220,68 +219,75 @@ describe("Group.addMember", () => {
     expect(personOnReaderNode.get("name")).toEqual(undefined);
   });
 
-  test("an admin should not be able downgrade an admin", async () => {
-    const admin = await setupTestAccount({
-      connected: true,
-    });
-
-    const otherAdmin = await setupTestAccount({
-      connected: true,
-    });
-
-    const group = admin.node.createGroup();
-    const person = group.createMap({
-      name: "John Doe",
-    });
-
-    const otherAdminOnAdminNode = await loadCoValueOrFail(
-      admin.node,
-      otherAdmin.accountID,
-    );
-    group.addMember(otherAdminOnAdminNode, "admin");
-
-    // Try to downgrade other admin
-    try {
-      group.addMember(otherAdminOnAdminNode, "writer");
-    } catch (e) {
-      expect(e).toBeDefined();
-    }
-
-    expect(group.roleOf(otherAdmin.accountID)).toEqual("admin");
-
-    // Verify other admin still has admin access by adding a new member
-    const reader = await setupTestAccount({
-      connected: true,
-    });
-
-    const readerOnOtherAdminNode = await loadCoValueOrFail(
-      otherAdmin.node,
-      reader.accountID,
-    );
-    group.addMember(readerOnOtherAdminNode, "reader");
-
-    const personOnReaderNode = await loadCoValueOrFail(reader.node, person.id);
-
-    await waitFor(() => {
-      expect(
-        expectMap(personOnReaderNode.core.getCurrentContent()).get("name"),
-      ).toEqual("John Doe");
-    });
-  });
-
-  test("an admin should be able downgrade themselves", async () => {
-    const admin = await setupTestAccount({
-      connected: true,
-    });
-
-    const group = admin.node.createGroup();
-
-    const account = await loadCoValueOrFail(admin.node, admin.accountID);
-
-    // Downgrade self to writer
-    group.addMember(account, "writer");
-    expect(group.roleOf(admin.accountID)).toEqual("writer");
-  });
+  test.each(["writer", "reader", "writeOnly"] as const)(
+    "an admin should not be able to downgrade an admin to %s",
+    async (targetRole) => {
+      const admin = await setupTestAccount({
+        connected: true,
+      });
+
+      const otherAdmin = await setupTestAccount({
+        connected: true,
+      });
+
+      const group = admin.node.createGroup();
+      const person = group.createMap({
+        name: "John Doe",
+      });
+
+      const otherAdminOnAdminNode = await loadCoValueOrFail(
+        admin.node,
+        otherAdmin.accountID,
+      );
+      group.addMember(otherAdminOnAdminNode, "admin");
+
+      // Try to downgrade other admin
+      expect(() => group.addMember(otherAdminOnAdminNode, targetRole)).toThrow(
+        "Administrators cannot demote other administrators in a group",
+      );
+
+      expect(group.roleOf(otherAdmin.accountID)).toEqual("admin");
+
+      // Verify other admin still has admin access by adding a new member
+      const reader = await setupTestAccount({
+        connected: true,
+      });
+
+      const readerOnOtherAdminNode = await loadCoValueOrFail(
+        otherAdmin.node,
+        reader.accountID,
+      );
+      group.addMember(readerOnOtherAdminNode, "reader");
+
+      const personOnReaderNode = await loadCoValueOrFail(
+        reader.node,
+        person.id,
+      );
+
+      await waitFor(() => {
+        expect(
+          expectMap(personOnReaderNode.core.getCurrentContent()).get("name"),
+        ).toEqual("John Doe");
+      });
+    },
+  );
+
+  test.each(["writer", "reader", "writeOnly"] as const)(
+    "an admin should be able downgrade themselves to %s",
+    async (targetRole) => {
+      const admin = await setupTestAccount({
+        connected: true,
+      });
+
+      const group = admin.node.createGroup();
+
+      const account = await loadCoValueOrFail(admin.node, admin.accountID);
+
+      // Downgrade self to target role
+      group.addMember(account, targetRole);
+      expect(group.roleOf(admin.accountID)).toEqual(targetRole);
+    },
+  );
 
   test("an admin should be able downgrade a writeOnly to reader", async () => {
     const admin = await setupTestAccount({

package/src/tests/sync.load.test.ts

@@ -9,6 +9,7 @@ import {
   SyncMessagesLog,
   TEST_NODE_CONFIG,
   blockMessageTypeOnOutgoingPeer,
+  getSyncServerConnectedPeer,
   loadCoValueOrFail,
   setupTestAccount,
   setupTestNode,
@@ -1034,4 +1035,55 @@ describe("loading coValues from server", () => {
 
     vi.useRealTimers();
   });
+
+  test("should not request dependencies if transaction verification is disabled", async () => {
+    // Create a disconnected client
+    const { node: client, accountID } = await setupTestAccount({
+      connected: false,
+    });
+    const account = client.expectCurrentAccount(accountID);
+
+    // Prepare a group -- this will be a non-account dependency of a forthcoming map.
+    const group = client.createGroup();
+    group.addMember("everyone", "writer");
+
+    // Create a sync server and disable transaction verification
+    const syncServer = await setupTestAccount({ isSyncServer: true });
+    syncServer.node.syncManager.disableTransactionVerification();
+
+    // Connect the client, but don't setup syncing just yet...
+    const { peer } = getSyncServerConnectedPeer({
+      peerId: client.getCurrentAgent().id,
+      syncServer: syncServer.node,
+    });
+
+    // Disable reconciliation while we setup syncing because we don't want the
+    // server to know about our forthcoming map's dependencies (group + account).
+    const blocker = blockMessageTypeOnOutgoingPeer(peer, "load", {});
+    client.syncManager.addPeer(peer);
+    blocker.unblock();
+
+    // Create a map and set a value on it.
+    // If transaction verification were enabled, this would trigger LOAD messages
+    // from the server to the client asking for the group and account. However, we
+    // don't expect to see those messages since we disabled transaction verification.
+    const map = group.createMap();
+    map.set("hello", "world");
+    await map.core.waitForSync();
+
+    const syncMessages = SyncMessagesLog.getMessages({
+      Account: account.core,
+      Group: group.core,
+      Map: map.core,
+    });
+    expect(
+      syncMessages.some(
+        (msg) => msg.includes("LOAD Account") || msg.includes("LOAD Group"),
+      ),
+    ).toBe(false);
+
+    // Verify the map is available on the server (transaction was accepted)
+    const mapOnServerCore = await syncServer.node.loadCoValueCore(map.core.id);
+    expect(mapOnServerCore.isAvailable()).toBe(true);
+  });
 });

package/src/tests/sync.test.ts

@@ -180,9 +180,7 @@ test("should not verify transactions when SyncManager has verification disabled"
         madeAt: Date.now(),
       },
     ],
-    undefined,
     Crypto.sign(agent.currentSignerSecret(), "hash_z12345678"),
-    "immediate",
     true,
   );
 

package/src/tests/testUtils.ts

@@ -12,6 +12,7 @@ import {
   type AgentSecret,
   type CoID,
   type CoValueCore,
+  CryptoProvider,
   type RawAccount,
   type RawCoValue,
   StorageAPI,
@@ -23,8 +24,15 @@ import type { Peer, SyncMessage } from "../sync.js";
 import { expectGroup } from "../typeUtils/expectGroup.js";
 import { toSimplifiedMessages } from "./messagesTestUtils.js";
 import { createAsyncStorage, createSyncStorage } from "./testStorage.js";
+import { PureJSCrypto } from "../crypto/PureJSCrypto.js";
 
-const Crypto = await WasmCrypto.create();
+let Crypto = await WasmCrypto.create();
+
+export function setCurrentTestCryptoProvider(
+  crypto: WasmCrypto | PureJSCrypto,
+) {
+  Crypto = crypto;
+}
 
 const syncServer: {
   current: undefined | LocalNode;