cojson 0.7.0-alpha.36 → 0.7.0-alpha.38

package/src/tests/sync.test.ts

@@ -1,4 +1,4 @@
-import { expect, test, beforeEach } from "vitest";
+import { expect, test } from "vitest";
 import { newRandomSessionID } from "../coValueCore.js";
 import { LocalNode } from "../localNode.js";
 import { SyncMessage } from "../sync.js";
@@ -11,22 +11,14 @@ import {
 } from "./testUtils.js";
 import { connectedPeers, newStreamPair } from "../streamUtils.js";
 import { AccountID } from "../coValues/account.js";
-import { cojsonReady } from "../index.js";
 import { stableStringify } from "../jsonStringify.js";
+import { WasmCrypto } from "../crypto/WasmCrypto.js";
 
-import { webcrypto } from "node:crypto";
-if (!("crypto" in globalThis)) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (globalThis as any).crypto = webcrypto;
-}
-
-beforeEach(async () => {
-    await cojsonReady;
-});
+const Crypto = await WasmCrypto.create();
 
 test("Node replies with initial tx and header to empty subscribe", async () => {
     const [admin, session] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(admin, session);
+    const node = new LocalNode(admin, session, Crypto);
 
     const group = node.createGroup();
 
@@ -105,7 +97,7 @@ test("Node replies with initial tx and header to empty subscribe", async () => {
 
 test("Node replies with only new tx to subscribe with some known state", async () => {
     const [admin, session] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(admin, session);
+    const node = new LocalNode(admin, session, Crypto);
 
     const group = node.createGroup();
 
@@ -180,12 +172,12 @@ test("Node replies with only new tx to subscribe with some known state", async (
 });
 
 test.todo(
-    "TODO: node only replies with new tx to subscribe with some known state, even in the depended on coValues"
+    "TODO: node only replies with new tx to subscribe with some known state, even in the depended on coValues",
 );
 
 test("After subscribing, node sends own known state and new txs to peer", async () => {
     const [admin, session] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(admin, session);
+    const node = new LocalNode(admin, session, Crypto);
 
     const group = node.createGroup();
 
@@ -298,7 +290,7 @@ test("After subscribing, node sends own known state and new txs to peer", async
 
 test("Client replies with known new content to tellKnownState from server", async () => {
     const [admin, session] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(admin, session);
+    const node = new LocalNode(admin, session, Crypto);
 
     const group = node.createGroup();
 
@@ -375,7 +367,7 @@ test("Client replies with known new content to tellKnownState from server", asyn
 
 test("No matter the optimistic known state, node respects invalid known state messages and resyncs", async () => {
     const [admin, session] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(admin, session);
+    const node = new LocalNode(admin, session, Crypto);
 
     const group = node.createGroup();
 
@@ -475,7 +467,7 @@ test("No matter the optimistic known state, node respects invalid known state me
 
 test("If we add a peer, but it never subscribes to a coValue, it won't get any messages", async () => {
     const [admin, session] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(admin, session);
+    const node = new LocalNode(admin, session, Crypto);
 
     const group = node.createGroup();
 
@@ -496,85 +488,92 @@ test("If we add a peer, but it never subscribes to a coValue, it won't get any m
     const reader = outRx.getReader();
 
     await expect(
-        shouldNotResolve(reader.read(), { timeout: 100 })
+        shouldNotResolve(reader.read(), { timeout: 100 }),
     ).resolves.toBeUndefined();
 });
 
-test("If we add a server peer, all updates to all coValues are sent to it, even if it doesn't subscribe", async () => {
-    const [admin, session] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(admin, session);
-
-    const group = node.createGroup();
-
-    const map = group.createMap();
-
-    const [inRx, _inTx] = newStreamPair<SyncMessage>();
-    const [outRx, outTx] = newStreamPair<SyncMessage>();
-
-    node.syncManager.addPeer({
-        id: "test",
-        incoming: inRx,
-        outgoing: outTx,
-        role: "server",
-    });
-
-    const reader = outRx.getReader();
-    // expect((await reader.read()).value).toMatchObject({
-    //     action: "load",
-    //     id: adminID,
-    // });
-    expect((await reader.read()).value).toMatchObject({
-        action: "load",
-        id: group.core.id,
-    });
-
-    const mapSubscribeMsg = await reader.read();
-
-    expect(mapSubscribeMsg.value).toEqual({
-        action: "load",
-        id: map.core.id,
-        header: true,
-        sessions: {},
-    } satisfies SyncMessage);
-
-    map.set("hello", "world", "trusting");
-
-    // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(groupContentEx(group));
-
-    const mapNewContentMsg = await reader.read();
-
-    expect(mapNewContentMsg.value).toEqual({
-        action: "content",
-        id: map.core.id,
-        header: map.core.header,
-        new: {
-            [node.currentSessionID]: {
-                after: 0,
-                newTransactions: [
-                    {
-                        privacy: "trusting" as const,
-                        madeAt: map.core.sessionLogs.get(node.currentSessionID)!
-                            .transactions[0]!.madeAt,
-                        changes: stableStringify([
-                            {
-                                op: "set",
-                                key: "hello",
-                                value: "world",
-                            } satisfies MapOpPayload<string, string>,
-                        ]),
-                    },
-                ],
-                lastSignature: map.core.sessionLogs.get(node.currentSessionID)!
-                    .lastSignature!,
+test.todo(
+    "If we add a server peer, all updates to all coValues are sent to it, even if it doesn't subscribe",
+    async () => {
+        const [admin, session] = randomAnonymousAccountAndSessionID();
+        const node = new LocalNode(admin, session, Crypto);
+
+        const group = node.createGroup();
+
+        const map = group.createMap();
+
+        const [inRx, _inTx] = newStreamPair<SyncMessage>();
+        const [outRx, outTx] = newStreamPair<SyncMessage>();
+
+        node.syncManager.addPeer({
+            id: "test",
+            incoming: inRx,
+            outgoing: outTx,
+            role: "server",
+        });
+
+        const reader = outRx.getReader();
+        // expect((await reader.read()).value).toMatchObject({
+        //     action: "load",
+        //     id: adminID,
+        // });
+        expect((await reader.read()).value).toMatchObject({
+            action: "load",
+            id: group.core.id,
+        });
+
+        const mapSubscribeMsg = await reader.read();
+
+        expect(mapSubscribeMsg.value).toEqual({
+            action: "load",
+            id: map.core.id,
+            header: true,
+            sessions: {},
+        } satisfies SyncMessage);
+
+        map.set("hello", "world", "trusting");
+
+        // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
+        expect((await reader.read()).value).toMatchObject(
+            groupContentEx(group),
+        );
+
+        const mapNewContentMsg = await reader.read();
+
+        expect(mapNewContentMsg.value).toEqual({
+            action: "content",
+            id: map.core.id,
+            header: map.core.header,
+            new: {
+                [node.currentSessionID]: {
+                    after: 0,
+                    newTransactions: [
+                        {
+                            privacy: "trusting" as const,
+                            madeAt: map.core.sessionLogs.get(
+                                node.currentSessionID,
+                            )!.transactions[0]!.madeAt,
+                            changes: stableStringify([
+                                {
+                                    op: "set",
+                                    key: "hello",
+                                    value: "world",
+                                } satisfies MapOpPayload<string, string>,
+                            ]),
+                        },
+                    ],
+                    lastSignature: map.core.sessionLogs.get(
+                        node.currentSessionID,
+                    )!.lastSignature!,
+                },
             },
-        },
-    } satisfies SyncMessage);
-});
+        } satisfies SyncMessage);
+    },
+);
 
 test.skip("If we add a server peer, newly created coValues are auto-subscribed to", async () => {
     const [admin, session] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(admin, session);
+    const node = new LocalNode(admin, session, Crypto);
 
     const group = node.createGroup();
 
@@ -621,12 +620,12 @@ test.skip("If we add a server peer, newly created coValues are auto-subscribed t
 });
 
 test.todo(
-    "TODO: when receiving a subscribe response that is behind our optimistic state (due to already sent content), we ignore it"
+    "TODO: when receiving a subscribe response that is behind our optimistic state (due to already sent content), we ignore it",
 );
 
 test("When we connect a new server peer, we try to sync all existing coValues to it", async () => {
     const [admin, session] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(admin, session);
+    const node = new LocalNode(admin, session, Crypto);
 
     const group = node.createGroup();
 
@@ -662,7 +661,7 @@ test("When we connect a new server peer, we try to sync all existing coValues to
 
 test("When receiving a subscribe with a known state that is ahead of our own, peers should respond with a corresponding subscribe response message", async () => {
     const [admin, session] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(admin, session);
+    const node = new LocalNode(admin, session, Crypto);
 
     const group = node.createGroup();
 
@@ -705,7 +704,7 @@ test.skip("When replaying creation and transactions of a coValue as new content,
     // TODO: this test is mostly correct but also slightly unrealistic, make sure we pass all messages back and forth as expected and then it should work
     const [admin, session] = randomAnonymousAccountAndSessionID();
 
-    const node1 = new LocalNode(admin, session);
+    const node1 = new LocalNode(admin, session, Crypto);
 
     const group = node1.createGroup();
 
@@ -722,7 +721,7 @@ test.skip("When replaying creation and transactions of a coValue as new content,
     const to1 = inTx1.getWriter();
     const from1 = outRx1.getReader();
 
-    const node2 = new LocalNode(admin, newRandomSessionID(admin.id));
+    const node2 = new LocalNode(admin, newRandomSessionID(admin.id), Crypto);
 
     const [inRx2, inTx2] = newStreamPair<SyncMessage>();
     const [outRx2, outTx2] = newStreamPair<SyncMessage>();
@@ -758,7 +757,7 @@ test.skip("When replaying creation and transactions of a coValue as new content,
     expect(groupTellKnownStateMsg.value).toMatchObject(groupStateEx(group));
 
     expect(
-        node2.syncManager.peers["test1"]!.optimisticKnownStates[group.core.id]
+        node2.syncManager.peers["test1"]!.optimisticKnownStates[group.core.id],
     ).toBeDefined();
 
     // await to1.write(adminTellKnownStateMsg.value!);
@@ -813,8 +812,8 @@ test.skip("When replaying creation and transactions of a coValue as new content,
 
     expect(
         expectMap(
-            node2.expectCoValueLoaded(map.core.id).getCurrentContent()
-        ).get("hello")
+            node2.expectCoValueLoaded(map.core.id).getCurrentContent(),
+        ).get("hello"),
     ).toEqual("world");
 });
 
@@ -822,14 +821,14 @@ test.skip("When loading a coValue on one node, the server node it is requested f
     // TODO: this test is mostly correct but also slightly unrealistic, make sure we pass all messages back and forth as expected and then it should work
     const [admin, session] = randomAnonymousAccountAndSessionID();
 
-    const node1 = new LocalNode(admin, session);
+    const node1 = new LocalNode(admin, session, Crypto);
 
     const group = node1.createGroup();
 
     const map = group.createMap();
     map.set("hello", "world", "trusting");
 
-    const node2 = new LocalNode(admin, newRandomSessionID(admin.id));
+    const node2 = new LocalNode(admin, newRandomSessionID(admin.id), Crypto);
 
     const [node1asPeer, node2asPeer] = connectedPeers("peer1", "peer2");
 
@@ -840,15 +839,15 @@ test.skip("When loading a coValue on one node, the server node it is requested f
 
     expect(
         expectMap(
-            node2.expectCoValueLoaded(map.core.id).getCurrentContent()
-        ).get("hello")
+            node2.expectCoValueLoaded(map.core.id).getCurrentContent(),
+        ).get("hello"),
     ).toEqual("world");
 });
 
 test("Can sync a coValue through a server to another client", async () => {
     const [admin, session] = randomAnonymousAccountAndSessionID();
 
-    const client1 = new LocalNode(admin, session);
+    const client1 = new LocalNode(admin, session, Crypto);
 
     const group = client1.createGroup();
 
@@ -857,7 +856,7 @@ test("Can sync a coValue through a server to another client", async () => {
 
     const [serverUser, serverSession] = randomAnonymousAccountAndSessionID();
 
-    const server = new LocalNode(serverUser, serverSession);
+    const server = new LocalNode(serverUser, serverSession, Crypto);
 
     const [serverAsPeer, client1AsPeer] = connectedPeers("server", "client1", {
         peer1role: "server",
@@ -868,12 +867,12 @@ test("Can sync a coValue through a server to another client", async () => {
     client1.syncManager.addPeer(serverAsPeer);
     server.syncManager.addPeer(client1AsPeer);
 
-    const client2 = new LocalNode(admin, newRandomSessionID(admin.id));
+    const client2 = new LocalNode(admin, newRandomSessionID(admin.id), Crypto);
 
     const [serverAsOtherPeer, client2AsPeer] = connectedPeers(
         "server",
         "client2",
-        { peer1role: "server", peer2role: "client", trace: true }
+        { peer1role: "server", peer2role: "client", trace: true },
     );
 
     client2.syncManager.addPeer(serverAsOtherPeer);
@@ -885,14 +884,14 @@ test("Can sync a coValue through a server to another client", async () => {
     }
 
     expect(expectMap(mapOnClient2.getCurrentContent()).get("hello")).toEqual(
-        "world"
+        "world",
     );
 });
 
 test("Can sync a coValue with private transactions through a server to another client", async () => {
     const [admin, session] = randomAnonymousAccountAndSessionID();
 
-    const client1 = new LocalNode(admin, session);
+    const client1 = new LocalNode(admin, session, Crypto);
 
     const group = client1.createGroup();
 
@@ -901,7 +900,7 @@ test("Can sync a coValue with private transactions through a server to another c
 
     const [serverUser, serverSession] = randomAnonymousAccountAndSessionID();
 
-    const server = new LocalNode(serverUser, serverSession);
+    const server = new LocalNode(serverUser, serverSession, Crypto);
 
     const [serverAsPeer, client1AsPeer] = connectedPeers("server", "client1", {
         trace: true,
@@ -912,12 +911,12 @@ test("Can sync a coValue with private transactions through a server to another c
     client1.syncManager.addPeer(serverAsPeer);
     server.syncManager.addPeer(client1AsPeer);
 
-    const client2 = new LocalNode(admin, newRandomSessionID(admin.id));
+    const client2 = new LocalNode(admin, newRandomSessionID(admin.id), Crypto);
 
     const [serverAsOtherPeer, client2AsPeer] = connectedPeers(
         "server",
         "client2",
-        { trace: true, peer1role: "server", peer2role: "client" }
+        { trace: true, peer1role: "server", peer2role: "client" },
     );
 
     client2.syncManager.addPeer(serverAsOtherPeer);
@@ -929,13 +928,13 @@ test("Can sync a coValue with private transactions through a server to another c
     }
 
     expect(expectMap(mapOnClient2.getCurrentContent()).get("hello")).toEqual(
-        "world"
+        "world",
     );
 });
 
 test.skip("When a peer's incoming/readable stream closes, we remove the peer", async () => {
     const [admin, session] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(admin, session);
+    const node = new LocalNode(admin, session, Crypto);
 
     const group = node.createGroup();
 
@@ -989,11 +988,11 @@ test.skip("When a peer's incoming/readable stream closes, we remove the peer", a
 
 test.skip("When a peer's outgoing/writable stream closes, we remove the peer", async () => {
     const [admin, session] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(admin, session);
+    const node = new LocalNode(admin, session, Crypto);
 
     const group = node.createGroup();
 
-    const [inRx, inTx] = newStreamPair<SyncMessage>();
+    const [inRx] = newStreamPair<SyncMessage>();
     const [outRx, outTx] = newStreamPair<SyncMessage>();
 
     node.syncManager.addPeer({
@@ -1047,14 +1046,14 @@ test.skip("When a peer's outgoing/writable stream closes, we remove the peer", a
 test("If we start loading a coValue before connecting to a peer that has it, it will load it once we connect", async () => {
     const [admin, session] = randomAnonymousAccountAndSessionID();
 
-    const node1 = new LocalNode(admin, session);
+    const node1 = new LocalNode(admin, session, Crypto);
 
     const group = node1.createGroup();
 
     const map = group.createMap();
     map.set("hello", "world", "trusting");
 
-    const node2 = new LocalNode(admin, newRandomSessionID(admin.id));
+    const node2 = new LocalNode(admin, newRandomSessionID(admin.id), Crypto);
 
     const [node1asPeer, node2asPeer] = connectedPeers("peer1", "peer2", {
         peer1role: "server",
@@ -1076,7 +1075,7 @@ test("If we start loading a coValue before connecting to a peer that has it, it
     }
 
     expect(expectMap(mapOnNode2.getCurrentContent()).get("hello")).toEqual(
-        "world"
+        "world",
     );
 });
 
@@ -1087,7 +1086,7 @@ function groupContentEx(group: RawGroup) {
     };
 }
 
-function admContEx(adminID: AccountID) {
+function _admContEx(adminID: AccountID) {
     return {
         action: "content",
         id: adminID,
@@ -1101,7 +1100,7 @@ function groupStateEx(group: RawGroup) {
     };
 }
 
-function admStateEx(adminID: AccountID) {
+function _admStateEx(adminID: AccountID) {
     return {
         action: "known",
         id: adminID,

package/src/tests/testUtils.ts

@@ -1,35 +1,40 @@
 import { expect } from "vitest";
-import { AgentSecret, createdNowUnique, getAgentID, newRandomAgentSecret  } from "../crypto.js";
 import { newRandomSessionID } from "../coValueCore.js";
 import { LocalNode } from "../localNode.js";
 import { expectGroup } from "../typeUtils/expectGroup.js";
 import { ControlledAgent } from "../coValues/account.js";
 import { SessionID } from "../ids.js";
+import { WasmCrypto } from "../crypto/WasmCrypto.js";
 
-export function randomAnonymousAccountAndSessionID(): [ControlledAgent, SessionID] {
-    const agentSecret = newRandomAgentSecret();
+const Crypto = await WasmCrypto.create();
 
-    const sessionID = newRandomSessionID(getAgentID(agentSecret));
+export function randomAnonymousAccountAndSessionID(): [
+    ControlledAgent,
+    SessionID,
+] {
+    const agentSecret = Crypto.newRandomAgentSecret();
 
-    return [new ControlledAgent(agentSecret), sessionID];
+    const sessionID = newRandomSessionID(Crypto.getAgentID(agentSecret));
+
+    return [new ControlledAgent(agentSecret, Crypto), sessionID];
 }
 
 export function newGroup() {
     const [admin, sessionID] = randomAnonymousAccountAndSessionID();
 
-    const node = new LocalNode(admin, sessionID);
+    const node = new LocalNode(admin, sessionID, Crypto);
 
     const groupCore = node.createCoValue({
         type: "comap",
         ruleset: { type: "group", initialAdmin: admin.id },
         meta: null,
-        ...createdNowUnique(),
+        ...Crypto.createdNowUnique(),
     });
 
     const group = expectGroup(groupCore.getCurrentContent());
 
     group.set(admin.id, "admin", "trusting");
-        expect(group.get(admin.id)).toEqual("admin");
+    expect(group.get(admin.id)).toEqual("admin");
 
     return { node, groupCore, admin };
 }
@@ -39,10 +44,10 @@ export function groupWithTwoAdmins() {
 
     const otherAdmin = node.createAccount();
 
-    let group = expectGroup(groupCore.getCurrentContent());
+    const group = expectGroup(groupCore.getCurrentContent());
 
-        group.set(otherAdmin.id, "admin", "trusting");
-        expect(group.get(otherAdmin.id)).toEqual("admin");
+    group.set(otherAdmin.id, "admin", "trusting");
+    expect(group.get(otherAdmin.id)).toEqual("admin");
 
     if (group.type !== "comap") {
         throw new Error("Expected map");
@@ -55,8 +60,7 @@ export function groupWithTwoAdmins() {
 export function newGroupHighLevel() {
     const [admin, sessionID] = randomAnonymousAccountAndSessionID();
 
-
-    const node = new LocalNode(admin, sessionID);
+    const node = new LocalNode(admin, sessionID, Crypto);
 
     const group = node.createGroup();
 
@@ -64,7 +68,7 @@ export function newGroupHighLevel() {
 }
 
 export function groupWithTwoAdminsHighLevel() {
-    let { admin, node, group } = newGroupHighLevel();
+    const { admin, node, group } = newGroupHighLevel();
 
     const otherAdmin = node.createAccount();
 
@@ -75,7 +79,7 @@ export function groupWithTwoAdminsHighLevel() {
 
 export function shouldNotResolve<T>(
     promise: Promise<T>,
-    ops: { timeout: number }
+    ops: { timeout: number },
 ): Promise<void> {
     return new Promise((resolve, reject) => {
         promise
@@ -83,12 +87,11 @@ export function shouldNotResolve<T>(
                 reject(
                     new Error(
                         "Should not have resolved, but resolved to " +
-                            JSON.stringify(v)
-                    )
-                )
+                            JSON.stringify(v),
+                    ),
+                ),
             )
             .catch(reject);
         setTimeout(resolve, ops.timeout);
     });
 }
-

package/src/typeUtils/accountOrAgentIDfromSessionID.ts

@@ -1,9 +1,8 @@
 import { AgentID, SessionID } from "../ids.js";
 import { AccountID } from "../coValues/account.js";
 
-
 export function accountOrAgentIDfromSessionID(
-    sessionID: SessionID
+    sessionID: SessionID,
 ): AccountID | AgentID {
     const until = sessionID.indexOf("_session");
     return sessionID.slice(0, until) as AccountID | AgentID;

package/src/typeUtils/expectGroup.ts

@@ -12,4 +12,4 @@ export function expectGroup(content: RawCoValue): RawGroup {
     }
 
     return map;
-}
+}

package/src/typeUtils/isAccountID.ts

@@ -1,7 +1,6 @@
 import type { AccountID } from "../coValues/account.js";
 import type { AgentID } from "../ids.js";
 
-
 export function isAccountID(id: AccountID | AgentID): id is AccountID {
     return id.startsWith("co_");
 }

package/src/typeUtils/isCoValue.ts

@@ -5,9 +5,8 @@ import { RawCoList } from "../coValues/coList.js";
 import { RawCoStream } from "../coValues/coStream.js";
 import { RawBinaryCoStream } from "../coValues/coStream.js";
 
-
 export function isCoValue(
-    value: JsonValue | RawCoValue | undefined
+    value: JsonValue | RawCoValue | undefined,
 ): value is RawCoValue {
     return (
         value instanceof RawCoMap ||

package/tsconfig.json

@@ -12,5 +12,4 @@
     "esModuleInterop": true
   },
   "include": ["./src/**/*"],
-  "exclude": ["./src/**/*.test.*"],
 }