cojson 0.13.16 → 0.13.18

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/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";
@@ -158,7 +160,7 @@ export class SyncManager {
   }
 
   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 +199,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 +218,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 +242,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 +284,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 +371,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 +383,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,
@@ -398,17 +400,16 @@ export class SyncManager {
       }
     }
 
-    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 +427,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 +441,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 +450,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 +472,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 +487,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 +501,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 +525,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 +555,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 +568,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) {
@@ -609,11 +644,9 @@ export class SyncManager {
   }
 
   async syncCoValue(coValue: CoValueCore) {
-    const entry = this.local.coValuesStore.get(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 (
@@ -669,11 +702,11 @@ export class SyncManager {
   }
 
   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(