cojson 0.13.17 → 0.13.20

package/dist/{coValueCore.js → coValueCore/coValueCore.js}

@@ -1,14 +1,15 @@
-import { err, ok } from "neverthrow";
-import { coreToCoValue } from "./coreToCoValue.js";
-import { StreamingHash, } from "./crypto/crypto.js";
-import { getGroupDependentKeyList, getParentGroupId, isParentGroupReference, } from "./ids.js";
-import { parseJSON, stableStringify } from "./jsonStringify.js";
-import { logger } from "./logger.js";
-import { determineValidTransactions, isKeyForKeyField, } from "./permissions.js";
-import { getPriorityFromHeader } from "./priority.js";
-import { accountOrAgentIDfromSessionID } from "./typeUtils/accountOrAgentIDfromSessionID.js";
-import { expectGroup } from "./typeUtils/expectGroup.js";
-import { isAccountID } from "./typeUtils/isAccountID.js";
+import { ValueType, metrics } from "@opentelemetry/api";
+import { err } from "neverthrow";
+import { coreToCoValue } from "../coreToCoValue.js";
+import { getGroupDependentKeyList, getParentGroupId, isParentGroupReference, } from "../ids.js";
+import { parseJSON, stableStringify } from "../jsonStringify.js";
+import { logger } from "../logger.js";
+import { determineValidTransactions, isKeyForKeyField, } from "../permissions.js";
+import { emptyKnownState } from "../sync.js";
+import { accountOrAgentIDfromSessionID } from "../typeUtils/accountOrAgentIDfromSessionID.js";
+import { expectGroup } from "../typeUtils/expectGroup.js";
+import { isAccountID } from "../typeUtils/isAccountID.js";
+import { VerifiedState } from "./verifiedState.js";
 /**
     In order to not block other concurrently syncing CoValues we introduce a maximum size of transactions,
     since they are the smallest unit of progress that can be synced within a CoValue.
@@ -22,27 +23,164 @@ export function idforHeader(header, crypto) {
     return `co_z${hash.slice("shortHash_z".length)}`;
 }
 const readKeyCache = new WeakMap();
+export const CO_VALUE_LOADING_CONFIG = {
+    MAX_RETRIES: 2,
+    TIMEOUT: 30000,
+};
 export class CoValueCore {
-    constructor(header, node, internalInitSessions = new Map()) {
+    /** Holds the fundamental syncable content of a CoValue,
+     * consisting of the header (verified by hash -> RawCoID)
+     * and the sessions (verified by signature).
+     *
+     * It does not do any *validation* or *decryption* and as such doesn't
+     * depend on other CoValues or the LocalNode.
+     *
+     * `CoValueCore.verified` may be null when a CoValue is requested to be
+     * loaded but no content has been received from storage or peers yet.
+     * In this case, it acts as a centralised entry to keep track of peer loading
+     * state and to subscribe to its content when it does become available. */
+    get verified() {
+        return this._verified;
+    }
+    constructor(init, node) {
+        this.peers = new Map();
         this.listeners = new Set();
         this._decryptionCache = {};
         this.deferredUpdates = 0;
         this.crypto = node.crypto;
-        this.id = idforHeader(header, node.crypto);
-        this.header = header;
-        this._sessionLogs = internalInitSessions;
+        if ("header" in init) {
+            this.id = idforHeader(init.header, node.crypto);
+            this._verified = new VerifiedState(this.id, node.crypto, init.header, new Map());
+        }
+        else {
+            this.id = init.id;
+            this._verified = null;
+        }
         this.node = node;
+        this.counter = metrics
+            .getMeter("cojson")
+            .createUpDownCounter("jazz.covalues.loaded", {
+            description: "The number of covalues in the system",
+            unit: "covalue",
+            valueType: ValueType.INT,
+        });
+        this.updateCounter(null);
+    }
+    static fromID(id, node) {
+        return new CoValueCore({ id }, node);
+    }
+    static fromHeader(header, node) {
+        return new CoValueCore({ header }, node);
+    }
+    get loadingState() {
+        if (this.verified) {
+            return "available";
+        }
+        else if (this.peers.size === 0) {
+            return "unknown";
+        }
+        for (const peer of this.peers.values()) {
+            if (peer.type === "pending") {
+                return "loading";
+            }
+            else if (peer.type === "unknown") {
+                return "unknown";
+            }
+        }
+        return "unavailable";
+    }
+    isAvailable() {
+        return !!this.verified;
+    }
+    isErroredInPeer(peerId) {
+        return this.peers.get(peerId)?.type === "errored";
+    }
+    waitForAvailableOrUnavailable() {
+        return new Promise((resolve) => {
+            const listener = (core) => {
+                if (core.isAvailable() || core.loadingState === "unavailable") {
+                    resolve(core);
+                    this.listeners.delete(listener);
+                }
+            };
+            this.listeners.add(listener);
+            listener(this);
+        });
+    }
+    getStateForPeer(peerId) {
+        return this.peers.get(peerId);
+    }
+    updateCounter(previousState) {
+        const newState = this.loadingState;
+        if (previousState !== newState) {
+            if (previousState) {
+                this.counter.add(-1, { state: previousState });
+            }
+            this.counter.add(1, { state: newState });
+        }
+    }
+    markNotFoundInPeer(peerId) {
+        const previousState = this.loadingState;
+        this.peers.set(peerId, { type: "unavailable" });
+        this.updateCounter(previousState);
+        this.notifyUpdate("immediate");
+    }
+    // TODO: rename to "provided"
+    markAvailable(header, fromPeerId) {
+        const previousState = this.loadingState;
+        if (this._verified?.sessions.size) {
+            throw new Error("CoValueCore: markAvailable called on coValue with verified sessions present!");
+        }
+        this._verified = new VerifiedState(this.id, this.node.crypto, header, new Map());
+        this.peers.set(fromPeerId, { type: "available" });
+        this.updateCounter(previousState);
+        this.notifyUpdate("immediate");
+    }
+    internalMarkMagicallyAvailable(verified, { forceOverwrite = false } = {}) {
+        const previousState = this.loadingState;
+        this.internalShamefullyCloneVerifiedStateFrom(verified, {
+            forceOverwrite,
+        });
+        this.updateCounter(previousState);
+        this.notifyUpdate("immediate");
+    }
+    markErrored(peerId, error) {
+        const previousState = this.loadingState;
+        this.peers.set(peerId, { type: "errored", error });
+        this.updateCounter(previousState);
+        this.notifyUpdate("immediate");
+    }
+    markPending(peerId) {
+        const previousState = this.loadingState;
+        this.peers.set(peerId, { type: "pending" });
+        this.updateCounter(previousState);
+        this.notifyUpdate("immediate");
+    }
+    internalShamefullyCloneVerifiedStateFrom(state, { forceOverwrite = false } = {}) {
+        if (!forceOverwrite && this._verified?.sessions.size) {
+            throw new Error("CoValueCore: internalShamefullyCloneVerifiedStateFrom called on coValue with verified sessions present!");
+        }
+        this._verified = state.clone();
+        this._cachedContent = undefined;
+        this._cachedDependentOn = undefined;
+    }
+    internalShamefullyResetCachedContent() {
+        this._cachedContent = undefined;
+        this._cachedDependentOn = undefined;
     }
     subscribeToGroupInvalidation() {
+        if (!this.verified) {
+            return;
+        }
         if (this.groupInvalidationSubscription) {
             return;
         }
-        const header = this.header;
+        const header = this.verified.header;
         if (header.ruleset.type == "ownedByGroup") {
             const groupId = header.ruleset.group;
-            const entry = this.node.coValuesStore.get(groupId);
+            const entry = this.node.getCoValue(groupId);
             if (entry.isAvailable()) {
-                this.groupInvalidationSubscription = entry.core.subscribe((_groupUpdate) => {
+                this.groupInvalidationSubscription = entry.subscribe((_groupUpdate) => {
                     this._cachedContent = undefined;
                     this.notifyUpdate("immediate");
                 }, false);
@@ -55,131 +193,71 @@ export class CoValueCore {
             }
         }
     }
-    get sessionLogs() {
-        return this._sessionLogs;
-    }
-    testWithDifferentAccount(account, currentSessionID) {
-        const newNode = this.node.testWithDifferentAccount(account, currentSessionID);
-        return newNode.expectCoValueLoaded(this.id);
+    contentInClonedNodeWithDifferentAccount(controlledAccountOrAgent) {
+        const newNode = this.node.cloneWithDifferentAccount(controlledAccountOrAgent);
+        return newNode.expectCoValueLoaded(this.id).getCurrentContent();
     }
     knownState() {
-        if (this._cachedKnownState) {
-            return this._cachedKnownState;
+        if (this.isAvailable()) {
+            return this.verified.knownState();
         }
         else {
-            const knownState = this.knownStateUncached();
-            this._cachedKnownState = knownState;
-            return knownState;
+            return emptyKnownState(this.id);
         }
     }
-    /** @internal */
-    knownStateUncached() {
-        const sessions = {};
-        for (const [sessionID, sessionLog] of this.sessionLogs.entries()) {
-            sessions[sessionID] = sessionLog.transactions.length;
-        }
-        return {
-            id: this.id,
-            header: true,
-            sessions,
-        };
-    }
     get meta() {
-        return this.header?.meta ?? null;
+        return this.verified?.header.meta ?? null;
     }
     nextTransactionID() {
+        if (!this.verified) {
+            throw new Error("CoValueCore: nextTransactionID called on coValue without verified state");
+        }
         // This is an ugly hack to get a unique but stable session ID for editing the current account
-        const sessionID = this.header.meta?.type === "account"
-            ? this.node.currentSessionID.replace(this.node.account.id, this.node.account.currentAgentID())
+        const sessionID = this.verified.header.meta?.type === "account"
+            ? this.node.currentSessionID.replace(this.node.getCurrentAgent().id, this.node.getCurrentAgent().currentAgentID())
             : this.node.currentSessionID;
         return {
             sessionID,
-            txIndex: this.sessionLogs.get(sessionID)?.transactions.length || 0,
+            txIndex: this.verified.sessions.get(sessionID)?.transactions.length || 0,
         };
     }
-    tryAddTransactions(sessionID, newTransactions, givenExpectedNewHash, newSignature, skipVerify = false, givenNewStreamingHash) {
+    tryAddTransactions(sessionID, newTransactions, givenExpectedNewHash, newSignature, notifyMode, skipVerify = false, givenNewStreamingHash) {
         return this.node
             .resolveAccountAgent(accountOrAgentIDfromSessionID(sessionID), "Expected to know signer of transaction")
             .andThen((agent) => {
-            const signerID = this.crypto.getAgentSignerID(agent);
-            if (skipVerify === true &&
-                givenNewStreamingHash &&
-                givenExpectedNewHash) {
-                this.doAddTransactions(sessionID, newTransactions, newSignature, givenExpectedNewHash, givenNewStreamingHash, "immediate");
+            if (!this.verified) {
+                return err({
+                    type: "TriedToAddTransactionsWithoutVerifiedState",
+                    id: this.id,
+                });
             }
-            else {
-                const { expectedNewHash, newStreamingHash } = this.expectedNewHashAfter(sessionID, newTransactions);
-                if (givenExpectedNewHash &&
-                    givenExpectedNewHash !== expectedNewHash) {
-                    return err({
-                        type: "InvalidHash",
-                        id: this.id,
-                        expectedNewHash,
-                        givenExpectedNewHash,
-                    });
+            const signerID = this.crypto.getAgentSignerID(agent);
+            const result = this.verified.tryAddTransactions(sessionID, signerID, newTransactions, givenExpectedNewHash, newSignature, skipVerify, givenNewStreamingHash);
+            if (result.isOk()) {
+                if (this._cachedContent &&
+                    "processNewTransactions" in this._cachedContent &&
+                    typeof this._cachedContent.processNewTransactions === "function") {
+                    this._cachedContent.processNewTransactions();
                 }
-                if (!this.crypto.verify(newSignature, expectedNewHash, signerID)) {
-                    return err({
-                        type: "InvalidSignature",
-                        id: this.id,
-                        newSignature,
-                        sessionID,
-                        signerID,
-                    });
+                else {
+                    this._cachedContent = undefined;
                 }
-                this.doAddTransactions(sessionID, newTransactions, newSignature, expectedNewHash, newStreamingHash, "immediate");
+                this._cachedDependentOn = undefined;
+                this.notifyUpdate(notifyMode);
             }
-            return ok(true);
+            return result;
         });
     }
-    doAddTransactions(sessionID, newTransactions, newSignature, expectedNewHash, newStreamingHash, notifyMode) {
-        if (this.node.crashed) {
-            throw new Error("Trying to add transactions after node is crashed");
-        }
-        const transactions = this.sessionLogs.get(sessionID)?.transactions ?? [];
-        for (const tx of newTransactions) {
-            transactions.push(tx);
-        }
-        const signatureAfter = this.sessionLogs.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._sessionLogs.set(sessionID, {
-            transactions,
-            lastHash: expectedNewHash,
-            streamingHash: newStreamingHash,
-            lastSignature: newSignature,
-            signatureAfter: signatureAfter,
-        });
-        if (this._cachedContent &&
-            "processNewTransactions" in this._cachedContent &&
-            typeof this._cachedContent.processNewTransactions === "function") {
-            this._cachedContent.processNewTransactions();
-        }
-        else {
-            this._cachedContent = undefined;
-        }
-        this._cachedKnownState = undefined;
-        this._cachedDependentOn = undefined;
-        this._cachedNewContentSinceEmpty = undefined;
-        this.notifyUpdate(notifyMode);
-    }
     notifyUpdate(notifyMode) {
         if (this.listeners.size === 0) {
             return;
         }
         if (notifyMode === "immediate") {
-            const content = this.getCurrentContent();
             for (const listener of this.listeners) {
                 try {
-                    listener(content);
+                    listener(this, () => {
+                        this.listeners.delete(listener);
+                    });
                 }
                 catch (e) {
                     logger.error("Error in listener for coValue " + this.id, { err: e });
@@ -192,10 +270,11 @@ export class CoValueCore {
                     setTimeout(() => {
                         this.nextDeferredNotify = undefined;
                         this.deferredUpdates = 0;
-                        const content = this.getCurrentContent();
                         for (const listener of this.listeners) {
                             try {
-                                listener(content);
+                                listener(this, () => {
+                                    this.listeners.delete(listener);
+                                });
                             }
                             catch (e) {
                                 logger.error("Error in listener for coValue " + this.id, {
@@ -213,24 +292,18 @@ export class CoValueCore {
     subscribe(listener, immediateInvoke = true) {
         this.listeners.add(listener);
         if (immediateInvoke) {
-            listener(this.getCurrentContent());
+            listener(this, () => {
+                this.listeners.delete(listener);
+            });
         }
         return () => {
             this.listeners.delete(listener);
         };
     }
-    expectedNewHashAfter(sessionID, newTransactions) {
-        const streamingHash = this.sessionLogs.get(sessionID)?.streamingHash.clone() ??
-            new StreamingHash(this.crypto);
-        for (const transaction of newTransactions) {
-            streamingHash.update(transaction);
-        }
-        return {
-            expectedNewHash: streamingHash.digest(),
-            newStreamingHash: streamingHash,
-        };
-    }
     makeTransaction(changes, privacy) {
+        if (!this.verified) {
+            throw new Error("CoValueCore: makeTransaction called on coValue without verified state");
+        }
         const madeAt = Date.now();
         let transaction;
         if (privacy === "private") {
@@ -258,12 +331,12 @@ export class CoValueCore {
             };
         }
         // This is an ugly hack to get a unique but stable session ID for editing the current account
-        const sessionID = this.header.meta?.type === "account"
-            ? this.node.currentSessionID.replace(this.node.account.id, this.node.account.currentAgentID())
+        const sessionID = this.verified.header.meta?.type === "account"
+            ? this.node.currentSessionID.replace(this.node.getCurrentAgent().id, this.node.getCurrentAgent().currentAgentID())
             : this.node.currentSessionID;
-        const { expectedNewHash, newStreamingHash } = this.expectedNewHashAfter(sessionID, [transaction]);
-        const signature = this.crypto.sign(this.node.account.currentSignerSecret(), expectedNewHash);
-        const success = this.tryAddTransactions(sessionID, [transaction], expectedNewHash, signature, true, newStreamingHash)._unsafeUnwrap({ withStackTrace: true });
+        const { expectedNewHash, newStreamingHash } = this.verified.expectedNewHashAfter(sessionID, [transaction]);
+        const signature = this.crypto.sign(this.node.getCurrentAgent().currentSignerSecret(), expectedNewHash);
+        const success = this.tryAddTransactions(sessionID, [transaction], expectedNewHash, signature, "immediate", true, newStreamingHash)._unsafeUnwrap({ withStackTrace: true });
         if (success) {
             this.node.syncManager.recordTransactionsSize([transaction], "local");
             void this.node.syncManager.requestCoValueSync(this);
@@ -271,6 +344,9 @@ export class CoValueCore {
         return success;
     }
     getCurrentContent(options) {
+        if (!this.verified) {
+            throw new Error("CoValueCore: getCurrentContent called on coValue without verified state");
+        }
         if (!options?.ignorePrivateTransactions && this._cachedContent) {
             return this._cachedContent;
         }
@@ -332,16 +408,19 @@ export class CoValueCore {
         return allTransactions;
     }
     compareTransactions(a, b) {
-        return (a.madeAt - b.madeAt ||
-            (a.txID.sessionID === b.txID.sessionID
-                ? 0
-                : a.txID.sessionID < b.txID.sessionID
-                    ? -1
-                    : 1) ||
-            a.txID.txIndex - b.txID.txIndex);
+        if (a.madeAt !== b.madeAt) {
+            return a.madeAt - b.madeAt;
+        }
+        if (a.txID.sessionID === b.txID.sessionID) {
+            return a.txID.txIndex - b.txID.txIndex;
+        }
+        return 0;
     }
     getCurrentReadKey() {
-        if (this.header.ruleset.type === "group") {
+        if (!this.verified) {
+            throw new Error("CoValueCore: getCurrentReadKey called on coValue without verified state");
+        }
+        if (this.verified.header.ruleset.type === "group") {
             const content = expectGroup(this.getCurrentContent());
             const currentKeyId = content.getCurrentReadKeyId();
             if (!currentKeyId) {
@@ -353,9 +432,9 @@ export class CoValueCore {
                 id: currentKeyId,
             };
         }
-        else if (this.header.ruleset.type === "ownedByGroup") {
+        else if (this.verified.header.ruleset.type === "ownedByGroup") {
             return this.node
-                .expectCoValueLoaded(this.header.ruleset.group)
+                .expectCoValueLoaded(this.verified.header.ruleset.group)
                 .getCurrentReadKey();
         }
         else {
@@ -378,22 +457,31 @@ export class CoValueCore {
         return key;
     }
     getUncachedReadKey(keyID) {
-        if (this.header.ruleset.type === "group") {
+        if (!this.verified) {
+            throw new Error("CoValueCore: getUncachedReadKey called on coValue without verified state");
+        }
+        if (this.verified.header.ruleset.type === "group") {
             const content = expectGroup(this.getCurrentContent({ ignorePrivateTransactions: true }));
             const keyForEveryone = content.get(`${keyID}_for_everyone`);
-            if (keyForEveryone)
+            if (keyForEveryone) {
                 return keyForEveryone;
+            }
             // Try to find key revelation for us
-            const lookupAccountOrAgentID = this.header.meta?.type === "account"
-                ? this.node.account.currentAgentID()
-                : this.node.account.id;
+            const currentAgentOrAccountID = accountOrAgentIDfromSessionID(this.node.currentSessionID);
+            // being careful here to avoid recursion
+            const lookupAccountOrAgentID = isAccountID(currentAgentOrAccountID)
+                ? this.id === currentAgentOrAccountID
+                    ? this.crypto.getAgentID(this.node.agentSecret) // in accounts, the read key is revealed for the primitive agent
+                    : currentAgentOrAccountID // current account ID
+                : currentAgentOrAccountID; // current agent ID
             const lastReadyKeyEdit = content.lastEditAt(`${keyID}_for_${lookupAccountOrAgentID}`);
             if (lastReadyKeyEdit?.value) {
                 const revealer = lastReadyKeyEdit.by;
                 const revealerAgent = this.node
                     .resolveAccountAgent(revealer, "Expected to know revealer")
                     ._unsafeUnwrap({ withStackTrace: true });
-                const secret = this.crypto.unseal(lastReadyKeyEdit.value, this.node.account.currentSealerSecret(), this.crypto.getAgentSealerID(revealerAgent), {
+                const secret = this.crypto.unseal(lastReadyKeyEdit.value, this.crypto.getAgentSealerSecret(this.node.agentSecret), // being careful here to avoid recursion
+                this.crypto.getAgentSealerID(revealerAgent), {
                     in: this.id,
                     tx: lastReadyKeyEdit.tx,
                 });
@@ -449,9 +537,9 @@ export class CoValueCore {
             }
             return undefined;
         }
-        else if (this.header.ruleset.type === "ownedByGroup") {
+        else if (this.verified.header.ruleset.type === "ownedByGroup") {
             return this.node
-                .expectCoValueLoaded(this.header.ruleset.group)
+                .expectCoValueLoaded(this.verified.header.ruleset.group)
                 .getReadKey(keyID);
         }
         else {
@@ -476,106 +564,18 @@ export class CoValueCore {
         return validParentKeys;
     }
     getGroup() {
-        if (this.header.ruleset.type !== "ownedByGroup") {
+        if (!this.verified) {
+            throw new Error("CoValueCore: getGroup called on coValue without verified state");
+        }
+        if (this.verified.header.ruleset.type !== "ownedByGroup") {
             throw new Error("Only values owned by groups have groups");
         }
         return expectGroup(this.node
-            .expectCoValueLoaded(this.header.ruleset.group)
+            .expectCoValueLoaded(this.verified.header.ruleset.group)
             .getCurrentContent());
     }
     getTx(txID) {
-        return this.sessionLogs.get(txID.sessionID)?.transactions[txID.txIndex];
-    }
-    newContentSince(knownState) {
-        const isKnownStateEmpty = !knownState?.header && !knownState?.sessions;
-        if (isKnownStateEmpty && this._cachedNewContentSinceEmpty) {
-            return this._cachedNewContentSinceEmpty;
-        }
-        let currentPiece = {
-            action: "content",
-            id: this.id,
-            header: knownState?.header ? undefined : this.header,
-            priority: getPriorityFromHeader(this.header),
-            new: {},
-        };
-        const pieces = [currentPiece];
-        const sentState = {};
-        let pieceSize = 0;
-        let sessionsTodoAgain = "first";
-        while (sessionsTodoAgain === "first" || sessionsTodoAgain?.size || 0 > 0) {
-            if (sessionsTodoAgain === "first") {
-                sessionsTodoAgain = undefined;
-            }
-            const sessionsTodo = sessionsTodoAgain ?? this.sessionLogs.keys();
-            for (const sessionIDKey of sessionsTodo) {
-                const sessionID = sessionIDKey;
-                const log = this.sessionLogs.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",
-                    };
-                    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;
+        return this.verified?.sessions.get(txID.sessionID)?.transactions[txID.txIndex];
     }
     getDependedOnCoValues() {
         if (this._cachedDependentOn) {
@@ -589,12 +589,15 @@ export class CoValueCore {
     }
     /** @internal */
     getDependedOnCoValuesUncached() {
-        return this.header.ruleset.type === "group"
+        if (!this.verified) {
+            return [];
+        }
+        return this.verified.header.ruleset.type === "group"
             ? getGroupDependentKeyList(expectGroup(this.getCurrentContent()).keys())
-            : this.header.ruleset.type === "ownedByGroup"
+            : this.verified.header.ruleset.type === "ownedByGroup"
                 ? [
-                    this.header.ruleset.group,
-                    ...new Set([...this.sessionLogs.keys()]
+                    this.verified.header.ruleset.group,
+                    ...new Set([...this.verified.sessions.keys()]
                         .map((sessionID) => accountOrAgentIDfromSessionID(sessionID))
                         .filter((session) => isAccountID(session) && session !== this.id)),
                 ]
@@ -603,11 +606,80 @@ export class CoValueCore {
     waitForSync(options) {
         return this.node.syncManager.waitForSync(this.id, options?.timeout);
     }
-}
-function getNextKnownSignatureIdx(log, knownStateForSessionID, sentStateForSessionID) {
-    return Object.keys(log.signatureAfter)
-        .map(Number)
-        .sort((a, b) => a - b)
-        .find((idx) => idx >= (sentStateForSessionID ?? knownStateForSessionID ?? -1));
+    async loadFromPeers(peers) {
+        if (peers.length === 0) {
+            return;
+        }
+        const peersToActuallyLoadFrom = [];
+        for (const peer of peers) {
+            const currentState = this.peers.get(peer.id);
+            if (currentState?.type === "available" ||
+                currentState?.type === "pending") {
+                continue;
+            }
+            if (currentState?.type === "errored") {
+                continue;
+            }
+            if (currentState?.type === "unavailable") {
+                if (peer.shouldRetryUnavailableCoValues()) {
+                    this.markPending(peer.id);
+                    peersToActuallyLoadFrom.push(peer);
+                }
+                continue;
+            }
+            if (!currentState || currentState?.type === "unknown") {
+                this.markPending(peer.id);
+                peersToActuallyLoadFrom.push(peer);
+            }
+        }
+        for (const peer of peersToActuallyLoadFrom) {
+            if (peer.closed) {
+                this.markNotFoundInPeer(peer.id);
+                continue;
+            }
+            peer.pushOutgoingMessage({
+                action: "load",
+                ...this.knownState(),
+            });
+            peer.trackLoadRequestSent(this.id);
+            /**
+             * Use a very long timeout for storage peers, because under pressure
+             * they may take a long time to consume the messages queue
+             *
+             * TODO: Track errors on storage and do not rely on timeout
+             */
+            const timeoutDuration = peer.role === "storage"
+                ? CO_VALUE_LOADING_CONFIG.TIMEOUT * 10
+                : CO_VALUE_LOADING_CONFIG.TIMEOUT;
+            const waitingForPeer = new Promise((resolve) => {
+                const markNotFound = () => {
+                    if (this.peers.get(peer.id)?.type === "pending") {
+                        logger.warn("Timeout waiting for peer to load coValue", {
+                            id: this.id,
+                            peerID: peer.id,
+                        });
+                        this.markNotFoundInPeer(peer.id);
+                    }
+                };
+                const timeout = setTimeout(markNotFound, timeoutDuration);
+                const removeCloseListener = peer.addCloseListener(markNotFound);
+                const listener = (state) => {
+                    const peerState = state.peers.get(peer.id);
+                    if (state.isAvailable() || // might have become available from another peer e.g. through handleNewContent
+                        peerState?.type === "available" ||
+                        peerState?.type === "errored" ||
+                        peerState?.type === "unavailable") {
+                        this.listeners.delete(listener);
+                        removeCloseListener();
+                        clearTimeout(timeout);
+                        resolve();
+                    }
+                };
+                this.listeners.add(listener);
+                listener(this);
+            });
+            await waitingForPeer;
+        }
+    }
 }
 //# sourceMappingURL=coValueCore.js.map