cojson 0.13.17 → 0.13.20

package/src/coValueCore/verifiedState.ts

@@ -0,0 +1,376 @@
+import { Result, err, ok } from "neverthrow";
+import { AnyRawCoValue } from "../coValue.js";
+import {
+  CryptoProvider,
+  Encrypted,
+  Hash,
+  KeyID,
+  Signature,
+  SignerID,
+  StreamingHash,
+} from "../crypto/crypto.js";
+import { RawCoID, SessionID, TransactionID } from "../ids.js";
+import { Stringified } from "../jsonStringify.js";
+import { JsonObject, JsonValue } from "../jsonValue.js";
+import { PermissionsDef as RulesetDef } from "../permissions.js";
+import { getPriorityFromHeader } from "../priority.js";
+import { CoValueKnownState, NewContentMessage } from "../sync.js";
+import {
+  InvalidHashError,
+  InvalidSignatureError,
+  MAX_RECOMMENDED_TX_SIZE,
+} from "./coValueCore.js";
+import { TryAddTransactionsError } from "./coValueCore.js";
+
+export type CoValueHeader = {
+  type: AnyRawCoValue["type"];
+  ruleset: RulesetDef;
+  meta: JsonObject | null;
+} & CoValueUniqueness;
+
+export type CoValueUniqueness = {
+  uniqueness: JsonValue;
+  createdAt?: `2${string}` | null;
+};
+
+export type PrivateTransaction = {
+  privacy: "private";
+  madeAt: number;
+  keyUsed: KeyID;
+  encryptedChanges: Encrypted<JsonValue[], { in: RawCoID; tx: TransactionID }>;
+};
+
+export type TrustingTransaction = {
+  privacy: "trusting";
+  madeAt: number;
+  changes: Stringified<JsonValue[]>;
+};
+
+export type Transaction = PrivateTransaction | TrustingTransaction;
+
+type SessionLog = {
+  readonly transactions: Transaction[];
+  lastHash?: Hash;
+  streamingHash: StreamingHash;
+  readonly signatureAfter: { [txIdx: number]: Signature | undefined };
+  lastSignature: Signature;
+};
+
+export type ValidatedSessions = Map<SessionID, SessionLog>;
+
+export class VerifiedState {
+  readonly id: RawCoID;
+  readonly crypto: CryptoProvider;
+  readonly header: CoValueHeader;
+  readonly sessions: ValidatedSessions;
+  private _cachedKnownState?: CoValueKnownState;
+  private _cachedNewContentSinceEmpty: NewContentMessage[] | undefined;
+
+  constructor(
+    id: RawCoID,
+    crypto: CryptoProvider,
+    header: CoValueHeader,
+    sessions: ValidatedSessions,
+  ) {
+    this.id = id;
+    this.crypto = crypto;
+    this.header = header;
+    this.sessions = sessions;
+  }
+
+  clone(): VerifiedState {
+    // do a deep clone, including the sessions
+    const clonedSessions = new Map();
+    for (let [sessionID, sessionLog] of this.sessions) {
+      clonedSessions.set(sessionID, {
+        lastSignature: sessionLog.lastSignature,
+        lastHash: sessionLog.lastHash,
+        streamingHash: sessionLog.streamingHash.clone(),
+        signatureAfter: { ...sessionLog.signatureAfter },
+        transactions: sessionLog.transactions.slice(),
+      } satisfies SessionLog);
+    }
+    return new VerifiedState(this.id, this.crypto, this.header, clonedSessions);
+  }
+
+  tryAddTransactions(
+    sessionID: SessionID,
+    signerID: SignerID,
+    newTransactions: Transaction[],
+    givenExpectedNewHash: Hash | undefined,
+    newSignature: Signature,
+    skipVerify: boolean = false,
+    givenNewStreamingHash?: StreamingHash,
+  ): Result<true, TryAddTransactionsError> {
+    if (skipVerify === true && givenNewStreamingHash && givenExpectedNewHash) {
+      this.doAddTransactions(
+        sessionID,
+        newTransactions,
+        newSignature,
+        givenExpectedNewHash,
+        givenNewStreamingHash,
+      );
+    } else {
+      const { expectedNewHash, newStreamingHash } = this.expectedNewHashAfter(
+        sessionID,
+        newTransactions,
+      );
+
+      if (givenExpectedNewHash && givenExpectedNewHash !== expectedNewHash) {
+        return err({
+          type: "InvalidHash",
+          id: this.id,
+          expectedNewHash,
+          givenExpectedNewHash,
+        } satisfies InvalidHashError);
+      }
+
+      if (!this.crypto.verify(newSignature, expectedNewHash, signerID)) {
+        return err({
+          type: "InvalidSignature",
+          id: this.id,
+          newSignature,
+          sessionID,
+          signerID,
+        } satisfies InvalidSignatureError);
+      }
+
+      this.doAddTransactions(
+        sessionID,
+        newTransactions,
+        newSignature,
+        expectedNewHash,
+        newStreamingHash,
+      );
+    }
+
+    return ok(true as const);
+  }
+
+  private doAddTransactions(
+    sessionID: SessionID,
+    newTransactions: Transaction[],
+    newSignature: Signature,
+    expectedNewHash: Hash,
+    newStreamingHash: StreamingHash,
+  ) {
+    const transactions = this.sessions.get(sessionID)?.transactions ?? [];
+
+    for (const tx of newTransactions) {
+      transactions.push(tx);
+    }
+
+    const signatureAfter = this.sessions.get(sessionID)?.signatureAfter ?? {};
+
+    const lastInbetweenSignatureIdx = Object.keys(signatureAfter).reduce(
+      (max, idx) => (parseInt(idx) > max ? parseInt(idx) : max),
+      -1,
+    );
+
+    const sizeOfTxsSinceLastInbetweenSignature = transactions
+      .slice(lastInbetweenSignatureIdx + 1)
+      .reduce(
+        (sum, tx) =>
+          sum +
+          (tx.privacy === "private"
+            ? tx.encryptedChanges.length
+            : tx.changes.length),
+        0,
+      );
+
+    if (sizeOfTxsSinceLastInbetweenSignature > MAX_RECOMMENDED_TX_SIZE) {
+      signatureAfter[transactions.length - 1] = newSignature;
+    }
+
+    this.sessions.set(sessionID, {
+      transactions,
+      lastHash: expectedNewHash,
+      streamingHash: newStreamingHash,
+      lastSignature: newSignature,
+      signatureAfter: signatureAfter,
+    });
+
+    this._cachedNewContentSinceEmpty = undefined;
+    this._cachedKnownState = undefined;
+  }
+
+  expectedNewHashAfter(
+    sessionID: SessionID,
+    newTransactions: Transaction[],
+  ): { expectedNewHash: Hash; newStreamingHash: StreamingHash } {
+    const streamingHash =
+      this.sessions.get(sessionID)?.streamingHash.clone() ??
+      new StreamingHash(this.crypto);
+
+    for (const transaction of newTransactions) {
+      streamingHash.update(transaction);
+    }
+
+    return {
+      expectedNewHash: streamingHash.digest(),
+      newStreamingHash: streamingHash,
+    };
+  }
+
+  newContentSince(
+    knownState: CoValueKnownState | undefined,
+  ): NewContentMessage[] | undefined {
+    const isKnownStateEmpty = !knownState?.header && !knownState?.sessions;
+
+    if (isKnownStateEmpty && this._cachedNewContentSinceEmpty) {
+      return this._cachedNewContentSinceEmpty;
+    }
+
+    let currentPiece: NewContentMessage = {
+      action: "content",
+      id: this.id,
+      header: knownState?.header ? undefined : this.header,
+      priority: getPriorityFromHeader(this.header),
+      new: {},
+    };
+
+    const pieces = [currentPiece];
+
+    const sentState: CoValueKnownState["sessions"] = {};
+
+    let pieceSize = 0;
+
+    let sessionsTodoAgain: Set<SessionID> | undefined | "first" = "first";
+
+    while (sessionsTodoAgain === "first" || sessionsTodoAgain?.size || 0 > 0) {
+      if (sessionsTodoAgain === "first") {
+        sessionsTodoAgain = undefined;
+      }
+      const sessionsTodo = sessionsTodoAgain ?? this.sessions.keys();
+
+      for (const sessionIDKey of sessionsTodo) {
+        const sessionID = sessionIDKey as SessionID;
+        const log = this.sessions.get(sessionID)!;
+        const knownStateForSessionID = knownState?.sessions[sessionID];
+        const sentStateForSessionID = sentState[sessionID];
+        const nextKnownSignatureIdx = getNextKnownSignatureIdx(
+          log,
+          knownStateForSessionID,
+          sentStateForSessionID,
+        );
+
+        const firstNewTxIdx =
+          sentStateForSessionID ?? knownStateForSessionID ?? 0;
+        const afterLastNewTxIdx =
+          nextKnownSignatureIdx === undefined
+            ? log.transactions.length
+            : nextKnownSignatureIdx + 1;
+
+        const nNewTx = Math.max(0, afterLastNewTxIdx - firstNewTxIdx);
+
+        if (nNewTx === 0) {
+          sessionsTodoAgain?.delete(sessionID);
+          continue;
+        }
+
+        if (afterLastNewTxIdx < log.transactions.length) {
+          if (!sessionsTodoAgain) {
+            sessionsTodoAgain = new Set();
+          }
+          sessionsTodoAgain.add(sessionID);
+        }
+
+        const oldPieceSize = pieceSize;
+        for (let txIdx = firstNewTxIdx; txIdx < afterLastNewTxIdx; txIdx++) {
+          const tx = log.transactions[txIdx]!;
+          pieceSize +=
+            tx.privacy === "private"
+              ? tx.encryptedChanges.length
+              : tx.changes.length;
+        }
+
+        if (pieceSize >= MAX_RECOMMENDED_TX_SIZE) {
+          currentPiece = {
+            action: "content",
+            id: this.id,
+            header: undefined,
+            new: {},
+            priority: getPriorityFromHeader(this.header),
+          };
+          pieces.push(currentPiece);
+          pieceSize = pieceSize - oldPieceSize;
+        }
+
+        let sessionEntry = currentPiece.new[sessionID];
+        if (!sessionEntry) {
+          sessionEntry = {
+            after: sentStateForSessionID ?? knownStateForSessionID ?? 0,
+            newTransactions: [],
+            lastSignature: "WILL_BE_REPLACED" as Signature,
+          };
+          currentPiece.new[sessionID] = sessionEntry;
+        }
+
+        for (let txIdx = firstNewTxIdx; txIdx < afterLastNewTxIdx; txIdx++) {
+          const tx = log.transactions[txIdx]!;
+          sessionEntry.newTransactions.push(tx);
+        }
+
+        sessionEntry.lastSignature =
+          nextKnownSignatureIdx === undefined
+            ? log.lastSignature!
+            : log.signatureAfter[nextKnownSignatureIdx]!;
+
+        sentState[sessionID] =
+          (sentStateForSessionID ?? knownStateForSessionID ?? 0) + nNewTx;
+      }
+    }
+
+    const piecesWithContent = pieces.filter(
+      (piece) => Object.keys(piece.new).length > 0 || piece.header,
+    );
+
+    if (piecesWithContent.length === 0) {
+      return undefined;
+    }
+
+    if (isKnownStateEmpty) {
+      this._cachedNewContentSinceEmpty = piecesWithContent;
+    }
+
+    return piecesWithContent;
+  }
+
+  knownState(): CoValueKnownState {
+    if (this._cachedKnownState) {
+      return this._cachedKnownState;
+    } else {
+      const knownState = this.knownStateUncached();
+      this._cachedKnownState = knownState;
+      return knownState;
+    }
+  }
+
+  /** @internal */
+  knownStateUncached(): CoValueKnownState {
+    const sessions: CoValueKnownState["sessions"] = {};
+
+    for (const [sessionID, sessionLog] of this.sessions.entries()) {
+      sessions[sessionID] = sessionLog.transactions.length;
+    }
+
+    return {
+      id: this.id,
+      header: true,
+      sessions,
+    };
+  }
+}
+
+function getNextKnownSignatureIdx(
+  log: SessionLog,
+  knownStateForSessionID?: number,
+  sentStateForSessionID?: number,
+) {
+  return Object.keys(log.signatureAfter)
+    .map(Number)
+    .sort((a, b) => a - b)
+    .find(
+      (idx) => idx >= (sentStateForSessionID ?? knownStateForSessionID ?? -1),
+    );
+}

package/src/coValues/account.ts

@@ -1,9 +1,12 @@
 import { CoID, RawCoValue } from "../coValue.js";
 import {
+  AvailableCoValueCore,
   CoValueCore,
+} from "../coValueCore/coValueCore.js";
+import {
   CoValueHeader,
   CoValueUniqueness,
-} from "../coValueCore.js";
+} from "../coValueCore/verifiedState.js";
 import {
   AgentSecret,
   CryptoProvider,
@@ -85,35 +88,20 @@ export interface ControlledAccountOrAgent {
 }
 
 /** @hidden */
-export class RawControlledAccount<Meta extends AccountMeta = AccountMeta>
-  extends RawAccount<Meta>
-  implements ControlledAccountOrAgent
-{
+export class ControlledAccount implements ControlledAccountOrAgent {
+  account: RawAccount<AccountMeta>;
   agentSecret: AgentSecret;
+  _cachedCurrentAgentID: AgentID | undefined;
   crypto: CryptoProvider;
 
-  constructor(core: CoValueCore, agentSecret: AgentSecret) {
-    super(core);
-
+  constructor(account: RawAccount<AccountMeta>, agentSecret: AgentSecret) {
+    this.account = account;
     this.agentSecret = agentSecret;
-    this.crypto = core.node.crypto;
-  }
-
-  /**
-   * Creates a new group (with the current account as the group's first admin).
-   * @category 1. High-level
-   */
-  createGroup(
-    uniqueness: CoValueUniqueness = this.core.crypto.createdNowUnique(),
-  ) {
-    return this.core.node.createGroup(uniqueness);
+    this.crypto = account.core.node.crypto;
   }
 
-  async acceptInvite<T extends RawCoValue>(
-    groupOrOwnedValueID: CoID<T>,
-    inviteSecret: InviteSecret,
-  ): Promise<void> {
-    return this.core.node.acceptInvite(groupOrOwnedValueID, inviteSecret);
+  get id(): RawAccountID {
+    return this.account.id;
   }
 
   currentAgentID(): AgentID {
@@ -186,7 +174,14 @@ export class RawProfile<
 > extends RawCoMap<Shape, Meta> {}
 
 export type RawAccountMigration<Meta extends AccountMeta = AccountMeta> = (
-  account: RawControlledAccount<Meta>,
+  account: RawAccount<Meta>,
   localNode: LocalNode,
   creationProps?: { name: string },
 ) => void | Promise<void>;
+
+export function expectAccount(content: RawCoValue): RawAccount {
+  if (!(content instanceof RawAccount)) {
+    throw new Error("Expected an account");
+  }
+  return content;
+}

package/src/coValues/coList.ts

@@ -1,5 +1,8 @@
 import { CoID, RawCoValue } from "../coValue.js";
-import { CoValueCore } from "../coValueCore.js";
+import {
+  AvailableCoValueCore,
+  CoValueCore,
+} from "../coValueCore/coValueCore.js";
 import { AgentID, SessionID, TransactionID } from "../ids.js";
 import { JsonObject, JsonValue } from "../jsonValue.js";
 import { CoValueKnownState } from "../sync.js";
@@ -52,7 +55,7 @@ export class RawCoList<
   /** @category 6. Meta */
   type: "colist" | "coplaintext" = "colist" as const;
   /** @category 6. Meta */
-  core: CoValueCore;
+  core: AvailableCoValueCore;
   /** @internal */
   afterStart: OpID[];
   /** @internal */
@@ -88,7 +91,7 @@ export class RawCoList<
   lastValidTransaction: number | undefined;
 
   /** @internal */
-  constructor(core: CoValueCore) {
+  constructor(core: AvailableCoValueCore) {
     this.id = core.id as CoID<this>;
     this.core = core;
 
@@ -234,7 +237,7 @@ export class RawCoList<
 
   /** @category 6. Meta */
   get headerMeta(): Meta {
-    return this.core.header.meta as Meta;
+    return this.core.verified.header.meta as Meta;
   }
 
   /** @category 6. Meta */
@@ -440,8 +443,8 @@ export class RawCoList<
 
   /** @category 3. Subscription */
   subscribe(listener: (coList: this) => void): () => void {
-    return this.core.subscribe((content) => {
-      listener(content as this);
+    return this.core.subscribe((core) => {
+      listener(core.getCurrentContent() as this);
     });
   }
 
@@ -621,6 +624,9 @@ export class RawCoList<
     this.afterStart = listAfter.afterStart;
     this.beforeEnd = listAfter.beforeEnd;
     this.insertions = listAfter.insertions;
+    this.totalValidTransactions = listAfter.totalValidTransactions;
+    this.lastValidTransaction = listAfter.lastValidTransaction;
+    this.knownTransactions = listAfter.knownTransactions;
     this.deletionsByInsertion = listAfter.deletionsByInsertion;
     this._cachedEntries = undefined;
   }

package/src/coValues/coMap.ts

@@ -1,5 +1,8 @@
 import { CoID, RawCoValue } from "../coValue.js";
-import { CoValueCore } from "../coValueCore.js";
+import {
+  AvailableCoValueCore,
+  CoValueCore,
+} from "../coValueCore/coValueCore.js";
 import { AgentID, TransactionID } from "../ids.js";
 import { JsonObject, JsonValue } from "../jsonValue.js";
 import { CoValueKnownState } from "../sync.js";
@@ -39,7 +42,7 @@ export class RawCoMapView<
   /** @category 6. Meta */
   type = "comap" as const;
   /** @category 6. Meta */
-  core: CoValueCore;
+  core: AvailableCoValueCore;
   /** @internal */
   latest: {
     [Key in keyof Shape & string]?: MapOp<Key, Shape[Key]>;
@@ -64,7 +67,7 @@ export class RawCoMapView<
 
   /** @internal */
   constructor(
-    core: CoValueCore,
+    core: AvailableCoValueCore,
     options?: {
       ignorePrivateTransactions: boolean;
     },
@@ -152,7 +155,7 @@ export class RawCoMapView<
 
   /** @category 6. Meta */
   get headerMeta(): Meta {
-    return this.core.header.meta as Meta;
+    return this.core.verified.header.meta as Meta;
   }
 
   /** @category 6. Meta */
@@ -344,8 +347,8 @@ export class RawCoMapView<
 
   /** @category 3. Subscription */
   subscribe(listener: (coMap: this) => void): () => void {
-    return this.core.subscribe((content) => {
-      listener(content as this);
+    return this.core.subscribe((core) => {
+      listener(core.getCurrentContent() as this);
     });
   }
 }

package/src/coValues/coPlainText.ts

@@ -1,4 +1,7 @@
-import { CoValueCore } from "../coValueCore.js";
+import {
+  AvailableCoValueCore,
+  CoValueCore,
+} from "../coValueCore/coValueCore.js";
 import { JsonObject } from "../jsonValue.js";
 import { DeletionOpPayload, OpID, RawCoList } from "./coList.js";
 
@@ -61,7 +64,7 @@ export class RawCoPlainText<
     PlaintextIdxMapping
   >;
 
-  constructor(core: CoValueCore) {
+  constructor(core: AvailableCoValueCore) {
     super(core);
     this._cachedMapping = new WeakMap();
     if (!Intl.Segmenter) {
@@ -72,10 +75,10 @@ export class RawCoPlainText<
 
     // Use locale from meta if provided, fallback to browser locale, or 'en' as last resort
     const effectiveLocale =
-      (core.header.meta &&
-      typeof core.header.meta === "object" &&
-      "locale" in core.header.meta
-        ? (core.header.meta.locale as string)
+      (core.verified.header.meta &&
+      typeof core.verified.header.meta === "object" &&
+      "locale" in core.verified.header.meta
+        ? (core.verified.header.meta.locale as string)
         : undefined) ||
       (typeof navigator !== "undefined" ? navigator.language : "en");
 

package/src/coValues/coStream.ts

@@ -1,6 +1,9 @@
 import { base64URLtoBytes, bytesToBase64url } from "../base64url.js";
 import { CoID, RawCoValue } from "../coValue.js";
-import { CoValueCore } from "../coValueCore.js";
+import {
+  AvailableCoValueCore,
+  CoValueCore,
+} from "../coValueCore/coValueCore.js";
 import { AgentID, SessionID, TransactionID } from "../ids.js";
 import { JsonObject, JsonValue } from "../jsonValue.js";
 import { logger } from "../logger.js";
@@ -50,7 +53,7 @@ export class RawCoStreamView<
 {
   id: CoID<this>;
   type = "costream" as const;
-  core: CoValueCore;
+  core: AvailableCoValueCore;
   items: {
     [key: SessionID]: CoStreamItem<Item>[];
   };
@@ -59,7 +62,7 @@ export class RawCoStreamView<
   totalValidTransactions = 0;
   readonly _item!: Item;
 
-  constructor(core: CoValueCore) {
+  constructor(core: AvailableCoValueCore) {
     this.id = core.id as CoID<this>;
     this.core = core;
     this.items = {};
@@ -68,7 +71,7 @@ export class RawCoStreamView<
   }
 
   get headerMeta(): Meta {
-    return this.core.header.meta as Meta;
+    return this.core.verified.header.meta as Meta;
   }
 
   get group(): RawGroup {
@@ -277,8 +280,8 @@ export class RawCoStreamView<
   }
 
   subscribe(listener: (coStream: this) => void): () => void {
-    return this.core.subscribe((content) => {
-      listener(content as this);
+    return this.core.subscribe((core) => {
+      listener(core.getCurrentContent() as this);
     });
   }
 }