cojson 0.18.33 → 0.18.35

package/src/coValueCore/coValueCore.ts

@@ -1,5 +1,4 @@
 import { UpDownCounter, ValueType, metrics } from "@opentelemetry/api";
-import { Result, err, ok } from "neverthrow";
 import type { PeerState } from "../PeerState.js";
 import type { RawCoValue } from "../coValue.js";
 import type { ControlledAccountOrAgent } from "../coValues/account.js";
@@ -201,7 +200,7 @@ export class CoValueCore {
       }
     | {
         type: "errored";
-        error: TryAddTransactionsError;
+        error: unknown;
       }
   >();
 
@@ -474,12 +473,10 @@ export class CoValueCore {
       new SessionMap(this.id, this.node.crypto, streamingKnownState),
     );
 
-    this.resetKnownStateCache();
-
     return true;
   }
 
-  markErrored(peerId: PeerID, error: TryAddTransactionsError) {
+  markErrored(peerId: PeerID, error: unknown) {
     const previousState = this.loadingState;
     this.loadingStatuses.set(peerId, { type: "errored", error });
     this.updateCounter(previousState);
@@ -531,27 +528,18 @@ export class CoValueCore {
       .then((core) => core.getCurrentContent());
   }
 
-  private _cachedKnownStateWithStreaming?: CoValueKnownState;
   /**
    * Returns the known state considering the known state of the streaming source
    *
    * Used to correctly manage the content & subscriptions during the content streaming process
    */
   knownStateWithStreaming(): CoValueKnownState {
-    if (this._cachedKnownStateWithStreaming) {
-      return this._cachedKnownStateWithStreaming;
-    }
-
-    const knownState = this.verified
-      ? cloneKnownState(this.verified.knownStateWithStreaming())
-      : emptyKnownState(this.id);
-
-    this._cachedKnownStateWithStreaming = knownState;
-
-    return knownState;
+    return (
+      this.verified?.immutableKnownStateWithStreaming() ??
+      emptyKnownState(this.id)
+    );
   }
 
-  private _cachedKnownState?: CoValueKnownState;
   /**
    * Returns the known state of the CoValue
    *
@@ -560,17 +548,7 @@ export class CoValueCore {
    * On change the knownState is invalidated and a new object is returned.
    */
   knownState(): CoValueKnownState {
-    if (this._cachedKnownState) {
-      return this._cachedKnownState;
-    }
-
-    const knownState = this.verified
-      ? cloneKnownState(this.verified.knownState())
-      : emptyKnownState(this.id);
-
-    this._cachedKnownState = knownState;
-
-    return knownState;
+    return this.verified?.immutableKnownState() ?? emptyKnownState(this.id);
   }
 
   get meta(): JsonValue {
@@ -612,31 +590,36 @@ export class CoValueCore {
     newTransactions: Transaction[],
     newSignature: Signature,
     skipVerify: boolean = false,
-  ): Result<true, TryAddTransactionsError> {
-    let result: Result<SignerID | undefined, TryAddTransactionsError>;
+  ) {
+    let signerID: SignerID | undefined;
 
-    if (skipVerify) {
-      result = ok(undefined);
-    } else {
-      result = this.node
-        .resolveAccountAgent(
-          accountOrAgentIDfromSessionID(sessionID),
-          "Expected to know signer of transaction",
-        )
-        .andThen((agent) => {
-          return ok(this.crypto.getAgentSignerID(agent));
-        });
-    }
+    if (!skipVerify) {
+      const result = this.node.resolveAccountAgent(
+        accountOrAgentIDfromSessionID(sessionID),
+        "Expected to know signer of transaction",
+      );
 
-    return result.andThen((signerID) => {
-      if (!this.verified) {
-        return err({
-          type: "TriedToAddTransactionsWithoutVerifiedState",
+      if (result.error || !result.value) {
+        return {
+          type: "ResolveAccountAgentError",
           id: this.id,
-        } satisfies TriedToAddTransactionsWithoutVerifiedStateErrpr);
+          error: result.error,
+        } as const;
       }
 
-      const result = this.verified.tryAddTransactions(
+      signerID = this.crypto.getAgentSignerID(result.value);
+    }
+
+    if (!this.verified) {
+      return {
+        type: "TriedToAddTransactionsWithoutVerifiedState",
+        id: this.id,
+        error: undefined,
+      };
+    }
+
+    try {
+      this.verified.tryAddTransactions(
         sessionID,
         signerID,
         newTransactions,
@@ -644,19 +627,11 @@ export class CoValueCore {
         skipVerify,
       );
 
-      if (result.isOk()) {
-        this.resetKnownStateCache();
-        this.processNewTransactions();
-        this.scheduleNotifyUpdate();
-      }
-
-      return result;
-    });
-  }
-
-  private resetKnownStateCache() {
-    this._cachedKnownState = undefined;
-    this._cachedKnownStateWithStreaming = undefined;
+      this.processNewTransactions();
+      this.scheduleNotifyUpdate();
+    } catch (e) {
+      return { type: "InvalidSignature", id: this.id, error: e } as const;
+    }
   }
 
   private processNewTransactions() {
@@ -769,6 +744,8 @@ export class CoValueCore {
 
     let result: { signature: Signature; transaction: Transaction };
 
+    const knownStateBefore = this.knownState();
+
     if (privacy === "private") {
       const { secret: keySecret, id: keyID } = this.getCurrentReadKey();
 
@@ -795,7 +772,7 @@ export class CoValueCore {
       );
     }
 
-    const { transaction, signature } = result;
+    const { transaction } = result;
 
     // Assign pre-parsed meta and changes to skip the parse/decrypt operation when loading
     // this transaction in the current content
@@ -803,23 +780,13 @@ export class CoValueCore {
 
     this.node.syncManager.recordTransactionsSize([transaction], "local");
 
-    const session = this.verified.sessions.get(sessionID);
-    const txIdx = session ? session.transactions.length - 1 : 0;
-
-    this.resetKnownStateCache();
     this.processNewTransactions();
     this.addDependenciesFromNewTransaction(transaction);
 
     // force immediate notification because local updates may come from the UI
     // where we need synchronous updates
     this.notifyUpdate();
-    this.node.syncManager.syncLocalTransaction(
-      this.verified,
-      transaction,
-      sessionID,
-      signature,
-      txIdx,
-    );
+    this.node.syncManager.syncLocalTransaction(this.verified, knownStateBefore);
 
     return true;
   }

package/src/coValueCore/verifiedState.ts

@@ -1,10 +1,10 @@
-import { Result, err, ok } from "neverthrow";
 import { AnyRawCoValue } from "../coValue.js";
 import {
   createContentMessage,
   exceedsRecommendedSize,
   getTransactionSize,
   addTransactionToContentMessage,
+  knownStateFromContent,
 } from "../coValueContentMessage.js";
 import {
   CryptoProvider,
@@ -20,9 +20,13 @@ import { JsonObject, JsonValue } from "../jsonValue.js";
 import { PermissionsDef as RulesetDef } from "../permissions.js";
 import { NewContentMessage } from "../sync.js";
 import { TryAddTransactionsError } from "./coValueCore.js";
-import { SessionLog, SessionMap } from "./SessionMap.js";
+import { SessionMap } from "./SessionMap.js";
 import { ControlledAccountOrAgent } from "../coValues/account.js";
-import { CoValueKnownState, KnownStateSessions } from "../knownState.js";
+import {
+  CoValueKnownState,
+  getKnownStateToSend,
+  KnownStateSessions,
+} from "../knownState.js";
 
 export type CoValueHeader = {
   type: AnyRawCoValue["type"];
@@ -89,16 +93,14 @@ export class VerifiedState {
     newTransactions: Transaction[],
     newSignature: Signature,
     skipVerify: boolean = false,
-  ): Result<true, TryAddTransactionsError> {
-    const result = this.sessions.addTransaction(
+  ) {
+    this.sessions.addTransaction(
       sessionID,
       signerID,
       newTransactions,
       newSignature,
       skipVerify,
     );
-
-    return result;
   }
 
   makeNewTrustingTransaction(
@@ -158,6 +160,9 @@ export class VerifiedState {
 
   newContentSince(
     knownState: CoValueKnownState | undefined,
+    opts?: {
+      skipExpectContentUntil?: boolean;
+    },
   ): NewContentMessage[] | undefined {
     let currentPiece: NewContentMessage = createContentMessage(
       this.id,
@@ -285,10 +290,19 @@ export class VerifiedState {
     );
 
     if (piecesWithContent.length > 1 || this.isStreaming()) {
-      // Flag that more content is coming
-      firstPiece.expectContentUntil = {
-        ...this.knownStateWithStreaming().sessions,
-      };
+      if (!opts?.skipExpectContentUntil) {
+        // Flag that more content is coming
+        if (knownState) {
+          firstPiece.expectContentUntil = getKnownStateToSend(
+            this.knownStateWithStreaming().sessions,
+            knownState.sessions,
+          );
+        } else {
+          firstPiece.expectContentUntil = {
+            ...this.knownStateWithStreaming().sessions,
+          };
+        }
+      }
     }
 
     if (piecesWithContent.length === 0) {
@@ -306,6 +320,17 @@ export class VerifiedState {
     return this.sessions.knownStateWithStreaming ?? this.knownState();
   }
 
+  immutableKnownState() {
+    return this.sessions.immutableKnownState;
+  }
+
+  immutableKnownStateWithStreaming() {
+    return (
+      this.sessions.immutableKnownStateWithStreaming ??
+      this.immutableKnownState()
+    );
+  }
+
   isStreaming(): boolean {
     return Boolean(this.sessions.knownStateWithStreaming);
   }

package/src/coValues/group.ts

@@ -508,12 +508,14 @@ export class RawGroup<
         memberRole === "writerInvite" ||
         memberRole === "adminInvite"
       ) {
-        const otherMemberAgent = this.core.node
-          .resolveAccountAgent(
-            otherMemberKey,
-            "Expected member agent to be loaded",
-          )
-          ._unsafeUnwrap({ withStackTrace: true });
+        const otherMemberAgent = this.core.node.resolveAccountAgent(
+          otherMemberKey,
+          "Expected member agent to be loaded",
+        ).value;
+
+        if (!otherMemberAgent) {
+          throw new Error("Expected member agent to be loaded");
+        }
 
         this.storeKeyRevelationForMember(
           otherMemberKey,
@@ -689,9 +691,14 @@ export class RawGroup<
 
     if (lastReadyKeyEdit?.value) {
       const revealer = lastReadyKeyEdit.by;
-      const revealerAgent = core.node
-        .resolveAccountAgent(revealer, "Expected to know revealer")
-        ._unsafeUnwrap({ withStackTrace: true });
+      const revealerAgent = core.node.resolveAccountAgent(
+        revealer,
+        "Expected to know revealer",
+      ).value;
+
+      if (!revealerAgent) {
+        throw new Error("Expected to know revealer");
+      }
 
       const secret = this.crypto.unseal(
         lastReadyKeyEdit.value,
@@ -841,12 +848,14 @@ export class RawGroup<
     const newReadKey = this.crypto.newRandomKeySecret();
 
     for (const readerID of currentlyPermittedReaders) {
-      const agent = this.core.node
-        .resolveAccountAgent(
-          readerID,
-          "Expected to know currently permitted reader",
-        )
-        ._unsafeUnwrap({ withStackTrace: true });
+      const agent = this.core.node.resolveAccountAgent(
+        readerID,
+        "Expected to know currently permitted reader",
+      ).value;
+
+      if (!agent) {
+        throw new Error("Expected to know currently permitted reader");
+      }
 
       this.storeKeyRevelationForMember(
         readerID,
@@ -861,12 +870,14 @@ export class RawGroup<
      * and reveal them to the other non-writeOnly members
      */
     for (const writeOnlyMemberID of writeOnlyMembers) {
-      const agent = this.core.node
-        .resolveAccountAgent(
-          writeOnlyMemberID,
-          "Expected to know writeOnly member",
-        )
-        ._unsafeUnwrap({ withStackTrace: true });
+      const agent = this.core.node.resolveAccountAgent(
+        writeOnlyMemberID,
+        "Expected to know writeOnly member",
+      ).value;
+
+      if (!agent) {
+        throw new Error("Expected to know writeOnly member");
+      }
 
       const writeOnlyKey = this.crypto.newRandomKeySecret();
 
@@ -879,12 +890,14 @@ export class RawGroup<
       this.set(`writeKeyFor_${writeOnlyMemberID}`, writeOnlyKey.id, "trusting");
 
       for (const readerID of currentlyPermittedReaders) {
-        const agent = this.core.node
-          .resolveAccountAgent(
-            readerID,
-            "Expected to know currently permitted reader",
-          )
-          ._unsafeUnwrap({ withStackTrace: true });
+        const agent = this.core.node.resolveAccountAgent(
+          readerID,
+          "Expected to know currently permitted reader",
+        ).value;
+
+        if (!agent) {
+          throw new Error("Expected to know currently permitted reader");
+        }
 
         this.storeKeyRevelationForMember(
           readerID,

package/src/knownState.ts

@@ -106,18 +106,53 @@ export function cloneKnownState(knownState: CoValueKnownState) {
   };
 }
 
+/**
+ * Checks if all the local sessions have the same counters as in remote.
+ */
+export function areCurrentSessionsInSyncWith(
+  current: Record<string, number>,
+  target: Record<string, number>,
+) {
+  for (const [sessionId, currentCount] of Object.entries(current)) {
+    const targetCount = target[sessionId] ?? 0;
+    if (currentCount !== targetCount) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
 /**
  * Checks if all the local sessions have the same counters as in remote.
  */
 export function isKnownStateSubsetOf(
-  local: Record<string, number>,
-  remote: Record<string, number>,
+  current: Record<string, number>,
+  target: Record<string, number>,
 ) {
-  for (const sessionId of Object.keys(local)) {
-    if (local[sessionId] !== remote[sessionId]) {
+  for (const [sessionId, currentCount] of Object.entries(current)) {
+    const targetCount = target[sessionId] ?? 0;
+    if (currentCount > targetCount) {
       return false;
     }
   }
 
   return true;
 }
+
+/**
+ * Returns the record with the sessions that need to be sent to the target
+ */
+export function getKnownStateToSend(
+  current: Record<string, number>,
+  target: Record<string, number>,
+) {
+  const toSend: Record<string, number> = {};
+  for (const [sessionId, currentCount] of Object.entries(current)) {
+    const targetCount = target[sessionId] ?? 0;
+    if (currentCount > targetCount) {
+      toSend[sessionId] = currentCount;
+    }
+  }
+  return toSend;
+}

package/src/localNode.ts

@@ -1,4 +1,3 @@
-import { Result, err, ok } from "neverthrow";
 import { GarbageCollector } from "./GarbageCollector.js";
 import type { CoID } from "./coValue.js";
 import type { RawCoValue } from "./coValue.js";
@@ -10,7 +9,6 @@ import {
 import {
   type CoValueHeader,
   type CoValueUniqueness,
-  VerifiedState,
 } from "./coValueCore/verifiedState.js";
 import {
   AccountMeta,
@@ -31,7 +29,7 @@ import {
   type RawGroup,
   secretSeedFromInviteSecret,
 } from "./coValues/group.js";
-import { CO_VALUE_LOADING_CONFIG, GARBAGE_COLLECTOR_CONFIG } from "./config.js";
+import { CO_VALUE_LOADING_CONFIG } from "./config.js";
 import { AgentSecret, CryptoProvider } from "./crypto/crypto.js";
 import { AgentID, RawCoID, SessionID, isAgentID } from "./ids.js";
 import { logger } from "./logger.js";
@@ -41,6 +39,7 @@ import { accountOrAgentIDfromSessionID } from "./typeUtils/accountOrAgentIDfromS
 import { expectGroup } from "./typeUtils/expectGroup.js";
 import { canBeBranched } from "./coValueCore/branching.js";
 import { connectedPeers } from "./streamUtils.js";
+import { emptyKnownState } from "./knownState.js";
 
 /** A `LocalNode` represents a local view of a set of loaded `CoValue`s, from the perspective of a particular account (or primitive cryptographic agent).
 
@@ -380,7 +379,10 @@ export class LocalNode {
     }
 
     this.garbageCollector?.trackCoValueAccess(coValue);
-    this.syncManager.syncHeader(coValue.verified);
+    this.syncManager.syncLocalTransaction(
+      coValue.verified,
+      emptyKnownState(id),
+    );
 
     return coValue;
   }
@@ -686,12 +688,9 @@ export class LocalNode {
   }
 
   /** @internal */
-  resolveAccountAgent(
-    id: RawAccountID | AgentID,
-    expectation?: string,
-  ): Result<AgentID, ResolveAccountAgentError> {
+  resolveAccountAgent(id: RawAccountID | AgentID, expectation?: string) {
     if (isAgentID(id)) {
-      return ok(id);
+      return { value: id, error: undefined };
     }
 
     let coValue: AvailableCoValueCore;
@@ -699,12 +698,7 @@ export class LocalNode {
     try {
       coValue = this.expectCoValueLoaded(id, expectation);
     } catch (e) {
-      return err({
-        type: "ErrorLoadingCoValueCore",
-        expectation,
-        id,
-        error: e,
-      } satisfies LoadCoValueCoreError);
+      return { value: undefined, error: e };
     }
 
     if (
@@ -714,14 +708,15 @@ export class LocalNode {
       !("type" in coValue.verified.header.meta) ||
       coValue.verified.header.meta.type !== "account"
     ) {
-      return err({
-        type: "UnexpectedlyNotAccount",
-        expectation,
-        id,
-      } satisfies UnexpectedlyNotAccountError);
+      return {
+        value: undefined,
+        error: new Error(`Unexpectedly not account: ${expectation}`),
+      };
     }
 
-    return ok((coValue.getCurrentContent() as RawAccount).currentAgentID());
+    const account = coValue.getCurrentContent() as RawAccount;
+
+    return { value: account.currentAgentID(), error: undefined };
   }
 
   createGroup(