@aztec/prover-client 0.56.0 → 0.58.0

package/src/orchestrator/orchestrator.ts

@@ -1,20 +1,14 @@
 import {
-  BlockProofError,
   Body,
   EncryptedNoteTxL2Logs,
   EncryptedTxL2Logs,
   L2Block,
   MerkleTreeId,
-  PROVING_STATUS,
   type PaddingProcessedTx,
   type ProcessedTx,
-  type ProvingBlockResult,
   ProvingRequestType,
-  type ProvingResult,
-  type ProvingTicket,
   type PublicInputsAndRecursiveProof,
   type ServerCircuitProver,
-  Tx,
   type TxEffect,
   UnencryptedTxL2Logs,
   makeEmptyProcessedTx,
@@ -22,7 +16,7 @@ import {
   mapProvingRequestTypeToCircuitName,
   toTxEffect,
 } from '@aztec/circuit-types';
-import { type EpochProver } from '@aztec/circuit-types/interfaces';
+import { type EpochProver, type MerkleTreeWriteOperations } from '@aztec/circuit-types/interfaces';
 import { type CircuitName } from '@aztec/circuit-types/stats';
 import {
   AvmCircuitInputs,
@@ -31,8 +25,10 @@ import {
   type BaseRollupInputs,
   type BlockRootOrBlockMergePublicInputs,
   BlockRootRollupInputs,
+  EmptyBlockRootRollupInputs,
   Fr,
   type GlobalVariables,
+  type Header,
   type KernelCircuitPublicInputs,
   L1_TO_L2_MSG_SUBTREE_HEIGHT,
   L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
@@ -46,6 +42,7 @@ import {
   type RecursiveProof,
   type RootParityInput,
   RootParityInputs,
+  TUBE_INDEX,
   type TUBE_PROOF_LENGTH,
   TubeInputs,
   type VMCircuitPublicInputs,
@@ -62,9 +59,9 @@ import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { type Tuple } from '@aztec/foundation/serialize';
 import { pushTestData } from '@aztec/foundation/testing';
 import { elapsed } from '@aztec/foundation/timer';
-import { getVKIndex, getVKSiblingPath, getVKTreeRoot } from '@aztec/noir-protocol-circuits-types';
+import { TubeVk, getVKIndex, getVKSiblingPath, getVKTreeRoot } from '@aztec/noir-protocol-circuits-types';
+import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
 import { Attributes, type TelemetryClient, type Tracer, trackSpan, wrapCallbackInSpan } from '@aztec/telemetry-client';
-import { type MerkleTreeOperations } from '@aztec/world-state';
 
 import { inspect } from 'util';
 
@@ -83,7 +80,12 @@ import {
   validateTx,
 } from './block-building-helpers.js';
 import { type BlockProvingState, type MergeRollupInputData } from './block-proving-state.js';
-import { type BlockMergeRollupInputData, EpochProvingState, type TreeSnapshots } from './epoch-proving-state.js';
+import {
+  type BlockMergeRollupInputData,
+  EpochProvingState,
+  type ProvingResult,
+  type TreeSnapshots,
+} from './epoch-proving-state.js';
 import { ProvingOrchestratorMetrics } from './orchestrator_metrics.js';
 import { TX_PROVING_CODE, type TxProvingInstruction, TxProvingState } from './tx-proving-state.js';
 
@@ -108,10 +110,11 @@ export class ProvingOrchestrator implements EpochProver {
   private pendingProvingJobs: AbortController[] = [];
   private paddingTx: PaddingProcessedTx | undefined = undefined;
 
+  private provingPromise: Promise<ProvingResult> | undefined = undefined;
   private metrics: ProvingOrchestratorMetrics;
 
   constructor(
-    private db: MerkleTreeOperations,
+    private db: MerkleTreeWriteOperations,
     private prover: ServerCircuitProver,
     telemetryClient: TelemetryClient,
     private readonly proverId: Fr = Fr.ZERO,
@@ -134,26 +137,20 @@ export class ProvingOrchestrator implements EpochProver {
     this.paddingTx = undefined;
   }
 
-  @trackSpan('ProvingOrchestrator.startNewEpoch', (epochNumber, totalNumBlocks) => ({
-    [Attributes.EPOCH_SIZE]: totalNumBlocks,
-    [Attributes.EPOCH_NUMBER]: epochNumber,
-  }))
-  public startNewEpoch(epochNumber: number, totalNumBlocks: number): ProvingTicket {
+  public startNewEpoch(epochNumber: number, totalNumBlocks: number) {
     const { promise: _promise, resolve, reject } = promiseWithResolvers<ProvingResult>();
-    const promise = _promise.catch(
-      (reason): ProvingResult => ({
-        status: PROVING_STATUS.FAILURE,
-        reason,
-      }),
-    );
-
+    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, totalNumBlocks, resolve, reject);
-    return { provingPromise: promise };
+    this.provingPromise = promise;
   }
 
   /**
    * Starts off a new block
-   * @param numTxs - The total number of transactions in the block. Must be a power of 2
+   * @param numTxs - The total number of transactions in the block.
    * @param globalVariables - The global variables for the block
    * @param l1ToL2Messages - The l1 to l2 messages for the block
    * @param verificationKeys - The private kernel verification keys
@@ -163,14 +160,9 @@ export class ProvingOrchestrator implements EpochProver {
     [Attributes.BLOCK_SIZE]: numTxs,
     [Attributes.BLOCK_NUMBER]: globalVariables.blockNumber.toNumber(),
   }))
-  public async startNewBlock(
-    numTxs: number,
-    globalVariables: GlobalVariables,
-    l1ToL2Messages: Fr[],
-  ): Promise<ProvingTicket> {
-    // If no proving state, assume we only care about proving this block and initialize a 1-block epoch
+  public async startNewBlock(numTxs: number, globalVariables: GlobalVariables, l1ToL2Messages: Fr[]) {
     if (!this.provingState) {
-      this.startNewEpoch(globalVariables.blockNumber.toNumber(), 1);
+      throw new Error(`Invalid proving state, call startNewEpoch before starting a block`);
     }
 
     if (!this.provingState?.isAcceptingBlocks()) {
@@ -178,10 +170,14 @@ export class ProvingOrchestrator implements EpochProver {
     }
 
     if (!Number.isInteger(numTxs) || numTxs < 2) {
-      throw new Error(`Length of txs for the block should be at least two (got ${numTxs})`);
+      throw new Error(`Invalid number of txs for block (got ${numTxs})`);
+    }
+
+    if (this.provingState.currentBlock && !this.provingState.currentBlock.block) {
+      throw new Error(`Must end previous block before starting a new one`);
     }
 
-    // TODO(palla/prover-node): Store block number in the db itself to make this check more reliable,
+    // TODO(palla/prover): Store block number in the db itself to make this check more reliable,
     // and turn this warning into an exception that we throw.
     const { blockNumber } = globalVariables;
     const dbBlockNumber = (await this.db.getTreeInfo(MerkleTreeId.ARCHIVE)).size - 1n;
@@ -234,9 +230,6 @@ export class ProvingOrchestrator implements EpochProver {
       BigInt(startArchiveSnapshot.nextAvailableLeafIndex - 1),
     );
 
-    const { promise: _promise, resolve, reject } = promiseWithResolvers<ProvingResult>();
-    const promise = _promise.catch((reason): ProvingResult => ({ status: PROVING_STATUS.FAILURE, reason }));
-
     this.provingState!.startNewBlock(
       numTxs,
       globalVariables,
@@ -247,16 +240,12 @@ export class ProvingOrchestrator implements EpochProver {
       startArchiveSnapshot,
       newArchiveSiblingPath,
       previousBlockHash!,
-      resolve,
-      reject,
     );
 
     // Enqueue base parity circuits for the block
     for (let i = 0; i < baseParityInputs.length; i++) {
       this.enqueueBaseParityCircuit(this.provingState!.currentBlock!, baseParityInputs[i], i);
     }
-
-    return { provingPromise: promise };
   }
 
   /**
@@ -276,6 +265,10 @@ export class ProvingOrchestrator implements EpochProver {
       throw new Error(`Rollup not accepting further transactions`);
     }
 
+    if (!provingState.verifyState()) {
+      throw new Error(`Invalid proving state when adding a tx`);
+    }
+
     validateTx(tx);
 
     logger.info(`Received transaction: ${tx.hash}`);
@@ -289,10 +282,7 @@ export class ProvingOrchestrator implements EpochProver {
     this.enqueueFirstProofs(inputs, treeSnapshots, tx, provingState);
 
     if (provingState.transactionsReceived === provingState.totalNumTxs) {
-      logger.verbose(
-        `All transactions received for block ${provingState.globalVariables.blockNumber}. Assembling header.`,
-      );
-      await this.buildBlockHeader(provingState);
+      logger.verbose(`All transactions received for block ${provingState.globalVariables.blockNumber}.`);
     }
   }
 
@@ -311,53 +301,132 @@ export class ProvingOrchestrator implements EpochProver {
       [Attributes.BLOCK_TXS_COUNT]: block.transactionsReceived,
     };
   })
-  public async setBlockCompleted() {
+  public async setBlockCompleted(expectedHeader?: Header): Promise<L2Block> {
     const provingState = this.provingState?.currentBlock;
     if (!provingState) {
       throw new Error(`Invalid proving state, call startNewBlock before adding transactions or completing the block`);
     }
 
-    // we may need to pad the rollup with empty transactions
+    if (!provingState.verifyState()) {
+      throw new Error(`Block proving failed: ${provingState.error}`);
+    }
+
+    // We may need to pad the rollup with empty transactions
     const paddingTxCount = provingState.totalNumTxs - provingState.transactionsReceived;
-    if (paddingTxCount === 0) {
-      return;
-    } else if (provingState.totalNumTxs > 2) {
+    if (paddingTxCount > 0 && provingState.totalNumTxs > 2) {
       throw new Error(`Block not ready for completion: expecting ${paddingTxCount} more transactions.`);
     }
 
-    logger.debug(`Padding rollup with ${paddingTxCount} empty transactions`);
-    // Make an empty padding transaction
-    // Required for:
-    // 0 (when we want an empty block, largely for testing), or
-    // 1 (we need to pad with one tx as all rollup circuits require a pair of inputs) txs
-    // Insert it into the tree the required number of times to get all of the
-    // base rollup inputs
-    // Then enqueue the proving of all the transactions
-    const unprovenPaddingTx = makeEmptyProcessedTx(
-      this.db.getInitialHeader(),
-      provingState.globalVariables.chainId,
-      provingState.globalVariables.version,
-      getVKTreeRoot(),
-    );
-    const txInputs: Array<{ inputs: BaseRollupInputs; snapshot: TreeSnapshots }> = [];
-    for (let i = 0; i < paddingTxCount; i++) {
-      const [inputs, snapshot] = await this.prepareTransaction(unprovenPaddingTx, provingState);
-      const txInput = {
-        inputs,
-        snapshot,
-      };
-      txInputs.push(txInput);
-    }
+    if (paddingTxCount > 0) {
+      logger.debug(`Padding rollup with ${paddingTxCount} empty transactions`);
+      // Make an empty padding transaction
+      // Required for:
+      // 0 (when we want an empty block, largely for testing), or
+      // 1 (we need to pad with one tx as all rollup circuits require a pair of inputs) txs
+      // Insert it into the tree the required number of times to get all of the
+      // base rollup inputs
+      // Then enqueue the proving of all the transactions
+      const unprovenPaddingTx = makeEmptyProcessedTx(
+        this.db.getInitialHeader(),
+        provingState.globalVariables.chainId,
+        provingState.globalVariables.version,
+        getVKTreeRoot(),
+        protocolContractTreeRoot,
+      );
+      const txInputs: Array<{ inputs: BaseRollupInputs; snapshot: TreeSnapshots }> = [];
+      for (let i = 0; i < paddingTxCount; i++) {
+        const [inputs, snapshot] = await this.prepareTransaction(unprovenPaddingTx, provingState);
+        const txInput = {
+          inputs,
+          snapshot,
+        };
+        txInputs.push(txInput);
+      }
 
-    // Now enqueue the proving
-    this.enqueuePaddingTxs(provingState, txInputs, unprovenPaddingTx);
+      // Now enqueue the proving
+      this.enqueuePaddingTxs(provingState, txInputs, unprovenPaddingTx);
+    }
 
     // And build the block header
-    logger.verbose(`Block ${provingState.globalVariables.blockNumber} padded with empty tx(s). Assembling header.`);
-    await this.buildBlockHeader(provingState);
+    logger.verbose(`Block ${provingState.globalVariables.blockNumber} completed. Assembling header.`);
+    await this.buildBlock(provingState, expectedHeader);
+
+    // If the proofs were faster than the block building, then we need to try the block root rollup again here
+    this.checkAndEnqueueBlockRootRollup(provingState);
+    return provingState.block!;
   }
 
-  private async buildBlockHeader(provingState: BlockProvingState) {
+  /** Returns the block as built for a given index. */
+  public getBlock(index: number): L2Block {
+    const block = this.provingState?.blocks[index].block;
+    if (!block) {
+      throw new Error(`Block at index ${index} not available`);
+    }
+    return block;
+  }
+
+  @trackSpan('ProvingOrchestrator.padEpoch', function () {
+    if (!this.provingState) {
+      return {};
+    }
+    return {
+      [Attributes.EPOCH_NUMBER]: this.provingState.epochNumber,
+      [Attributes.EPOCH_SIZE]: this.provingState.totalNumBlocks,
+    };
+  })
+  private padEpoch(): Promise<void> {
+    const provingState = this.provingState!;
+    const lastBlock = provingState.currentBlock?.block;
+    if (!lastBlock) {
+      return Promise.reject(new Error(`Epoch needs at least one completed block in order to be padded`));
+    }
+
+    const paddingBlockCount = Math.max(2, provingState.totalNumBlocks) - provingState.blocks.length;
+    if (paddingBlockCount === 0) {
+      return Promise.resolve();
+    }
+
+    logger.debug(`Padding epoch proof with ${paddingBlockCount} empty block proofs`);
+
+    const inputs = EmptyBlockRootRollupInputs.from({
+      archive: lastBlock.archive,
+      blockHash: lastBlock.header.hash(),
+      globalVariables: lastBlock.header.globalVariables,
+      vkTreeRoot: getVKTreeRoot(),
+      protocolContractTreeRoot,
+      proverId: this.proverId,
+    });
+
+    logger.debug(`Enqueuing deferred proving for padding block to enqueue ${paddingBlockCount} paddings`);
+    this.deferredProving(
+      provingState,
+      wrapCallbackInSpan(
+        this.tracer,
+        'ProvingOrchestrator.prover.getEmptyBlockRootRollupProof',
+        {
+          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'empty-block-root-rollup' satisfies CircuitName,
+        },
+        signal => this.prover.getEmptyBlockRootRollupProof(inputs, signal, provingState.epochNumber),
+      ),
+      result => {
+        logger.debug(`Completed proof for padding block`);
+        const currentLevel = provingState.numMergeLevels + 1n;
+        for (let i = 0; i < paddingBlockCount; i++) {
+          logger.debug(`Enqueuing padding block with index ${provingState.blocks.length + i}`);
+          const index = BigInt(provingState.blocks.length + i);
+          this.storeAndExecuteNextBlockMergeLevel(provingState, currentLevel, index, [
+            result.inputs,
+            result.proof,
+            result.verificationKey.keyAsFields,
+          ]);
+        }
+      },
+    );
+    return Promise.resolve();
+  }
+
+  private async buildBlock(provingState: BlockProvingState, expectedHeader?: Header) {
     // Collect all new nullifiers, commitments, and contracts from all txs in this block to build body
     const gasFees = provingState.globalVariables.gasFees;
     const nonEmptyTxEffects: TxEffect[] = provingState!.allTxs
@@ -374,12 +443,17 @@ export class ProvingOrchestrator implements EpochProver {
       this.db,
     );
 
+    if (expectedHeader && !header.equals(expectedHeader)) {
+      logger.error(`Block header mismatch: header=${header} expectedHeader=${expectedHeader}`);
+      throw new Error('Block header mismatch');
+    }
+
     logger.verbose(`Updating archive tree with block ${provingState.blockNumber} header ${header.hash().toString()}`);
     await this.db.updateArchive(header);
 
     // Assemble the L2 block
     const newArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, this.db);
-    const l2Block = L2Block.fromFields({ archive: newArchive, header, body });
+    const l2Block = new L2Block(newArchive, header, body);
 
     if (!l2Block.body.getTxsEffectsHash().equals(header.contentCommitment.txsEffectsHash)) {
       throw new Error(
@@ -426,6 +500,7 @@ export class ProvingOrchestrator implements EpochProver {
               unprovenPaddingTx.data.constants.txContext.chainId,
               unprovenPaddingTx.data.constants.txContext.version,
               getVKTreeRoot(),
+              protocolContractTreeRoot,
             ),
             signal,
             provingState.epochNumber,
@@ -499,52 +574,29 @@ export class ProvingOrchestrator implements EpochProver {
   }
 
   /**
-   * Returns the fully proven block. Requires proving to have been completed.
-   * @param index - The index of the block to finalise. Defaults to the last block.
-   * @returns The fully proven block and proof.
+   * Returns the proof for the current epoch.
    */
-  public finaliseBlock(index?: number) {
-    try {
-      const block = this.provingState?.blocks[index ?? this.provingState?.blocks.length - 1];
-
-      if (!block || !block.blockRootRollupPublicInputs || !block.finalProof || !block.block) {
-        throw new Error(`Invalid proving state, a block must be proven before it can be finalised`);
-      }
+  public async finaliseEpoch() {
+    if (!this.provingState || !this.provingPromise) {
+      throw new Error(`Invalid proving state, an epoch must be proven before it can be finalised`);
+    }
 
-      const blockResult: ProvingBlockResult = {
-        proof: block.finalProof,
-        aggregationObject: block.finalProof.extractAggregationObject(),
-        block: block.block!,
-      };
-
-      pushTestData('blockResults', {
-        proverId: this.proverId.toString(),
-        vkTreeRoot: getVKTreeRoot().toString(),
-        block: blockResult.block.toString(),
-        proof: blockResult.proof.toString(),
-        aggregationObject: blockResult.aggregationObject.map(x => x.toString()),
-      });
+    await this.padEpoch();
 
-      return Promise.resolve(blockResult);
-    } catch (err) {
-      throw new BlockProofError(
-        err && typeof err === 'object' && 'message' in err ? String(err.message) : String(err),
-        this.provingState?.blocks[index ?? this.provingState?.blocks.length - 1]?.allTxs.map(x =>
-          Tx.getHash(x.processedTx),
-        ) ?? [],
-      );
+    const result = await this.provingPromise!;
+    if (result.status === 'failure') {
+      throw new Error(`Epoch proving failed: ${result.reason}`);
     }
-  }
 
-  /**
-   * Returns the proof for the current epoch.
-   * Requires proving to have been completed.
-   */
-  public finaliseEpoch() {
-    if (!this.provingState || !this.provingState.rootRollupPublicInputs || !this.provingState.finalProof) {
-      throw new Error(`Invalid proving state, an epoch must be proven before it can be finalised`);
+    if (!this.provingState.rootRollupPublicInputs || !this.provingState.finalProof) {
+      throw new Error(`Invalid proving state, missing root rollup public inputs or final proof`);
     }
 
+    pushTestData('epochProofResult', {
+      proof: this.provingState.finalProof.toString(),
+      publicInputs: this.provingState.rootRollupPublicInputs.toString(),
+    });
+
     return { proof: this.provingState.finalProof, publicInputs: this.provingState.rootRollupPublicInputs };
   }
 
@@ -663,7 +715,7 @@ export class ProvingOrchestrator implements EpochProver {
         makeEmptyRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH),
         provingState.globalVariables,
         this.db,
-        VerificationKeyData.makeFake(),
+        TubeVk,
       ),
     );
 
@@ -795,8 +847,14 @@ export class ProvingOrchestrator implements EpochProver {
       ),
       result => {
         logger.debug(`Completed tube proof for tx index: ${txIndex}`);
-        const nextKernelRequest = txProvingState.getNextPublicKernelFromTubeProof(result.tubeProof, result.tubeVK);
-        this.checkAndEnqueueNextTxCircuit(provingState, txIndex, result.tubeProof, result.tubeVK, nextKernelRequest);
+        const nextKernelRequest = txProvingState.getNextPublicKernelFromTubeProof(result.proof, result.verificationKey);
+        this.checkAndEnqueueNextTxCircuit(
+          provingState,
+          txIndex,
+          result.proof,
+          result.verificationKey,
+          nextKernelRequest,
+        );
       },
     );
   }
@@ -836,11 +894,17 @@ export class ProvingOrchestrator implements EpochProver {
   }
 
   // Executes the block root rollup circuit
-  private enqueueBlockRootRollup(provingState: BlockProvingState | undefined) {
-    if (!provingState?.verifyState()) {
+  private enqueueBlockRootRollup(provingState: BlockProvingState) {
+    if (!provingState.block) {
+      throw new Error(`Invalid proving state for block root rollup, block not available`);
+    }
+
+    if (!provingState.verifyState()) {
       logger.debug('Not running block root rollup, state no longer valid');
       return;
     }
+
+    provingState.blockRootRollupStarted = true;
     const mergeInputData = provingState.getMergeInputs(0);
     const rootParityInput = provingState.finalRootParityInput!;
 
@@ -868,8 +932,6 @@ export class ProvingOrchestrator implements EpochProver {
       proverId: this.proverId,
     });
 
-    const shouldProveEpoch = this.provingState!.totalNumBlocks > 1;
-
     this.deferredProving(
       provingState,
       wrapCallbackInSpan(
@@ -879,10 +941,7 @@ export class ProvingOrchestrator implements EpochProver {
           [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
           [Attributes.PROTOCOL_CIRCUIT_NAME]: 'block-root-rollup' satisfies CircuitName,
         },
-        signal =>
-          shouldProveEpoch
-            ? this.prover.getBlockRootRollupProof(inputs, signal, provingState.epochNumber)
-            : this.prover.getBlockRootRollupFinalProof(inputs, signal, provingState.epochNumber),
+        signal => this.prover.getBlockRootRollupProof(inputs, signal, provingState.epochNumber),
       ),
       result => {
         const header = this.extractBlockHeaderFromPublicInputs(provingState, result.inputs);
@@ -895,17 +954,10 @@ export class ProvingOrchestrator implements EpochProver {
 
         provingState.blockRootRollupPublicInputs = result.inputs;
         provingState.finalProof = result.proof.binaryProof;
-        provingState.resolve({ status: PROVING_STATUS.SUCCESS });
 
         logger.debug(`Completed proof for block root rollup for ${provingState.block?.number}`);
         // validatePartialState(result.inputs.end, tx.treeSnapshots); // TODO(palla/prover)
 
-        // TODO(palla/prover): Remove this once we've dropped the flow for proving single blocks
-        if (!shouldProveEpoch) {
-          logger.verbose(`Skipping epoch rollup, only one block in epoch`);
-          return;
-        }
-
         const currentLevel = this.provingState!.numMergeLevels + 1n;
         this.storeAndExecuteNextBlockMergeLevel(this.provingState!, currentLevel, BigInt(provingState.index), [
           result.inputs,
@@ -1032,18 +1084,23 @@ export class ProvingOrchestrator implements EpochProver {
         signal => this.prover.getRootRollupProof(inputs, signal, provingState.epochNumber),
       ),
       result => {
+        logger.verbose(`Orchestrator completed root rollup for epoch ${provingState.epochNumber}`);
         provingState.rootRollupPublicInputs = result.inputs;
         provingState.finalProof = result.proof.binaryProof;
-        provingState.resolve({ status: PROVING_STATUS.SUCCESS });
+        provingState.resolve({ status: 'success' });
       },
     );
   }
 
-  private checkAndEnqueueBlockRootRollup(provingState: BlockProvingState | undefined) {
+  private checkAndEnqueueBlockRootRollup(provingState: BlockProvingState) {
     if (!provingState?.isReadyForBlockRootRollup()) {
       logger.debug('Not ready for root rollup');
       return;
     }
+    if (provingState.blockRootRollupStarted) {
+      logger.debug('Block root rollup already started');
+      return;
+    }
     this.enqueueBlockRootRollup(provingState);
   }
 
@@ -1181,7 +1238,10 @@ export class ProvingOrchestrator implements EpochProver {
               logger.warn(
                 `Error thrown when proving AVM circuit, but AVM_PROVING_STRICT is off, so faking AVM proof and carrying on. Error: ${err}.`,
               );
-              return { proof: makeEmptyProof(), verificationKey: VerificationKeyData.makeFake() };
+              return {
+                proof: makeEmptyProof(),
+                verificationKey: VerificationKeyData.makeFakeHonk(),
+              };
             }
           }
         },
@@ -1234,7 +1294,12 @@ export class ProvingOrchestrator implements EpochProver {
       // Take the final proof and assign it to the base rollup inputs
       txProvingState.baseRollupInputs.kernelData.proof = proof;
       txProvingState.baseRollupInputs.kernelData.vk = verificationKey;
-      txProvingState.baseRollupInputs.kernelData.vkIndex = getVKIndex(verificationKey);
+      try {
+        txProvingState.baseRollupInputs.kernelData.vkIndex = getVKIndex(verificationKey);
+      } catch (_ignored) {
+        // TODO(#7410) The VK for the tube won't be in the tree for now, so we manually set it to the tube vk index
+        txProvingState.baseRollupInputs.kernelData.vkIndex = TUBE_INDEX;
+      }
       txProvingState.baseRollupInputs.kernelData.vkPath = getVKSiblingPath(
         txProvingState.baseRollupInputs.kernelData.vkIndex,
       );

package/src/prover-agent/memory-proving-queue.ts

@@ -1,5 +1,5 @@
 import {
-  type AvmProofAndVerificationKey,
+  type ProofAndVerificationKey,
   type ProvingJob,
   type ProvingJobSource,
   type ProvingRequest,
@@ -16,10 +16,12 @@ import type {
   BlockMergeRollupInputs,
   BlockRootOrBlockMergePublicInputs,
   BlockRootRollupInputs,
+  EmptyBlockRootRollupInputs,
   KernelCircuitPublicInputs,
   MergeRollupInputs,
   NESTED_RECURSIVE_PROOF_LENGTH,
   PrivateKernelEmptyInputData,
+  Proof,
   PublicKernelCircuitPrivateInputs,
   PublicKernelCircuitPublicInputs,
   PublicKernelInnerCircuitPrivateInputs,
@@ -32,7 +34,6 @@ import type {
   RootRollupPublicInputs,
   TubeInputs,
   VMCircuitPublicInputs,
-  VerificationKeyData,
 } from '@aztec/circuits.js';
 import { randomBytes } from '@aztec/foundation/crypto';
 import { AbortError, TimeoutError } from '@aztec/foundation/error';
@@ -279,7 +280,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     inputs: TubeInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<{ tubeVK: VerificationKeyData; tubeProof: RecursiveProof<typeof RECURSIVE_PROOF_LENGTH> }> {
+  ): Promise<ProofAndVerificationKey<RecursiveProof<typeof RECURSIVE_PROOF_LENGTH>>> {
     return this.enqueue({ type: ProvingRequestType.TUBE_PROOF, inputs }, signal, epochNumber);
   }
 
@@ -351,12 +352,12 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     return this.enqueue({ type: ProvingRequestType.BLOCK_ROOT_ROLLUP, inputs: input }, signal, epochNumber);
   }
 
-  getBlockRootRollupFinalProof(
-    input: BlockRootRollupInputs,
+  getEmptyBlockRootRollupProof(
+    input: EmptyBlockRootRollupInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
-    return this.enqueue({ type: ProvingRequestType.BLOCK_ROOT_ROLLUP_FINAL, inputs: input }, signal, epochNumber);
+    return this.enqueue({ type: ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP, inputs: input }, signal, epochNumber);
   }
 
   /**
@@ -426,7 +427,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     inputs: AvmCircuitInputs,
     signal?: AbortSignal,
     epochNumber?: number,
-  ): Promise<AvmProofAndVerificationKey> {
+  ): Promise<ProofAndVerificationKey<Proof>> {
     return this.enqueue({ type: ProvingRequestType.PUBLIC_VM, inputs }, signal, epochNumber);
   }
 

package/src/prover-agent/prover-agent.ts

@@ -181,12 +181,12 @@ export class ProverAgent {
         return this.circuitProver.getMergeRollupProof(inputs);
       }
 
-      case ProvingRequestType.BLOCK_ROOT_ROLLUP: {
-        return this.circuitProver.getBlockRootRollupProof(inputs);
+      case ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP: {
+        return this.circuitProver.getEmptyBlockRootRollupProof(inputs);
       }
 
-      case ProvingRequestType.BLOCK_ROOT_ROLLUP_FINAL: {
-        return this.circuitProver.getBlockRootRollupFinalProof(inputs);
+      case ProvingRequestType.BLOCK_ROOT_ROLLUP: {
+        return this.circuitProver.getBlockRootRollupProof(inputs);
       }
 
       case ProvingRequestType.BLOCK_MERGE_ROLLUP: {