cojson 0.7.0-alpha.37 → 0.7.0-alpha.38

package/src/sync.ts

@@ -1,4 +1,4 @@
-import { Signature } from "./crypto.js";
+import { Signature } from "./crypto/crypto.js";
 import { CoValueHeader, Transaction } from "./coValueCore.js";
 import { CoValueCore } from "./coValueCore.js";
 import { LocalNode } from "./localNode.js";
@@ -82,7 +82,7 @@ export interface PeerState {
 
 export function combinedKnownStates(
     stateA: CoValueKnownState,
-    stateB: CoValueKnownState
+    stateB: CoValueKnownState,
 ): CoValueKnownState {
     const sessionStates: CoValueKnownState["sessions"] = {};
 
@@ -108,7 +108,11 @@ export function combinedKnownStates(
 export class SyncManager {
     peers: { [key: PeerID]: PeerState } = {};
     local: LocalNode;
-    requestedSyncs: { [id: RawCoID]: {done: Promise<void>, nRequestsThisTick: number} | undefined } = {};
+    requestedSyncs: {
+        [id: RawCoID]:
+            | { done: Promise<void>; nRequestsThisTick: number }
+            | undefined;
+    } = {};
 
     constructor(local: LocalNode) {
         this.local = local;
@@ -175,7 +179,7 @@ export class SyncManager {
                             id,
                             "from",
                             peer.id,
-                            e
+                            e,
                         );
                         resolve();
                     });
@@ -203,7 +207,7 @@ export class SyncManager {
                 throw new Error(
                     `Unknown message type ${
                         (msg as { action: "string" }).action
-                    }`
+                    }`,
                 );
         }
     }
@@ -243,15 +247,21 @@ export class SyncManager {
     async tellUntoldKnownStateIncludingDependencies(
         id: RawCoID,
         peer: PeerState,
-        asDependencyOf?: RawCoID
+        asDependencyOf?: RawCoID,
     ) {
         const coValue = this.local.expectCoValueLoaded(id);
 
-        await Promise.all(coValue.getDependedOnCoValues().map(dependentCoID => this.tellUntoldKnownStateIncludingDependencies(
-            dependentCoID,
-            peer,
-            asDependencyOf || id
-        )));
+        await Promise.all(
+            coValue
+                .getDependedOnCoValues()
+                .map((dependentCoID) =>
+                    this.tellUntoldKnownStateIncludingDependencies(
+                        dependentCoID,
+                        peer,
+                        asDependencyOf || id,
+                    ),
+                ),
+        );
 
         if (!peer.toldKnownState.has(id)) {
             await this.trySendToPeer(peer, {
@@ -267,10 +277,16 @@ export class SyncManager {
     async sendNewContentIncludingDependencies(id: RawCoID, peer: PeerState) {
         const coValue = this.local.expectCoValueLoaded(id);
 
-        await Promise.all(coValue.getDependedOnCoValues().map(id => this.sendNewContentIncludingDependencies(id, peer)));
+        await Promise.all(
+            coValue
+                .getDependedOnCoValues()
+                .map((id) =>
+                    this.sendNewContentIncludingDependencies(id, peer),
+                ),
+        );
 
         const newContentPieces = coValue.newContentSince(
-            peer.optimisticKnownStates[id]
+            peer.optimisticKnownStates[id],
         );
 
         if (newContentPieces) {
@@ -302,7 +318,7 @@ export class SyncManager {
 
             peer.optimisticKnownStates[id] = combinedKnownStates(
                 optimisticKnownStateBefore,
-                coValue.knownState()
+                coValue.knownState(),
             );
         }
     }
@@ -323,7 +339,7 @@ export class SyncManager {
         if (peer.role === "server") {
             const initialSync = async () => {
                 for (const id of Object.keys(
-                    this.local.coValues
+                    this.local.coValues,
                 ) as RawCoID[]) {
                     // console.log("subscribing to after peer added", id, peer.id)
                     await this.subscribeToIncludingDependencies(id, peerState);
@@ -350,9 +366,9 @@ export class SyncManager {
                                 JSON.stringify(msg, (k, v) =>
                                     k === "changes" || k === "encryptedChanges"
                                         ? v.slice(0, 20) + "..."
-                                        : v
+                                        : v,
                                 ),
-                                e
+                                e,
                             );
                         });
                         // await new Promise<void>((resolve) => {
@@ -365,9 +381,9 @@ export class SyncManager {
                             JSON.stringify(msg, (k, v) =>
                                 k === "changes" || k === "encryptedChanges"
                                     ? v.slice(0, 20) + "..."
-                                    : v
+                                    : v,
                             ),
-                            e
+                            e,
                         );
                         if (peerState.delayOnError) {
                             await new Promise<void>((resolve) => {
@@ -417,8 +433,8 @@ export class SyncManager {
                             `Error writing to peer ${peer.id}, disconnecting`,
                             {
                                 cause: e,
-                            }
-                        )
+                            },
+                        ),
                     );
                     delete this.peers[peer.id];
                 });
@@ -470,7 +486,7 @@ export class SyncManager {
 
         peer.optimisticKnownStates[msg.id] = combinedKnownStates(
             peer.optimisticKnownStates[msg.id] || emptyKnownState(msg.id),
-            knownStateIn(msg)
+            knownStateIn(msg),
         );
 
         if (!entry) {
@@ -481,18 +497,18 @@ export class SyncManager {
                         .catch((e) => {
                             console.error(
                                 `Error loading coValue ${msg.id} to create loading state, as dependency of ${msg.asDependencyOf}`,
-                                e
+                                e,
                             );
                         });
                     entry = this.local.coValues[msg.id]!; // must exist after loadCoValueCore
                 } else {
                     throw new Error(
-                        "Expected coValue dependency entry to be created, missing subscribe?"
+                        "Expected coValue dependency entry to be created, missing subscribe?",
                     );
                 }
             } else {
                 throw new Error(
-                    "Expected coValue entry to be created, missing subscribe?"
+                    "Expected coValue entry to be created, missing subscribe?",
                 );
             }
         }
@@ -516,7 +532,7 @@ export class SyncManager {
             // );
             if (
                 Object.values(entry.firstPeerState).every(
-                    (s) => s.type === "unavailable"
+                    (s) => s.type === "unavailable",
                 )
             ) {
                 entry.resolve("unavailable");
@@ -533,7 +549,7 @@ export class SyncManager {
 
         if (!entry) {
             throw new Error(
-                "Expected coValue entry to be created, missing subscribe?"
+                "Expected coValue entry to be created, missing subscribe?",
             );
         }
 
@@ -543,7 +559,7 @@ export class SyncManager {
 
         if (!peerOptimisticKnownState) {
             throw new Error(
-                "Expected optimisticKnownState to be set for coValue we receive new content for"
+                "Expected optimisticKnownState to be set for coValue we receive new content for",
             );
         }
 
@@ -578,7 +594,7 @@ export class SyncManager {
         let invalidStateAssumed = false;
 
         for (const [sessionID, newContentForSession] of Object.entries(
-            msg.new
+            msg.new,
         ) as [SessionID, SessionNewContent][]) {
             const ourKnownTxIdx =
                 coValue.sessionLogs.get(sessionID)?.transactions.length;
@@ -605,7 +621,7 @@ export class SyncManager {
                 sessionID,
                 newTransactions,
                 undefined,
-                newContentForSession.lastSignature
+                newContentForSession.lastSignature,
             );
             const after = performance.now();
             if (after - before > 80) {
@@ -613,7 +629,7 @@ export class SyncManager {
                     .map((t) =>
                         t.privacy === "private"
                             ? t.encryptedChanges.length
-                            : t.changes.length
+                            : t.changes.length,
                     )
                     .reduce((a, b) => a + b, 0);
                 console.log(
@@ -623,16 +639,16 @@ export class SyncManager {
                         (1000 * totalTxLength) /
                         (after - before) /
                         (1024 * 1024)
-                    ).toFixed(2)} MB/s`
+                    ).toFixed(2)} MB/s`,
                 );
             }
 
             const theirTotalnTxs = Object.values(
-                peer.optimisticKnownStates[msg.id]?.sessions || {}
+                peer.optimisticKnownStates[msg.id]?.sessions || {},
             ).reduce((sum, nTxs) => sum + nTxs, 0);
             const ourTotalnTxs = [...coValue.sessionLogs.values()].reduce(
                 (sum, session) => sum + session.transactions.length,
-                0
+                0,
             );
 
             entry.onProgress?.(ourTotalnTxs / theirTotalnTxs);
@@ -644,8 +660,8 @@ export class SyncManager {
                     JSON.stringify(newTransactions, (k, v) =>
                         k === "changes" || k === "encryptedChanges"
                             ? v.slice(0, 20) + "..."
-                            : v
-                    )
+                            : v,
+                    ),
                 );
                 continue;
             }
@@ -653,7 +669,7 @@ export class SyncManager {
             peerOptimisticKnownState.sessions[sessionID] = Math.max(
                 peerOptimisticKnownState.sessions[sessionID] || 0,
                 newContentForSession.after +
-                    newContentForSession.newTransactions.length
+                    newContentForSession.newTransactions.length,
             );
         }
 
@@ -720,17 +736,17 @@ export class SyncManager {
             if (optimisticKnownState) {
                 await this.tellUntoldKnownStateIncludingDependencies(
                     coValue.id,
-                    peer
+                    peer,
                 );
                 await this.sendNewContentIncludingDependencies(
                     coValue.id,
-                    peer
+                    peer,
                 );
             } else if (peer.role === "server") {
                 await this.subscribeToIncludingDependencies(coValue.id, peer);
                 await this.sendNewContentIncludingDependencies(
                     coValue.id,
-                    peer
+                    peer,
                 );
             }
         }

package/src/tests/account.test.ts

@@ -1,23 +1,16 @@
-import { expect, test, beforeEach } from "vitest";
+import { expect, test } from "vitest";
 import { newRandomSessionID } from "../coValueCore.js";
-import { cojsonReady } from "../index.js";
 import { LocalNode } from "../localNode.js";
 import { connectedPeers } from "../streamUtils.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("Can create a node while creating a new account with profile", async () => {
     const { node, accountID, accountSecret, sessionID } =
         await LocalNode.withNewlyCreatedAccount({
             creationProps: { name: "Hermes Puggington" },
+            crypto: Crypto,
         });
 
     expect(node).not.toBeNull();
@@ -26,13 +19,14 @@ test("Can create a node while creating a new account with profile", async () =>
     expect(sessionID).not.toBeNull();
 
     expect(node.expectProfileLoaded(accountID).get("name")).toEqual(
-        "Hermes Puggington"
+        "Hermes Puggington",
     );
 });
 
 test("A node with an account can create groups and and objects within them", async () => {
     const { node, accountID } = await LocalNode.withNewlyCreatedAccount({
         creationProps: { name: "Hermes Puggington" },
+        crypto: Crypto,
     });
 
     const group = await node.createGroup();
@@ -48,6 +42,7 @@ test("Can create account with one node, and then load it on another", async () =
     const { node, accountID, accountSecret } =
         await LocalNode.withNewlyCreatedAccount({
             creationProps: { name: "Hermes Puggington" },
+            crypto: Crypto,
         });
 
     const group = await node.createGroup();
@@ -70,6 +65,7 @@ test("Can create account with one node, and then load it on another", async () =
         accountSecret,
         sessionID: newRandomSessionID(accountID),
         peersToLoadFrom: [node1asPeer],
+        crypto: Crypto,
     });
 
     const map2 = await node2.load(map.id);

package/src/tests/coList.test.ts

@@ -1,30 +1,19 @@
-import { expect, test, beforeEach } from "vitest";
-import { expectList, expectMap, expectStream } from "../coValue.js";
-import { RawBinaryCoStream } from "../coValues/coStream.js";
-import { createdNowUnique } from "../crypto.js";
-import { MAX_RECOMMENDED_TX_SIZE, cojsonReady } from "../index.js";
+import { expect, test } from "vitest";
+import { expectList } from "../coValue.js";
+import { WasmCrypto } from "../index.js";
 import { LocalNode } from "../localNode.js";
-import { accountOrAgentIDfromSessionID } from "../typeUtils/accountOrAgentIDfromSessionID.js";
 import { randomAnonymousAccountAndSessionID } from "./testUtils.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("Empty CoList works", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
     const coValue = node.createCoValue({
         type: "colist",
         ruleset: { type: "unsafeAllowAll" },
         meta: null,
-        ...createdNowUnique(),
+        ...Crypto.createdNowUnique(),
     });
 
     const content = expectList(coValue.getCurrentContent());
@@ -34,13 +23,13 @@ test("Empty CoList works", () => {
 });
 
 test("Can append, prepend, delete and replace items in CoList", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
     const coValue = node.createCoValue({
         type: "colist",
         ruleset: { type: "unsafeAllowAll" },
         meta: null,
-        ...createdNowUnique(),
+        ...Crypto.createdNowUnique(),
     });
 
     const content = expectList(coValue.getCurrentContent());
@@ -54,19 +43,24 @@ test("Can append, prepend, delete and replace items in CoList", () => {
     content.prepend("hooray", 3, "trusting");
     expect(content.toJSON()).toEqual(["hello", "beautiful", "world", "hooray"]);
     content.replace(2, "universe", "trusting");
-    expect(content.toJSON()).toEqual(["hello", "beautiful", "universe", "hooray"]);
+    expect(content.toJSON()).toEqual([
+        "hello",
+        "beautiful",
+        "universe",
+        "hooray",
+    ]);
     content.delete(2, "trusting");
     expect(content.toJSON()).toEqual(["hello", "beautiful", "hooray"]);
 });
 
 test("Push is equivalent to append after last item", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
     const coValue = node.createCoValue({
         type: "colist",
         ruleset: { type: "unsafeAllowAll" },
         meta: null,
-        ...createdNowUnique(),
+        ...Crypto.createdNowUnique(),
     });
 
     const content = expectList(coValue.getCurrentContent());
@@ -82,13 +76,13 @@ test("Push is equivalent to append after last item", () => {
 });
 
 test("Can push into empty list", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
     const coValue = node.createCoValue({
         type: "colist",
         ruleset: { type: "unsafeAllowAll" },
         meta: null,
-        ...createdNowUnique(),
+        ...Crypto.createdNowUnique(),
     });
 
     const content = expectList(coValue.getCurrentContent());
@@ -97,4 +91,4 @@ test("Can push into empty list", () => {
 
     content.append("hello", undefined, "trusting");
     expect(content.toJSON()).toEqual(["hello"]);
-});
+});

package/src/tests/coMap.test.ts

@@ -1,31 +1,20 @@
-import { expect, test, beforeEach } from "vitest";
-import { expectList, expectMap, expectStream } from "../coValue.js";
-import { RawBinaryCoStream } from "../coValues/coStream.js";
-import { createdNowUnique } from "../crypto.js";
-import { MAX_RECOMMENDED_TX_SIZE, cojsonReady } from "../index.js";
+import { expect, test } from "vitest";
+import { expectMap } from "../coValue.js";
+import { WasmCrypto } from "../index.js";
 import { LocalNode } from "../localNode.js";
 import { accountOrAgentIDfromSessionID } from "../typeUtils/accountOrAgentIDfromSessionID.js";
 import { randomAnonymousAccountAndSessionID } from "./testUtils.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("Empty CoMap works", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
     const coValue = node.createCoValue({
         type: "comap",
         ruleset: { type: "unsafeAllowAll" },
         meta: null,
-        ...createdNowUnique(),
+        ...Crypto.createdNowUnique(),
     });
 
     const content = expectMap(coValue.getCurrentContent());
@@ -36,13 +25,13 @@ test("Empty CoMap works", () => {
 });
 
 test("Can insert and delete CoMap entries in edit()", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
     const coValue = node.createCoValue({
         type: "comap",
         ruleset: { type: "unsafeAllowAll" },
         meta: null,
-        ...createdNowUnique(),
+        ...Crypto.createdNowUnique(),
     });
 
     const content = expectMap(coValue.getCurrentContent());
@@ -60,13 +49,13 @@ test("Can insert and delete CoMap entries in edit()", () => {
 });
 
 test("Can get CoMap entry values at different points in time", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
     const coValue = node.createCoValue({
         type: "comap",
         ruleset: { type: "unsafeAllowAll" },
         meta: null,
-        ...createdNowUnique(),
+        ...Crypto.createdNowUnique(),
     });
 
     const content = expectMap(coValue.getCurrentContent());
@@ -74,13 +63,19 @@ test("Can get CoMap entry values at different points in time", () => {
     expect(content.type).toEqual("comap");
 
     const beforeA = Date.now();
-    while (Date.now() < beforeA + 10) {}
+    while (Date.now() < beforeA + 10) {
+        /* hot sleep */
+    }
     content.set("hello", "A", "trusting");
     const beforeB = Date.now();
-    while (Date.now() < beforeB + 10) {}
+    while (Date.now() < beforeB + 10) {
+        /* hot sleep */
+    }
     content.set("hello", "B", "trusting");
     const beforeC = Date.now();
-    while (Date.now() < beforeC + 10) {}
+    while (Date.now() < beforeC + 10) {
+        /* hot sleep */
+    }
     content.set("hello", "C", "trusting");
     expect(content.get("hello")).toEqual("C");
     expect(content.atTime(Date.now()).get("hello")).toEqual("C");
@@ -90,13 +85,13 @@ test("Can get CoMap entry values at different points in time", () => {
 });
 
 test("Can get all historic values of key in CoMap", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
     const coValue = node.createCoValue({
         type: "comap",
         ruleset: { type: "unsafeAllowAll" },
         meta: null,
-        ...createdNowUnique(),
+        ...Crypto.createdNowUnique(),
     });
 
     const content = expectMap(coValue.getCurrentContent());
@@ -140,13 +135,13 @@ test("Can get all historic values of key in CoMap", () => {
 });
 
 test("Can get last tx ID for a key in CoMap", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
     const coValue = node.createCoValue({
         type: "comap",
         ruleset: { type: "unsafeAllowAll" },
         meta: null,
-        ...createdNowUnique(),
+        ...Crypto.createdNowUnique(),
     });
 
     const content = expectMap(coValue.getCurrentContent());
@@ -157,11 +152,11 @@ test("Can get last tx ID for a key in CoMap", () => {
     content.set("hello", "A", "trusting");
     const sessionID = content.lastEditAt("hello")?.tx.sessionID;
     expect(sessionID && accountOrAgentIDfromSessionID(sessionID)).toEqual(
-        node.account.id
+        node.account.id,
     );
     expect(content.lastEditAt("hello")?.tx.txIndex).toEqual(0);
     content.set("hello", "B", "trusting");
     expect(content.lastEditAt("hello")?.tx.txIndex).toEqual(1);
     content.set("hello", "C", "trusting");
     expect(content.lastEditAt("hello")?.tx.txIndex).toEqual(2);
-});
+});