@aztec/prover-client 1.0.0-nightly.20250608 → 1.0.0-nightly.20250610

package/src/orchestrator/block-proving-state.ts

@@ -1,4 +1,4 @@
-import { SpongeBlob } from '@aztec/blob-lib';
+import { BatchedBlobAccumulator, SpongeBlob } from '@aztec/blob-lib';
 import {
   type ARCHIVE_HEIGHT,
   BLOBS_PER_BLOCK,
@@ -9,7 +9,7 @@ import {
   type RECURSIVE_PROOF_LENGTH,
 } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
+import { BLS12Point, Fr } from '@aztec/foundation/fields';
 import type { Tuple } from '@aztec/foundation/serialize';
 import { type TreeNodeLocation, UnbalancedTreeStore } from '@aztec/foundation/trees';
 import { getVKIndex, getVKSiblingPath, getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
@@ -19,11 +19,11 @@ import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/ser
 import { type ParityPublicInputs, RootParityInput, RootParityInputs } from '@aztec/stdlib/parity';
 import {
   type BaseOrMergeRollupPublicInputs,
+  BlockConstantData,
   type BlockRootOrBlockMergePublicInputs,
   BlockRootRollupBlobData,
   BlockRootRollupData,
   BlockRootRollupInputs,
-  ConstantRollupData,
   EmptyBlockRootRollupInputs,
   MergeRollupInputs,
   PreviousRollupData,
@@ -34,7 +34,7 @@ import type { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
 import { type BlockHeader, type GlobalVariables, StateReference } from '@aztec/stdlib/tx';
 import { VkData } from '@aztec/stdlib/vks';
 
-import { buildBlobHints, buildHeaderFromCircuitOutputs } from './block-building-helpers.js';
+import { accumulateBlobs, buildBlobHints, buildHeaderFromCircuitOutputs } from './block-building-helpers.js';
 import type { EpochProvingState } from './epoch-proving-state.js';
 import type { TxProvingState } from './tx-proving-state.js';
 
@@ -56,6 +56,9 @@ export class BlockProvingState {
   public blockRootRollupStarted: boolean = false;
   public block: L2Block | undefined;
   public spongeBlobState: SpongeBlob | undefined;
+  public startBlobAccumulator: BatchedBlobAccumulator | undefined;
+  public endBlobAccumulator: BatchedBlobAccumulator | undefined;
+  public blobsHash: Buffer | undefined;
   public totalNumTxs: number;
   private txs: TxProvingState[] = [];
   public error: string | undefined;
@@ -64,6 +67,7 @@ export class BlockProvingState {
     public readonly index: number,
     public readonly globalVariables: GlobalVariables,
     public readonly newL1ToL2Messages: Fr[],
+    public readonly l1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot,
     private readonly l1ToL2MessageSubtreeSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>,
     private readonly l1ToL2MessageTreeSnapshotAfterInsertion: AppendOnlyTreeSnapshot,
     private readonly lastArchiveSnapshot: AppendOnlyTreeSnapshot,
@@ -74,6 +78,9 @@ export class BlockProvingState {
   ) {
     this.baseParityProvingOutputs = 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);
+    }
   }
 
   public get blockNumber() {
@@ -97,7 +104,6 @@ export class BlockProvingState {
     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;
@@ -146,6 +152,30 @@ export class BlockProvingState {
     this.blockRootProvingOutput = provingOutput;
   }
 
+  public setBlock(block: L2Block) {
+    this.block = block;
+  }
+
+  public setStartBlobAccumulator(accumulator: BatchedBlobAccumulator) {
+    this.startBlobAccumulator = accumulator;
+  }
+
+  public setEndBlobAccumulator(accumulator: BatchedBlobAccumulator) {
+    this.endBlobAccumulator = accumulator;
+  }
+
+  public 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 endBlobAccumulator = await accumulateBlobs(
+      this.allTxs.map(t => t.processedTx),
+      this.startBlobAccumulator,
+    );
+    this.setEndBlobAccumulator(endBlobAccumulator);
+  }
+
   // Returns the complete set of transaction proving state objects
   public get allTxs() {
     return this.txs;
@@ -183,8 +213,9 @@ export class BlockProvingState {
     const data = this.#getBlockRootRollupData(proverId);
 
     if (this.totalNumTxs === 0) {
-      const constants = ConstantRollupData.from({
+      const constants = BlockConstantData.from({
         lastArchive: this.lastArchiveSnapshot,
+        lastL1ToL2: this.l1ToL2MessageTreeSnapshot,
         globalVariables: this.globalVariables,
         vkTreeRoot: getVKTreeRoot(),
         protocolContractTreeRoot,
@@ -202,6 +233,7 @@ export class BlockProvingState {
 
     const previousRollupData = await Promise.all(nonEmptyProofs.map(p => this.#getPreviousRollupData(p!)));
     const blobData = await this.#getBlockRootRollupBlobData();
+    this.blobsHash = blobData.blobsHash.toBuffer();
 
     if (previousRollupData.length === 1) {
       return {
@@ -225,21 +257,29 @@ export class BlockProvingState {
       throw new Error('Root parity is not ready.');
     }
 
-    // Use the new block header and archive of the current block as the previous header and archiver of the next padding block.
-    const newBlockHeader = await this.buildHeaderFromProvingOutputs();
-    const newArchive = this.blockRootProvingOutput!.inputs.newArchive;
+    if (!this.blockRootProvingOutput || !this.endBlobAccumulator) {
+      throw new Error('Block root not ready for padding.');
+    }
+
+    // Use the new block header, archive and l1toL2 of the current block as the previous header, archive and l1toL2 of the next padding block.
+    const previousBlockHeader = await this.buildHeaderFromProvingOutputs();
+    const lastArchive = this.blockRootProvingOutput!.inputs.newArchive;
+    const lastL1ToL2 = this.l1ToL2MessageTreeSnapshotAfterInsertion;
 
     const data = BlockRootRollupData.from({
       l1ToL2Roots: this.#getRootParityData(this.rootParityProvingOutput!),
       l1ToL2MessageSubtreeSiblingPath: this.l1ToL2MessageSubtreeSiblingPath,
       previousArchiveSiblingPath: this.lastArchiveSiblingPath,
       newArchiveSiblingPath: this.newArchiveSiblingPath,
-      previousBlockHeader: newBlockHeader,
+      previousBlockHeader,
+      startBlobAccumulator: this.endBlobAccumulator.toBlobAccumulatorPublicInputs(),
+      finalBlobChallenges: this.endBlobAccumulator.finalBlobChallenges,
       proverId,
     });
 
-    const constants = ConstantRollupData.from({
-      lastArchive: newArchive,
+    const constants = BlockConstantData.from({
+      lastArchive,
+      lastL1ToL2,
       globalVariables: this.globalVariables,
       vkTreeRoot: getVKTreeRoot(),
       protocolContractTreeRoot,
@@ -285,10 +325,18 @@ export class BlockProvingState {
     }
     const endState = new StateReference(this.l1ToL2MessageTreeSnapshotAfterInsertion, endPartialState);
 
+    // TODO(MW): cleanup
+    if (!this.blobsHash) {
+      this.blobsHash = (
+        await buildBlobHints(this.txs.map(txProvingState => txProvingState.processedTx.txEffect))
+      ).blobsHash.toBuffer();
+    }
+
     return buildHeaderFromCircuitOutputs(
       previousRollupData.map(d => d.baseOrMergeRollupPublicInputs),
       this.rootParityProvingOutput!.inputs,
       this.blockRootProvingOutput!.inputs,
+      this.blobsHash,
       endState,
     );
   }
@@ -300,7 +348,12 @@ export class BlockProvingState {
   // Returns true if we have sufficient inputs to execute the block root rollup
   public isReadyForBlockRootRollup() {
     const childProofs = this.#getChildProofsForBlockRoot();
-    return this.block !== undefined && this.rootParityProvingOutput !== undefined && childProofs.every(p => !!p);
+    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
@@ -329,6 +382,8 @@ export class BlockProvingState {
       previousArchiveSiblingPath: this.lastArchiveSiblingPath,
       newArchiveSiblingPath: this.newArchiveSiblingPath,
       previousBlockHeader: this.previousBlockHeader,
+      startBlobAccumulator: this.startBlobAccumulator!.toBlobAccumulatorPublicInputs(),
+      finalBlobChallenges: this.startBlobAccumulator!.finalBlobChallenges,
       proverId,
     });
   }
@@ -338,7 +393,7 @@ export class BlockProvingState {
     const { blobFields, blobCommitments, blobsHash } = await buildBlobHints(txEffects);
     return BlockRootRollupBlobData.from({
       blobFields: padArrayEnd(blobFields, Fr.ZERO, FIELDS_PER_BLOB * BLOBS_PER_BLOCK),
-      blobCommitments: padArrayEnd(blobCommitments, [Fr.ZERO, Fr.ZERO], BLOBS_PER_BLOCK),
+      blobCommitments: padArrayEnd(blobCommitments, BLS12Point.ZERO, BLOBS_PER_BLOCK),
       blobsHash,
     });
   }

package/src/orchestrator/epoch-proving-state.ts

@@ -1,3 +1,4 @@
+import { BatchedBlob, type FinalBlobBatchingChallenges } from '@aztec/blob-lib';
 import type {
   ARCHIVE_HEIGHT,
   L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
@@ -48,6 +49,7 @@ export class EpochProvingState {
     | PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>
     | undefined;
   private rootRollupProvingOutput: PublicInputsAndRecursiveProof<RootRollupPublicInputs> | undefined;
+  private finalBatchedBlob: BatchedBlob | undefined;
   private provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_CREATED;
 
   // Map from tx hash to tube proof promise. Used when kickstarting tube proofs before tx processing.
@@ -59,6 +61,7 @@ export class EpochProvingState {
     public readonly epochNumber: number,
     public readonly firstBlockNumber: number,
     public readonly totalNumBlocks: number,
+    public readonly finalBlobBatchingChallenges: FinalBlobBatchingChallenges,
     private completionCallback: (result: ProvingResult) => void,
     private rejectionCallback: (reason: string) => void,
   ) {
@@ -70,6 +73,7 @@ export class EpochProvingState {
   public startNewBlock(
     globalVariables: GlobalVariables,
     l1ToL2Messages: Fr[],
+    l1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot,
     l1ToL2MessageSubtreeSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH>,
     l1ToL2MessageTreeSnapshotAfterInsertion: AppendOnlyTreeSnapshot,
     lastArchiveSnapshot: AppendOnlyTreeSnapshot,
@@ -82,6 +86,7 @@ export class EpochProvingState {
       index,
       globalVariables,
       l1ToL2Messages,
+      l1ToL2MessageTreeSnapshot,
       l1ToL2MessageSubtreeSiblingPath,
       l1ToL2MessageTreeSnapshotAfterInsertion,
       lastArchiveSnapshot,
@@ -143,6 +148,31 @@ export class EpochProvingState {
     this.paddingBlockRootProvingOutput = proof;
   }
 
+  public setFinalBatchedBlob(batchedBlob: BatchedBlob) {
+    this.finalBatchedBlob = batchedBlob;
+  }
+
+  public async setBlobAccumulators(toBlock?: number) {
+    let previousAccumulator;
+    const end = toBlock ? toBlock - this.firstBlockNumber : this.blocks.length;
+    // Accumulate blobs as far as we can for this epoch.
+    for (let i = 0; i <= end; i++) {
+      const block = this.blocks[i];
+      if (!block || !block.block) {
+        // If the block proving state does not have a .block property, it may be awaiting more txs.
+        break;
+      }
+      if (!block.startBlobAccumulator) {
+        // startBlobAccumulator always exists for firstBlockNumber, so the below should never assign an undefined:
+        block.setStartBlobAccumulator(previousAccumulator!);
+      }
+      if (block.startBlobAccumulator && !block.endBlobAccumulator) {
+        await block.accumulateBlobs();
+      }
+      previousAccumulator = block.endBlobAccumulator;
+    }
+  }
+
   public getParentLocation(location: TreeNodeLocation) {
     return this.blockRootOrMergeProvingOutputs.getParentLocation(location);
   }
@@ -156,7 +186,7 @@ export class EpochProvingState {
     return new BlockMergeRollupInputs([this.#getPreviousRollupData(left), this.#getPreviousRollupData(right)]);
   }
 
-  public getRootRollupInputs(proverId: Fr) {
+  public getRootRollupInputs() {
     const [left, right] = this.#getChildProofsForRoot();
     if (!left || !right) {
       throw new Error('At lease one child is not ready.');
@@ -164,7 +194,6 @@ export class EpochProvingState {
 
     return RootRollupInputs.from({
       previousRollupData: [this.#getPreviousRollupData(left), this.#getPreviousRollupData(right)],
-      proverId,
     });
   }
 
@@ -181,14 +210,15 @@ export class EpochProvingState {
     return this.blocks.find(block => block?.blockNumber === blockNumber);
   }
 
-  public getEpochProofResult(): { proof: Proof; publicInputs: RootRollupPublicInputs } {
-    if (!this.rootRollupProvingOutput) {
+  public getEpochProofResult(): { proof: Proof; publicInputs: RootRollupPublicInputs; batchedBlobInputs: BatchedBlob } {
+    if (!this.rootRollupProvingOutput || !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,
+      batchedBlobInputs: this.finalBatchedBlob,
     };
   }
 

package/src/orchestrator/orchestrator.ts

@@ -1,3 +1,4 @@
+import { FinalBlobBatchingChallenges } from '@aztec/blob-lib';
 import {
   L1_TO_L2_MSG_SUBTREE_HEIGHT,
   L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
@@ -107,14 +108,26 @@ export class ProvingOrchestrator implements EpochProver {
     return Promise.resolve();
   }
 
-  public startNewEpoch(epochNumber: number, firstBlockNumber: number, totalNumBlocks: number) {
+  public startNewEpoch(
+    epochNumber: number,
+    firstBlockNumber: number,
+    totalNumBlocks: number,
+    finalBlobBatchingChallenges: FinalBlobBatchingChallenges,
+  ) {
     const { promise: _promise, resolve, reject } = promiseWithResolvers<ProvingResult>();
     const promise = _promise.catch((reason): ProvingResult => ({ status: 'failure', reason }));
     if (totalNumBlocks <= 0 || !Number.isInteger(totalNumBlocks)) {
       throw new Error(`Invalid number of blocks for epoch (got ${totalNumBlocks})`);
     }
     logger.info(`Starting epoch ${epochNumber} with ${totalNumBlocks} blocks`);
-    this.provingState = new EpochProvingState(epochNumber, firstBlockNumber, totalNumBlocks, resolve, reject);
+    this.provingState = new EpochProvingState(
+      epochNumber,
+      firstBlockNumber,
+      totalNumBlocks,
+      finalBlobBatchingChallenges,
+      resolve,
+      reject,
+    );
     this.provingPromise = promise;
   }
 
@@ -145,8 +158,12 @@ export class ProvingOrchestrator implements EpochProver {
     this.dbs.set(globalVariables.blockNumber.toNumber(), db);
 
     // we start the block by enqueueing all of the base parity circuits
-    const { l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, baseParityInputs } =
-      await this.prepareBaseParityInputs(l1ToL2Messages, db);
+    const {
+      l1ToL2MessageTreeSnapshot,
+      l1ToL2MessageSubtreeSiblingPath,
+      l1ToL2MessageTreeSnapshotAfterInsertion,
+      baseParityInputs,
+    } = await this.prepareBaseParityInputs(l1ToL2Messages, db);
 
     // Get archive snapshot before this block lands
     const lastArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
@@ -156,6 +173,7 @@ export class ProvingOrchestrator implements EpochProver {
     const blockProvingState = this.provingState!.startNewBlock(
       globalVariables,
       l1ToL2Messages,
+      l1ToL2MessageTreeSnapshot,
       l1ToL2MessageSubtreeSiblingPath,
       l1ToL2MessageTreeSnapshotAfterInsertion,
       lastArchive,
@@ -184,7 +202,7 @@ export class ProvingOrchestrator implements EpochProver {
       logger.warn(`Provided no txs to orchestrator addTxs.`);
       return;
     }
-    const blockNumber = txs[0].constants.globalVariables.blockNumber.toNumber();
+    const blockNumber = txs[0].globalVariables.blockNumber.toNumber();
     const provingState = this.provingState?.getBlockProvingStateByBlockNumber(blockNumber!);
     if (!provingState) {
       throw new Error(`Block proving state for ${blockNumber} not found`);
@@ -272,6 +290,9 @@ export class ProvingOrchestrator implements EpochProver {
     logger.verbose(`Block ${blockNumber} completed. Assembling header.`);
     await this.buildBlock(provingState, expectedHeader);
 
+    logger.debug(`Accumulating blobs for ${blockNumber}`);
+    await this.provingState?.setBlobAccumulators(blockNumber);
+
     // If the proofs were faster than the block building, then we need to try the block root rollup again here
     await this.checkAndEnqueueBlockRootRollup(provingState);
     return provingState.block!;
@@ -319,7 +340,7 @@ export class ProvingOrchestrator implements EpochProver {
     await this.verifyBuiltBlockAgainstSyncedState(l2Block, newArchive);
 
     logger.verbose(`Orchestrator finalised block ${l2Block.number}`);
-    provingState.block = l2Block;
+    provingState.setBlock(l2Block);
   }
 
   // Flagged as protected to disable in certain unit tests
@@ -358,6 +379,15 @@ export class ProvingOrchestrator implements EpochProver {
       throw new Error(`Epoch proving failed: ${result.reason}`);
     }
 
+    // TODO(MW): Move this? Requires async and don't want to force root methods to be async
+    // TODO(MW): EpochProvingState uses this.blocks.filter(b => !!b).length as total blocks, use this below:
+    const finalBlock = this.provingState.blocks[this.provingState.totalNumBlocks - 1];
+    if (!finalBlock || !finalBlock.endBlobAccumulator) {
+      throw new Error(`Epoch's final block not ready for finalise`);
+    }
+    const finalBatchedBlob = await finalBlock.endBlobAccumulator.finalize();
+    this.provingState.setFinalBatchedBlob(finalBatchedBlob);
+
     const epochProofResult = this.provingState.getEpochProofResult();
 
     pushTestData('epochProofResult', {
@@ -455,6 +485,8 @@ export class ProvingOrchestrator implements EpochProver {
       BaseParityInputs.fromSlice(l1ToL2MessagesPadded, i, getVKTreeRoot()),
     );
 
+    const l1ToL2MessageTreeSnapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
+
     const l1ToL2MessageSubtreeSiblingPath = assertLength(
       await getSubtreeSiblingPath(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, L1_TO_L2_MSG_SUBTREE_HEIGHT, db),
       L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
@@ -465,6 +497,7 @@ export class ProvingOrchestrator implements EpochProver {
     const l1ToL2MessageTreeSnapshotAfterInsertion = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
 
     return {
+      l1ToL2MessageTreeSnapshot,
       l1ToL2MessageSubtreeSiblingPath,
       l1ToL2MessageTreeSnapshotAfterInsertion,
       baseParityInputs,
@@ -489,7 +522,13 @@ export class ProvingOrchestrator implements EpochProver {
     // We build the base rollup inputs using a mock proof and verification key.
     // These will be overwritten later once we have proven the tube circuit and any public kernels
     const [ms, hints] = await elapsed(
-      insertSideEffectsAndBuildBaseRollupHints(tx, provingState.globalVariables, db, provingState.spongeBlobState),
+      insertSideEffectsAndBuildBaseRollupHints(
+        tx,
+        provingState.globalVariables,
+        provingState.l1ToL2MessageTreeSnapshot,
+        db,
+        provingState.spongeBlobState,
+      ),
     );
 
     this.metrics.recordBaseRollupInputs(ms);
@@ -687,6 +726,17 @@ export class ProvingOrchestrator implements EpochProver {
           provingState.reject(`New archive root mismatch.`);
         }
 
+        const endBlobAccumulator = provingState.endBlobAccumulator!;
+        const circuitEndBlobAccumulatorState = result.inputs.blobPublicInputs.endBlobAccumulator;
+        if (!circuitEndBlobAccumulatorState.equals(endBlobAccumulator.toBlobAccumulatorPublicInputs())) {
+          logger.error(
+            `Blob accumulator state mismatch.\nCircuit: ${inspect(circuitEndBlobAccumulatorState)}\nComputed: ${inspect(
+              endBlobAccumulator.toBlobAccumulatorPublicInputs(),
+            )}`,
+          );
+          provingState.reject(`Blob accumulator state mismatch.`);
+        }
+
         logger.debug(`Completed ${rollupType} proof for block ${provingState.block!.number}`);
         // validatePartialState(result.inputs.end, tx.treeSnapshots); // TODO(palla/prover)
 
@@ -770,7 +820,6 @@ export class ProvingOrchestrator implements EpochProver {
     }
 
     const inputs = provingState.getBlockMergeRollupInputs(location);
-
     this.deferredProving(
       provingState,
       wrapCallbackInSpan(
@@ -825,7 +874,7 @@ export class ProvingOrchestrator implements EpochProver {
 
     logger.debug(`Preparing root rollup`);
 
-    const inputs = provingState.getRootRollupInputs(this.proverId);
+    const inputs = provingState.getRootRollupInputs();
 
     this.deferredProving(
       provingState,
@@ -859,15 +908,17 @@ export class ProvingOrchestrator implements EpochProver {
   }
 
   private async checkAndEnqueueBlockRootRollup(provingState: BlockProvingState) {
+    const blockNumber = provingState.blockNumber;
+    // Accumulate as far as we can, in case blocks came in out of order and we are behind:
+    await this.provingState?.setBlobAccumulators(blockNumber);
     if (!provingState.isReadyForBlockRootRollup()) {
-      logger.debug('Not ready for root rollup');
+      logger.debug('Not ready for block root rollup');
       return;
     }
     if (provingState.blockRootRollupStarted) {
       logger.debug('Block root rollup already started');
       return;
     }
-    const blockNumber = provingState.blockNumber;
 
     // TODO(palla/prover): This closes the fork only on the happy path. If this epoch orchestrator
     // is aborted and never reaches this point, it will leak the fork. We need to add a global cleanup,

package/src/prover-client/prover-client.ts

@@ -3,15 +3,16 @@ import { times } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { NativeACVMSimulator } from '@aztec/simulator/server';
-import type {
-  ActualProverConfig,
-  EpochProver,
-  EpochProverManager,
-  ForkMerkleTreeOperations,
-  ProvingJobBroker,
-  ProvingJobConsumer,
-  ProvingJobProducer,
-  ServerCircuitProver,
+import {
+  type ActualProverConfig,
+  type EpochProver,
+  type EpochProverManager,
+  type ForkMerkleTreeOperations,
+  type ProvingJobBroker,
+  type ProvingJobConsumer,
+  type ProvingJobProducer,
+  type ServerCircuitProver,
+  tryStop,
 } from '@aztec/stdlib/interfaces/server';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
@@ -87,6 +88,7 @@ export class ProverClient implements EpochProverManager {
     }
     this.running = false;
     await this.stopAgents();
+    await tryStop(this.orchestratorClient);
   }
 
   /**

package/src/prover-client/server-epoch-prover.ts

@@ -1,3 +1,4 @@
+import type { BatchedBlob, FinalBlobBatchingChallenges } from '@aztec/blob-lib';
 import type { Fr } from '@aztec/foundation/fields';
 import type { L2Block } from '@aztec/stdlib/block';
 import type { EpochProver } from '@aztec/stdlib/interfaces/server';
@@ -15,8 +16,13 @@ export class ServerEpochProver implements EpochProver {
     private orchestrator: ProvingOrchestrator,
   ) {}
 
-  startNewEpoch(epochNumber: number, firstBlockNumber: number, totalNumBlocks: number): void {
-    this.orchestrator.startNewEpoch(epochNumber, firstBlockNumber, totalNumBlocks);
+  startNewEpoch(
+    epochNumber: number,
+    firstBlockNumber: number,
+    totalNumBlocks: number,
+    finalBlobBatchingChallenges: FinalBlobBatchingChallenges,
+  ): void {
+    this.orchestrator.startNewEpoch(epochNumber, firstBlockNumber, totalNumBlocks, finalBlobBatchingChallenges);
     this.facade.start();
   }
   startTubeCircuits(txs: Tx[]): Promise<void> {
@@ -25,7 +31,7 @@ export class ServerEpochProver implements EpochProver {
   setBlockCompleted(blockNumber: number, expectedBlockHeader?: BlockHeader): Promise<L2Block> {
     return this.orchestrator.setBlockCompleted(blockNumber, expectedBlockHeader);
   }
-  finaliseEpoch(): Promise<{ publicInputs: RootRollupPublicInputs; proof: Proof }> {
+  finaliseEpoch(): Promise<{ publicInputs: RootRollupPublicInputs; proof: Proof; batchedBlobInputs: BatchedBlob }> {
     return this.orchestrator.finaliseEpoch();
   }
   cancel(): void {