cojson 0.18.32 → 0.18.33

package/src/coValueCore/verifiedState.ts

@@ -4,6 +4,7 @@ import {
   createContentMessage,
   exceedsRecommendedSize,
   getTransactionSize,
+  addTransactionToContentMessage,
 } from "../coValueContentMessage.js";
 import {
   CryptoProvider,
@@ -21,7 +22,7 @@ import { NewContentMessage } from "../sync.js";
 import { TryAddTransactionsError } from "./coValueCore.js";
 import { SessionLog, SessionMap } from "./SessionMap.js";
 import { ControlledAccountOrAgent } from "../coValues/account.js";
-import { cloneKnownState, CoValueKnownState } from "../knownState.js";
+import { CoValueKnownState, KnownStateSessions } from "../knownState.js";
 
 export type CoValueHeader = {
   type: AnyRawCoValue["type"];
@@ -55,7 +56,6 @@ export class VerifiedState {
   readonly crypto: CryptoProvider;
   readonly header: CoValueHeader;
   readonly sessions: SessionMap;
-  private _cachedNewContentSinceEmpty: NewContentMessage[] | undefined;
   public lastAccessed: number | undefined;
   public branchSourceId?: RawCoID;
   public branchName?: string;
@@ -98,10 +98,6 @@ export class VerifiedState {
       skipVerify,
     );
 
-    if (result.isOk()) {
-      this._cachedNewContentSinceEmpty = undefined;
-    }
-
     return result;
   }
 
@@ -120,8 +116,6 @@ export class VerifiedState {
       madeAt,
     );
 
-    this._cachedNewContentSinceEmpty = undefined;
-
     return result;
   }
 
@@ -144,8 +138,6 @@ export class VerifiedState {
       madeAt,
     );
 
-    this._cachedNewContentSinceEmpty = undefined;
-
     return result;
   }
 
@@ -160,119 +152,147 @@ export class VerifiedState {
     );
   }
 
+  setStreamingKnownState(streamingKnownState: KnownStateSessions) {
+    this.sessions.setStreamingKnownState(streamingKnownState);
+  }
+
   newContentSince(
     knownState: CoValueKnownState | undefined,
   ): NewContentMessage[] | undefined {
-    const isKnownStateEmpty = !knownState?.header && !knownState?.sessions;
-
-    if (isKnownStateEmpty && this._cachedNewContentSinceEmpty) {
-      return this._cachedNewContentSinceEmpty;
-    }
-
     let currentPiece: NewContentMessage = createContentMessage(
       this.id,
       this.header,
-      !knownState?.header,
+      false,
     );
-
-    const pieces = [currentPiece];
-
-    const sentState: CoValueKnownState["sessions"] = {};
-
+    const pieces: NewContentMessage[] = [currentPiece];
     let pieceSize = 0;
 
-    let sessionsTodoAgain: Set<SessionID> | undefined | "first" = "first";
-
-    while (sessionsTodoAgain === "first" || sessionsTodoAgain?.size || 0 > 0) {
-      if (sessionsTodoAgain === "first") {
-        sessionsTodoAgain = undefined;
+    const startNewPiece = () => {
+      currentPiece = createContentMessage(this.id, this.header, false);
+      pieces.push(currentPiece);
+      pieceSize = 0;
+    };
+
+    const moveSessionContentToNewPiece = (sessionID: SessionID) => {
+      const sessionContent = currentPiece.new[sessionID];
+
+      if (!sessionContent) {
+        throw new Error("Session content not found", {
+          cause: {
+            sessionID,
+            currentPiece,
+          },
+        });
       }
-      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();
+      delete currentPiece.new[sessionID];
+
+      const newPiece = createContentMessage(this.id, this.header, false);
+      newPiece.new[sessionID] = sessionContent;
+
+      // Insert the new piece before the current piece, to ensure that the order of the new transactions is preserved
+      pieces.splice(pieces.length - 1, 0, newPiece);
+    };
+
+    const sessionSent = knownState?.sessions;
+
+    for (const [sessionID, log] of this.sessions.sessions) {
+      const startFrom = sessionSent?.[sessionID] ?? 0;
+
+      let currentSessionSize = 0;
+
+      for (let txIdx = startFrom; txIdx < log.transactions.length; txIdx++) {
+        const isLastItem = txIdx === log.transactions.length - 1;
+        const tx = log.transactions[txIdx]!;
+
+        currentSessionSize += getTransactionSize(tx);
+
+        const signatureAfter = log.signatureAfter[txIdx];
+
+        if (signatureAfter) {
+          addTransactionToContentMessage(
+            currentPiece,
+            tx,
+            sessionID,
+            signatureAfter,
+            txIdx,
+          );
+          // When we meet a signatureAfter it means that the transaction log exceeds the recommended size
+          // so we move the session content to a dedicated piece, because it must be sent in a standalone piece
+          moveSessionContentToNewPiece(sessionID);
+          currentSessionSize = 0;
+        } else if (isLastItem) {
+          if (!log.lastSignature) {
+            throw new Error(
+              "All the SessionLogs sent must have a lastSignature",
+              {
+                cause: log,
+              },
+            );
           }
-          sessionsTodoAgain.add(sessionID);
-        }
 
-        const oldPieceSize = pieceSize;
-        for (let txIdx = firstNewTxIdx; txIdx < afterLastNewTxIdx; txIdx++) {
-          const tx = log.transactions[txIdx]!;
-          pieceSize += getTransactionSize(tx);
-        }
-
-        if (exceedsRecommendedSize(pieceSize)) {
-          if (!currentPiece.expectContentUntil && pieces.length === 1) {
-            currentPiece.expectContentUntil =
-              this.knownStateWithStreaming().sessions;
+          addTransactionToContentMessage(
+            currentPiece,
+            tx,
+            sessionID,
+            log.lastSignature,
+            txIdx,
+          );
+
+          // If the current session size already exceeds the recommended size, we move the session content to a dedicated piece
+          if (exceedsRecommendedSize(currentSessionSize)) {
+            assertLastSignature(sessionID, currentPiece);
+            moveSessionContentToNewPiece(sessionID);
+          } else if (exceedsRecommendedSize(pieceSize, currentSessionSize)) {
+            assertLastSignature(sessionID, currentPiece);
+            startNewPiece();
+          } else {
+            pieceSize += currentSessionSize;
           }
-
-          currentPiece = createContentMessage(this.id, this.header, false);
-          pieces.push(currentPiece);
-          pieceSize = pieceSize - oldPieceSize;
+        } else {
+          // Unsafely add the transaction to the content message, without a signature because we don't have one for this session
+          // Checks and assertions are enforced in this function to avoid that a content message gets out without a signature
+          const signature = undefined as Signature | undefined;
+          addTransactionToContentMessage(
+            currentPiece,
+            tx,
+            sessionID,
+            signature!,
+            txIdx,
+          );
         }
+      }
 
-        let sessionEntry = currentPiece.new[sessionID];
-        if (!sessionEntry) {
-          sessionEntry = {
-            after: sentStateForSessionID ?? knownStateForSessionID ?? 0,
-            newTransactions: [],
-            lastSignature: "WILL_BE_REPLACED" as Signature,
-          };
-          currentPiece.new[sessionID] = sessionEntry;
-        }
+      assertLastSignature(sessionID, currentPiece);
+    }
 
-        for (let txIdx = firstNewTxIdx; txIdx < afterLastNewTxIdx; txIdx++) {
-          const tx = log.transactions[txIdx]!;
-          sessionEntry.newTransactions.push(tx);
-        }
+    const firstPiece = pieces[0];
 
-        sessionEntry.lastSignature =
-          nextKnownSignatureIdx === undefined
-            ? log.lastSignature!
-            : log.signatureAfter[nextKnownSignatureIdx]!;
+    if (!firstPiece) {
+      throw new Error("First piece not found", {
+        cause: pieces,
+      });
+    }
 
-        sentState[sessionID] =
-          (sentStateForSessionID ?? knownStateForSessionID ?? 0) + nNewTx;
-      }
+    const includeHeader = !knownState?.header;
+
+    if (includeHeader) {
+      firstPiece.header = this.header;
     }
 
     const piecesWithContent = pieces.filter(
-      (piece) => Object.keys(piece.new).length > 0 || piece.header,
+      (piece) => piece.header || Object.keys(piece.new).length > 0,
     );
 
-    if (piecesWithContent.length === 0) {
-      return undefined;
+    if (piecesWithContent.length > 1 || this.isStreaming()) {
+      // Flag that more content is coming
+      firstPiece.expectContentUntil = {
+        ...this.knownStateWithStreaming().sessions,
+      };
     }
 
-    if (isKnownStateEmpty) {
-      this._cachedNewContentSinceEmpty = piecesWithContent;
+    if (piecesWithContent.length === 0) {
+      return undefined;
     }
 
     return piecesWithContent;
@@ -307,15 +327,10 @@ export class VerifiedState {
   }
 }
 
-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),
-    );
+function assertLastSignature(sessionID: SessionID, content: NewContentMessage) {
+  if (content.new[sessionID] && !content.new[sessionID].lastSignature) {
+    throw new Error("The SessionContent sent must have a lastSignature", {
+      cause: content.new[sessionID],
+    });
+  }
 }

package/src/coValues/group.ts

@@ -123,6 +123,13 @@ function healMissingKeyForEveryone(group: RawGroup) {
 }
 
 function needsKeyRotation(group: RawGroup) {
+  const myRole = group.myRole();
+
+  // Checking only direct membership because inside the migrations we can't navigate the parent groups
+  if (myRole !== "admin" && myRole !== "manager") {
+    return false;
+  }
+
   const currentReadKeyId = group.get("readKey");
 
   if (!currentReadKeyId) {
@@ -190,11 +197,27 @@ export class RawGroup<
   ) {
     super(core, options);
     this.crypto = core.node.crypto;
+    this.migrate();
+  }
 
-    // Checks if this is not an account
-    if (core.isGroup() && !core.verified.isStreaming()) {
-      // rotateReadKeyIfNeeded(this);
+  migrate() {
+    if (!this.core.isGroup()) {
+      return;
+    }
+
+    const runMigrations = () => {
+      rotateReadKeyIfNeeded(this);
       healMissingKeyForEveryone(this);
+    };
+
+    // We need the group and their parents to be completely downloaded to correctly handle the migrations
+    if (!this.core.isCompletelyDownloaded()) {
+      this.core.waitFor({
+        predicate: (core) => core.isCompletelyDownloaded(),
+        onSuccess: runMigrations,
+      });
+    } else {
+      runMigrations();
     }
   }
 
@@ -318,7 +341,7 @@ export class RawGroup<
    * @category 1. Role reading
    */
   myRole(): Role | undefined {
-    return this.roleOfInternal(this.core.node.getCurrentAgent().id);
+    return this.roleOfInternal(this.core.node.getCurrentAccountOrAgentID());
   }
 
   /**

package/src/knownState.ts

@@ -109,7 +109,7 @@ export function cloneKnownState(knownState: CoValueKnownState) {
 /**
  * Checks if all the local sessions have the same counters as in remote.
  */
-export function areLocalSessionsUploaded(
+export function isKnownStateSubsetOf(
   local: Record<string, number>,
   remote: Record<string, number>,
 ) {

package/src/localNode.ts

@@ -650,8 +650,7 @@ export class LocalNode {
     );
 
     const contentPieces =
-      groupAsInvite.core.verified.newContentSince(group.core.knownState()) ??
-      [];
+      groupAsInvite.core.newContentSince(group.core.knownState()) ?? [];
 
     // Import the new transactions to the current localNode
     for (const contentPiece of contentPieces) {

package/src/queue/LocalTransactionsSyncQueue.ts

@@ -1,10 +1,15 @@
 import {
   addTransactionToContentMessage,
   createContentMessage,
+  knownStateFromContent,
 } from "../coValueContentMessage.js";
 import { Transaction, VerifiedState } from "../coValueCore/verifiedState.js";
 import { Signature } from "../crypto/crypto.js";
 import { RawCoID, SessionID } from "../ids.js";
+import {
+  combineKnownStateSessions,
+  KnownStateSessions,
+} from "../knownState.js";
 import { NewContentMessage } from "../sync.js";
 import { LinkedList } from "./LinkedList.js";
 
@@ -113,9 +118,29 @@ export class LocalTransactionsSyncQueue {
     this.processingSyncs = true;
 
     queueMicrotask(() => {
+      const firstContentPieceMap = new Map<RawCoID, NewContentMessage>();
+
       while (this.queue.head) {
         const content = this.queue.head.value;
 
+        const firstContentPiece = firstContentPieceMap.get(content.id);
+
+        if (!firstContentPiece) {
+          firstContentPieceMap.set(content.id, content);
+        } else {
+          // There is already a content piece for this coValue, so this means that we need to flag
+          // that this content is going to be streamed
+          if (!firstContentPiece.expectContentUntil) {
+            firstContentPiece.expectContentUntil =
+              knownStateFromContent(firstContentPiece).sessions;
+          }
+
+          combineKnownStateSessions(
+            firstContentPiece.expectContentUntil,
+            knownStateFromContent(content).sessions,
+          );
+        }
+
         this.sync(content);
 
         this.queue.shift();

package/src/storage/knownState.ts

@@ -3,7 +3,7 @@ import { RawCoID } from "../ids.js";
 import {
   CoValueKnownState,
   emptyKnownState,
-  areLocalSessionsUploaded,
+  isKnownStateSubsetOf,
 } from "../knownState.js";
 
 /**
@@ -87,7 +87,7 @@ function isInSync(
     return false;
   }
 
-  return areLocalSessionsUploaded(
+  return isKnownStateSubsetOf(
     knownState.sessions,
     knownStateFromStorage.sessions,
   );

package/src/sync.ts

@@ -228,7 +228,7 @@ export class SyncManager {
       }
     }
 
-    const newContentPieces = coValue.verified.newContentSince(
+    const newContentPieces = coValue.newContentSince(
       peer.getOptimisticKnownState(id),
     );
 
@@ -585,6 +585,8 @@ export class SyncManager {
           sessions: msg.expectContentUntil,
         });
       }
+    } else if (msg.expectContentUntil) {
+      coValue.verified.setStreamingKnownState(msg.expectContentUntil);
     }
 
     // At this point the CoValue must be in memory, if not we have a bug
@@ -647,6 +649,9 @@ export class SyncManager {
             peerRole: peer.role,
             id: msg.id,
             err: result.error,
+            msgKnownState: knownStateFromContent(msg).sessions,
+            knownState: coValue.knownState().sessions,
+            newContent: validNewContent.new,
           });
           // TODO Mark only the session as errored, not the whole coValue
           coValue.markErrored(peer.id, result.error);
@@ -822,7 +827,7 @@ export class SyncManager {
         return undefined;
       }
 
-      return value.verified.newContentSince(correction);
+      return value.newContentSince(correction);
     });
   }
 

package/src/tests/PureJSCrypto.test.ts

@@ -117,8 +117,7 @@ describe("PureJSCrypto", () => {
       true,
     );
 
-    const content =
-      mapInOtherSession.core.verified.newContentSince(undefined)?.[0];
+    const content = mapInOtherSession.core.newContentSince(undefined)?.[0];
     assert(content);
 
     client.node.syncManager.handleNewContent(content, "storage");

package/src/tests/StorageApiAsync.test.ts

@@ -31,7 +31,7 @@ function getNewContentSince(
     throw new Error(`CoValue ${coValue.id} is not verified`);
   }
 
-  const contentMessage = coValue.verified.newContentSince(knownState)?.[0];
+  const contentMessage = coValue.newContentSince(knownState)?.[0];
 
   if (!contentMessage) {
     throw new Error(`No new content available for coValue ${coValue.id}`);
@@ -295,7 +295,7 @@ describe("StorageApiAsync", () => {
       const contentMessage = getNewContentSince(group.core, knownState);
       const correctionCallback = vi.fn((known) => {
         expect(known).toEqual(emptyKnownState(group.id));
-        return group.core.verified.newContentSince(known);
+        return group.core.newContentSince(known);
       });
 
       // Get initial known state
@@ -339,7 +339,7 @@ describe("StorageApiAsync", () => {
       const contentMessage = getNewContentSince(group.core, knownState);
       const correctionCallback = vi.fn((known) => {
         expect(known).toEqual(initialKnownState);
-        return group.core.verified.newContentSince(known);
+        return group.core.newContentSince(known);
       });
 
       // Get initial storage known state
@@ -539,16 +539,16 @@ describe("StorageApiAsync", () => {
         }),
       ).toMatchInlineSnapshot(`
         [
-          "test -> test-storage | CONTENT Core header: false new: After: 1 New: 1",
-          "test -> test-storage | CONTENT Core2 header: false new: After: 1 New: 1",
+          "test -> test-storage | CONTENT Core header: false new: After: 1 New: 1 expectContentUntil: header/3",
+          "test -> test-storage | CONTENT Core2 header: false new: After: 1 New: 1 expectContentUntil: header/3",
           "test -> test-storage | CONTENT Core header: false new: After: 2 New: 1",
           "test -> test-storage | CONTENT Core2 header: false new: After: 2 New: 1",
           "test-storage -> test | KNOWN CORRECTION Core sessions: empty",
           "test -> test-storage | CONTENT Core header: true new: After: 0 New: 3",
           "test-storage -> test | KNOWN CORRECTION Core2 sessions: empty",
           "test -> test-storage | CONTENT Core2 header: true new: After: 0 New: 3",
-          "test -> test-storage | CONTENT Core header: false new: After: 3 New: 1",
-          "test -> test-storage | CONTENT Core2 header: false new: After: 3 New: 1",
+          "test -> test-storage | CONTENT Core header: false new: After: 3 New: 1 expectContentUntil: header/5",
+          "test -> test-storage | CONTENT Core2 header: false new: After: 3 New: 1 expectContentUntil: header/5",
           "test -> test-storage | CONTENT Core header: false new: After: 4 New: 1",
           "test -> test-storage | CONTENT Core2 header: false new: After: 4 New: 1",
         ]
@@ -606,14 +606,14 @@ describe("StorageApiAsync", () => {
         }),
       ).toMatchInlineSnapshot(`
         [
-          "test -> test-storage | CONTENT Core header: false new: After: 1 New: 1",
-          "test -> test-storage | CONTENT Core2 header: false new: After: 1 New: 1",
+          "test -> test-storage | CONTENT Core header: false new: After: 1 New: 1 expectContentUntil: header/3",
+          "test -> test-storage | CONTENT Core2 header: false new: After: 1 New: 1 expectContentUntil: header/3",
           "test -> test-storage | CONTENT Core header: false new: After: 2 New: 1",
           "test -> test-storage | CONTENT Core2 header: false new: After: 2 New: 1",
           "test-storage -> test | KNOWN CORRECTION Core sessions: empty",
           "test -> test-storage | CONTENT Core header: true new: After: 0 New: 3",
-          "test -> test-storage | CONTENT Core header: false new: After: 3 New: 1",
-          "test -> test-storage | CONTENT Core2 header: false new: After: 3 New: 1",
+          "test -> test-storage | CONTENT Core header: false new: After: 3 New: 1 expectContentUntil: header/5",
+          "test -> test-storage | CONTENT Core2 header: false new: After: 3 New: 1 expectContentUntil: header/5",
           "test -> test-storage | CONTENT Core header: false new: After: 4 New: 1",
           "test -> test-storage | CONTENT Core2 header: false new: After: 4 New: 1",
         ]

package/src/tests/StorageApiSync.test.ts

@@ -26,7 +26,7 @@ function getNewContentSince(
     throw new Error(`CoValue ${coValue.id} is not verified`);
   }
 
-  const contentMessage = coValue.verified.newContentSince(knownState)?.[0];
+  const contentMessage = coValue.newContentSince(knownState)?.[0];
 
   if (!contentMessage) {
     throw new Error(`No new content available for coValue ${coValue.id}`);
@@ -274,7 +274,7 @@ describe("StorageApiSync", () => {
       const contentMessage = getNewContentSince(group.core, knownState);
       const correctionCallback = vi.fn((known) => {
         expect(known).toEqual(emptyKnownState(group.id));
-        return group.core.verified.newContentSince(known);
+        return group.core.newContentSince(known);
       });
 
       // Get initial known state
@@ -318,7 +318,7 @@ describe("StorageApiSync", () => {
       const contentMessage = getNewContentSince(group.core, knownState);
       const correctionCallback = vi.fn((known) => {
         expect(known).toEqual(initialKnownState);
-        return group.core.verified.newContentSince(known);
+        return group.core.newContentSince(known);
       });
 
       // Get initial storage known state

package/src/tests/WasmCrypto.test.ts

@@ -117,8 +117,7 @@ describe("WasmCrypto", () => {
       true,
     );
 
-    const content =
-      mapInOtherSession.core.verified.newContentSince(undefined)?.[0];
+    const content = mapInOtherSession.core.newContentSince(undefined)?.[0];
     assert(content);
 
     client.node.syncManager.handleNewContent(content, "storage");

package/src/tests/coPlainText.test.ts

@@ -371,7 +371,7 @@ test("chunks transactions when when the chars are longer than MAX_RECOMMENDED_TX
     }),
   ).toMatchInlineSnapshot(`
     [
-      "client -> storage | CONTENT CoPlainText header: true new: After: 0 New: 1",
+      "client -> storage | CONTENT CoPlainText header: true new: After: 0 New: 1 expectContentUntil: header/42",
       "client -> storage | CONTENT CoPlainText header: false new: After: 1 New: 1",
       "client -> storage | CONTENT CoPlainText header: false new: After: 2 New: 1",
       "client -> storage | CONTENT CoPlainText header: false new: After: 3 New: 1",

package/src/tests/coStream.test.ts

@@ -217,24 +217,24 @@ test("When adding large transactions (small fraction of MAX_RECOMMENDED_TX_SIZE)
   expect(sessionEntry.signatureAfter[10]).not.toBeDefined();
   expect(sessionEntry.signatureAfter[11]).not.toBeDefined();
 
-  const newContent = coValue.verified.newContentSince({
+  const newContent = coValue.newContentSince({
     id: coValue.id,
     header: false,
     sessions: {},
   })!;
 
-  expect(newContent.length).toEqual(5);
+  expect(newContent.length).toEqual(4);
   expect(newContent[0]!.header).toBeDefined();
-  expect(newContent[1]!.new[node.currentSessionID]!.lastSignature).toEqual(
+  expect(newContent[0]!.new[node.currentSessionID]!.lastSignature).toEqual(
     sessionEntry.signatureAfter[3],
   );
-  expect(newContent[2]!.new[node.currentSessionID]!.lastSignature).toEqual(
+  expect(newContent[1]!.new[node.currentSessionID]!.lastSignature).toEqual(
     sessionEntry.signatureAfter[6],
   );
-  expect(newContent[3]!.new[node.currentSessionID]!.lastSignature).toEqual(
+  expect(newContent[2]!.new[node.currentSessionID]!.lastSignature).toEqual(
     sessionEntry.signatureAfter[9],
   );
-  expect(newContent[4]!.new[node.currentSessionID]!.lastSignature).toEqual(
+  expect(newContent[3]!.new[node.currentSessionID]!.lastSignature).toEqual(
     sessionEntry.lastSignature,
   );
 });
@@ -286,24 +286,24 @@ test("When adding large transactions (bigger than MAX_RECOMMENDED_TX_SIZE), we s
   expect(sessionEntry.signatureAfter[3]).toBeDefined();
   expect(sessionEntry.signatureAfter[4]).not.toBeDefined();
 
-  const newContent = coValue.verified.newContentSince({
+  const newContent = coValue.newContentSince({
     id: coValue.id,
     header: false,
     sessions: {},
   })!;
 
-  expect(newContent.length).toEqual(5);
+  expect(newContent.length).toEqual(4);
   expect(newContent[0]!.header).toBeDefined();
-  expect(newContent[1]!.new[node.currentSessionID]!.lastSignature).toEqual(
+  expect(newContent[0]!.new[node.currentSessionID]!.lastSignature).toEqual(
     sessionEntry.signatureAfter[1],
   );
-  expect(newContent[2]!.new[node.currentSessionID]!.lastSignature).toEqual(
+  expect(newContent[1]!.new[node.currentSessionID]!.lastSignature).toEqual(
     sessionEntry.signatureAfter[2],
   );
-  expect(newContent[3]!.new[node.currentSessionID]!.lastSignature).toEqual(
+  expect(newContent[2]!.new[node.currentSessionID]!.lastSignature).toEqual(
     sessionEntry.signatureAfter[3],
   );
-  expect(newContent[4]!.new[node.currentSessionID]!.lastSignature).toEqual(
+  expect(newContent[3]!.new[node.currentSessionID]!.lastSignature).toEqual(
     sessionEntry.lastSignature,
   );
 });