cojson 0.13.17 → 0.13.20

package/src/permissions.ts

@@ -1,5 +1,6 @@
 import { CoID } from "./coValue.js";
-import { CoValueCore, Transaction } from "./coValueCore.js";
+import { CoValueCore } from "./coValueCore/coValueCore.js";
+import { Transaction } from "./coValueCore/verifiedState.js";
 import { RawAccount, RawAccountID, RawProfile } from "./coValues/account.js";
 import { MapOpPayload } from "./coValues/coMap.js";
 import {
@@ -64,19 +65,23 @@ export function determineValidTransactions(
   coValue: CoValueCore,
   knownTransactions?: CoValueKnownState["sessions"],
 ): { txID: TransactionID; tx: Transaction }[] {
-  if (coValue.header.ruleset.type === "group") {
-    const initialAdmin = coValue.header.ruleset.initialAdmin;
+  if (!coValue.isAvailable()) {
+    throw new Error("determineValidTransactions CoValue is not available");
+  }
+
+  if (coValue.verified.header.ruleset.type === "group") {
+    const initialAdmin = coValue.verified.header.ruleset.initialAdmin;
     if (!initialAdmin) {
       throw new Error("Group must have initialAdmin");
     }
 
     return determineValidTransactionsForGroup(coValue, initialAdmin)
       .validTransactions;
-  } else if (coValue.header.ruleset.type === "ownedByGroup") {
+  } else if (coValue.verified.header.ruleset.type === "ownedByGroup") {
     const groupContent = expectGroup(
       coValue.node
         .expectCoValueLoaded(
-          coValue.header.ruleset.group,
+          coValue.verified.header.ruleset.group,
           "Determining valid transaction in owned object but its group wasn't loaded",
         )
         .getCurrentContent(),
@@ -88,7 +93,7 @@ export function determineValidTransactions(
 
     const validTransactions: ValidTransactionsResult[] = [];
 
-    for (const [sessionID, sessionLog] of coValue.sessionLogs.entries()) {
+    for (const [sessionID, sessionLog] of coValue.verified.sessions.entries()) {
       const transactor = accountOrAgentIDfromSessionID(sessionID);
       const knownTransactionsForSession = knownTransactions?.[sessionID] ?? -1;
 
@@ -123,10 +128,10 @@ export function determineValidTransactions(
     }
 
     return validTransactions;
-  } else if (coValue.header.ruleset.type === "unsafeAllowAll") {
+  } else if (coValue.verified.header.ruleset.type === "unsafeAllowAll") {
     const validTransactions: ValidTransactionsResult[] = [];
 
-    for (const [sessionID, sessionLog] of coValue.sessionLogs.entries()) {
+    for (const [sessionID, sessionLog] of coValue.verified.sessions.entries()) {
       const knownTransactionsForSession = knownTransactions?.[sessionID] ?? -1;
 
       sessionLog.transactions.forEach((tx, txIndex) => {
@@ -141,7 +146,7 @@ export function determineValidTransactions(
   } else {
     throw new Error(
       "Unknown ruleset type " +
-        (coValue.header.ruleset as { type: string }).type,
+        (coValue.verified.header.ruleset as { type: string }).type,
     );
   }
 }
@@ -167,7 +172,7 @@ function resolveMemberStateFromParentReference(
     "Expected parent group to be loaded",
   );
 
-  if (parentGroup.header.ruleset.type !== "group") {
+  if (parentGroup.verified.header.ruleset.type !== "group") {
     return;
   }
 
@@ -176,7 +181,7 @@ function resolveMemberStateFromParentReference(
     return;
   }
 
-  const initialAdmin = parentGroup.header.ruleset.initialAdmin;
+  const initialAdmin = parentGroup.verified.header.ruleset.initialAdmin;
 
   if (!initialAdmin) {
     throw new Error("Group must have initialAdmin");
@@ -214,7 +219,8 @@ function determineValidTransactionsForGroup(
     tx: Transaction;
   }[] = [];
 
-  for (const [sessionID, sessionLog] of coValue.sessionLogs.entries()) {
+  for (const [sessionID, sessionLog] of coValue.verified?.sessions.entries() ??
+    []) {
     sessionLog.transactions.forEach((tx, txIndex) => {
       allTransactionsSorted.push({ sessionID, txIndex, tx });
     });

package/src/priority.ts

@@ -1,4 +1,4 @@
-import { type CoValueHeader } from "./coValueCore.js";
+import { type CoValueHeader } from "./coValueCore/verifiedState.js";
 
 /**
  * The priority of a `CoValue` determines how much priority is given

package/src/streamUtils.ts

@@ -6,23 +6,17 @@ export function connectedPeers(
   peer1id: PeerID,
   peer2id: PeerID,
   {
-    trace = false,
     peer1role = "client",
     peer2role = "client",
     crashOnClose = false,
   }: {
-    trace?: boolean;
     peer1role?: Peer["role"];
     peer2role?: Peer["role"];
     crashOnClose?: boolean;
   } = {},
 ): [Peer, Peer] {
-  const [from1to2Rx, from1to2Tx] = newQueuePair(
-    trace ? { traceAs: `${peer1id} -> ${peer2id}` } : undefined,
-  );
-  const [from2to1Rx, from2to1Tx] = newQueuePair(
-    trace ? { traceAs: `${peer2id} -> ${peer1id}` } : undefined,
-  );
+  const [from1to2Rx, from1to2Tx] = newQueuePair();
+  const [from2to1Rx, from2to1Tx] = newQueuePair();
 
   const peer2AsPeer: Peer = {
     id: peer2id,
@@ -43,32 +37,11 @@ export function connectedPeers(
   return [peer1AsPeer, peer2AsPeer];
 }
 
-export function newQueuePair(
-  options: { traceAs?: string } = {},
-): [AsyncIterable<SyncMessage>, Channel<SyncMessage>] {
+export function newQueuePair(): [
+  AsyncIterable<SyncMessage>,
+  Channel<SyncMessage>,
+] {
   const channel = new Channel<SyncMessage>();
 
-  if (options.traceAs) {
-    return [
-      (async function* () {
-        for await (const msg of channel) {
-          console.debug(
-            options.traceAs,
-            JSON.stringify(
-              msg,
-              (k, v) =>
-                k === "changes" || k === "encryptedChanges"
-                  ? v.slice(0, 20) + "..."
-                  : v,
-              2,
-            ),
-          );
-          yield msg;
-        }
-      })(),
-      channel,
-    ];
-  } else {
-    return [channel.wrap(), channel];
-  }
+  return [channel.wrap(), channel];
 }

package/src/sync.ts

@@ -1,9 +1,11 @@
 import { Histogram, ValueType, metrics } from "@opentelemetry/api";
 import { PeerState } from "./PeerState.js";
 import { SyncStateManager } from "./SyncStateManager.js";
-import { CoValueHeader, Transaction } from "./coValueCore.js";
-import { CoValueCore } from "./coValueCore.js";
-import { CoValueState } from "./coValueState.js";
+import {
+  AvailableCoValueCore,
+  CoValueCore,
+} from "./coValueCore/coValueCore.js";
+import { CoValueHeader, Transaction } from "./coValueCore/verifiedState.js";
 import { Signature } from "./crypto/crypto.js";
 import { RawCoID, SessionID } from "./ids.js";
 import { LocalNode } from "./localNode.js";
@@ -157,8 +159,14 @@ export class SyncManager {
     );
   }
 
+  hasStoragePeers(): boolean {
+    return this.getPeers().some(
+      (peer) => peer.role === "storage" && !peer.closed,
+    );
+  }
+
   handleSyncMessage(msg: SyncMessage, peer: PeerState) {
-    if (this.local.coValuesStore.get(msg.id).isErroredInPeer(peer.id)) {
+    if (this.local.getCoValue(msg.id).isErroredInPeer(peer.id)) {
       logger.warn(
         `Skipping message ${msg.action} on errored coValue ${msg.id} from peer ${peer.id}`,
       );
@@ -197,13 +205,17 @@ export class SyncManager {
   }
 
   sendNewContentIncludingDependencies(id: RawCoID, peer: PeerState) {
-    const coValue = this.local.expectCoValueLoaded(id);
+    const coValue = this.local.getCoValue(id);
+
+    if (!coValue.isAvailable()) {
+      return;
+    }
 
     coValue
       .getDependedOnCoValues()
       .map((id) => this.sendNewContentIncludingDependencies(id, peer));
 
-    const newContentPieces = coValue.newContentSince(
+    const newContentPieces = coValue.verified.newContentSince(
       peer.optimisticKnownStates.get(id),
     );
 
@@ -212,16 +224,15 @@ export class SyncManager {
         this.trySendToPeer(peer, piece);
       }
 
-      peer.toldKnownState.add(id);
       peer.combineOptimisticWith(id, coValue.knownState());
     } else if (!peer.toldKnownState.has(id)) {
       this.trySendToPeer(peer, {
         action: "known",
         ...coValue.knownState(),
       });
-
-      peer.toldKnownState.add(id);
     }
+
+    peer.trackToldKnownState(id);
   }
 
   startPeerReconciliation(peer: PeerState) {
@@ -237,40 +248,38 @@ export class SyncManager {
       gathered.add(coValue.id);
 
       for (const id of coValue.getDependedOnCoValues()) {
-        const entry = this.local.coValuesStore.get(id);
+        const coValue = this.local.getCoValue(id);
 
-        if (entry.isAvailable()) {
-          buildOrderedCoValueList(entry.core);
+        if (coValue.isAvailable()) {
+          buildOrderedCoValueList(coValue);
         }
       }
 
       coValuesOrderedByDependency.push(coValue);
     };
 
-    for (const entry of this.local.coValuesStore.getValues()) {
-      if (!entry.isAvailable()) {
+    for (const coValue of this.local.allCoValues()) {
+      if (!coValue.isAvailable()) {
         // If the coValue is unavailable and we never tried this peer
         // we try to load it from the peer
-        if (!peer.toldKnownState.has(entry.id)) {
-          peer.toldKnownState.add(entry.id);
+        if (!peer.loadRequestSent.has(coValue.id)) {
+          peer.trackLoadRequestSent(coValue.id);
           this.trySendToPeer(peer, {
             action: "load",
             header: false,
-            id: entry.id,
+            id: coValue.id,
             sessions: {},
           });
         }
       } else {
-        const coValue = entry.core;
-
         // Build the list of coValues ordered by dependency
         // so we can send the load message in the correct order
         buildOrderedCoValueList(coValue);
       }
 
       // Fill the missing known states with empty known states
-      if (!peer.optimisticKnownStates.has(entry.id)) {
-        peer.setOptimisticKnownState(entry.id, "empty");
+      if (!peer.optimisticKnownStates.has(coValue.id)) {
+        peer.setOptimisticKnownState(coValue.id, "empty");
       }
     }
 
@@ -281,7 +290,7 @@ export class SyncManager {
        * - Start the sync process in case we or the other peer
        *   lacks some transactions
        */
-      peer.toldKnownState.add(coValue.id);
+      peer.trackLoadRequestSent(coValue.id);
       this.trySendToPeer(peer, {
         action: "load",
         ...coValue.knownState(),
@@ -368,11 +377,11 @@ export class SyncManager {
      *
      */
     peer.setKnownState(msg.id, knownStateIn(msg));
-    const entry = this.local.coValuesStore.get(msg.id);
+    const coValue = this.local.getCoValue(msg.id);
 
     if (
-      entry.highLevelState === "unknown" ||
-      entry.highLevelState === "unavailable"
+      coValue.loadingState === "unknown" ||
+      coValue.loadingState === "unavailable"
     ) {
       const eligiblePeers = this.getServerAndStoragePeers(peer.id);
 
@@ -380,8 +389,7 @@ export class SyncManager {
         // We don't have any eligible peers to load the coValue from
         // so we send a known state back to the sender to let it know
         // that the coValue is unavailable
-        peer.toldKnownState.add(msg.id);
-
+        peer.trackToldKnownState(msg.id);
         this.trySendToPeer(peer, {
           action: "known",
           id: msg.id,
@@ -391,24 +399,25 @@ export class SyncManager {
 
         return;
       } else {
-        // Should move the state to loading
-        this.local.loadCoValueCore(msg.id, peer.id).catch((e) => {
-          logger.error("Error loading coValue in handleLoad", { err: e });
-        });
+        // Syncronously updates the state loading is possible
+        coValue
+          .loadFromPeers(this.getServerAndStoragePeers(peer.id))
+          .catch((e) => {
+            logger.error("Error loading coValue in handleLoad", { err: e });
+          });
       }
     }
 
-    if (entry.highLevelState === "loading") {
+    if (coValue.loadingState === "loading") {
       // We need to return from handleLoad immediately and wait for the CoValue to be loaded
       // in a new task, otherwise we might block further incoming content messages that would
       // resolve the CoValue as available. This can happen when we receive fresh
       // content from a client, but we are a server with our own upstream server(s)
-      entry
-        .getCoValue()
+      coValue
+        .waitForAvailableOrUnavailable()
         .then(async (value) => {
-          if (value === "unavailable") {
-            peer.toldKnownState.add(msg.id);
-
+          if (!value.isAvailable()) {
+            peer.trackToldKnownState(msg.id);
             this.trySendToPeer(peer, {
               action: "known",
               id: msg.id,
@@ -426,9 +435,10 @@ export class SyncManager {
             err: e,
           });
         });
-    } else if (entry.isAvailable()) {
+    } else if (coValue.isAvailable()) {
       this.sendNewContentIncludingDependencies(msg.id, peer);
     } else {
+      peer.trackToldKnownState(msg.id);
       this.trySendToPeer(peer, {
         action: "known",
         id: msg.id,
@@ -439,7 +449,7 @@ export class SyncManager {
   }
 
   handleKnownState(msg: KnownStateMessage, peer: PeerState) {
-    const entry = this.local.coValuesStore.get(msg.id);
+    const coValue = this.local.getCoValue(msg.id);
 
     peer.combineWith(msg.id, knownStateIn(msg));
 
@@ -448,10 +458,10 @@ export class SyncManager {
     const availableOnPeer = peer.optimisticKnownStates.get(msg.id)?.header;
 
     if (!availableOnPeer) {
-      entry.markNotFoundInPeer(peer.id);
+      coValue.markNotFoundInPeer(peer.id);
     }
 
-    if (entry.isAvailable()) {
+    if (coValue.isAvailable()) {
       this.sendNewContentIncludingDependencies(msg.id, peer);
     }
   }
@@ -470,11 +480,9 @@ export class SyncManager {
   }
 
   handleNewContent(msg: NewContentMessage, peer: PeerState) {
-    const entry = this.local.coValuesStore.get(msg.id);
-
-    let coValue: CoValueCore;
+    const coValue = this.local.getCoValue(msg.id);
 
-    if (!entry.isAvailable()) {
+    if (!coValue.isAvailable()) {
       if (!msg.header) {
         this.trySendToPeer(peer, {
           action: "known",
@@ -487,12 +495,11 @@ export class SyncManager {
       }
 
       peer.updateHeader(msg.id, true);
+      coValue.markAvailable(msg.header, peer.id);
+    }
 
-      coValue = new CoValueCore(msg.header, this.local);
-
-      entry.markAvailable(coValue, peer.id);
-    } else {
-      coValue = entry.core;
+    if (!coValue.isAvailable()) {
+      throw new Error("Unreachable: CoValue should be available in every case");
     }
 
     let invalidStateAssumed = false;
@@ -502,7 +509,7 @@ export class SyncManager {
       SessionNewContent,
     ][]) {
       const ourKnownTxIdx =
-        coValue.sessionLogs.get(sessionID)?.transactions.length;
+        coValue.verified.sessions.get(sessionID)?.transactions.length;
       const theirFirstNewTxIdx = newContentForSession.after;
 
       if ((ourKnownTxIdx || 0) < theirFirstNewTxIdx) {
@@ -526,16 +533,17 @@ export class SyncManager {
         newTransactions,
         undefined,
         newContentForSession.lastSignature,
+        "immediate", // TODO: can we change this to deferred?
       );
 
       if (result.isErr()) {
-        logger.error("Failed to add transactions", {
+        console.error("Failed to add transactions", {
           peerId: peer.id,
           peerRole: peer.role,
           id: msg.id,
           err: result.error,
         });
-        entry.markErrored(peer.id, result.error);
+        coValue.markErrored(peer.id, result.error);
         continue;
       }
 
@@ -555,7 +563,7 @@ export class SyncManager {
         isCorrection: true,
         ...coValue.knownState(),
       });
-      peer.toldKnownState.add(msg.id);
+      peer.trackToldKnownState(msg.id);
     } else {
       /**
        * We are sending a known state message to the peer to acknowledge the
@@ -568,15 +576,50 @@ export class SyncManager {
         action: "known",
         ...coValue.knownState(),
       });
-      peer.toldKnownState.add(msg.id);
+      peer.trackToldKnownState(msg.id);
     }
 
-    /**
-     * We do send a correction/ack message before syncing to give an immediate
-     * response to the peers that are waiting for confirmation that a coValue is
-     * fully synced
-     */
-    this.requestCoValueSync(coValue);
+    const sourcePeer = peer;
+    const syncedPeers = [];
+
+    for (const peer of this.peersInPriorityOrder()) {
+      /**
+       * We sync the content against the source peer if it is a client or server peers
+       * to upload any content that is available on the current node and not on the source peer.
+       *
+       * We don't need to do this with storage peers because we don't get updates from those peers,
+       * only load and store content.
+       */
+      if (peer.id === sourcePeer.id && sourcePeer.role === "storage") continue;
+      if (peer.closed) continue;
+      if (coValue.isErroredInPeer(peer.id)) continue;
+
+      // We directly forward the new content to peers that have an active subscription
+      if (peer.optimisticKnownStates.has(coValue.id)) {
+        this.sendNewContentIncludingDependencies(coValue.id, peer);
+        syncedPeers.push(peer);
+      } else if (
+        peer.isServerOrStoragePeer() &&
+        !peer.loadRequestSent.has(coValue.id)
+      ) {
+        const state = coValue.getStateForPeer(peer.id)?.type;
+
+        // Check if there is a inflight load operation and we
+        // are waiting for other peers to send the load request
+        if (state === "unknown" || state === undefined) {
+          this.trySendToPeer(peer, {
+            action: "load",
+            ...coValue.knownState(),
+          });
+          peer.trackLoadRequestSent(coValue.id);
+          syncedPeers.push(peer);
+        }
+      }
+    }
+
+    for (const peer of syncedPeers) {
+      this.syncState.triggerUpdate(peer.id, coValue.id);
+    }
   }
 
   handleCorrection(msg: KnownStateMessage, peer: PeerState) {
@@ -587,33 +630,27 @@ export class SyncManager {
 
   handleUnsubscribe(_msg: DoneMessage) {}
 
-  requestedSyncs = new Map<RawCoID, Promise<void>>();
-
-  async requestCoValueSync(coValue: CoValueCore) {
-    const promise = this.requestedSyncs.get(coValue.id);
+  requestedSyncs = new Set<RawCoID>();
+  requestCoValueSync(coValue: CoValueCore) {
+    if (this.requestedSyncs.has(coValue.id)) {
+      return;
+    }
 
-    if (promise) {
-      return promise;
-    } else {
-      const promise = new Promise<void>((resolve) => {
-        queueMicrotask(() => {
-          this.requestedSyncs.delete(coValue.id);
-          this.syncCoValue(coValue);
-          resolve();
-        });
-      });
+    queueMicrotask(() => {
+      if (this.requestedSyncs.has(coValue.id)) {
+        this.syncCoValue(coValue);
+      }
+    });
 
-      this.requestedSyncs.set(coValue.id, promise);
-      return promise;
-    }
+    this.requestedSyncs.add(coValue.id);
   }
 
   async syncCoValue(coValue: CoValueCore) {
-    const entry = this.local.coValuesStore.get(coValue.id);
+    this.requestedSyncs.delete(coValue.id);
 
     for (const peer of this.peersInPriorityOrder()) {
       if (peer.closed) continue;
-      if (entry.isErroredInPeer(peer.id)) continue;
+      if (coValue.isErroredInPeer(peer.id)) continue;
 
       // Only subscribed CoValues are synced to clients
       if (
@@ -641,6 +678,21 @@ export class SyncManager {
       return true;
     }
 
+    const peerState = this.peers[peerId];
+
+    // The peer has been closed, so it isn't possible to sync
+    if (!peerState || peerState.closed) {
+      return true;
+    }
+
+    // The client isn't subscribed to the coValue, so we won't sync it
+    if (
+      peerState.role === "client" &&
+      !peerState.optimisticKnownStates.has(id)
+    ) {
+      return true;
+    }
+
     return new Promise((resolve, reject) => {
       const unsubscribe = this.syncState.subscribeToPeerUpdates(
         peerId,
@@ -660,20 +712,30 @@ export class SyncManager {
     });
   }
 
+  async waitForStorageSync(id: RawCoID, timeout = 30_000) {
+    const peers = this.getPeers();
+
+    await Promise.all(
+      peers
+        .filter((peer) => peer.role === "storage")
+        .map((peer) => this.waitForSyncWithPeer(peer.id, id, timeout)),
+    );
+  }
+
   async waitForSync(id: RawCoID, timeout = 30_000) {
     const peers = this.getPeers();
 
-    return Promise.all(
+    await Promise.all(
       peers.map((peer) => this.waitForSyncWithPeer(peer.id, id, timeout)),
     );
   }
 
   async waitForAllCoValuesSync(timeout = 60_000) {
-    const coValues = this.local.coValuesStore.getValues();
+    const coValues = this.local.allCoValues();
     const validCoValues = Array.from(coValues).filter(
       (coValue) =>
-        coValue.highLevelState === "available" ||
-        coValue.highLevelState === "loading",
+        coValue.loadingState === "available" ||
+        coValue.loadingState === "loading",
     );
 
     return Promise.all(

package/src/tests/PeerState.test.ts

@@ -174,9 +174,6 @@ describe("PeerState", () => {
   test("should dispatch to both states", () => {
     const { peerState } = setup();
     const knownStatesSpy = vi.spyOn(peerState._knownStates, "set");
-    if (peerState._optimisticKnownStates === "assumeInfallible") {
-      throw new Error("Expected normal optimisticKnownStates");
-    }
 
     const optimisticKnownStatesSpy = vi.spyOn(
       peerState._optimisticKnownStates,
@@ -195,40 +192,6 @@ describe("PeerState", () => {
     expect(optimisticKnownStatesSpy).toHaveBeenCalledWith("co_z1", state);
   });
 
-  test("should use same reference for knownStates and optimisticKnownStates for storage peers", () => {
-    const mockStoragePeer: Peer = {
-      id: "test-storage-peer",
-      role: "storage",
-      priority: 1,
-      crashOnClose: false,
-      incoming: (async function* () {})(),
-      outgoing: {
-        push: vi.fn().mockResolvedValue(undefined),
-        close: vi.fn(),
-      },
-    };
-    const peerState = new PeerState(mockStoragePeer, undefined);
-
-    // Verify they are the same reference
-    expect(peerState.knownStates).toBe(peerState.optimisticKnownStates);
-
-    // Verify that dispatching only updates one state
-    const knownStatesSpy = vi.spyOn(peerState._knownStates, "set");
-    expect(peerState._optimisticKnownStates).toBe("assumeInfallible");
-
-    const state: CoValueKnownState = {
-      id: "co_z1",
-      header: false,
-      sessions: {},
-    };
-
-    peerState.setKnownState("co_z1", state);
-
-    // Only one dispatch should happen since they're the same reference
-    expect(knownStatesSpy).toHaveBeenCalledTimes(1);
-    expect(knownStatesSpy).toHaveBeenCalledWith("co_z1", state);
-  });
-
   test("should use separate references for knownStates and optimisticKnownStates for non-storage peers", () => {
     const { peerState } = setup(); // Uses a regular peer