@aztec/prover-client 0.0.1-fake-c83136db25 → 0.0.1-fake-ceab37513c

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

@@ -1,303 +1,268 @@
-import { NUM_BASE_PARITY_PER_ROOT_PARITY } from '@aztec/constants';
-import { assertLength } from '@aztec/foundation/serialize';
+import { BatchedBlobAccumulator, BlobAccumulatorPublicInputs, SpongeBlob } from '@aztec/blob-lib';
+import { BLOBS_PER_BLOCK, FIELDS_PER_BLOB, NUM_BASE_PARITY_PER_ROOT_PARITY } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { BLS12Point, Fr } from '@aztec/foundation/fields';
 import { UnbalancedTreeStore } from '@aztec/foundation/trees';
-import { ParityRootPrivateInputs } from '@aztec/stdlib/parity';
-import { BlockRootEmptyTxFirstRollupPrivateInputs, BlockRootFirstRollupPrivateInputs, BlockRootRollupPrivateInputs, BlockRootSingleTxFirstRollupPrivateInputs, BlockRootSingleTxRollupPrivateInputs, TxMergeRollupPrivateInputs } from '@aztec/stdlib/rollup';
-import { GlobalVariables } from '@aztec/stdlib/tx';
-import { buildHeaderFromCircuitOutputs, toProofData } from './block-building-helpers.js';
+import { getVKIndex, getVKSiblingPath, getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { RootParityInput, RootParityInputs } from '@aztec/stdlib/parity';
+import { BlockConstantData, BlockRootRollupBlobData, BlockRootRollupData, BlockRootRollupInputs, EmptyBlockRootRollupInputs, EpochConstantData, MergeRollupInputs, PaddingBlockRootRollupInputs, PreviousRollupData, SingleTxBlockRootRollupInputs } from '@aztec/stdlib/rollup';
+import { StateReference } from '@aztec/stdlib/tx';
+import { VkData } from '@aztec/stdlib/vks';
+import { accumulateBlobs, buildBlobHints, buildHeaderFromCircuitOutputs, getEmptyBlockBlobsHash } 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;
+    globalVariables;
+    newL1ToL2Messages;
+    l1ToL2MessageTreeSnapshot;
+    l1ToL2MessageSubtreeSiblingPath;
+    l1ToL2MessageTreeSnapshotAfterInsertion;
+    lastArchiveSnapshot;
     lastArchiveSiblingPath;
-    lastL1ToL2MessageTreeSnapshot;
-    lastL1ToL2MessageSubtreeRootSiblingPath;
-    newL1ToL2MessageTreeSnapshot;
-    headerOfLastBlockInPreviousCheckpoint;
-    startSpongeBlob;
-    parentCheckpoint;
-    baseOrMergeProofs;
-    baseParityProofs;
-    rootParityProof;
-    blockRootProof;
-    builtBlockHeader;
-    endSpongeBlob;
+    newArchiveSiblingPath;
+    previousBlockHeader;
+    proverId;
+    parentEpoch;
+    baseOrMergeProvingOutputs;
+    baseParityProvingOutputs;
+    rootParityProvingOutput;
+    blockRootProvingOutput;
+    blockRootRollupStarted;
+    block;
+    spongeBlobState;
+    startBlobAccumulator;
+    endBlobAccumulator;
+    blobsHash;
+    totalNumTxs;
     txs;
-    isFirstBlock;
     error;
-    constructor(index, blockNumber, totalNumTxs, constants, timestamp, lastArchiveTreeSnapshot, lastArchiveSiblingPath, lastL1ToL2MessageTreeSnapshot, lastL1ToL2MessageSubtreeRootSiblingPath, newL1ToL2MessageTreeSnapshot, headerOfLastBlockInPreviousCheckpoint, startSpongeBlob, parentCheckpoint){
+    constructor(index, globalVariables, newL1ToL2Messages, l1ToL2MessageTreeSnapshot, l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, lastArchiveSnapshot, lastArchiveSiblingPath, newArchiveSiblingPath, previousBlockHeader, proverId, parentEpoch){
         this.index = index;
-        this.blockNumber = blockNumber;
-        this.totalNumTxs = totalNumTxs;
-        this.constants = constants;
-        this.timestamp = timestamp;
-        this.lastArchiveTreeSnapshot = lastArchiveTreeSnapshot;
+        this.globalVariables = globalVariables;
+        this.newL1ToL2Messages = newL1ToL2Messages;
+        this.l1ToL2MessageTreeSnapshot = l1ToL2MessageTreeSnapshot;
+        this.l1ToL2MessageSubtreeSiblingPath = l1ToL2MessageSubtreeSiblingPath;
+        this.l1ToL2MessageTreeSnapshotAfterInsertion = l1ToL2MessageTreeSnapshotAfterInsertion;
+        this.lastArchiveSnapshot = lastArchiveSnapshot;
         this.lastArchiveSiblingPath = lastArchiveSiblingPath;
-        this.lastL1ToL2MessageTreeSnapshot = lastL1ToL2MessageTreeSnapshot;
-        this.lastL1ToL2MessageSubtreeRootSiblingPath = lastL1ToL2MessageSubtreeRootSiblingPath;
-        this.newL1ToL2MessageTreeSnapshot = newL1ToL2MessageTreeSnapshot;
-        this.headerOfLastBlockInPreviousCheckpoint = headerOfLastBlockInPreviousCheckpoint;
-        this.startSpongeBlob = startSpongeBlob;
-        this.parentCheckpoint = parentCheckpoint;
-        this.baseOrMergeProofs = new UnbalancedTreeStore(0);
-        this.baseParityProofs = Array.from({
+        this.newArchiveSiblingPath = newArchiveSiblingPath;
+        this.previousBlockHeader = previousBlockHeader;
+        this.proverId = proverId;
+        this.parentEpoch = parentEpoch;
+        this.baseOrMergeProvingOutputs = new UnbalancedTreeStore(0);
+        this.blockRootRollupStarted = false;
+        this.txs = [];
+        this.baseParityProvingOutputs = Array.from({
             length: NUM_BASE_PARITY_PER_ROOT_PARITY
         }).map((_)=>undefined);
-        this.txs = [];
-        this.isFirstBlock = index === 0;
-        if (!totalNumTxs && !this.isFirstBlock) {
-            throw new Error(`Cannot create a block with 0 txs, unless it's the first block.`);
+        this.totalNumTxs = 0;
+        if (this.blockNumber == parentEpoch.firstBlockNumber) {
+            this.startBlobAccumulator = BatchedBlobAccumulator.newWithChallenges(parentEpoch.finalBlobBatchingChallenges);
         }
-        this.baseOrMergeProofs = new UnbalancedTreeStore(totalNumTxs);
     }
-    get epochNumber() {
-        return this.parentCheckpoint.epochNumber;
+    get blockNumber() {
+        return this.globalVariables.blockNumber;
+    }
+    startNewBlock(numTxs, numBlobFields) {
+        if (this.spongeBlobState) {
+            throw new Error(`Block ${this.blockNumber} already initalised.`);
+        }
+        this.baseOrMergeProvingOutputs = new UnbalancedTreeStore(numTxs);
+        // Initialize the sponge which will eventually absorb all tx effects to be added to the blob.
+        // Like l1 to l2 messages, we need to know beforehand how many effects will be absorbed.
+        this.spongeBlobState = SpongeBlob.init(numBlobFields);
+        this.totalNumTxs = numTxs;
     }
     // 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}.`);
+        if (!this.spongeBlobState) {
+            throw new Error(`Invalid block proving state, call startNewBlock before adding transactions.`);
         }
         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;
-        }
+        return this.baseOrMergeProvingOutputs.setLeaf(txIndex, provingOutput);
     }
     setMergeRollupProof(location, provingOutput) {
-        this.baseOrMergeProofs.setNode(location, {
-            provingOutput
-        });
-    }
-    tryStartProvingBaseParity(index) {
-        if (this.baseParityProofs[index]?.isProving) {
-            return false;
-        } else {
-            this.baseParityProofs[index] = {
-                isProving: true
-            };
-            return true;
-        }
+        this.baseOrMergeProvingOutputs.setNode(location, provingOutput);
     }
     // Stores a set of root parity inputs at the given index
     setBaseParityProof(index, provingOutput) {
         if (index >= NUM_BASE_PARITY_PER_ROOT_PARITY) {
             throw new Error(`Unable to set a base parity proofs at index ${index}. Expected at most ${NUM_BASE_PARITY_PER_ROOT_PARITY} proofs.`);
         }
-        this.baseParityProofs[index] = {
-            provingOutput
-        };
-    }
-    tryStartProvingRootParity() {
-        if (this.rootParityProof?.isProving) {
-            return false;
-        } else {
-            this.rootParityProof = {
-                isProving: true
-            };
-            return true;
-        }
+        this.baseParityProvingOutputs[index] = provingOutput;
     }
     setRootParityProof(provingOutput) {
-        this.rootParityProof = {
-            provingOutput
-        };
-    }
-    tryStartProvingBlockRoot() {
-        if (this.blockRootProof?.isProving) {
-            return false;
-        } else {
-            this.blockRootProof = {
-                isProving: true
-            };
-            return true;
-        }
+        this.rootParityProvingOutput = provingOutput;
     }
     setBlockRootRollupProof(provingOutput) {
-        this.blockRootProof = {
-            provingOutput
-        };
-        return this.parentCheckpoint.setBlockRootRollupProof(this.index, provingOutput);
+        this.blockRootProvingOutput = provingOutput;
     }
-    getBlockRootRollupOutput() {
-        return this.blockRootProof?.provingOutput?.inputs;
+    setBlock(block) {
+        this.block = block;
     }
-    setBuiltBlockHeader(blockHeader) {
-        this.builtBlockHeader = blockHeader;
+    setStartBlobAccumulator(accumulator) {
+        this.startBlobAccumulator = accumulator;
     }
-    getBuiltBlockHeader() {
-        return this.builtBlockHeader;
+    setEndBlobAccumulator(accumulator) {
+        this.endBlobAccumulator = accumulator;
     }
-    getGlobalVariables() {
-        if (this.txs.length) {
-            return this.txs[0].processedTx.globalVariables;
+    async accumulateBlobs() {
+        if (!this.block || !this.startBlobAccumulator) {
+            // We only want to accumulate once we have all txs, so we wait until the block is set.
+            return;
         }
-        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
-        });
-    }
-    getStartSpongeBlob() {
-        return this.startSpongeBlob;
+        const endBlobAccumulator = await accumulateBlobs(this.allTxs.map((t)=>t.processedTx), this.startBlobAccumulator);
+        this.setEndBlobAccumulator(endBlobAccumulator);
     }
-    setEndSpongeBlob(endSpongeBlob) {
-        this.endSpongeBlob = endSpongeBlob;
+    // Returns the complete set of transaction proving state objects
+    get allTxs() {
+        return this.txs;
     }
-    getEndSpongeBlob() {
-        return this.endSpongeBlob;
-    }
-    getTxEffects() {
-        return this.txs.map((t)=>t.processedTx.txEffect);
+    /** Returns the block number as an epoch number. Used for prioritizing proof requests. */ get epochNumber() {
+        return this.parentEpoch.epochNumber;
     }
     getParentLocation(location) {
-        return this.baseOrMergeProofs.getParentLocation(location);
+        return this.baseOrMergeProvingOutputs.getParentLocation(location);
     }
     getMergeRollupInputs(mergeLocation) {
-        const [left, right] = this.baseOrMergeProofs.getChildren(mergeLocation).map((c)=>c?.provingOutput);
+        const [left, right] = this.baseOrMergeProvingOutputs.getChildren(mergeLocation);
         if (!left || !right) {
-            throw new Error('At least one child is not ready for the merge rollup.');
+            throw new Error('At lease one child is not ready.');
         }
-        return new TxMergeRollupPrivateInputs([
-            toProofData(left),
-            toProofData(right)
+        return new MergeRollupInputs([
+            this.#getPreviousRollupData(left),
+            this.#getPreviousRollupData(right)
         ]);
     }
-    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.');
+    async getBlockRootRollupTypeAndInputs() {
+        if (!this.rootParityProvingOutput) {
+            throw new Error('Root parity is not ready.');
         }
-        const previousRollups = provingOutputs.map((p)=>toProofData(p));
-        if (this.isFirstBlock) {
-            return this.#getFirstBlockRootRollupTypeAndInputs(previousRollups);
+        const proofs = this.#getChildProofsForBlockRoot();
+        const nonEmptyProofs = proofs.filter((p)=>!!p);
+        if (proofs.length !== nonEmptyProofs.length) {
+            throw new Error('At lease one child is not ready for the block root.');
         }
-        const [leftRollup, rightRollup] = previousRollups;
-        if (!rightRollup) {
-            return {
-                rollupType: 'rollup-block-root-single-tx',
-                inputs: new BlockRootSingleTxRollupPrivateInputs(leftRollup, this.lastArchiveSiblingPath)
-            };
-        } else {
+        const data = this.#getBlockRootRollupData();
+        if (this.totalNumTxs === 0) {
+            const constants = BlockConstantData.from({
+                lastArchive: this.lastArchiveSnapshot,
+                newL1ToL2: this.l1ToL2MessageTreeSnapshotAfterInsertion,
+                globalVariables: this.globalVariables,
+                vkTreeRoot: getVKTreeRoot(),
+                protocolContractTreeRoot
+            });
+            this.blobsHash = await getEmptyBlockBlobsHash();
             return {
-                rollupType: 'rollup-block-root',
-                inputs: new BlockRootRollupPrivateInputs([
-                    leftRollup,
-                    rightRollup
-                ], this.lastArchiveSiblingPath)
+                rollupType: 'empty-block-root-rollup',
+                inputs: EmptyBlockRootRollupInputs.from({
+                    data,
+                    constants
+                })
             };
         }
-    }
-    #getFirstBlockRootRollupTypeAndInputs([leftRollup, rightRollup]) {
-        if (!this.rootParityProof?.provingOutput) {
-            throw new Error('Root parity is not ready.');
-        }
-        const l1ToL2Roots = toProofData(this.rootParityProof.provingOutput);
-        if (!leftRollup) {
+        const previousRollupData = await Promise.all(nonEmptyProofs.map((p)=>this.#getPreviousRollupData(p)));
+        const blobData = await this.#getBlockRootRollupBlobData();
+        this.blobsHash = blobData.blobsHash;
+        if (previousRollupData.length === 1) {
             return {
-                rollupType: 'rollup-block-root-first-empty-tx',
-                inputs: new BlockRootEmptyTxFirstRollupPrivateInputs(l1ToL2Roots, this.lastArchiveTreeSnapshot, this.headerOfLastBlockInPreviousCheckpoint.state, this.constants, this.startSpongeBlob, this.timestamp, this.lastL1ToL2MessageSubtreeRootSiblingPath, this.lastArchiveSiblingPath)
-            };
-        } else if (!rightRollup) {
-            return {
-                rollupType: 'rollup-block-root-first-single-tx',
-                inputs: new BlockRootSingleTxFirstRollupPrivateInputs(l1ToL2Roots, leftRollup, this.lastL1ToL2MessageTreeSnapshot, this.lastL1ToL2MessageSubtreeRootSiblingPath, this.lastArchiveSiblingPath)
+                rollupType: 'single-tx-block-root-rollup',
+                inputs: new SingleTxBlockRootRollupInputs(previousRollupData, data, blobData)
             };
         } else {
             return {
-                rollupType: 'rollup-block-root-first',
-                inputs: new BlockRootFirstRollupPrivateInputs(l1ToL2Roots, [
-                    leftRollup,
-                    rightRollup
-                ], this.lastL1ToL2MessageTreeSnapshot, this.lastL1ToL2MessageSubtreeRootSiblingPath, this.lastArchiveSiblingPath)
+                rollupType: 'block-root-rollup',
+                inputs: new BlockRootRollupInputs(previousRollupData, data, blobData)
             };
         }
     }
-    getParityRootInputs() {
-        const baseParityProvingOutputs = this.baseParityProofs.filter((p)=>!!p?.provingOutput).map((p)=>p.provingOutput);
-        if (baseParityProvingOutputs.length !== this.baseParityProofs.length) {
+    getPaddingBlockRootInputs() {
+        const constants = EpochConstantData.from({
+            vkTreeRoot: getVKTreeRoot(),
+            protocolContractTreeRoot,
+            proverId: this.proverId.toField()
+        });
+        return PaddingBlockRootRollupInputs.from({
+            constants
+        });
+    }
+    getRootParityInputs() {
+        if (!this.baseParityProvingOutputs.every((p)=>!!p)) {
             throw new Error('At lease one base parity is not ready.');
         }
-        const children = baseParityProvingOutputs.map((p)=>toProofData(p));
-        return new ParityRootPrivateInputs(assertLength(children, NUM_BASE_PARITY_PER_ROOT_PARITY));
+        const children = this.baseParityProvingOutputs.map((p)=>this.#getRootParityData(p));
+        return new RootParityInputs(children);
     }
     // 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.');
+        const previousRollupData = this.totalNumTxs === 0 ? [] : await Promise.all(this.#getChildProofsForBlockRoot().map((p)=>this.#getPreviousRollupData(p)));
+        let endPartialState = this.previousBlockHeader.state.partial;
+        if (this.totalNumTxs !== 0) {
+            const previousRollupData = this.#getChildProofsForBlockRoot();
+            const lastRollup = previousRollupData[previousRollupData.length - 1];
+            if (!lastRollup) {
+                throw new Error('End state of the block is not available. Last rollup is not ready yet.');
+            }
+            endPartialState = lastRollup.inputs.end;
         }
-        return await buildHeaderFromCircuitOutputs(this.blockRootProof.provingOutput.inputs);
+        const endState = new StateReference(this.l1ToL2MessageTreeSnapshotAfterInsertion, endPartialState);
+        return buildHeaderFromCircuitOutputs(previousRollupData.map((d)=>d.baseOrMergeRollupPublicInputs), this.rootParityProvingOutput.inputs, this.blockRootProvingOutput.inputs, this.blobsHash, endState);
     }
     isReadyForMergeRollup(location) {
-        return !!this.baseOrMergeProofs.getSibling(location)?.provingOutput;
+        return this.baseOrMergeProvingOutputs.getSibling(location) !== undefined;
     }
     // Returns true if we have sufficient inputs to execute the block root rollup
     isReadyForBlockRootRollup() {
-        const childProofs = this.#getChildProvingOutputsForBlockRoot();
-        return (!this.isFirstBlock || !!this.rootParityProof?.provingOutput) && childProofs.every((p)=>!!p);
+        const childProofs = this.#getChildProofsForBlockRoot();
+        return this.block !== undefined && this.rootParityProvingOutput !== undefined && this.endBlobAccumulator !== undefined && childProofs.every((p)=>!!p);
     }
     // Returns true if we have sufficient root parity inputs to execute the root parity circuit
     isReadyForRootParity() {
-        return this.baseParityProofs.every((p)=>!!p?.provingOutput);
+        return this.baseParityProvingOutputs.every((p)=>!!p);
     }
     isComplete() {
-        return !!this.blockRootProof;
+        return !!this.blockRootProvingOutput;
     }
+    // Returns whether the proving state is still valid
     verifyState() {
-        return this.parentCheckpoint.verifyState();
-    }
-    getError() {
-        return this.error;
+        return this.parentEpoch.verifyState();
     }
     reject(reason) {
         this.error = reason;
-        this.parentCheckpoint.reject(reason);
+        this.parentEpoch.reject(reason);
+    }
+    #getBlockRootRollupData() {
+        return BlockRootRollupData.from({
+            l1ToL2Roots: this.#getRootParityData(this.rootParityProvingOutput),
+            l1ToL2MessageSubtreeSiblingPath: this.l1ToL2MessageSubtreeSiblingPath,
+            previousArchiveSiblingPath: this.lastArchiveSiblingPath,
+            newArchiveSiblingPath: this.newArchiveSiblingPath,
+            previousBlockHeader: this.previousBlockHeader,
+            startBlobAccumulator: BlobAccumulatorPublicInputs.fromBatchedBlobAccumulator(this.startBlobAccumulator),
+            finalBlobChallenges: this.startBlobAccumulator.finalBlobChallenges,
+            proverId: this.proverId.toField()
+        });
     }
-    #getChildProvingOutputsForBlockRoot() {
+    async #getBlockRootRollupBlobData() {
+        const txEffects = this.txs.map((txProvingState)=>txProvingState.processedTx.txEffect);
+        const { blobFields, blobCommitments, blobsHash } = await buildBlobHints(txEffects);
+        return BlockRootRollupBlobData.from({
+            blobFields: padArrayEnd(blobFields, Fr.ZERO, FIELDS_PER_BLOB * BLOBS_PER_BLOCK),
+            blobCommitments: padArrayEnd(blobCommitments, BLS12Point.ZERO, BLOBS_PER_BLOCK),
+            blobsHash
+        });
+    }
+    #getChildProofsForBlockRoot() {
         if (this.totalNumTxs === 0) {
             return [];
         }
@@ -307,7 +272,15 @@ import { buildHeaderFromCircuitOutputs, toProofData } from './block-building-hel
         };
         // 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);
+            this.baseOrMergeProvingOutputs.getNode(rootLocation)
+        ] : this.baseOrMergeProvingOutputs.getChildren(rootLocation);
+    }
+    #getPreviousRollupData({ inputs, proof, verificationKey }) {
+        const leafIndex = getVKIndex(verificationKey.keyAsFields);
+        const vkData = new VkData(verificationKey, leafIndex, getVKSiblingPath(leafIndex));
+        return new PreviousRollupData(inputs, proof, vkData);
+    }
+    #getRootParityData({ inputs, proof, verificationKey }) {
+        return new RootParityInput(proof, verificationKey.keyAsFields, getVKSiblingPath(getVKIndex(verificationKey)), inputs);
     }
 }

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

@@ -1,14 +1,15 @@
 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 { ARCHIVE_HEIGHT, L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { Fr } from '@aztec/foundation/fields';
 import type { Tuple } from '@aztec/foundation/serialize';
 import { type TreeNodeLocation } from '@aztec/foundation/trees';
-import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
+import type { ProofAndVerificationKey, PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
 import type { Proof } from '@aztec/stdlib/proofs';
-import { CheckpointConstantData, CheckpointMergeRollupPrivateInputs, CheckpointPaddingRollupPrivateInputs, CheckpointRollupPublicInputs, PublicChonkVerifierPublicInputs, RootRollupPrivateInputs, type RootRollupPublicInputs } from '@aztec/stdlib/rollup';
+import { BlockMergeRollupInputs, type BlockRootOrBlockMergePublicInputs, RootRollupInputs, type RootRollupPublicInputs } from '@aztec/stdlib/rollup';
 import type { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
-import type { BlockHeader } from '@aztec/stdlib/tx';
-import { CheckpointProvingState } from './checkpoint-proving-state.js';
+import type { BlockHeader, GlobalVariables } from '@aztec/stdlib/tx';
+import { BlockProvingState } from './block-proving-state.js';
 export type TreeSnapshots = Map<MerkleTreeId, AppendOnlyTreeSnapshot>;
 export type ProvingResult = {
     status: 'success';
@@ -25,46 +26,39 @@ export type ProvingResult = {
 export declare class EpochProvingState {
     #private;
     readonly epochNumber: number;
-    readonly totalNumCheckpoints: number;
-    private readonly finalBlobBatchingChallenges;
-    private onCheckpointBlobAccumulatorSet;
+    readonly firstBlockNumber: number;
+    readonly totalNumBlocks: number;
+    readonly finalBlobBatchingChallenges: FinalBlobBatchingChallenges;
     private completionCallback;
     private rejectionCallback;
-    private checkpointProofs;
-    private checkpointPaddingProof;
-    private rootRollupProof;
-    private checkpoints;
-    private startBlobAccumulator;
-    private endBlobAccumulator;
+    private blockRootOrMergeProvingOutputs;
+    private paddingBlockRootProvingOutput;
+    private rootRollupProvingOutput;
     private finalBatchedBlob;
     private provingStateLifecycle;
-    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;
+    readonly cachedTubeProofs: Map<string, Promise<ProofAndVerificationKey<535>>>;
+    blocks: (BlockProvingState | undefined)[];
+    constructor(epochNumber: number, firstBlockNumber: number, totalNumBlocks: number, finalBlobBatchingChallenges: FinalBlobBatchingChallenges, completionCallback: (result: ProvingResult) => void, rejectionCallback: (reason: string) => void);
+    startNewBlock(globalVariables: GlobalVariables, l1ToL2Messages: Fr[], l1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, l1ToL2MessageSubtreeSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>, l1ToL2MessageTreeSnapshotAfterInsertion: AppendOnlyTreeSnapshot, lastArchiveSnapshot: AppendOnlyTreeSnapshot, lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>, newArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>, previousBlockHeader: BlockHeader, proverId: EthAddress): BlockProvingState;
     verifyState(): boolean;
-    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>;
+    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;
+    setFinalBatchedBlob(batchedBlob: BatchedBlob): void;
+    setBlobAccumulators(toBlock?: number): Promise<void>;
     getParentLocation(location: TreeNodeLocation): TreeNodeLocation;
-    getCheckpointMergeRollupInputs(mergeLocation: TreeNodeLocation): CheckpointMergeRollupPrivateInputs;
-    getRootRollupInputs(): RootRollupPrivateInputs;
-    getPaddingCheckpointInputs(): CheckpointPaddingRollupPrivateInputs;
+    getBlockMergeRollupInputs(mergeLocation: TreeNodeLocation): BlockMergeRollupInputs;
+    getRootRollupInputs(): RootRollupInputs;
+    getPaddingBlockRootInputs(): import("@aztec/stdlib/rollup").PaddingBlockRootRollupInputs;
+    getBlockProvingStateByBlockNumber(blockNumber: number): BlockProvingState | undefined;
     getEpochProofResult(): {
         proof: Proof;
         publicInputs: RootRollupPublicInputs;
         batchedBlobInputs: BatchedBlob;
     };
-    isReadyForCheckpointMerge(location: TreeNodeLocation): boolean;
+    isReadyForBlockMerge(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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"}