@aztec/prover-client 0.0.0-test.0 → 0.0.1-fake-c83136db25

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

@@ -0,0 +1,211 @@
+import { SpongeBlob } from '@aztec/blob-lib';
+import { BLOBS_PER_BLOCK, FIELDS_PER_BLOB, NUM_MSGS_PER_BASE_PARITY } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { BLS12Point, Fr } from '@aztec/foundation/fields';
+import { UnbalancedTreeStore } from '@aztec/foundation/trees';
+import { getCheckpointBlobFields } from '@aztec/stdlib/checkpoint';
+import { ParityBasePrivateInputs } from '@aztec/stdlib/parity';
+import { BlockMergeRollupPrivateInputs, CheckpointRootRollupHints, CheckpointRootRollupPrivateInputs, CheckpointRootSingleBlockRollupPrivateInputs } from '@aztec/stdlib/rollup';
+import { accumulateBlobs, buildBlobHints, toProofData } from './block-building-helpers.js';
+import { BlockProvingState } from './block-proving-state.js';
+export class CheckpointProvingState {
+    index;
+    constants;
+    totalNumBlocks;
+    totalNumBlobFields;
+    finalBlobBatchingChallenges;
+    headerOfLastBlockInPreviousCheckpoint;
+    lastArchiveSiblingPath;
+    l1ToL2Messages;
+    lastL1ToL2MessageTreeSnapshot;
+    lastL1ToL2MessageSubtreeRootSiblingPath;
+    newL1ToL2MessageTreeSnapshot;
+    newL1ToL2MessageSubtreeRootSiblingPath;
+    parentEpoch;
+    onBlobAccumulatorSet;
+    blockProofs;
+    checkpointRootProof;
+    blocks;
+    startBlobAccumulator;
+    endBlobAccumulator;
+    blobFields;
+    error;
+    firstBlockNumber;
+    constructor(index, constants, totalNumBlocks, totalNumBlobFields, finalBlobBatchingChallenges, headerOfLastBlockInPreviousCheckpoint, lastArchiveSiblingPath, l1ToL2Messages, // The snapshot and sibling path before the new l1 to l2 message subtree is inserted.
+    lastL1ToL2MessageTreeSnapshot, lastL1ToL2MessageSubtreeRootSiblingPath, // The snapshot and sibling path after the new l1 to l2 message subtree is inserted.
+    newL1ToL2MessageTreeSnapshot, newL1ToL2MessageSubtreeRootSiblingPath, parentEpoch, onBlobAccumulatorSet){
+        this.index = index;
+        this.constants = constants;
+        this.totalNumBlocks = totalNumBlocks;
+        this.totalNumBlobFields = totalNumBlobFields;
+        this.finalBlobBatchingChallenges = finalBlobBatchingChallenges;
+        this.headerOfLastBlockInPreviousCheckpoint = headerOfLastBlockInPreviousCheckpoint;
+        this.lastArchiveSiblingPath = lastArchiveSiblingPath;
+        this.l1ToL2Messages = l1ToL2Messages;
+        this.lastL1ToL2MessageTreeSnapshot = lastL1ToL2MessageTreeSnapshot;
+        this.lastL1ToL2MessageSubtreeRootSiblingPath = lastL1ToL2MessageSubtreeRootSiblingPath;
+        this.newL1ToL2MessageTreeSnapshot = newL1ToL2MessageTreeSnapshot;
+        this.newL1ToL2MessageSubtreeRootSiblingPath = newL1ToL2MessageSubtreeRootSiblingPath;
+        this.parentEpoch = parentEpoch;
+        this.onBlobAccumulatorSet = onBlobAccumulatorSet;
+        this.blocks = [];
+        this.blockProofs = new UnbalancedTreeStore(totalNumBlocks);
+        this.firstBlockNumber = headerOfLastBlockInPreviousCheckpoint.globalVariables.blockNumber + 1;
+    }
+    get epochNumber() {
+        return this.parentEpoch.epochNumber;
+    }
+    async startNewBlock(blockNumber, timestamp, totalNumTxs, lastArchiveTreeSnapshot, lastArchiveSiblingPath) {
+        const index = blockNumber - this.firstBlockNumber;
+        if (index >= this.totalNumBlocks) {
+            throw new Error(`Unable to start a new block at index ${index}. Expected at most ${this.totalNumBlocks} blocks.`);
+        }
+        // If this is the first block, we use the snapshot and sibling path before the new l1 to l2 messages are inserted.
+        // Otherwise, we use the snapshot and sibling path after the new l1 to l2 messages are inserted, which will always
+        // happen in the first block.
+        const lastL1ToL2MessageTreeSnapshot = index === 0 ? this.lastL1ToL2MessageTreeSnapshot : this.newL1ToL2MessageTreeSnapshot;
+        const lastL1ToL2MessageSubtreeRootSiblingPath = index === 0 ? this.lastL1ToL2MessageSubtreeRootSiblingPath : this.newL1ToL2MessageSubtreeRootSiblingPath;
+        const startSpongeBlob = index === 0 ? await SpongeBlob.init(this.totalNumBlobFields) : 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.');
+        }
+        const block = new BlockProvingState(index, blockNumber, totalNumTxs, this.constants, timestamp, lastArchiveTreeSnapshot, lastArchiveSiblingPath, lastL1ToL2MessageTreeSnapshot, lastL1ToL2MessageSubtreeRootSiblingPath, this.newL1ToL2MessageTreeSnapshot, this.headerOfLastBlockInPreviousCheckpoint, 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
+        });
+    }
+    tryStartProvingCheckpointRoot() {
+        if (this.checkpointRootProof?.isProving) {
+            return false;
+        } else {
+            this.checkpointRootProof = {
+                isProving: true
+            };
+            return true;
+        }
+    }
+    setCheckpointRootRollupProof(provingOutput) {
+        this.checkpointRootProof = {
+            provingOutput
+        };
+        return this.parentEpoch.setCheckpointRootRollupProof(this.index, provingOutput);
+    }
+    getBaseParityInputs(baseParityIndex) {
+        const messages = padArrayEnd(this.l1ToL2Messages.slice(baseParityIndex * NUM_MSGS_PER_BASE_PARITY, (baseParityIndex + 1) * NUM_MSGS_PER_BASE_PARITY), Fr.ZERO, NUM_MSGS_PER_BASE_PARITY);
+        return new ParityBasePrivateInputs(messages, this.constants.vkTreeRoot);
+    }
+    async accumulateBlobs(startBlobAccumulator) {
+        if (this.isAcceptingBlocks() || this.blocks.some((b)=>b.isAcceptingTxs())) {
+            return;
+        }
+        this.blobFields = getCheckpointBlobFields(this.blocks.map((b)=>b.getTxEffects()));
+        this.endBlobAccumulator = await accumulateBlobs(this.blobFields, startBlobAccumulator);
+        this.startBlobAccumulator = startBlobAccumulator;
+        this.onBlobAccumulatorSet(this);
+        return this.endBlobAccumulator;
+    }
+    getEndBlobAccumulator() {
+        return this.endBlobAccumulator;
+    }
+    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)
+        ]);
+    }
+    getCheckpointRootRollupType() {
+        return this.totalNumBlocks === 1 ? 'rollup-checkpoint-root-single-block' : 'rollup-checkpoint-root';
+    }
+    getCheckpointRootRollupInputs() {
+        const proofs = this.#getChildProofsForRoot();
+        const nonEmptyProofs = proofs.filter((p)=>!!p);
+        if (proofs.length !== nonEmptyProofs.length) {
+            throw new Error('At least one child is not ready for the checkpoint root rollup.');
+        }
+        if (!this.startBlobAccumulator) {
+            throw new Error('Start blob accumulator is not set.');
+        }
+        // `blobFields` must've been set if `startBlobAccumulator` is set (in `accumulateBlobs`).
+        const blobFields = this.blobFields;
+        const { blobCommitments, blobsHash } = buildBlobHints(blobFields);
+        const hints = CheckpointRootRollupHints.from({
+            previousBlockHeader: this.headerOfLastBlockInPreviousCheckpoint,
+            previousArchiveSiblingPath: this.lastArchiveSiblingPath,
+            startBlobAccumulator: this.startBlobAccumulator.toBlobAccumulator(),
+            finalBlobChallenges: this.finalBlobBatchingChallenges,
+            blobFields: padArrayEnd(blobFields, Fr.ZERO, FIELDS_PER_BLOB * BLOBS_PER_BLOCK),
+            blobCommitments: padArrayEnd(blobCommitments, BLS12Point.ZERO, BLOBS_PER_BLOCK),
+            blobsHash
+        });
+        const [left, right] = nonEmptyProofs.map((p)=>toProofData(p));
+        return !right ? new CheckpointRootSingleBlockRollupPrivateInputs(left, hints) : new CheckpointRootRollupPrivateInputs([
+            left,
+            right
+        ], hints);
+    }
+    getBlockProvingStateByBlockNumber(blockNumber) {
+        const index = blockNumber - this.firstBlockNumber;
+        return this.blocks[index];
+    }
+    isReadyForBlockMerge(location) {
+        return !!this.blockProofs.getSibling(location)?.provingOutput;
+    }
+    isReadyForCheckpointRoot() {
+        const allChildProofsReady = this.#getChildProofsForRoot().every((p)=>!!p);
+        return allChildProofsReady && !!this.startBlobAccumulator;
+    }
+    verifyState() {
+        return this.parentEpoch.verifyState();
+    }
+    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.parentEpoch.reject(reason);
+    }
+    #getChildProofsForRoot() {
+        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);
+    }
+}

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

@@ -1,13 +1,14 @@
-import { type ARCHIVE_HEIGHT, type L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH, type NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import { BatchedBlob, type FinalBlobBatchingChallenges } from '@aztec/blob-lib';
+import type { ARCHIVE_HEIGHT, L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
 import type { Fr } from '@aztec/foundation/fields';
 import type { Tuple } from '@aztec/foundation/serialize';
 import { type TreeNodeLocation } from '@aztec/foundation/trees';
-import type { ProofAndVerificationKey, PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
+import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
 import type { Proof } from '@aztec/stdlib/proofs';
-import { BlockMergeRollupInputs, type BlockRootOrBlockMergePublicInputs, RootRollupInputs, type RootRollupPublicInputs } from '@aztec/stdlib/rollup';
+import { CheckpointConstantData, CheckpointMergeRollupPrivateInputs, CheckpointPaddingRollupPrivateInputs, CheckpointRollupPublicInputs, PublicChonkVerifierPublicInputs, RootRollupPrivateInputs, type RootRollupPublicInputs } from '@aztec/stdlib/rollup';
 import type { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
-import type { BlockHeader, GlobalVariables } from '@aztec/stdlib/tx';
-import { BlockProvingState } from './block-proving-state.js';
+import type { BlockHeader } from '@aztec/stdlib/tx';
+import { CheckpointProvingState } from './checkpoint-proving-state.js';
 export type TreeSnapshots = Map<MerkleTreeId, AppendOnlyTreeSnapshot>;
 export type ProvingResult = {
     status: 'success';
@@ -24,34 +25,46 @@ export type ProvingResult = {
 export declare class EpochProvingState {
     #private;
     readonly epochNumber: number;
-    readonly firstBlockNumber: number;
-    readonly totalNumBlocks: number;
+    readonly totalNumCheckpoints: number;
+    private readonly finalBlobBatchingChallenges;
+    private onCheckpointBlobAccumulatorSet;
     private completionCallback;
     private rejectionCallback;
-    private blockRootOrMergeProvingOutputs;
-    private paddingBlockRootProvingOutput;
-    private rootRollupProvingOutput;
+    private checkpointProofs;
+    private checkpointPaddingProof;
+    private rootRollupProof;
+    private checkpoints;
+    private startBlobAccumulator;
+    private endBlobAccumulator;
+    private finalBatchedBlob;
     private provingStateLifecycle;
-    readonly cachedTubeProofs: Map<string, Promise<ProofAndVerificationKey<538>>>;
-    blocks: (BlockProvingState | undefined)[];
-    constructor(epochNumber: number, firstBlockNumber: number, totalNumBlocks: number, completionCallback: (result: ProvingResult) => void, rejectionCallback: (reason: string) => void);
-    startNewBlock(globalVariables: GlobalVariables, l1ToL2Messages: Fr[], l1ToL2MessageSubtreeSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>, l1ToL2MessageTreeSnapshotAfterInsertion: AppendOnlyTreeSnapshot, lastArchiveSnapshot: AppendOnlyTreeSnapshot, newArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>, previousBlockHeader: BlockHeader): BlockProvingState;
+    readonly cachedChonkVerifierProofs: Map<string, Promise<PublicInputsAndRecursiveProof<PublicChonkVerifierPublicInputs, 535>>>;
+    constructor(epochNumber: number, totalNumCheckpoints: number, finalBlobBatchingChallenges: FinalBlobBatchingChallenges, onCheckpointBlobAccumulatorSet: (checkpoint: CheckpointProvingState) => void, completionCallback: (result: ProvingResult) => void, rejectionCallback: (reason: string) => void);
+    startNewCheckpoint(checkpointIndex: number, constants: CheckpointConstantData, totalNumBlocks: number, totalNumBlobFields: number, previousBlockHeader: BlockHeader, lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>, l1ToL2Messages: Fr[], lastL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, lastL1ToL2MessageSubtreeRootSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH>, newL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, newL1ToL2MessageSubtreeRootSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH>): CheckpointProvingState;
+    getCheckpointProvingState(index: number): CheckpointProvingState | undefined;
+    getCheckpointProvingStateByBlockNumber(blockNumber: number): CheckpointProvingState | undefined;
+    getBlockProvingStateByBlockNumber(blockNumber: number): import("./block-proving-state.js").BlockProvingState | undefined;
     verifyState(): boolean;
-    isAcceptingBlocks(): boolean;
-    setBlockRootRollupProof(blockIndex: number, proof: PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): TreeNodeLocation;
-    setBlockMergeRollupProof(location: TreeNodeLocation, proof: PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): void;
-    setRootRollupProof(proof: PublicInputsAndRecursiveProof<RootRollupPublicInputs>): void;
-    setPaddingBlockRootProof(proof: PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): void;
+    isAcceptingCheckpoints(): boolean;
+    setCheckpointRootRollupProof(checkpointIndex: number, provingOutput: PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): TreeNodeLocation;
+    tryStartProvingCheckpointMerge(location: TreeNodeLocation): boolean;
+    setCheckpointMergeRollupProof(location: TreeNodeLocation, provingOutput: PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): void;
+    tryStartProvingRootRollup(): boolean;
+    setRootRollupProof(provingOutput: PublicInputsAndRecursiveProof<RootRollupPublicInputs>): void;
+    tryStartProvingPaddingCheckpoint(): boolean;
+    setCheckpointPaddingProof(provingOutput: PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): void;
+    setBlobAccumulators(): Promise<void>;
+    finalizeBatchedBlob(): Promise<void>;
     getParentLocation(location: TreeNodeLocation): TreeNodeLocation;
-    getBlockMergeRollupInputs(mergeLocation: TreeNodeLocation): BlockMergeRollupInputs;
-    getRootRollupInputs(proverId: Fr): RootRollupInputs;
-    getPaddingBlockRootInputs(proverId: Fr): Promise<import("@aztec/stdlib/rollup").EmptyBlockRootRollupInputs>;
-    getBlockProvingStateByBlockNumber(blockNumber: number): BlockProvingState | undefined;
+    getCheckpointMergeRollupInputs(mergeLocation: TreeNodeLocation): CheckpointMergeRollupPrivateInputs;
+    getRootRollupInputs(): RootRollupPrivateInputs;
+    getPaddingCheckpointInputs(): CheckpointPaddingRollupPrivateInputs;
     getEpochProofResult(): {
         proof: Proof;
         publicInputs: RootRollupPublicInputs;
+        batchedBlobInputs: BatchedBlob;
     };
-    isReadyForBlockMerge(location: TreeNodeLocation): boolean;
+    isReadyForCheckpointMerge(location: TreeNodeLocation): boolean;
     isReadyForRootRollup(): boolean;
     cancel(): void;
     reject(reason: string): void;

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

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

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

@@ -1,8 +1,8 @@
-import { VK_TREE_HEIGHT } from '@aztec/constants';
-import { MembershipWitness, UnbalancedTreeStore } from '@aztec/foundation/trees';
-import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { BlockMergeRollupInputs, PreviousRollupBlockData, RootRollupInputs } from '@aztec/stdlib/rollup';
-import { BlockProvingState } from './block-proving-state.js';
+import { BatchedBlobAccumulator } from '@aztec/blob-lib';
+import { UnbalancedTreeStore } from '@aztec/foundation/trees';
+import { CheckpointMergeRollupPrivateInputs, CheckpointPaddingRollupPrivateInputs, RootRollupPrivateInputs } from '@aztec/stdlib/rollup';
+import { toProofData } from './block-building-helpers.js';
+import { CheckpointProvingState } from './checkpoint-proving-state.js';
 var PROVING_STATE_LIFECYCLE = /*#__PURE__*/ function(PROVING_STATE_LIFECYCLE) {
     PROVING_STATE_LIFECYCLE[PROVING_STATE_LIFECYCLE["PROVING_STATE_CREATED"] = 0] = "PROVING_STATE_CREATED";
     PROVING_STATE_LIFECYCLE[PROVING_STATE_LIFECYCLE["PROVING_STATE_FULL"] = 1] = "PROVING_STATE_FULL";
@@ -17,106 +17,180 @@ var PROVING_STATE_LIFECYCLE = /*#__PURE__*/ function(PROVING_STATE_LIFECYCLE) {
  * Captures resolve and reject callbacks to provide a promise base interface to the consumer of our proving.
  */ export class EpochProvingState {
     epochNumber;
-    firstBlockNumber;
-    totalNumBlocks;
+    totalNumCheckpoints;
+    finalBlobBatchingChallenges;
+    onCheckpointBlobAccumulatorSet;
     completionCallback;
     rejectionCallback;
-    blockRootOrMergeProvingOutputs;
-    paddingBlockRootProvingOutput;
-    rootRollupProvingOutput;
+    checkpointProofs;
+    checkpointPaddingProof;
+    rootRollupProof;
+    checkpoints;
+    startBlobAccumulator;
+    endBlobAccumulator;
+    finalBatchedBlob;
     provingStateLifecycle;
-    // Map from tx hash to tube proof promise. Used when kickstarting tube proofs before tx processing.
-    cachedTubeProofs;
-    blocks;
-    constructor(epochNumber, firstBlockNumber, totalNumBlocks, completionCallback, rejectionCallback){
+    // Map from tx hash to chonk verifier proof promise. Used when kickstarting chonk verifier proofs before tx processing.
+    cachedChonkVerifierProofs;
+    constructor(epochNumber, totalNumCheckpoints, finalBlobBatchingChallenges, onCheckpointBlobAccumulatorSet, completionCallback, rejectionCallback){
         this.epochNumber = epochNumber;
-        this.firstBlockNumber = firstBlockNumber;
-        this.totalNumBlocks = totalNumBlocks;
+        this.totalNumCheckpoints = totalNumCheckpoints;
+        this.finalBlobBatchingChallenges = finalBlobBatchingChallenges;
+        this.onCheckpointBlobAccumulatorSet = onCheckpointBlobAccumulatorSet;
         this.completionCallback = completionCallback;
         this.rejectionCallback = rejectionCallback;
+        this.checkpoints = [];
         this.provingStateLifecycle = 0;
-        this.cachedTubeProofs = new Map();
-        this.blocks = [];
-        this.blockRootOrMergeProvingOutputs = new UnbalancedTreeStore(totalNumBlocks);
+        this.cachedChonkVerifierProofs = new Map();
+        this.checkpointProofs = new UnbalancedTreeStore(totalNumCheckpoints);
+        this.startBlobAccumulator = BatchedBlobAccumulator.newWithChallenges(finalBlobBatchingChallenges);
     }
     // Adds a block to the proving state, returns its index
     // Will update the proving life cycle if this is the last block
-    startNewBlock(globalVariables, l1ToL2Messages, l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, lastArchiveSnapshot, newArchiveSiblingPath, previousBlockHeader) {
-        const index = globalVariables.blockNumber.toNumber() - this.firstBlockNumber;
-        const block = new BlockProvingState(index, globalVariables, l1ToL2Messages, l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, lastArchiveSnapshot, newArchiveSiblingPath, previousBlockHeader, this);
-        this.blocks[index] = block;
-        if (this.blocks.filter((b)=>!!b).length === this.totalNumBlocks) {
+    startNewCheckpoint(checkpointIndex, constants, totalNumBlocks, totalNumBlobFields, previousBlockHeader, lastArchiveSiblingPath, l1ToL2Messages, lastL1ToL2MessageTreeSnapshot, lastL1ToL2MessageSubtreeRootSiblingPath, newL1ToL2MessageTreeSnapshot, newL1ToL2MessageSubtreeRootSiblingPath) {
+        if (checkpointIndex >= this.totalNumCheckpoints) {
+            throw new Error(`Unable to start a new checkpoint at index ${checkpointIndex}. Expected at most ${this.totalNumCheckpoints} checkpoints.`);
+        }
+        const checkpoint = new CheckpointProvingState(checkpointIndex, constants, totalNumBlocks, totalNumBlobFields, this.finalBlobBatchingChallenges, previousBlockHeader, lastArchiveSiblingPath, l1ToL2Messages, lastL1ToL2MessageTreeSnapshot, lastL1ToL2MessageSubtreeRootSiblingPath, newL1ToL2MessageTreeSnapshot, newL1ToL2MessageSubtreeRootSiblingPath, this, this.onCheckpointBlobAccumulatorSet);
+        this.checkpoints[checkpointIndex] = checkpoint;
+        if (this.checkpoints.filter((c)=>!!c).length === this.totalNumCheckpoints) {
             this.provingStateLifecycle = 1;
         }
-        return block;
+        return checkpoint;
+    }
+    getCheckpointProvingState(index) {
+        return this.checkpoints[index];
+    }
+    getCheckpointProvingStateByBlockNumber(blockNumber) {
+        return this.checkpoints.find((c)=>c && blockNumber >= c.firstBlockNumber && blockNumber < c.firstBlockNumber + c.totalNumBlocks);
+    }
+    getBlockProvingStateByBlockNumber(blockNumber) {
+        return this.getCheckpointProvingStateByBlockNumber(blockNumber)?.getBlockProvingStateByBlockNumber(blockNumber);
     }
     // Returns true if this proving state is still valid, false otherwise
     verifyState() {
         return this.provingStateLifecycle === 0 || this.provingStateLifecycle === 1;
     }
-    // Returns true if we are still able to accept blocks, false otherwise
-    isAcceptingBlocks() {
-        return this.provingStateLifecycle === 0;
+    // Returns true if we are still able to accept checkpoints, false otherwise.
+    isAcceptingCheckpoints() {
+        return this.checkpoints.filter((c)=>!!c).length < this.totalNumCheckpoints;
+    }
+    setCheckpointRootRollupProof(checkpointIndex, provingOutput) {
+        return this.checkpointProofs.setLeaf(checkpointIndex, {
+            provingOutput
+        });
+    }
+    tryStartProvingCheckpointMerge(location) {
+        if (this.checkpointProofs.getNode(location)?.isProving) {
+            return false;
+        } else {
+            this.checkpointProofs.setNode(location, {
+                isProving: true
+            });
+            return true;
+        }
+    }
+    setCheckpointMergeRollupProof(location, provingOutput) {
+        this.checkpointProofs.setNode(location, {
+            provingOutput
+        });
+    }
+    tryStartProvingRootRollup() {
+        if (this.rootRollupProof?.isProving) {
+            return false;
+        } else {
+            this.rootRollupProof = {
+                isProving: true
+            };
+            return true;
+        }
     }
-    setBlockRootRollupProof(blockIndex, proof) {
-        return this.blockRootOrMergeProvingOutputs.setLeaf(blockIndex, proof);
+    setRootRollupProof(provingOutput) {
+        this.rootRollupProof = {
+            provingOutput
+        };
     }
-    setBlockMergeRollupProof(location, proof) {
-        this.blockRootOrMergeProvingOutputs.setNode(location, proof);
+    tryStartProvingPaddingCheckpoint() {
+        if (this.checkpointPaddingProof?.isProving) {
+            return false;
+        } else {
+            this.checkpointPaddingProof = {
+                isProving: true
+            };
+            return true;
+        }
     }
-    setRootRollupProof(proof) {
-        this.rootRollupProvingOutput = proof;
+    setCheckpointPaddingProof(provingOutput) {
+        this.checkpointPaddingProof = {
+            provingOutput
+        };
     }
-    setPaddingBlockRootProof(proof) {
-        this.paddingBlockRootProvingOutput = proof;
+    async setBlobAccumulators() {
+        let previousAccumulator = this.startBlobAccumulator;
+        // Accumulate blobs as far as we can for this epoch.
+        for(let i = 0; i < this.totalNumCheckpoints; i++){
+            const checkpoint = this.checkpoints[i];
+            if (!checkpoint) {
+                break;
+            }
+            const endAccumulator = checkpoint.getEndBlobAccumulator() || await checkpoint.accumulateBlobs(previousAccumulator);
+            if (!endAccumulator) {
+                break;
+            }
+            previousAccumulator = endAccumulator;
+            // If this is the last checkpoint, set the end blob accumulator.
+            if (i === this.totalNumCheckpoints - 1) {
+                this.endBlobAccumulator = endAccumulator;
+            }
+        }
+    }
+    async finalizeBatchedBlob() {
+        if (!this.endBlobAccumulator) {
+            throw new Error('End blob accumulator not ready.');
+        }
+        this.finalBatchedBlob = await this.endBlobAccumulator.finalize(true);
     }
     getParentLocation(location) {
-        return this.blockRootOrMergeProvingOutputs.getParentLocation(location);
+        return this.checkpointProofs.getParentLocation(location);
     }
-    getBlockMergeRollupInputs(mergeLocation) {
-        const [left, right] = this.blockRootOrMergeProvingOutputs.getChildren(mergeLocation);
+    getCheckpointMergeRollupInputs(mergeLocation) {
+        const [left, right] = this.checkpointProofs.getChildren(mergeLocation).map((c)=>c?.provingOutput);
         if (!left || !right) {
-            throw new Error('At lease one child is not ready.');
+            throw new Error('At least one child is not ready for the checkpoint merge rollup.');
         }
-        return new BlockMergeRollupInputs([
-            this.#getPreviousRollupData(left),
-            this.#getPreviousRollupData(right)
+        return new CheckpointMergeRollupPrivateInputs([
+            toProofData(left),
+            toProofData(right)
         ]);
     }
-    getRootRollupInputs(proverId) {
+    getRootRollupInputs() {
         const [left, right] = this.#getChildProofsForRoot();
         if (!left || !right) {
-            throw new Error('At lease one child is not ready.');
+            throw new Error('At least one child is not ready for the root rollup.');
         }
-        return RootRollupInputs.from({
-            previousRollupData: [
-                this.#getPreviousRollupData(left),
-                this.#getPreviousRollupData(right)
-            ],
-            proverId
+        return RootRollupPrivateInputs.from({
+            previousRollups: [
+                toProofData(left),
+                toProofData(right)
+            ]
         });
     }
-    getPaddingBlockRootInputs(proverId) {
-        if (!this.blocks[0]?.isComplete()) {
-            throw new Error('Epoch needs one completed block in order to be padded.');
-        }
-        return this.blocks[0].getPaddingBlockRootInputs(proverId);
-    }
-    // Returns a specific transaction proving state
-    getBlockProvingStateByBlockNumber(blockNumber) {
-        return this.blocks.find((block)=>block?.blockNumber === blockNumber);
+    getPaddingCheckpointInputs() {
+        return new CheckpointPaddingRollupPrivateInputs();
     }
     getEpochProofResult() {
-        if (!this.rootRollupProvingOutput) {
+        const provingOutput = this.rootRollupProof?.provingOutput;
+        if (!provingOutput || !this.finalBatchedBlob) {
             throw new Error('Unable to get epoch proof result. Root rollup is not ready.');
         }
         return {
-            proof: this.rootRollupProvingOutput.proof.binaryProof,
-            publicInputs: this.rootRollupProvingOutput.inputs
+            proof: provingOutput.proof.binaryProof,
+            publicInputs: provingOutput.inputs,
+            batchedBlobInputs: this.finalBatchedBlob
         };
     }
-    isReadyForBlockMerge(location) {
-        return this.blockRootOrMergeProvingOutputs.getSibling(location) !== undefined;
+    isReadyForCheckpointMerge(location) {
+        return !!this.checkpointProofs.getSibling(location)?.provingOutput;
     }
     // Returns true if we have sufficient inputs to execute the block root rollup
     isReadyForRootRollup() {
@@ -151,13 +225,9 @@ var PROVING_STATE_LIFECYCLE = /*#__PURE__*/ function(PROVING_STATE_LIFECYCLE) {
             index: 0
         };
         // If there's only 1 block, its block root proof will be stored at the root.
-        return this.totalNumBlocks === 1 ? [
-            this.blockRootOrMergeProvingOutputs.getNode(rootLocation),
-            this.paddingBlockRootProvingOutput
-        ] : this.blockRootOrMergeProvingOutputs.getChildren(rootLocation);
-    }
-    #getPreviousRollupData({ inputs, proof, verificationKey }) {
-        const leafIndex = getVKIndex(verificationKey.keyAsFields);
-        return new PreviousRollupBlockData(inputs, proof, verificationKey.keyAsFields, new MembershipWitness(VK_TREE_HEIGHT, BigInt(leafIndex), getVKSiblingPath(leafIndex)));
+        return this.totalNumCheckpoints === 1 ? [
+            this.checkpointProofs.getNode(rootLocation)?.provingOutput,
+            this.checkpointPaddingProof?.provingOutput
+        ] : this.checkpointProofs.getChildren(rootLocation).map((c)=>c?.provingOutput);
     }
 }