cojson 0.18.12 → 0.18.13

package/src/crypto/PureJSCrypto.ts

@@ -24,7 +24,6 @@ import {
   Signature,
   SignerID,
   SignerSecret,
-  StreamingHash,
   textDecoder,
   textEncoder,
 } from "./crypto.js";
@@ -68,14 +67,6 @@ export class PureJSCrypto extends CryptoProvider<Blake3State> {
     return new PureJSCrypto();
   }
 
-  emptyBlake3State(): Blake3State {
-    return blake3.create({});
-  }
-
-  cloneBlake3State(state: Blake3State): Blake3State {
-    return state.clone();
-  }
-
   blake3HashOnce(data: Uint8Array) {
     return blake3(data);
   }
@@ -87,14 +78,6 @@ export class PureJSCrypto extends CryptoProvider<Blake3State> {
     return blake3.create({}).update(context).update(data).digest();
   }
 
-  blake3IncrementalUpdate(state: Blake3State, data: Uint8Array) {
-    return state.update(data);
-  }
-
-  blake3DigestForState(state: Blake3State): Uint8Array {
-    return state.clone().digest();
-  }
-
   generateNonce(input: Uint8Array): Uint8Array {
     return this.blake3HashOnce(input).slice(0, 24);
   }
@@ -241,7 +224,7 @@ export class PureJSSessionLog implements SessionLogImpl {
     private readonly signerID: SignerID | undefined,
     private readonly crypto: PureJSCrypto,
   ) {
-    this.streamingHash = this.crypto.emptyBlake3State();
+    this.streamingHash = blake3.create({});
   }
 
   clone(): SessionLogImpl {
@@ -253,7 +236,7 @@ export class PureJSSessionLog implements SessionLogImpl {
     );
     newLog.transactions = this.transactions.slice();
     newLog.lastSignature = this.lastSignature;
-    newLog.streamingHash = this.crypto.cloneBlake3State(this.streamingHash);
+    newLog.streamingHash = this.streamingHash.clone();
     return newLog;
   }
 
@@ -274,29 +257,29 @@ export class PureJSSessionLog implements SessionLogImpl {
     newSignature: Signature,
     skipVerify: boolean,
   ) {
+    for (const tx of transactions) {
+      this.streamingHash.update(textEncoder.encode(tx));
+    }
+
     if (!skipVerify) {
       if (!this.signerID) {
         throw new Error("Tried to add transactions without signer ID");
       }
 
-      const checkHasher = this.crypto.cloneBlake3State(this.streamingHash);
-
-      for (const tx of transactions) {
-        checkHasher.update(textEncoder.encode(tx));
-      }
-      const newHash = checkHasher.digest();
+      const newHash = this.streamingHash.clone().digest();
       const newHashEncoded = `hash_z${base58.encode(newHash)}`;
 
       if (!this.crypto.verify(newSignature, newHashEncoded, this.signerID)) {
+        // Rebuild the streaming hash to the original state
+        this.streamingHash = blake3.create({});
+        for (const tx of this.transactions) {
+          this.streamingHash.update(textEncoder.encode(tx));
+        }
         throw new Error("Signature verification failed");
       }
     }
 
     for (const tx of transactions) {
-      this.crypto.blake3IncrementalUpdate(
-        this.streamingHash,
-        textEncoder.encode(tx),
-      );
       this.transactions.push(tx);
     }
 
@@ -305,24 +288,12 @@ export class PureJSSessionLog implements SessionLogImpl {
     return newSignature;
   }
 
-  expectedHashAfter(transactionsJson: string[]): string {
-    const hasher = this.crypto.cloneBlake3State(this.streamingHash);
-    for (const tx of transactionsJson) {
-      hasher.update(textEncoder.encode(tx));
-    }
-    const newHash = hasher.digest();
-    return `hash_z${base58.encode(newHash)}`;
-  }
-
   internalAddNewTransaction(
     transaction: string,
     signerAgent: ControlledAccountOrAgent,
   ) {
-    this.crypto.blake3IncrementalUpdate(
-      this.streamingHash,
-      textEncoder.encode(transaction),
-    );
-    const newHash = this.crypto.blake3DigestForState(this.streamingHash);
+    this.streamingHash.update(textEncoder.encode(transaction));
+    const newHash = this.streamingHash.clone().digest();
     const newHashEncoded = `hash_z${base58.encode(newHash)}`;
     const signature = this.crypto.sign(
       signerAgent.currentSignerSecret(),

package/src/crypto/WasmCrypto.ts

@@ -2,7 +2,6 @@ import {
   SessionLog,
   initialize,
   Blake3Hasher,
-  blake3_empty_state,
   blake3_hash_once,
   blake3_hash_once_with_context,
   decrypt,
@@ -25,7 +24,6 @@ import { PureJSCrypto } from "./PureJSCrypto.js";
 import {
   CryptoProvider,
   Encrypted,
-  Hash,
   KeyID,
   KeySecret,
   Sealed,
@@ -73,14 +71,6 @@ export class WasmCrypto extends CryptoProvider<Blake3State> {
     return new WasmCrypto();
   }
 
-  emptyBlake3State(): Blake3State {
-    return blake3_empty_state();
-  }
-
-  cloneBlake3State(state: Blake3State): Blake3State {
-    return state.clone();
-  }
-
   blake3HashOnce(data: Uint8Array) {
     return blake3_hash_once(data);
   }
@@ -92,15 +82,6 @@ export class WasmCrypto extends CryptoProvider<Blake3State> {
     return blake3_hash_once_with_context(data, context);
   }
 
-  blake3IncrementalUpdate(state: Blake3State, data: Uint8Array): Blake3State {
-    state.update(data);
-    return state;
-  }
-
-  blake3DigestForState(state: Blake3State): Uint8Array {
-    return state.finalize();
-  }
-
   newEd25519SigningKey(): Uint8Array {
     return new_ed25519_signing_key();
   }

package/src/crypto/crypto.ts

@@ -40,14 +40,6 @@ export abstract class CryptoProvider<Blake3State = any> {
     return `signerSecret_z${base58.encode(this.newEd25519SigningKey())}`;
   }
 
-  signerSecretToBytes(secret: SignerSecret): Uint8Array {
-    return base58.decode(secret.substring("signerSecret_z".length));
-  }
-
-  signerSecretFromBytes(bytes: Uint8Array): SignerSecret {
-    return `signerSecret_z${base58.encode(bytes)}`;
-  }
-
   abstract getSignerID(secret: SignerSecret): SignerID;
 
   abstract sign(secret: SignerSecret, message: JsonValue): Signature;
@@ -64,39 +56,25 @@ export abstract class CryptoProvider<Blake3State = any> {
     return `sealerSecret_z${base58.encode(this.newX25519StaticSecret())}`;
   }
 
-  sealerSecretToBytes(secret: SealerSecret): Uint8Array {
-    return base58.decode(secret.substring("sealerSecret_z".length));
-  }
-
-  sealerSecretFromBytes(bytes: Uint8Array): SealerSecret {
-    return `sealerSecret_z${base58.encode(bytes)}`;
-  }
-
   abstract getSealerID(secret: SealerSecret): SealerID;
 
   newRandomAgentSecret(): AgentSecret {
     return `${this.newRandomSealer()}/${this.newRandomSigner()}`;
   }
 
-  agentSecretToBytes(secret: AgentSecret): Uint8Array {
-    const [sealerSecret, signerSecret] = secret.split("/");
-    return new Uint8Array([
-      ...this.sealerSecretToBytes(sealerSecret as SealerSecret),
-      ...this.signerSecretToBytes(signerSecret as SignerSecret),
-    ]);
-  }
-
-  agentSecretFromBytes(bytes: Uint8Array): AgentSecret {
-    const sealerSecret = this.sealerSecretFromBytes(bytes.slice(0, 32));
-    const signerSecret = this.signerSecretFromBytes(bytes.slice(32));
-    return `${sealerSecret}/${signerSecret}`;
-  }
-
+  agentIdCache = new Map<string, AgentID>();
   getAgentID(secret: AgentSecret): AgentID {
-    const [sealerSecret, signerSecret] = secret.split("/");
-    return `${this.getSealerID(
-      sealerSecret as SealerSecret,
-    )}/${this.getSignerID(signerSecret as SignerSecret)}`;
+    const cacheKey = secret;
+    let agentId = this.agentIdCache.get(cacheKey);
+    if (!agentId) {
+      const [sealerSecret, signerSecret] = secret.split("/") as [
+        SealerSecret,
+        SignerSecret,
+      ];
+      agentId = `${this.getSealerID(sealerSecret)}/${this.getSignerID(signerSecret)}`;
+      this.agentIdCache.set(cacheKey, agentId);
+    }
+    return agentId;
   }
 
   getAgentSignerID(agentId: AgentID): SignerID {
@@ -115,18 +93,11 @@ export abstract class CryptoProvider<Blake3State = any> {
     return agentSecret.split("/")[0] as SealerSecret;
   }
 
-  abstract emptyBlake3State(): Blake3State;
-  abstract cloneBlake3State(state: Blake3State): Blake3State;
   abstract blake3HashOnce(data: Uint8Array): Uint8Array;
   abstract blake3HashOnceWithContext(
     data: Uint8Array,
     { context }: { context: Uint8Array },
   ): Uint8Array;
-  abstract blake3IncrementalUpdate(
-    state: Blake3State,
-    data: Uint8Array,
-  ): Blake3State;
-  abstract blake3DigestForState(state: Blake3State): Uint8Array;
 
   secureHash(value: JsonValue): Hash {
     return `hash_z${base58.encode(
@@ -149,14 +120,6 @@ export abstract class CryptoProvider<Blake3State = any> {
     nOnceMaterial: N,
   ): Encrypted<T, N>;
 
-  encryptForTransaction<T extends JsonValue>(
-    value: T,
-    keySecret: KeySecret,
-    nOnceMaterial: { in: RawCoID; tx: TransactionID },
-  ): Encrypted<T, { in: RawCoID; tx: TransactionID }> {
-    return this.encrypt(value, keySecret, nOnceMaterial);
-  }
-
   abstract decryptRaw<T extends JsonValue, N extends JsonValue>(
     encrypted: Encrypted<T, N>,
     keySecret: KeySecret,
@@ -183,22 +146,6 @@ export abstract class CryptoProvider<Blake3State = any> {
     };
   }
 
-  decryptRawForTransaction<T extends JsonValue>(
-    encrypted: Encrypted<T, { in: RawCoID; tx: TransactionID }>,
-    keySecret: KeySecret,
-    nOnceMaterial: { in: RawCoID; tx: TransactionID },
-  ): Stringified<T> | undefined {
-    return this.decryptRaw(encrypted, keySecret, nOnceMaterial);
-  }
-
-  decryptForTransaction<T extends JsonValue>(
-    encrypted: Encrypted<T, { in: RawCoID; tx: TransactionID }>,
-    keySecret: KeySecret,
-    nOnceMaterial: { in: RawCoID; tx: TransactionID },
-  ): T | undefined {
-    return this.decrypt(encrypted, keySecret, nOnceMaterial);
-  }
-
   encryptKeySecret(keys: {
     toEncrypt: { id: KeyID; secret: KeySecret };
     encrypting: { id: KeyID; secret: KeySecret };
@@ -311,35 +258,6 @@ export abstract class CryptoProvider<Blake3State = any> {
 }
 
 export type Hash = `hash_z${string}`;
-
-export class StreamingHash {
-  state: Uint8Array;
-  crypto: CryptoProvider;
-
-  constructor(crypto: CryptoProvider, fromClone?: Uint8Array) {
-    this.state = fromClone || crypto.emptyBlake3State();
-    this.crypto = crypto;
-  }
-
-  update(value: JsonValue): Uint8Array {
-    const encoded = textEncoder.encode(stableStringify(value));
-    this.state = this.crypto.blake3IncrementalUpdate(this.state, encoded);
-    return encoded;
-  }
-
-  digest(): Hash {
-    const hash = this.crypto.blake3DigestForState(this.state);
-    return `hash_z${base58.encode(hash)}`;
-  }
-
-  clone(): StreamingHash {
-    return new StreamingHash(
-      this.crypto,
-      this.crypto.cloneBlake3State(this.state),
-    );
-  }
-}
-
 export type ShortHash = `shortHash_z${string}`;
 export const shortHashLength = 19;
 

package/src/exports.ts

@@ -27,7 +27,6 @@ import { EVERYONE, RawGroup } from "./coValues/group.js";
 import type { Everyone } from "./coValues/group.js";
 import {
   CryptoProvider,
-  StreamingHash,
   secretSeedLength,
   shortHashLength,
 } from "./crypto/crypto.js";
@@ -85,6 +84,7 @@ import {
 import { LogLevel, logger } from "./logger.js";
 import { CO_VALUE_PRIORITY, getPriorityFromHeader } from "./priority.js";
 import { getDependedOnCoValues } from "./storage/syncUtils.js";
+import { canBeBranched } from "./coValueCore/branching.js";
 
 type Value = JsonValue | AnyRawCoValue;
 
@@ -107,7 +107,6 @@ export const cojsonInternals = {
   isAccountID,
   accountHeaderForInitialAgentSecret,
   idforHeader,
-  StreamingHash,
   getPriorityFromHeader,
   getGroupDependentKeyList,
   getGroupDependentKey,
@@ -124,6 +123,7 @@ export const cojsonInternals = {
   getContentMessageSize,
   TRANSACTION_CONFIG,
   setMaxRecommendedTxSize,
+  canBeBranched,
 };
 
 export {

package/src/knownState.ts

@@ -0,0 +1,17 @@
+import type { SessionID } from "./exports";
+import type { CoValueKnownState } from "./sync";
+
+export function combineKnownStateSessions(
+  a: CoValueKnownState["sessions"],
+  b: CoValueKnownState["sessions"],
+): CoValueKnownState["sessions"] {
+  const sessionStates: CoValueKnownState["sessions"] = {};
+
+  for (const sessionID of Object.keys(a).concat(
+    Object.keys(b),
+  ) as SessionID[]) {
+    sessionStates[sessionID] = Math.max(a[sessionID] || 0, b[sessionID] || 0);
+  }
+
+  return sessionStates;
+}

package/src/localNode.ts

@@ -39,6 +39,7 @@ import { StorageAPI } from "./storage/index.js";
 import { Peer, PeerID, SyncManager } from "./sync.js";
 import { accountOrAgentIDfromSessionID } from "./typeUtils/accountOrAgentIDfromSessionID.js";
 import { expectGroup } from "./typeUtils/expectGroup.js";
+import { canBeBranched } from "./coValueCore/branching.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).
 
@@ -477,6 +478,10 @@ export class LocalNode {
       return "unavailable";
     }
 
+    if (!canBeBranched(source)) {
+      return source.getCurrentContent() as T;
+    }
+
     const branch = source.getBranch(branchName, branchOwnerID);
 
     if (branch.isAvailable()) {

package/src/sync.ts

@@ -594,13 +594,22 @@ export class SyncManager {
         }
       }
 
-      peer?.updateHeader(msg.id, true);
-      coValue.provideHeader(
+      const success = coValue.provideHeader(
         msg.header,
         peer?.id ?? "storage",
         msg.expectContentUntil,
       );
 
+      if (!success) {
+        logger.error("Failed to provide header", {
+          id: msg.id,
+          header: msg.header,
+        });
+        return;
+      }
+
+      peer?.updateHeader(msg.id, true);
+
       if (msg.expectContentUntil) {
         peer?.combineWith(msg.id, {
           id: msg.id,

package/src/tests/branching.test.ts

@@ -92,14 +92,20 @@ describe("Branching Logic", () => {
 
       // Merge branch twice - second merge should not create new commit
       expectMap(branch.core.mergeBranch().getCurrentContent());
-      const result = expectMap(branch.core.mergeBranch().getCurrentContent());
 
-      // Verify only one merge commit was created
-      expect(branch.core.mergeCommits.length).toBe(1);
+      const knownState = originalMap.core.knownState();
+
+      expectMap(branch.core.mergeBranch().getCurrentContent());
+
+      // Verify the known state is the same
+      expect(originalMap.core.knownState()).toEqual(knownState);
 
       // Verify source contains branch transactions
-      expect(result.get("key1")).toBe("branchValue1");
-      expect(result.get("key2")).toBe("value2");
+      expect(originalMap.get("key1")).toBe("branchValue1");
+      expect(originalMap.get("key2")).toBe("value2");
+
+      // Verify only one merge commit was created
+      expect(originalMap.core.mergeCommits.length).toBe(1);
     });
 
     test("should not create merge commit when merging empty branch", () => {
@@ -118,10 +124,10 @@ describe("Branching Logic", () => {
       );
 
       // Merge empty branch
-      const result = expectMap(branch.core.mergeBranch().getCurrentContent());
+      expectMap(branch.core.mergeBranch().getCurrentContent());
 
       // Verify no merge commit was created
-      expect(result.core.mergeCommits.length).toBe(0);
+      expect(originalMap.core.mergeCommits.length).toBe(0);
     });
 
     test("should merge only new changes from branch after previous merge", () => {
@@ -155,7 +161,7 @@ describe("Branching Logic", () => {
       branch.core.mergeBranch();
 
       // Verify two merge commits exist
-      expect(branch.core.mergeCommits.length).toBe(2);
+      expect(originalMap.core.mergeCommits.length).toBe(2);
 
       // Verify both changes are now in original map
       expect(originalMap.get("key1")).toBe("branchValue1");
@@ -496,56 +502,61 @@ describe("Branching Logic", () => {
 
   describe("Branch Conflict Resolution", () => {
     test("should successfully handle concurrent branch creation on different nodes", async () => {
-      const bob = setupTestNode();
-      const { peer: bobPeer } = bob.connectToSyncServer();
       const alice = setupTestNode({
         connected: true,
       });
 
-      const client = setupTestNode();
+      const bob = setupTestNode();
+      let { peerState: bobPeer } = bob.connectToSyncServer();
+
       const group = jazzCloud.node.createGroup();
       group.addMember("everyone", "writer");
 
       // Create map without any branches
-      const originalMap = group.createMap();
+      const map = group.createMap();
 
-      const originalMapOnBob = await loadCoValueOrFail(
-        bob.node,
-        originalMap.id,
-      );
+      const bobMap = await loadCoValueOrFail(bob.node, map.id);
 
       // Disconnect bob from sync server to create isolation
-      bobPeer.outgoing.close();
+      bobPeer.gracefulShutdown();
+
+      bobMap.set("bob", "main");
+      map.set("alice", "main");
 
       // Create branches on different nodes
       const aliceBranch = await alice.node.checkoutBranch(
-        originalMap.id,
+        map.id,
         "feature-branch",
       );
-      const bobBranch = expectMap(
-        originalMapOnBob.core
-          .createBranch("feature-branch", group.id)
-          .getCurrentContent(),
-      );
+      const bobBranch = await bob.node.checkoutBranch(map.id, "feature-branch");
 
-      if (aliceBranch === "unavailable") {
-        throw new Error("Alice branch is unavailable");
+      if (aliceBranch === "unavailable" || bobBranch === "unavailable") {
+        throw new Error("Alice or bob branch is unavailable");
       }
 
-      // Add different data to each branch
-      bobBranch.set("bob", true);
-      aliceBranch.set("alice", true);
+      // The branch start should be different
+      expect(aliceBranch.get("alice")).toBe("main");
+      expect(aliceBranch.get("bob")).toBe(undefined);
+      expect(bobBranch.get("alice")).toBe(undefined);
+      expect(bobBranch.get("bob")).toBe("main");
+
+      expect(aliceBranch.core.branchStart).not.toEqual(
+        bobBranch.core.branchStart,
+      );
 
       // Reconnect bob to sync server
-      bob.connectToSyncServer();
+      bobPeer = bob.connectToSyncServer().peerState;
 
-      // Wait for sync to complete
-      await bobBranch.core.waitForSync();
       await aliceBranch.core.waitForSync();
+      await bobBranch.core.waitForSync();
+
+      // The branch start from both branches should be aligned now
+      expect(aliceBranch.get("alice")).toBe("main");
+      expect(aliceBranch.get("bob")).toBe("main");
+      expect(bobBranch.get("alice")).toBe("main");
+      expect(bobBranch.get("bob")).toBe("main");
 
-      // Verify both branches now contain data from the other
-      expect(bobBranch.get("alice")).toBe(true);
-      expect(aliceBranch.get("bob")).toBe(true);
+      expect(aliceBranch.core.branchStart).toEqual(bobBranch.core.branchStart);
     });
   });
 

package/src/tests/coValueCore.test.ts

@@ -7,7 +7,7 @@ import {
   test,
   vi,
 } from "vitest";
-import { CoValueCore } from "../coValueCore/coValueCore.js";
+import { CoValueCore, idforHeader } from "../coValueCore/coValueCore.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import { stableStringify } from "../jsonStringify.js";
 import { LocalNode } from "../localNode.js";
@@ -519,10 +519,46 @@ describe("markErrored and isErroredInPeer", () => {
     // Mark peer as unavailable
     coValue.markNotFoundInPeer(peerId);
     expect(coValue.isErroredInPeer(peerId)).toBe(false);
+  });
 
-    // Mark peer as available
-    coValue.provideHeader({} as any, peerId);
-    expect(coValue.isErroredInPeer(peerId)).toBe(false);
+  test("provideHeader should work", () => {
+    const [agent, sessionID] = randomAgentAndSessionID();
+    const node = new LocalNode(agent.agentSecret, sessionID, Crypto);
+
+    const header = {
+      type: "costream",
+      ruleset: { type: "unsafeAllowAll" },
+      meta: null,
+      ...Crypto.createdNowUnique(),
+    } as const;
+
+    const coValue = node.getCoValue(idforHeader(header, Crypto));
+
+    expect(coValue.isAvailable()).toBe(false);
+
+    const success = coValue.provideHeader(header, "peerId");
+    expect(success).toBe(true);
+    expect(coValue.isAvailable()).toBe(true);
+  });
+
+  test("provideHeader should return false if the header hash doesn't match the coValue id", () => {
+    const [agent, sessionID] = randomAgentAndSessionID();
+    const node = new LocalNode(agent.agentSecret, sessionID, Crypto);
+
+    const header = {
+      type: "costream",
+      ruleset: { type: "unsafeAllowAll" },
+      meta: null,
+      ...Crypto.createdNowUnique(),
+    } as const;
+
+    const coValue = node.getCoValue("co_ztest123");
+
+    expect(coValue.isAvailable()).toBe(false);
+
+    const success = coValue.provideHeader(header, "peerId");
+    expect(success).toBe(false);
+    expect(coValue.isAvailable()).toBe(false);
   });
 
   test("markErrored should work with multiple peers", () => {

package/src/tests/coValueCoreLoadingState.test.ts

@@ -1,11 +1,12 @@
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { PeerState } from "../PeerState";
-import { CoValueCore } from "../coValueCore/coValueCore";
+import { CoValueCore, idforHeader } from "../coValueCore/coValueCore";
 import { CoValueHeader, VerifiedState } from "../coValueCore/verifiedState";
 import { RawCoID } from "../ids";
 import { LocalNode } from "../localNode";
 import { Peer } from "../sync";
 import { createTestMetricReader, tearDownTestMetricReader } from "./testUtils";
+import { WasmCrypto } from "../crypto/WasmCrypto";
 
 let metricReader: ReturnType<typeof createTestMetricReader>;
 
@@ -17,10 +18,21 @@ afterEach(() => {
   tearDownTestMetricReader();
 });
 
-const mockNode = {} as LocalNode;
+const mockNode = {
+  crypto: await WasmCrypto.create(),
+} as unknown as LocalNode;
+
+const testCoValueHeader = {
+  type: "comap",
+  ruleset: { type: "ownedByGroup", group: "co_ztest123" },
+  meta: null,
+  uniqueness: null,
+} as CoValueHeader;
+
+const testCoValueId = idforHeader(testCoValueHeader, mockNode.crypto);
 
 describe("CoValueCore loading state", () => {
-  const mockCoValueId = "co_test123" as RawCoID;
+  const mockCoValueId = testCoValueId;
 
   test("should create unknown state", async () => {
     const state = CoValueCore.fromID(mockCoValueId, mockNode);
@@ -195,7 +207,7 @@ describe("CoValueCore loading state", () => {
         role: "server",
       },
       async () => {
-        state.provideHeader({} as CoValueHeader, "peer1");
+        state.provideHeader(testCoValueHeader, "peer1");
       },
     );
     const peer2 = createMockPeerState(
@@ -248,7 +260,7 @@ describe("CoValueCore loading state", () => {
         role: "server",
       },
       async () => {
-        state.provideHeader({} as CoValueHeader, "peer2");
+        state.provideHeader(testCoValueHeader, "peer2");
       },
     );