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

package/dest/orchestrator/block-building-helpers.js

@@ -1,4 +1,4 @@
-import { Blob } from '@aztec/blob-lib';
+import { BatchedBlob, Blob, SpongeBlob } from '@aztec/blob-lib';
 import { ARCHIVE_HEIGHT, CIVC_PROOF_LENGTH, MAX_CONTRACT_CLASS_LOGS_PER_TX, MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NOTE_HASH_SUBTREE_HEIGHT, NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH, NULLIFIER_SUBTREE_HEIGHT, NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH, NULLIFIER_TREE_HEIGHT, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, PUBLIC_DATA_TREE_HEIGHT } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
 import { padArrayEnd } from '@aztec/foundation/collection';
@@ -7,23 +7,21 @@ import { BLS12Point, Fr } from '@aztec/foundation/fields';
 import { assertLength, toFriendlyJSON } from '@aztec/foundation/serialize';
 import { MembershipWitness, MerkleTreeCalculator, computeUnbalancedMerkleTreeRoot } from '@aztec/foundation/trees';
 import { getVkData } from '@aztec/noir-protocol-circuits-types/server/vks';
-import { getVKIndex, getVKSiblingPath, getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { computeFeePayerBalanceLeafSlot } from '@aztec/protocol-contracts/fee-juice';
 import { PublicDataHint } from '@aztec/stdlib/avm';
-import { Body } from '@aztec/stdlib/block';
+import { Body, L2BlockHeader, getBlockBlobFields } from '@aztec/stdlib/block';
 import { ContractClassLogFields } from '@aztec/stdlib/logs';
 import { Proof, ProofData, RecursiveProof } from '@aztec/stdlib/proofs';
 import { BlockConstantData, PrivateBaseRollupHints, PrivateBaseStateDiffHints, PublicBaseRollupHints, PublicTubePrivateInputs } from '@aztec/stdlib/rollup';
 import { AppendOnlyTreeSnapshot, MerkleTreeId, NullifierLeafPreimage, PublicDataTreeLeaf, PublicDataTreeLeafPreimage, getTreeHeight } from '@aztec/stdlib/trees';
-import { BlockHeader, ContentCommitment, PartialStateReference, StateReference } from '@aztec/stdlib/tx';
+import { BlockHeader, ContentCommitment, GlobalVariables, PartialStateReference, StateReference } from '@aztec/stdlib/tx';
 import { VkData } from '@aztec/stdlib/vks';
 import { Attributes, runInSpan } from '@aztec/telemetry-client';
 // Builds the hints for base rollup. Updating the contract, nullifier, and data trees in the process.
-export const insertSideEffectsAndBuildBaseRollupHints = runInSpan('BlockBuilderHelpers', 'buildBaseRollupHints', async (span, tx, globalVariables, newL1ToL2MessageTreeSnapshot, db, startSpongeBlob)=>{
+export const insertSideEffectsAndBuildBaseRollupHints = runInSpan('BlockBuilderHelpers', 'buildBaseRollupHints', async (span, tx, lastArchive, newL1ToL2MessageTreeSnapshot, startSpongeBlob, proverId, db)=>{
     span.setAttribute(Attributes.TX_HASH, tx.hash.toString());
     // Get trees info before any changes hit
-    const lastArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
     const start = new PartialStateReference(await getTreeSnapshot(MerkleTreeId.NOTE_HASH_TREE, db), await getTreeSnapshot(MerkleTreeId.NULLIFIER_TREE, db), await getTreeSnapshot(MerkleTreeId.PUBLIC_DATA_TREE, db));
     // Get the subtree sibling paths for the circuit
     const noteHashSubtreeSiblingPathArray = await getSubtreeSiblingPath(MerkleTreeId.NOTE_HASH_TREE, NOTE_HASH_SUBTREE_HEIGHT, db);
@@ -47,18 +45,16 @@ export const insertSideEffectsAndBuildBaseRollupHints = runInSpan('BlockBuilderH
     const nullifierPredecessorMembershipWitnessesWithoutPadding = nullifierWitnessLeaves.map((l)=>MembershipWitness.fromBufferArray(l.index, assertLength(l.siblingPath.toBufferArray(), NULLIFIER_TREE_HEIGHT)));
     const nullifierSubtreeSiblingPathArray = nullifiersSubtreeSiblingPath.toFields();
     const nullifierSubtreeSiblingPath = makeTuple(NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH, (i)=>i < nullifierSubtreeSiblingPathArray.length ? nullifierSubtreeSiblingPathArray[i] : Fr.ZERO);
-    // Append new data to startSpongeBlob
-    const inputSpongeBlob = startSpongeBlob.clone();
-    await startSpongeBlob.absorb(tx.txEffect.toBlobFields());
     const contractClassLogsFields = makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, (i)=>tx.txEffect.contractClassLogs[i]?.fields || ContractClassLogFields.empty());
     if (tx.avmProvingRequest) {
-        const blockHash = await tx.data.constants.historicalHeader.hash();
+        const blockHash = await tx.data.constants.anchorBlockHeader.hash();
         const archiveRootMembershipWitness = await getMembershipWitnessFor(blockHash, MerkleTreeId.ARCHIVE, ARCHIVE_HEIGHT, db);
         return PublicBaseRollupHints.from({
-            startSpongeBlob: inputSpongeBlob,
+            startSpongeBlob,
             lastArchive,
             archiveRootMembershipWitness,
-            contractClassLogsFields
+            contractClassLogsFields,
+            proverId
         });
     } else {
         if (txPublicDataUpdateRequestInfo.lowPublicDataWritesMembershipWitnesses.length > 1 || txPublicDataUpdateRequestInfo.lowPublicDataWritesPreimages.length > 1 || txPublicDataUpdateRequestInfo.publicDataWritesSiblingPaths.length > 1) {
@@ -78,18 +74,19 @@ export const insertSideEffectsAndBuildBaseRollupHints = runInSpan('BlockBuilderH
             feeWriteLowLeafMembershipWitness,
             feeWriteSiblingPath
         });
-        const blockHash = await tx.data.constants.historicalHeader.hash();
+        const blockHash = await tx.data.constants.anchorBlockHeader.hash();
         const archiveRootMembershipWitness = await getMembershipWitnessFor(blockHash, MerkleTreeId.ARCHIVE, ARCHIVE_HEIGHT, db);
         const constants = BlockConstantData.from({
             lastArchive,
-            newL1ToL2: newL1ToL2MessageTreeSnapshot,
-            vkTreeRoot: getVKTreeRoot(),
-            protocolContractTreeRoot,
-            globalVariables
+            l1ToL2TreeSnapshot: newL1ToL2MessageTreeSnapshot,
+            vkTreeRoot: tx.data.constants.vkTreeRoot,
+            protocolContractTreeRoot: tx.data.constants.protocolContractTreeRoot,
+            globalVariables: tx.globalVariables,
+            proverId
         });
         return PrivateBaseRollupHints.from({
             start,
-            startSpongeBlob: inputSpongeBlob,
+            startSpongeBlob,
             stateDiffHints,
             feePayerFeeJuiceBalanceReadHint,
             archiveRootMembershipWitness,
@@ -124,8 +121,10 @@ export function getPublicTubePrivateInputsFromTx(tx) {
     const proofData = new ProofData(tx.data.toPrivateToPublicKernelCircuitPublicInputs(), getCivcProofFromTx(tx), getVkData('HidingKernelToPublic'));
     return new PublicTubePrivateInputs(proofData);
 }
-export const buildBlobHints = runInSpan('BlockBuilderHelpers', 'buildBlobHints', async (_span, txEffects)=>{
-    const blobFields = txEffects.flatMap((tx)=>tx.toBlobFields());
+// Build "hints" as the private inputs for the checkpoint root rollup circuit.
+// The `blobCommitments` will be accumulated and checked in the root rollup against the `finalBlobChallenges`.
+// The `blobsHash` will be validated on L1 against the blob fields.
+export const buildBlobHints = runInSpan('BlockBuilderHelpers', 'buildBlobHints', async (_span, blobFields)=>{
     const blobs = await Blob.getBlobsPerBlock(blobFields);
     // TODO(#13430): The blobsHash is confusingly similar to blobCommitmentsHash, calculated from below blobCommitments:
     // - blobsHash := sha256([blobhash_0, ..., blobhash_m]) = a hash of all blob hashes in a block with m+1 blobs inserted into the header, exists so a user can cross check blobs.
@@ -135,32 +134,45 @@ export const buildBlobHints = runInSpan('BlockBuilderHelpers', 'buildBlobHints',
     const blobCommitments = blobs.map((b)=>BLS12Point.decompress(b.commitment));
     const blobsHash = new Fr(getBlobsHashFromBlobs(blobs));
     return {
-        blobFields,
         blobCommitments,
         blobs,
         blobsHash
     };
 });
-export const accumulateBlobs = runInSpan('BlockBuilderHelpers', 'accumulateBlobs', async (_span, txs, startBlobAccumulator)=>{
-    const blobFields = txs.flatMap((tx)=>tx.txEffect.toBlobFields());
+// Build the data required to prove the txs in an epoch. Currently only used in tests.
+export const buildBlobDataFromTxs = async (txsPerCheckpoint)=>{
+    const blobFields = txsPerCheckpoint.map((txs)=>getBlockBlobFields(txs.map((tx)=>tx.txEffect)));
+    const finalBlobChallenges = await buildFinalBlobChallenges(blobFields);
+    return {
+        blobFieldsLengths: blobFields.map((fields)=>fields.length),
+        finalBlobChallenges
+    };
+};
+export const buildFinalBlobChallenges = async (blobFieldsPerCheckpoint)=>{
+    const blobs = await Promise.all(blobFieldsPerCheckpoint.map((blobFields)=>Blob.getBlobsPerBlock(blobFields)));
+    return await BatchedBlob.precomputeBatchedBlobChallenges(blobs.flat());
+};
+export const accumulateBlobs = runInSpan('BlockBuilderHelpers', 'accumulateBlobs', async (_span, blobFields, startBlobAccumulator)=>{
     const blobs = await Blob.getBlobsPerBlock(blobFields);
     const endBlobAccumulator = startBlobAccumulator.accumulateBlobs(blobs);
     return endBlobAccumulator;
 });
-export const buildHeaderFromCircuitOutputs = runInSpan('BlockBuilderHelpers', 'buildHeaderFromCircuitOutputs', (_span, previousRollupData, parityPublicInputs, rootRollupOutputs, blobsHash, endState)=>{
-    if (previousRollupData.length > 2) {
-        throw new Error(`There can't be more than 2 previous rollups. Received ${previousRollupData.length}.`);
-    }
-    const outHash = previousRollupData.length === 0 ? Fr.ZERO : previousRollupData.length === 1 ? previousRollupData[0].outHash : sha256ToField([
-        previousRollupData[0].outHash,
-        previousRollupData[1].outHash
-    ]);
-    const contentCommitment = new ContentCommitment(blobsHash, parityPublicInputs.shaRoot, outHash);
-    const accumulatedFees = previousRollupData.reduce((sum, d)=>sum.add(d.accumulatedFees), Fr.ZERO);
-    const accumulatedManaUsed = previousRollupData.reduce((sum, d)=>sum.add(d.accumulatedManaUsed), Fr.ZERO);
-    return new BlockHeader(rootRollupOutputs.previousArchive, contentCommitment, endState, rootRollupOutputs.endGlobalVariables, accumulatedFees, accumulatedManaUsed);
+export const buildHeaderFromCircuitOutputs = runInSpan('BlockBuilderHelpers', 'buildHeaderFromCircuitOutputs', async (_span, blockRootRollupOutput)=>{
+    const constants = blockRootRollupOutput.constants;
+    const globalVariables = GlobalVariables.from({
+        chainId: constants.chainId,
+        version: constants.version,
+        blockNumber: blockRootRollupOutput.previousArchive.nextAvailableLeafIndex,
+        timestamp: blockRootRollupOutput.endTimestamp,
+        slotNumber: constants.slotNumber,
+        coinbase: constants.coinbase,
+        feeRecipient: constants.feeRecipient,
+        gasFees: constants.gasFees
+    });
+    const spongeBlobHash = await blockRootRollupOutput.endSpongeBlob.clone().squeeze();
+    return new BlockHeader(blockRootRollupOutput.previousArchive, blockRootRollupOutput.endState, spongeBlobHash, globalVariables, blockRootRollupOutput.accumulatedFees, blockRootRollupOutput.accumulatedManaUsed);
 });
-export const buildHeaderAndBodyFromTxs = runInSpan('BlockBuilderHelpers', 'buildHeaderAndBodyFromTxs', async (span, txs, globalVariables, l1ToL2Messages, db)=>{
+export const buildHeaderAndBodyFromTxs = runInSpan('BlockBuilderHelpers', 'buildHeaderAndBodyFromTxs', async (span, txs, globalVariables, l1ToL2Messages, db, startSpongeBlob)=>{
     span.setAttribute(Attributes.BLOCK_NUMBER, globalVariables.blockNumber);
     const stateReference = new StateReference(await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db), new PartialStateReference(await getTreeSnapshot(MerkleTreeId.NOTE_HASH_TREE, db), await getTreeSnapshot(MerkleTreeId.NULLIFIER_TREE, db), await getTreeSnapshot(MerkleTreeId.PUBLIC_DATA_TREE, db)));
     const previousArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
@@ -169,16 +181,33 @@ export const buildHeaderAndBodyFromTxs = runInSpan('BlockBuilderHelpers', 'build
     const txOutHashes = txEffects.map((tx)=>tx.txOutHash());
     const outHash = txOutHashes.length === 0 ? Fr.ZERO : new Fr(computeUnbalancedMerkleTreeRoot(txOutHashes));
     const parityShaRoot = await computeInHashFromL1ToL2Messages(l1ToL2Messages);
-    const blobsHash = getBlobsHashFromBlobs(await Blob.getBlobsPerBlock(body.toBlobFields()));
+    const blobFields = body.toBlobFields();
+    const blobsHash = getBlobsHashFromBlobs(await Blob.getBlobsPerBlock(blobFields));
     const contentCommitment = new ContentCommitment(blobsHash, parityShaRoot, outHash);
     const fees = txEffects.reduce((acc, tx)=>acc.add(tx.transactionFee), Fr.ZERO);
     const manaUsed = txs.reduce((acc, tx)=>acc.add(new Fr(tx.gasUsed.billedGas.l2Gas)), Fr.ZERO);
-    const header = new BlockHeader(previousArchive, contentCommitment, stateReference, globalVariables, fees, manaUsed);
+    const endSpongeBlob = startSpongeBlob?.clone() ?? SpongeBlob.init(blobFields.length);
+    await endSpongeBlob.absorb(blobFields);
+    const spongeBlobHash = await endSpongeBlob.squeeze();
+    const header = new L2BlockHeader(previousArchive, contentCommitment, stateReference, globalVariables, fees, manaUsed, spongeBlobHash);
     return {
         header,
         body
     };
 });
+export const buildBlockHeaderFromTxs = runInSpan('BlockBuilderHelpers', 'buildBlockHeaderFromTxs', async (span, txs, globalVariables, startSpongeBlob, db)=>{
+    span.setAttribute(Attributes.BLOCK_NUMBER, globalVariables.blockNumber);
+    const stateReference = new StateReference(await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db), new PartialStateReference(await getTreeSnapshot(MerkleTreeId.NOTE_HASH_TREE, db), await getTreeSnapshot(MerkleTreeId.NULLIFIER_TREE, db), await getTreeSnapshot(MerkleTreeId.PUBLIC_DATA_TREE, db)));
+    const previousArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
+    const blobFields = getBlockBlobFields(txs.map((tx)=>tx.txEffect));
+    const endSpongeBlob = startSpongeBlob.clone();
+    await endSpongeBlob.absorb(blobFields);
+    const spongeBlobHash = await endSpongeBlob.squeeze();
+    const txEffects = txs.map((tx)=>tx.txEffect);
+    const fees = txEffects.reduce((acc, tx)=>acc.add(tx.transactionFee), Fr.ZERO);
+    const manaUsed = txs.reduce((acc, tx)=>acc.add(new Fr(tx.gasUsed.billedGas.l2Gas)), Fr.ZERO);
+    return new BlockHeader(previousArchive, stateReference, spongeBlobHash, globalVariables, fees, manaUsed);
+});
 /** Computes the inHash for a block's ContentCommitment given its l1 to l2 messages. */ export async function computeInHashFromL1ToL2Messages(unpaddedL1ToL2Messages) {
     const l1ToL2Messages = padArrayEnd(unpaddedL1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
     const hasher = (left, right)=>Promise.resolve(sha256Trunc(Buffer.concat([
@@ -199,32 +228,6 @@ export async function getEmptyBlockBlobsHash() {
     const blobHash = (await Blob.getBlobsPerBlock([])).map((b)=>b.getEthVersionedBlobHash());
     return sha256ToField(blobHash);
 }
-// Validate that the roots of all local trees match the output of the root circuit simulation
-// TODO: does this get called?
-export async function validateBlockRootOutput(blockRootOutput, blockHeader, db) {
-    await Promise.all([
-        validateState(blockHeader.state, db),
-        validateSimulatedTree(await getTreeSnapshot(MerkleTreeId.ARCHIVE, db), blockRootOutput.newArchive, 'Archive')
-    ]);
-}
-export const validateState = runInSpan('BlockBuilderHelpers', 'validateState', async (_span, state, db)=>{
-    const promises = [
-        MerkleTreeId.NOTE_HASH_TREE,
-        MerkleTreeId.NULLIFIER_TREE,
-        MerkleTreeId.PUBLIC_DATA_TREE
-    ].map(async (id)=>{
-        return {
-            key: id,
-            value: await getTreeSnapshot(id, db)
-        };
-    });
-    const snapshots = new Map((await Promise.all(promises)).map((obj)=>[
-            obj.key,
-            obj.value
-        ]));
-    validatePartialState(state.partial, snapshots);
-    validateSimulatedTree(await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db), state.l1ToL2MessageTree, 'L1ToL2MessageTree');
-});
 export async function getLastSiblingPath(treeId, db) {
     const { size } = await db.getTreeInfo(treeId);
     const path = await db.getSiblingPath(treeId, size - 1n);
@@ -300,7 +303,7 @@ function validateSimulatedTree(localTree, simulatedTree, name, label) {
     }
 }
 export function validateTx(tx) {
-    const txHeader = tx.data.constants.historicalHeader;
+    const txHeader = tx.data.constants.anchorBlockHeader;
     if (txHeader.state.l1ToL2MessageTree.isEmpty()) {
         throw new Error(`Empty L1 to L2 messages tree in tx: ${toFriendlyJSON(tx)}`);
     }

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

@@ -1,17 +1,20 @@
-import { BatchedBlobAccumulator, SpongeBlob } from '@aztec/blob-lib';
+import type { SpongeBlob } 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 { EthAddress, L2Block } from '@aztec/stdlib/block';
 import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
 import { type ParityPublicInputs, RootParityInputs } from '@aztec/stdlib/parity';
-import { type BaseOrMergeRollupPublicInputs, type BlockRootOrBlockMergePublicInputs, BlockRootRollupInputs, EmptyBlockRootRollupInputs, MergeRollupInputs, PaddingBlockRootRollupInputs, SingleTxBlockRootRollupInputs } from '@aztec/stdlib/rollup';
-import { AppendOnlyTreeSnapshot, type MerkleTreeId } from '@aztec/stdlib/trees';
-import { type BlockHeader, type GlobalVariables } from '@aztec/stdlib/tx';
-import type { EpochProvingState } from './epoch-proving-state.js';
+import { type BaseOrMergeRollupPublicInputs, BlockRollupPublicInputs, BlockRootEmptyTxFirstRollupPrivateInputs, BlockRootRollupPrivateInputs, BlockRootSingleTxRollupPrivateInputs, CheckpointConstantData, MergeRollupInputs } from '@aztec/stdlib/rollup';
+import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
+import { type BlockHeader, GlobalVariables } from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
+import type { CheckpointProvingState } from './checkpoint-proving-state.js';
 import type { TxProvingState } from './tx-proving-state.js';
-export type TreeSnapshots = Map<MerkleTreeId, AppendOnlyTreeSnapshot>;
+export type ProofState<T, PROOF_LENGTH extends number> = {
+    provingOutput?: PublicInputsAndRecursiveProof<T, PROOF_LENGTH>;
+    isProving?: boolean;
+};
 /**
  * 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.
@@ -19,59 +22,62 @@ export type TreeSnapshots = Map<MerkleTreeId, AppendOnlyTreeSnapshot>;
 export declare class BlockProvingState {
     #private;
     readonly index: number;
-    readonly globalVariables: GlobalVariables;
-    readonly newL1ToL2Messages: Fr[];
-    readonly l1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot;
-    private readonly l1ToL2MessageSubtreeSiblingPath;
-    readonly l1ToL2MessageTreeSnapshotAfterInsertion: AppendOnlyTreeSnapshot;
-    private readonly lastArchiveSnapshot;
+    readonly blockNumber: number;
+    readonly totalNumTxs: number;
+    private readonly constants;
+    private readonly timestamp;
+    readonly lastArchiveTreeSnapshot: AppendOnlyTreeSnapshot;
     private readonly lastArchiveSiblingPath;
-    private readonly newArchiveSiblingPath;
-    private readonly previousBlockHeader;
-    private readonly proverId;
-    private readonly parentEpoch;
-    private baseOrMergeProvingOutputs;
-    private baseParityProvingOutputs;
-    private rootParityProvingOutput;
-    private blockRootProvingOutput;
-    blockRootRollupStarted: boolean;
-    block: L2Block | undefined;
-    spongeBlobState: SpongeBlob | undefined;
-    startBlobAccumulator: BatchedBlobAccumulator | undefined;
-    endBlobAccumulator: BatchedBlobAccumulator | undefined;
-    blobsHash: Fr | undefined;
-    totalNumTxs: number;
+    private readonly lastL1ToL2MessageTreeSnapshot;
+    private readonly lastL1ToL2MessageSubtreeSiblingPath;
+    readonly newL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot;
+    private readonly headerOfLastBlockInPreviousCheckpoint;
+    private readonly startSpongeBlob;
+    parentCheckpoint: CheckpointProvingState;
+    private baseOrMergeProofs;
+    private baseParityProofs;
+    private rootParityProof;
+    private blockRootProof;
+    private builtBlockHeader;
+    private endSpongeBlob;
     private txs;
-    error: string | undefined;
-    constructor(index: number, globalVariables: GlobalVariables, newL1ToL2Messages: 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, parentEpoch: EpochProvingState);
-    get blockNumber(): number;
-    startNewBlock(numTxs: number, numBlobFields: number): void;
+    private isFirstBlock;
+    private error;
+    constructor(index: number, blockNumber: number, totalNumTxs: number, constants: CheckpointConstantData, timestamp: UInt64, lastArchiveTreeSnapshot: AppendOnlyTreeSnapshot, lastArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>, lastL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, lastL1ToL2MessageSubtreeSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>, newL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, headerOfLastBlockInPreviousCheckpoint: BlockHeader, startSpongeBlob: SpongeBlob, parentCheckpoint: CheckpointProvingState);
+    get epochNumber(): number;
     addNewTx(tx: TxProvingState): number;
+    isAcceptingTxs(): boolean;
+    getProcessedTxs(): import("@aztec/stdlib/tx").ProcessedTx[];
+    tryStartProvingBase(txIndex: number): boolean;
     setBaseRollupProof(txIndex: number, provingOutput: PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): TreeNodeLocation;
+    tryStartProvingMerge(location: TreeNodeLocation): boolean;
     setMergeRollupProof(location: TreeNodeLocation, provingOutput: PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): void;
+    tryStartProvingBaseParity(index: number): boolean;
     setBaseParityProof(index: number, provingOutput: PublicInputsAndRecursiveProof<ParityPublicInputs>): void;
+    tryStartProvingRootParity(): boolean;
     setRootParityProof(provingOutput: PublicInputsAndRecursiveProof<ParityPublicInputs>): void;
-    setBlockRootRollupProof(provingOutput: PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): void;
-    setBlock(block: L2Block): void;
-    setStartBlobAccumulator(accumulator: BatchedBlobAccumulator): void;
-    setEndBlobAccumulator(accumulator: BatchedBlobAccumulator): void;
-    accumulateBlobs(): Promise<void>;
-    get allTxs(): TxProvingState[];
-    /** Returns the block number as an epoch number. Used for prioritizing proof requests. */
-    get epochNumber(): number;
+    tryStartProvingBlockRoot(): boolean;
+    setBlockRootRollupProof(provingOutput: PublicInputsAndRecursiveProof<BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>): TreeNodeLocation;
+    getBlockRootRollupOutput(): BlockRollupPublicInputs | undefined;
+    setBuiltBlockHeader(blockHeader: BlockHeader): void;
+    getBuiltBlockHeader(): BlockHeader | undefined;
+    getGlobalVariables(): GlobalVariables;
+    getStartSpongeBlob(): SpongeBlob;
+    setEndSpongeBlob(endSpongeBlob: SpongeBlob): void;
+    getEndSpongeBlob(): SpongeBlob | undefined;
+    getBlockBlobFields(): Fr[];
     getParentLocation(location: TreeNodeLocation): TreeNodeLocation;
     getMergeRollupInputs(mergeLocation: TreeNodeLocation): MergeRollupInputs;
-    getBlockRootRollupTypeAndInputs(): Promise<{
+    getBlockRootRollupTypeAndInputs(): {
         rollupType: string;
-        inputs: EmptyBlockRootRollupInputs;
+        inputs: BlockRootEmptyTxFirstRollupPrivateInputs;
     } | {
         rollupType: string;
-        inputs: SingleTxBlockRootRollupInputs;
+        inputs: BlockRootSingleTxRollupPrivateInputs;
     } | {
         rollupType: string;
-        inputs: BlockRootRollupInputs;
-    }>;
-    getPaddingBlockRootInputs(): PaddingBlockRootRollupInputs;
+        inputs: BlockRootRollupPrivateInputs;
+    };
     getRootParityInputs(): RootParityInputs;
     getTxProvingState(txIndex: number): TxProvingState;
     buildHeaderFromProvingOutputs(): Promise<BlockHeader>;
@@ -80,6 +86,7 @@ export declare class BlockProvingState {
     isReadyForRootParity(): boolean;
     isComplete(): boolean;
     verifyState(): boolean;
+    getError(): string | undefined;
     reject(reason: string): void;
 }
 //# sourceMappingURL=block-proving-state.d.ts.map

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

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