@aztec-labs/prover-client 6.0.0-nightly.20260829

package/dest/orchestrator/block-proving-state.js

@@ -0,0 +1,339 @@
+import { encodeBlockEndBlobData } from '@aztec-labs/blob-lib';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { UnbalancedTreeStore } from '@aztec-labs/foundation/trees';
+import { L1ToL2MessageBundle, makeL1ToL2MessageBundle } from '@aztec-labs/stdlib/messaging';
+import { BlockRootNoTxsRollupPrivateInputs, BlockRootRollupPrivateInputs, BlockRootSingleTxRollupPrivateInputs, TxMergeRollupPrivateInputs } from '@aztec-labs/stdlib/rollup';
+import { BlockHeader, GlobalVariables } from '@aztec-labs/stdlib/tx';
+import { buildHeaderFromCircuitOutputs, toProofData } from './block-building-helpers.js';
+/**
+ * The current state of the proving schedule for a given block. Managed by ProvingState.
+ * Contains the raw inputs and intermediate state to generate every constituent proof in the tree.
+ */ export class BlockProvingState {
+    index;
+    blockNumber;
+    totalNumTxs;
+    constants;
+    timestamp;
+    lastArchiveTreeSnapshot;
+    lastArchiveSiblingPath;
+    previousState;
+    startL1ToL2MessageTreeSnapshot;
+    newL1ToL2MessageTreeSnapshot;
+    l1ToL2MessageFrontierHint;
+    l1ToL2Messages;
+    startMsgSponge;
+    endMsgSponge;
+    startSpongeBlob;
+    parentCheckpoint;
+    baseOrMergeProofs;
+    blockRootProof;
+    builtBlockHeader;
+    builtArchive;
+    endState;
+    endSpongeBlob;
+    txs;
+    error;
+    constructor(index, blockNumber, totalNumTxs, constants, timestamp, lastArchiveTreeSnapshot, lastArchiveSiblingPath, // The full state reference of the previous block, before this block's bundle is appended. Feeds the msgs-only
+    // block root, whose zero-tx block has no tx constants to pin the previous state.
+    previousState, // This block's L1-to-L2 message tree snapshot before and after its own bundle. The start is
+    // the previous block's end (block-merge continuity); the end is this block's own post-bundle snapshot.
+    startL1ToL2MessageTreeSnapshot, newL1ToL2MessageTreeSnapshot, // Full-height frontier (left-sibling path) at the block's start index, pinning the append at a compact index.
+    l1ToL2MessageFrontierHint, // This block's own real L1-to-L2 message leaves (unpadded slice).
+    l1ToL2Messages, // Message sponge threaded across the checkpoint's blocks: the start is the previous block's
+    // end sponge (empty for the first block), the end absorbs this block's own slice. Block merges assert the
+    // continuity, so the end is exposed for the next block to inherit.
+    startMsgSponge, endMsgSponge, startSpongeBlob, parentCheckpoint){
+        this.index = index;
+        this.blockNumber = blockNumber;
+        this.totalNumTxs = totalNumTxs;
+        this.constants = constants;
+        this.timestamp = timestamp;
+        this.lastArchiveTreeSnapshot = lastArchiveTreeSnapshot;
+        this.lastArchiveSiblingPath = lastArchiveSiblingPath;
+        this.previousState = previousState;
+        this.startL1ToL2MessageTreeSnapshot = startL1ToL2MessageTreeSnapshot;
+        this.newL1ToL2MessageTreeSnapshot = newL1ToL2MessageTreeSnapshot;
+        this.l1ToL2MessageFrontierHint = l1ToL2MessageFrontierHint;
+        this.l1ToL2Messages = l1ToL2Messages;
+        this.startMsgSponge = startMsgSponge;
+        this.endMsgSponge = endMsgSponge;
+        this.startSpongeBlob = startSpongeBlob;
+        this.parentCheckpoint = parentCheckpoint;
+        this.baseOrMergeProofs = new UnbalancedTreeStore(0);
+        this.txs = [];
+        this.baseOrMergeProofs = new UnbalancedTreeStore(totalNumTxs);
+    }
+    /** The message sponge after absorbing this block's slice; inherited by the next block as its start sponge. */ getEndMsgSponge() {
+        return this.endMsgSponge;
+    }
+    get epochNumber() {
+        return this.parentCheckpoint.epochNumber;
+    }
+    // Adds a transaction to the proving state, returns it's index
+    addNewTx(tx) {
+        if (!this.isAcceptingTxs()) {
+            throw new Error(`Cannot add more txs to block ${this.blockNumber}.`);
+        }
+        const txIndex = this.txs.length;
+        this.txs[txIndex] = tx;
+        return txIndex;
+    }
+    isAcceptingTxs() {
+        return this.txs.length < this.totalNumTxs;
+    }
+    getProcessedTxs() {
+        return this.txs.map((t)=>t.processedTx);
+    }
+    tryStartProvingBase(txIndex) {
+        if (this.baseOrMergeProofs.getLeaf(txIndex)?.isProving) {
+            return false;
+        } else {
+            this.baseOrMergeProofs.setLeaf(txIndex, {
+                isProving: true
+            });
+            return true;
+        }
+    }
+    setBaseRollupProof(txIndex, provingOutput) {
+        return this.baseOrMergeProofs.setLeaf(txIndex, {
+            provingOutput
+        });
+    }
+    tryStartProvingMerge(location) {
+        if (this.baseOrMergeProofs.getNode(location)?.isProving) {
+            return false;
+        } else {
+            this.baseOrMergeProofs.setNode(location, {
+                isProving: true
+            });
+            return true;
+        }
+    }
+    setMergeRollupProof(location, provingOutput) {
+        this.baseOrMergeProofs.setNode(location, {
+            provingOutput
+        });
+    }
+    tryStartProvingBlockRoot() {
+        if (this.blockRootProof?.isProving) {
+            return false;
+        } else {
+            this.blockRootProof = {
+                isProving: true
+            };
+            return true;
+        }
+    }
+    setBlockRootRollupProof(provingOutput) {
+        this.blockRootProof = {
+            provingOutput
+        };
+        return this.parentCheckpoint.setBlockRootRollupProof(this.index, provingOutput);
+    }
+    getBlockRootRollupOutput() {
+        return this.blockRootProof?.provingOutput?.inputs;
+    }
+    async buildBlockHeader() {
+        if (this.isAcceptingTxs()) {
+            throw new Error('All txs must be added to the block before building the header.');
+        }
+        if (!this.endState) {
+            throw new Error('Call `setEndState` first.');
+        }
+        if (!this.endSpongeBlob) {
+            throw new Error('Call `setEndSpongeBlob` first.');
+        }
+        const endSpongeBlob = this.endSpongeBlob.clone();
+        const endSpongeBlobHash = await endSpongeBlob.squeeze();
+        this.builtBlockHeader = new BlockHeader(this.lastArchiveTreeSnapshot, this.endState, endSpongeBlobHash, this.#getGlobalVariables(), this.#getTotalFees(), new Fr(this.#getTotalManaUsed()));
+        return this.builtBlockHeader;
+    }
+    getBuiltBlockHeader() {
+        return this.builtBlockHeader;
+    }
+    setBuiltArchive(archive) {
+        this.builtArchive = archive;
+    }
+    getBuiltArchive() {
+        return this.builtArchive;
+    }
+    getStartSpongeBlob() {
+        return this.startSpongeBlob;
+    }
+    setEndSpongeBlob(endSpongeBlob) {
+        this.endSpongeBlob = endSpongeBlob;
+    }
+    getEndSpongeBlob() {
+        return this.endSpongeBlob;
+    }
+    setEndState(endState) {
+        this.endState = endState;
+    }
+    hasEndState() {
+        return !!this.endState;
+    }
+    getBlockEndBlobFields() {
+        return encodeBlockEndBlobData(this.getBlockEndBlobData());
+    }
+    getBlockEndBlobData() {
+        if (!this.endState) {
+            throw new Error('Call `setEndState` first.');
+        }
+        const partial = this.endState.partial;
+        return {
+            blockEndMarker: {
+                numTxs: this.totalNumTxs,
+                timestamp: this.timestamp,
+                blockNumber: this.blockNumber
+            },
+            blockEndStateField: {
+                l1ToL2MessageNextAvailableLeafIndex: this.newL1ToL2MessageTreeSnapshot.nextAvailableLeafIndex,
+                noteHashNextAvailableLeafIndex: partial.noteHashTree.nextAvailableLeafIndex,
+                nullifierNextAvailableLeafIndex: partial.nullifierTree.nextAvailableLeafIndex,
+                publicDataNextAvailableLeafIndex: partial.publicDataTree.nextAvailableLeafIndex,
+                totalManaUsed: this.#getTotalManaUsed()
+            },
+            lastArchiveRoot: this.lastArchiveTreeSnapshot.root,
+            noteHashRoot: partial.noteHashTree.root,
+            nullifierRoot: partial.nullifierTree.root,
+            publicDataRoot: partial.publicDataTree.root,
+            // Every block carries its own post-bundle l1-to-l2 message tree root.
+            l1ToL2MessageRoot: this.newL1ToL2MessageTreeSnapshot.root
+        };
+    }
+    getBlockBlobData() {
+        return {
+            ...this.getBlockEndBlobData(),
+            txs: this.getTxEffects().map((t)=>t.toTxBlobData())
+        };
+    }
+    getTxEffects() {
+        return this.txs.map((t)=>t.processedTx.txEffect);
+    }
+    getParentLocation(location) {
+        return this.baseOrMergeProofs.getParentLocation(location);
+    }
+    getMergeRollupInputs(mergeLocation) {
+        const [left, right] = this.baseOrMergeProofs.getChildren(mergeLocation).map((c)=>c?.provingOutput);
+        if (!left || !right) {
+            throw new Error('At least one child is not ready for the merge rollup.');
+        }
+        return new TxMergeRollupPrivateInputs([
+            toProofData(left),
+            toProofData(right)
+        ]);
+    }
+    /**
+   * The block root variant is selected by transaction count alone. Whether this is the checkpoint's first block is
+   * expressed through the start sponge values it feeds the circuit, which the checkpoint root pins to their initial
+   * values for the leftmost block and the block merge pins to the previous block's end values otherwise.
+   */ getBlockRootRollupTypeAndInputs() {
+        const provingOutputs = this.#getChildProvingOutputsForBlockRoot();
+        if (!provingOutputs.every((p)=>!!p)) {
+            throw new Error('At least one child is not ready for the block root rollup.');
+        }
+        const previousRollups = provingOutputs.map((p)=>toProofData(p));
+        const messageBundle = this.#getMessageBundle();
+        const frontierHint = this.#getFrontierHint();
+        const startMsgSponge = this.startMsgSponge;
+        const [leftRollup, rightRollup] = previousRollups;
+        if (!leftRollup) {
+            return {
+                rollupType: 'rollup-block-root-no-txs',
+                inputs: new BlockRootNoTxsRollupPrivateInputs(this.lastArchiveTreeSnapshot, this.previousState, this.constants, this.timestamp, this.startSpongeBlob, startMsgSponge, messageBundle, frontierHint, this.lastArchiveSiblingPath)
+            };
+        } else if (!rightRollup) {
+            return {
+                rollupType: 'rollup-block-root-single-tx',
+                inputs: new BlockRootSingleTxRollupPrivateInputs(leftRollup, messageBundle, this.startL1ToL2MessageTreeSnapshot, startMsgSponge, frontierHint, this.lastArchiveSiblingPath)
+            };
+        } else {
+            return {
+                rollupType: 'rollup-block-root',
+                inputs: new BlockRootRollupPrivateInputs([
+                    leftRollup,
+                    rightRollup
+                ], messageBundle, this.startL1ToL2MessageTreeSnapshot, startMsgSponge, frontierHint, this.lastArchiveSiblingPath)
+            };
+        }
+    }
+    /**
+   * The real-count message bundle this block appends: the block's own message slice, inserted at
+   * compact indices and absorbed into its block-root message sponge.
+   */ #getMessageBundle() {
+        return this.l1ToL2Messages.length === 0 ? L1ToL2MessageBundle.empty() : makeL1ToL2MessageBundle(this.l1ToL2Messages);
+    }
+    /**
+   * Full-height frontier hint for the bundle append: the left-sibling path at the block's compact start index, which
+   * the block-root circuit re-hashes against its start snapshot root.
+   */ #getFrontierHint() {
+        return this.l1ToL2MessageFrontierHint;
+    }
+    // Returns a specific transaction proving state
+    getTxProvingState(txIndex) {
+        return this.txs[txIndex];
+    }
+    async buildHeaderFromProvingOutputs() {
+        if (!this.blockRootProof?.provingOutput) {
+            throw new Error('Block root rollup is not ready.');
+        }
+        return await buildHeaderFromCircuitOutputs(this.blockRootProof.provingOutput.inputs);
+    }
+    isReadyForMergeRollup(location) {
+        return !!this.baseOrMergeProofs.getSibling(location)?.provingOutput;
+    }
+    // Returns true if we have sufficient inputs to execute the block root rollup. Parity no longer gates the block root
+    // (it moved to the checkpoint root), so the block root is ready once its child tx proofs land.
+    isReadyForBlockRootRollup() {
+        const childProofs = this.#getChildProvingOutputsForBlockRoot();
+        return childProofs.every((p)=>!!p);
+    }
+    isComplete() {
+        return !!this.blockRootProof;
+    }
+    verifyState() {
+        return this.parentCheckpoint.verifyState();
+    }
+    getError() {
+        return this.error;
+    }
+    reject(reason) {
+        this.error = reason;
+        this.parentCheckpoint.reject(reason);
+    }
+    #getChildProvingOutputsForBlockRoot() {
+        if (this.totalNumTxs === 0) {
+            return [];
+        }
+        const rootLocation = {
+            level: 0,
+            index: 0
+        };
+        // If there's only 1 tx, its base rollup proof will be stored at the root.
+        return this.totalNumTxs === 1 ? [
+            this.baseOrMergeProofs.getNode(rootLocation)?.provingOutput
+        ] : this.baseOrMergeProofs.getChildren(rootLocation).map((c)=>c?.provingOutput);
+    }
+    #getGlobalVariables() {
+        if (this.txs.length) {
+            return this.txs[0].processedTx.globalVariables;
+        }
+        const constants = this.constants;
+        return GlobalVariables.from({
+            chainId: constants.chainId,
+            version: constants.version,
+            blockNumber: this.blockNumber,
+            slotNumber: constants.slotNumber,
+            timestamp: this.timestamp,
+            coinbase: constants.coinbase,
+            feeRecipient: constants.feeRecipient,
+            gasFees: constants.gasFees
+        });
+    }
+    #getTotalFees() {
+        return this.txs.reduce((acc, tx)=>acc.add(tx.processedTx.txEffect.transactionFee), Fr.ZERO);
+    }
+    #getTotalManaUsed() {
+        return this.txs.reduce((acc, tx)=>acc + BigInt(tx.processedTx.gasUsed.billedGas.l2Gas), 0n);
+    }
+}

package/dest/orchestrator/checkpoint-proving-state.d.ts

@@ -0,0 +1,67 @@
+import type { ARCHIVE_HEIGHT, L1_TO_L2_MSG_TREE_HEIGHT, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec-labs/constants';
+import { BlockNumber } from '@aztec-labs/foundation/branded-types';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { Tuple } from '@aztec-labs/foundation/serialize';
+import { type TreeNodeLocation } from '@aztec-labs/foundation/trees';
+import type { PublicInputsAndRecursiveProof } from '@aztec-labs/stdlib/interfaces/server';
+import { InboxParityPrivateInputs, type ParityPublicInputs } from '@aztec-labs/stdlib/parity';
+import { BlockMergeRollupPrivateInputs, BlockRollupPublicInputs, CheckpointConstantData } from '@aztec-labs/stdlib/rollup';
+import type { AppendOnlyTreeSnapshot } from '@aztec-labs/stdlib/trees';
+import type { BlockHeader, StateReference } from '@aztec-labs/stdlib/tx';
+import type { UInt64 } from '@aztec-labs/stdlib/types';
+import { BlockProvingState } from './block-proving-state.js';
+export declare class CheckpointProvingState {
+    readonly index: number;
+    readonly constants: CheckpointConstantData;
+    readonly totalNumBlocks: number;
+    private readonly headerOfLastBlockInPreviousCheckpoint;
+    private readonly lastArchiveSiblingPath;
+    private readonly l1ToL2Messages;
+    private readonly startInboxRollingHash;
+    readonly epochNumber: number;
+    /** Owner's liveness check. `verifyState()` returns false once this returns false. */
+    private readonly isAlive;
+    /** Owner's failure callback. Invoked from `reject` to surface the error upward. */
+    private readonly onReject;
+    private blockProofs;
+    private inboxParityProof;
+    private blocks;
+    private error;
+    readonly firstBlockNumber: BlockNumber;
+    constructor(index: number, constants: CheckpointConstantData, totalNumBlocks: number, headerOfLastBlockInPreviousCheckpoint: BlockHeader, lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>, l1ToL2Messages: Fr[], startInboxRollingHash: Fr, epochNumber: number, 
+    /** Owner's liveness check. `verifyState()` returns false once this returns false. */
+    isAlive: () => boolean, 
+    /** Owner's failure callback. Invoked from `reject` to surface the error upward. */
+    onReject: (reason: string) => void);
+    /** The checkpoint's real L1-to-L2 messages (unpadded), consumed across its blocks. */
+    getL1ToL2Messages(): Fr[];
+    startNewBlock(blockNumber: BlockNumber, timestamp: UInt64, totalNumTxs: number, lastArchiveTreeSnapshot: AppendOnlyTreeSnapshot, lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>, previousState: StateReference, startL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, endL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, l1ToL2MessageFrontierHint: Tuple<Fr, typeof L1_TO_L2_MSG_TREE_HEIGHT>, l1ToL2Messages: Fr[]): Promise<BlockProvingState>;
+    isAcceptingBlocks(): boolean;
+    setBlockRootRollupProof(blockIndex: number, provingOutput: PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): TreeNodeLocation;
+    tryStartProvingBlockMerge(location: TreeNodeLocation): boolean;
+    setBlockMergeRollupProof(location: TreeNodeLocation, provingOutput: PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): void;
+    /**
+     * Builds the checkpoint's single InboxParity input. The circuit is sized to the smallest ladder rung that fits the
+     * message count and the rolling hash starts from the previous checkpoint's end.
+     */
+    getInboxParityInputs(): InboxParityPrivateInputs;
+    tryStartProvingInboxParity(): boolean;
+    setInboxParityProof(provingOutput: PublicInputsAndRecursiveProof<ParityPublicInputs>): void;
+    getInboxParityProof(): PublicInputsAndRecursiveProof<ParityPublicInputs, 410> | undefined;
+    getParentLocation(location: TreeNodeLocation): TreeNodeLocation;
+    getBlockMergeRollupInputs(mergeLocation: TreeNodeLocation): BlockMergeRollupPrivateInputs;
+    getBlockProvingStateByBlockNumber(blockNumber: BlockNumber): BlockProvingState | undefined;
+    isReadyForBlockMerge(location: TreeNodeLocation): boolean;
+    verifyState(): boolean;
+    getError(): string | undefined;
+    cancel(): void;
+    reject(reason: string): void;
+    /**
+     * Returns the block-level proof outputs that feed into the checkpoint root rollup.
+     * Used by `CheckpointSubTreeOrchestrator` to surface its sub-tree result.
+     */
+    getSubTreeOutputProofs(): (PublicInputsAndRecursiveProof<BlockRollupPublicInputs, 480> | undefined)[];
+    /** Sibling path of the archive tree captured before any block in this checkpoint landed. */
+    getLastArchiveSiblingPath(): [Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr, Fr];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/orchestrator/checkpoint-proving-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint-proving-state.d.ts","sourceRoot":"","sources":["../../src/orchestrator/checkpoint-proving-state.ts"],"names":[],"mappings":"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"}

package/dest/orchestrator/checkpoint-proving-state.js

@@ -0,0 +1,175 @@
+import { SpongeBlob } from '@aztec-labs/blob-lib';
+import { BlockNumber } from '@aztec-labs/foundation/branded-types';
+import { UnbalancedTreeStore } from '@aztec-labs/foundation/trees';
+import { L1ToL2MessageSponge } from '@aztec-labs/stdlib/messaging';
+import { InboxParityPrivateInputs } from '@aztec-labs/stdlib/parity';
+import { BlockMergeRollupPrivateInputs } from '@aztec-labs/stdlib/rollup';
+import { toProofData } from './block-building-helpers.js';
+import { BlockProvingState } from './block-proving-state.js';
+export class CheckpointProvingState {
+    index;
+    constants;
+    totalNumBlocks;
+    headerOfLastBlockInPreviousCheckpoint;
+    lastArchiveSiblingPath;
+    l1ToL2Messages;
+    startInboxRollingHash;
+    epochNumber;
+    isAlive;
+    onReject;
+    blockProofs;
+    // The checkpoint's single InboxParity proof. Parity gates the checkpoint root, not the first block root: one
+    // variable-size proof per checkpoint replaces the former base + root parity fan-in. Surfaced as part of the
+    // sub-tree result.
+    inboxParityProof;
+    blocks;
+    error;
+    firstBlockNumber;
+    constructor(index, constants, totalNumBlocks, headerOfLastBlockInPreviousCheckpoint, lastArchiveSiblingPath, l1ToL2Messages, // Inbox rolling hash before this checkpoint's messages (the previous checkpoint's end value; genesis is zero).
+    // Threaded into the InboxParity circuit so the resulting checkpoint header rolling hash matches the proposer's.
+    startInboxRollingHash, epochNumber, /** Owner's liveness check. `verifyState()` returns false once this returns false. */ isAlive, /** Owner's failure callback. Invoked from `reject` to surface the error upward. */ onReject){
+        this.index = index;
+        this.constants = constants;
+        this.totalNumBlocks = totalNumBlocks;
+        this.headerOfLastBlockInPreviousCheckpoint = headerOfLastBlockInPreviousCheckpoint;
+        this.lastArchiveSiblingPath = lastArchiveSiblingPath;
+        this.l1ToL2Messages = l1ToL2Messages;
+        this.startInboxRollingHash = startInboxRollingHash;
+        this.epochNumber = epochNumber;
+        this.isAlive = isAlive;
+        this.onReject = onReject;
+        this.blocks = [];
+        this.blockProofs = new UnbalancedTreeStore(totalNumBlocks);
+        this.firstBlockNumber = BlockNumber(headerOfLastBlockInPreviousCheckpoint.globalVariables.blockNumber + 1);
+    }
+    /** The checkpoint's real L1-to-L2 messages (unpadded), consumed across its blocks. */ getL1ToL2Messages() {
+        return this.l1ToL2Messages;
+    }
+    async startNewBlock(blockNumber, timestamp, totalNumTxs, lastArchiveTreeSnapshot, lastArchiveSiblingPath, // The full state reference of the previous block (before this block's message bundle is appended). Feeds the
+    // msgs-only block root, whose zero-tx block carries no tx constants to pin the previous state.
+    previousState, // Per-block L1-to-L2 message state: the block's start snapshot (its parent's end), its own
+    // post-bundle end snapshot, the full-height frontier at the start index, and its own real message slice.
+    startL1ToL2MessageTreeSnapshot, endL1ToL2MessageTreeSnapshot, l1ToL2MessageFrontierHint, l1ToL2Messages) {
+        const index = Number(blockNumber) - Number(this.firstBlockNumber);
+        if (index >= this.totalNumBlocks) {
+            throw new Error(`Unable to start a new block at index ${index}. Expected at most ${this.totalNumBlocks} blocks.`);
+        }
+        const startSpongeBlob = index === 0 ? SpongeBlob.init() : this.blocks[index - 1]?.getEndSpongeBlob();
+        if (!startSpongeBlob) {
+            throw new Error('Cannot start a new block before the trees have progressed from the tx effects in the previous block.');
+        }
+        // Thread the message sponge across the checkpoint's blocks: each block starts from the
+        // previous block's end sponge (empty for the first block) and absorbs its own real slice. The block merge and
+        // checkpoint root circuits assert exactly this continuity (`right.start_msg_sponge == left.end_msg_sponge`, first
+        // block starts empty, merged end equals the InboxParity sponge), so the end sponge is computed eagerly here for
+        // the next block to inherit. Blocks must therefore be started in order, which the sequential per-block message
+        // appends already require.
+        const startMsgSponge = index === 0 ? L1ToL2MessageSponge.empty() : this.blocks[index - 1]?.getEndMsgSponge();
+        if (!startMsgSponge) {
+            throw new Error('Cannot start a new block before the previous block in the checkpoint has been started.');
+        }
+        const endMsgSponge = startMsgSponge.clone();
+        await endMsgSponge.absorb(l1ToL2Messages);
+        const block = new BlockProvingState(index, blockNumber, totalNumTxs, this.constants, timestamp, lastArchiveTreeSnapshot, lastArchiveSiblingPath, previousState, startL1ToL2MessageTreeSnapshot, endL1ToL2MessageTreeSnapshot, l1ToL2MessageFrontierHint, l1ToL2Messages, startMsgSponge, endMsgSponge, startSpongeBlob, this);
+        this.blocks[index] = block;
+        return block;
+    }
+    // Returns true if we are still able to accept blocks, false otherwise.
+    isAcceptingBlocks() {
+        return this.blocks.filter((b)=>!!b).length < this.totalNumBlocks;
+    }
+    setBlockRootRollupProof(blockIndex, provingOutput) {
+        return this.blockProofs.setLeaf(blockIndex, {
+            provingOutput
+        });
+    }
+    tryStartProvingBlockMerge(location) {
+        if (this.blockProofs.getNode(location)?.isProving) {
+            return false;
+        } else {
+            this.blockProofs.setNode(location, {
+                isProving: true
+            });
+            return true;
+        }
+    }
+    setBlockMergeRollupProof(location, provingOutput) {
+        this.blockProofs.setNode(location, {
+            provingOutput
+        });
+    }
+    // ---------------- inbox parity proof orchestration ----------------
+    /**
+   * Builds the checkpoint's single InboxParity input. The circuit is sized to the smallest ladder rung that fits the
+   * message count and the rolling hash starts from the previous checkpoint's end.
+   */ getInboxParityInputs() {
+        return InboxParityPrivateInputs.fromMessages(this.l1ToL2Messages, this.startInboxRollingHash, this.constants.proverId);
+    }
+    tryStartProvingInboxParity() {
+        if (this.inboxParityProof?.isProving) {
+            return false;
+        }
+        this.inboxParityProof = {
+            isProving: true
+        };
+        return true;
+    }
+    setInboxParityProof(provingOutput) {
+        this.inboxParityProof = {
+            provingOutput
+        };
+    }
+    getInboxParityProof() {
+        return this.inboxParityProof?.provingOutput;
+    }
+    getParentLocation(location) {
+        return this.blockProofs.getParentLocation(location);
+    }
+    getBlockMergeRollupInputs(mergeLocation) {
+        const [left, right] = this.blockProofs.getChildren(mergeLocation).map((c)=>c?.provingOutput);
+        if (!left || !right) {
+            throw new Error('At least one child is not ready for the block merge rollup.');
+        }
+        return new BlockMergeRollupPrivateInputs([
+            toProofData(left),
+            toProofData(right)
+        ]);
+    }
+    getBlockProvingStateByBlockNumber(blockNumber) {
+        const index = Number(blockNumber) - Number(this.firstBlockNumber);
+        return this.blocks[index];
+    }
+    isReadyForBlockMerge(location) {
+        return !!this.blockProofs.getSibling(location)?.provingOutput;
+    }
+    verifyState() {
+        return this.isAlive();
+    }
+    getError() {
+        return this.error;
+    }
+    // Attempts to reject the proving state promise with a reason of 'cancelled'
+    cancel() {
+        this.reject('Proving cancelled');
+    }
+    reject(reason) {
+        this.error = reason;
+        this.onReject(reason);
+    }
+    /**
+   * Returns the block-level proof outputs that feed into the checkpoint root rollup.
+   * Used by `CheckpointSubTreeOrchestrator` to surface its sub-tree result.
+   */ getSubTreeOutputProofs() {
+        const rootLocation = {
+            level: 0,
+            index: 0
+        };
+        return this.totalNumBlocks === 1 ? [
+            this.blockProofs.getNode(rootLocation)?.provingOutput
+        ] // If there's only 1 block, its proof will be stored at the root.
+         : this.blockProofs.getChildren(rootLocation).map((c)=>c?.provingOutput);
+    }
+    /** Sibling path of the archive tree captured before any block in this checkpoint landed. */ getLastArchiveSiblingPath() {
+        return this.lastArchiveSiblingPath;
+    }
+}