@aztec/prover-client 3.0.0-nightly.20250917 → 3.0.0-nightly.20250919

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

@@ -1,268 +1,304 @@
-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 { NUM_BASE_PARITY_PER_ROOT_PARITY } from '@aztec/constants';
+import { assertLength } from '@aztec/foundation/serialize';
 import { UnbalancedTreeStore } from '@aztec/foundation/trees';
-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';
+import { getBlockBlobFields } from '@aztec/stdlib/block';
+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';
 /**
  * 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;
-    globalVariables;
-    newL1ToL2Messages;
-    l1ToL2MessageTreeSnapshot;
-    l1ToL2MessageSubtreeSiblingPath;
-    l1ToL2MessageTreeSnapshotAfterInsertion;
-    lastArchiveSnapshot;
-    lastArchiveSiblingPath;
-    newArchiveSiblingPath;
-    previousBlockHeader;
-    proverId;
-    parentEpoch;
-    baseOrMergeProvingOutputs;
-    baseParityProvingOutputs;
-    rootParityProvingOutput;
-    blockRootProvingOutput;
-    blockRootRollupStarted;
-    block;
-    spongeBlobState;
-    startBlobAccumulator;
-    endBlobAccumulator;
-    blobsHash;
+    blockNumber;
     totalNumTxs;
+    constants;
+    timestamp;
+    lastArchiveTreeSnapshot;
+    lastArchiveSiblingPath;
+    lastL1ToL2MessageTreeSnapshot;
+    lastL1ToL2MessageSubtreeSiblingPath;
+    newL1ToL2MessageTreeSnapshot;
+    headerOfLastBlockInPreviousCheckpoint;
+    startSpongeBlob;
+    parentCheckpoint;
+    baseOrMergeProofs;
+    baseParityProofs;
+    rootParityProof;
+    blockRootProof;
+    builtBlockHeader;
+    endSpongeBlob;
     txs;
+    isFirstBlock;
     error;
-    constructor(index, globalVariables, newL1ToL2Messages, l1ToL2MessageTreeSnapshot, l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, lastArchiveSnapshot, lastArchiveSiblingPath, newArchiveSiblingPath, previousBlockHeader, proverId, parentEpoch){
+    constructor(index, blockNumber, totalNumTxs, constants, timestamp, lastArchiveTreeSnapshot, lastArchiveSiblingPath, lastL1ToL2MessageTreeSnapshot, lastL1ToL2MessageSubtreeSiblingPath, newL1ToL2MessageTreeSnapshot, headerOfLastBlockInPreviousCheckpoint, startSpongeBlob, parentCheckpoint){
         this.index = index;
-        this.globalVariables = globalVariables;
-        this.newL1ToL2Messages = newL1ToL2Messages;
-        this.l1ToL2MessageTreeSnapshot = l1ToL2MessageTreeSnapshot;
-        this.l1ToL2MessageSubtreeSiblingPath = l1ToL2MessageSubtreeSiblingPath;
-        this.l1ToL2MessageTreeSnapshotAfterInsertion = l1ToL2MessageTreeSnapshotAfterInsertion;
-        this.lastArchiveSnapshot = lastArchiveSnapshot;
+        this.blockNumber = blockNumber;
+        this.totalNumTxs = totalNumTxs;
+        this.constants = constants;
+        this.timestamp = timestamp;
+        this.lastArchiveTreeSnapshot = lastArchiveTreeSnapshot;
         this.lastArchiveSiblingPath = lastArchiveSiblingPath;
-        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({
+        this.lastL1ToL2MessageTreeSnapshot = lastL1ToL2MessageTreeSnapshot;
+        this.lastL1ToL2MessageSubtreeSiblingPath = lastL1ToL2MessageSubtreeSiblingPath;
+        this.newL1ToL2MessageTreeSnapshot = newL1ToL2MessageTreeSnapshot;
+        this.headerOfLastBlockInPreviousCheckpoint = headerOfLastBlockInPreviousCheckpoint;
+        this.startSpongeBlob = startSpongeBlob;
+        this.parentCheckpoint = parentCheckpoint;
+        this.baseOrMergeProofs = new UnbalancedTreeStore(0);
+        this.baseParityProofs = Array.from({
             length: NUM_BASE_PARITY_PER_ROOT_PARITY
         }).map((_)=>undefined);
-        this.totalNumTxs = 0;
-        if (this.blockNumber == parentEpoch.firstBlockNumber) {
-            this.startBlobAccumulator = BatchedBlobAccumulator.newWithChallenges(parentEpoch.finalBlobBatchingChallenges);
+        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.baseOrMergeProofs = new UnbalancedTreeStore(totalNumTxs);
     }
-    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;
+    get epochNumber() {
+        return this.parentCheckpoint.epochNumber;
     }
     // Adds a transaction to the proving state, returns it's index
     addNewTx(tx) {
-        if (!this.spongeBlobState) {
-            throw new Error(`Invalid block proving state, call startNewBlock before adding transactions.`);
+        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.baseOrMergeProvingOutputs.setLeaf(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.baseOrMergeProvingOutputs.setNode(location, provingOutput);
+        this.baseOrMergeProofs.setNode(location, {
+            provingOutput
+        });
+    }
+    tryStartProvingBaseParity(index) {
+        if (this.baseParityProofs[index]?.isProving) {
+            return false;
+        } else {
+            this.baseParityProofs[index] = {
+                isProving: true
+            };
+            return true;
+        }
     }
     // 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.baseParityProvingOutputs[index] = provingOutput;
+        this.baseParityProofs[index] = {
+            provingOutput
+        };
+    }
+    tryStartProvingRootParity() {
+        if (this.rootParityProof?.isProving) {
+            return false;
+        } else {
+            this.rootParityProof = {
+                isProving: true
+            };
+            return true;
+        }
     }
     setRootParityProof(provingOutput) {
-        this.rootParityProvingOutput = provingOutput;
+        this.rootParityProof = {
+            provingOutput
+        };
+    }
+    tryStartProvingBlockRoot() {
+        if (this.blockRootProof?.isProving) {
+            return false;
+        } else {
+            this.blockRootProof = {
+                isProving: true
+            };
+            return true;
+        }
     }
     setBlockRootRollupProof(provingOutput) {
-        this.blockRootProvingOutput = provingOutput;
+        this.blockRootProof = {
+            provingOutput
+        };
+        return this.parentCheckpoint.setBlockRootRollupProof(this.index, provingOutput);
     }
-    setBlock(block) {
-        this.block = block;
+    getBlockRootRollupOutput() {
+        return this.blockRootProof?.provingOutput?.inputs;
     }
-    setStartBlobAccumulator(accumulator) {
-        this.startBlobAccumulator = accumulator;
+    setBuiltBlockHeader(blockHeader) {
+        this.builtBlockHeader = blockHeader;
     }
-    setEndBlobAccumulator(accumulator) {
-        this.endBlobAccumulator = accumulator;
+    getBuiltBlockHeader() {
+        return this.builtBlockHeader;
     }
-    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;
+    getGlobalVariables() {
+        if (this.txs.length) {
+            return this.txs[0].processedTx.globalVariables;
         }
-        const endBlobAccumulator = await accumulateBlobs(this.allTxs.map((t)=>t.processedTx), this.startBlobAccumulator);
-        this.setEndBlobAccumulator(endBlobAccumulator);
+        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;
     }
-    // Returns the complete set of transaction proving state objects
-    get allTxs() {
-        return this.txs;
+    setEndSpongeBlob(endSpongeBlob) {
+        this.endSpongeBlob = endSpongeBlob;
     }
-    /** Returns the block number as an epoch number. Used for prioritizing proof requests. */ get epochNumber() {
-        return this.parentEpoch.epochNumber;
+    getEndSpongeBlob() {
+        return this.endSpongeBlob;
+    }
+    getBlockBlobFields() {
+        return getBlockBlobFields(this.txs.map((t)=>t.processedTx.txEffect));
     }
     getParentLocation(location) {
-        return this.baseOrMergeProvingOutputs.getParentLocation(location);
+        return this.baseOrMergeProofs.getParentLocation(location);
     }
     getMergeRollupInputs(mergeLocation) {
-        const [left, right] = this.baseOrMergeProvingOutputs.getChildren(mergeLocation);
+        const [left, right] = this.baseOrMergeProofs.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 merge rollup.');
         }
-        return new MergeRollupInputs([
-            this.#getPreviousRollupData(left),
-            this.#getPreviousRollupData(right)
+        return new TxMergeRollupPrivateInputs([
+            toProofData(left),
+            toProofData(right)
         ]);
     }
-    async getBlockRootRollupTypeAndInputs() {
-        if (!this.rootParityProvingOutput) {
-            throw new Error('Root parity is not ready.');
+    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 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 previousRollups = provingOutputs.map((p)=>toProofData(p));
+        if (this.isFirstBlock) {
+            return this.#getFirstBlockRootRollupTypeAndInputs(previousRollups);
         }
-        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();
+        const [leftRollup, rightRollup] = previousRollups;
+        if (!rightRollup) {
+            return {
+                rollupType: 'rollup-block-root-single-tx',
+                inputs: new BlockRootSingleTxRollupPrivateInputs(leftRollup, this.lastArchiveSiblingPath)
+            };
+        } else {
             return {
-                rollupType: 'empty-block-root-rollup',
-                inputs: EmptyBlockRootRollupInputs.from({
-                    data,
-                    constants
-                })
+                rollupType: 'rollup-block-root',
+                inputs: new BlockRootRollupPrivateInputs([
+                    leftRollup,
+                    rightRollup
+                ], this.lastArchiveSiblingPath)
             };
         }
-        const previousRollupData = await Promise.all(nonEmptyProofs.map((p)=>this.#getPreviousRollupData(p)));
-        const blobData = await this.#getBlockRootRollupBlobData();
-        this.blobsHash = blobData.blobsHash;
-        if (previousRollupData.length === 1) {
+    }
+    #getFirstBlockRootRollupTypeAndInputs([leftRollup, rightRollup]) {
+        if (!this.rootParityProof?.provingOutput) {
+            throw new Error('Root parity is not ready.');
+        }
+        const l1ToL2Roots = toProofData(this.rootParityProof.provingOutput);
+        if (!leftRollup) {
             return {
-                rollupType: 'single-tx-block-root-rollup',
-                inputs: new SingleTxBlockRootRollupInputs(previousRollupData, data, blobData)
+                rollupType: 'rollup-block-root-first-empty-tx',
+                inputs: new BlockRootEmptyTxFirstRollupPrivateInputs(l1ToL2Roots, this.lastArchiveTreeSnapshot, this.headerOfLastBlockInPreviousCheckpoint.state, this.constants, this.startSpongeBlob, this.timestamp, this.lastL1ToL2MessageSubtreeSiblingPath, this.lastArchiveSiblingPath)
+            };
+        } else if (!rightRollup) {
+            return {
+                rollupType: 'rollup-block-root-first-single-tx',
+                inputs: new BlockRootSingleTxFirstRollupPrivateInputs(l1ToL2Roots, leftRollup, this.lastL1ToL2MessageTreeSnapshot, this.lastL1ToL2MessageSubtreeSiblingPath, this.lastArchiveSiblingPath)
             };
         } else {
             return {
-                rollupType: 'block-root-rollup',
-                inputs: new BlockRootRollupInputs(previousRollupData, data, blobData)
+                rollupType: 'rollup-block-root-first',
+                inputs: new BlockRootFirstRollupPrivateInputs(l1ToL2Roots, [
+                    leftRollup,
+                    rightRollup
+                ], this.lastL1ToL2MessageTreeSnapshot, this.lastL1ToL2MessageSubtreeSiblingPath, this.lastArchiveSiblingPath)
             };
         }
     }
-    getPaddingBlockRootInputs() {
-        const constants = EpochConstantData.from({
-            vkTreeRoot: getVKTreeRoot(),
-            protocolContractTreeRoot,
-            proverId: this.proverId.toField()
-        });
-        return PaddingBlockRootRollupInputs.from({
-            constants
-        });
-    }
-    getRootParityInputs() {
-        if (!this.baseParityProvingOutputs.every((p)=>!!p)) {
+    getParityRootInputs() {
+        const baseParityProvingOutputs = this.baseParityProofs.filter((p)=>!!p?.provingOutput).map((p)=>p.provingOutput);
+        if (baseParityProvingOutputs.length !== this.baseParityProofs.length) {
             throw new Error('At lease one base parity is not ready.');
         }
-        const children = this.baseParityProvingOutputs.map((p)=>this.#getRootParityData(p));
-        return new RootParityInputs(children);
+        const children = baseParityProvingOutputs.map((p)=>toProofData(p));
+        return new ParityRootPrivateInputs(assertLength(children, NUM_BASE_PARITY_PER_ROOT_PARITY));
     }
     // Returns a specific transaction proving state
     getTxProvingState(txIndex) {
         return this.txs[txIndex];
     }
     async buildHeaderFromProvingOutputs() {
-        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;
+        if (!this.blockRootProof?.provingOutput) {
+            throw new Error('Block root rollup is not ready.');
         }
-        const endState = new StateReference(this.l1ToL2MessageTreeSnapshotAfterInsertion, endPartialState);
-        return buildHeaderFromCircuitOutputs(previousRollupData.map((d)=>d.baseOrMergeRollupPublicInputs), this.rootParityProvingOutput.inputs, this.blockRootProvingOutput.inputs, this.blobsHash, endState);
+        return await buildHeaderFromCircuitOutputs(this.blockRootProof.provingOutput.inputs);
     }
     isReadyForMergeRollup(location) {
-        return this.baseOrMergeProvingOutputs.getSibling(location) !== undefined;
+        return !!this.baseOrMergeProofs.getSibling(location)?.provingOutput;
     }
     // Returns true if we have sufficient inputs to execute the block root rollup
     isReadyForBlockRootRollup() {
-        const childProofs = this.#getChildProofsForBlockRoot();
-        return this.block !== undefined && this.rootParityProvingOutput !== undefined && this.endBlobAccumulator !== undefined && childProofs.every((p)=>!!p);
+        const childProofs = this.#getChildProvingOutputsForBlockRoot();
+        return (!this.isFirstBlock || !!this.rootParityProof?.provingOutput) && childProofs.every((p)=>!!p);
     }
     // Returns true if we have sufficient root parity inputs to execute the root parity circuit
     isReadyForRootParity() {
-        return this.baseParityProvingOutputs.every((p)=>!!p);
+        return this.baseParityProofs.every((p)=>!!p?.provingOutput);
     }
     isComplete() {
-        return !!this.blockRootProvingOutput;
+        return !!this.blockRootProof;
     }
-    // Returns whether the proving state is still valid
     verifyState() {
-        return this.parentEpoch.verifyState();
+        return this.parentCheckpoint.verifyState();
+    }
+    getError() {
+        return this.error;
     }
     reject(reason) {
         this.error = 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()
-        });
+        this.parentCheckpoint.reject(reason);
     }
-    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() {
+    #getChildProvingOutputsForBlockRoot() {
         if (this.totalNumTxs === 0) {
             return [];
         }
@@ -272,15 +308,7 @@ import { accumulateBlobs, buildBlobHints, buildHeaderFromCircuitOutputs, getEmpt
         };
         // If there's only 1 tx, its base rollup proof will be stored at the root.
         return this.totalNumTxs === 1 ? [
-            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);
+            this.baseOrMergeProofs.getNode(rootLocation)?.provingOutput
+        ] : this.baseOrMergeProofs.getChildren(rootLocation).map((c)=>c?.provingOutput);
     }
 }

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

@@ -0,0 +1,62 @@
+import { BatchedBlobAccumulator, type FinalBlobBatchingChallenges } from '@aztec/blob-lib';
+import { type ARCHIVE_HEIGHT, type L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH, type NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import { 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 { ParityBasePrivateInputs } from '@aztec/stdlib/parity';
+import { BlockMergeRollupPrivateInputs, BlockRollupPublicInputs, CheckpointConstantData, CheckpointRollupPublicInputs, CheckpointRootRollupPrivateInputs, CheckpointRootSingleBlockRollupPrivateInputs } from '@aztec/stdlib/rollup';
+import type { CircuitName } from '@aztec/stdlib/stats';
+import type { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
+import type { BlockHeader } from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
+import { BlockProvingState } from './block-proving-state.js';
+import type { EpochProvingState } from './epoch-proving-state.js';
+export declare class CheckpointProvingState {
+    #private;
+    readonly index: number;
+    readonly constants: CheckpointConstantData;
+    readonly totalNumBlocks: number;
+    private readonly totalNumBlobFields;
+    private readonly finalBlobBatchingChallenges;
+    private readonly headerOfLastBlockInPreviousCheckpoint;
+    private readonly lastArchiveSiblingPath;
+    private readonly l1ToL2Messages;
+    private readonly lastL1ToL2MessageTreeSnapshot;
+    private readonly lastL1ToL2MessageSubtreeSiblingPath;
+    private readonly newL1ToL2MessageTreeSnapshot;
+    private readonly newL1ToL2MessageSubtreeSiblingPath;
+    parentEpoch: EpochProvingState;
+    private onBlobAccumulatorSet;
+    private blockProofs;
+    private checkpointRootProof;
+    private blocks;
+    private startBlobAccumulator;
+    private endBlobAccumulator;
+    private error;
+    readonly firstBlockNumber: number;
+    constructor(index: number, constants: CheckpointConstantData, totalNumBlocks: number, totalNumBlobFields: number, finalBlobBatchingChallenges: FinalBlobBatchingChallenges, headerOfLastBlockInPreviousCheckpoint: BlockHeader, lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>, l1ToL2Messages: Fr[], lastL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, lastL1ToL2MessageSubtreeSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>, newL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, newL1ToL2MessageSubtreeSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>, parentEpoch: EpochProvingState, onBlobAccumulatorSet: (checkpoint: CheckpointProvingState) => void);
+    get epochNumber(): number;
+    startNewBlock(blockNumber: number, timestamp: UInt64, totalNumTxs: number, lastArchiveTreeSnapshot: AppendOnlyTreeSnapshot, lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>): 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;
+    tryStartProvingCheckpointRoot(): boolean;
+    setCheckpointRootRollupProof(provingOutput: PublicInputsAndRecursiveProof<CheckpointRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): TreeNodeLocation;
+    getBaseParityInputs(baseParityIndex: number): ParityBasePrivateInputs;
+    accumulateBlobs(startBlobAccumulator: BatchedBlobAccumulator): Promise<BatchedBlobAccumulator | undefined>;
+    getEndBlobAccumulator(): BatchedBlobAccumulator | undefined;
+    getParentLocation(location: TreeNodeLocation): TreeNodeLocation;
+    getBlockMergeRollupInputs(mergeLocation: TreeNodeLocation): BlockMergeRollupPrivateInputs;
+    getCheckpointRootRollupType(): CircuitName;
+    getCheckpointRootRollupInputs(): Promise<CheckpointRootSingleBlockRollupPrivateInputs | CheckpointRootRollupPrivateInputs>;
+    getBlockProvingStateByBlockNumber(blockNumber: number): BlockProvingState | undefined;
+    isReadyForBlockMerge(location: TreeNodeLocation): boolean;
+    isReadyForCheckpointRoot(): boolean;
+    verifyState(): boolean;
+    getError(): string | undefined;
+    cancel(): void;
+    reject(reason: string): void;
+}
+//# sourceMappingURL=checkpoint-proving-state.d.ts.map

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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"}