@aztec/prover-client 0.0.0-test.1 → 0.0.1-fake-ceab37513c

package/src/orchestrator/orchestrator.ts

@@ -1,6 +1,5 @@
+import { BlobAccumulatorPublicInputs, FinalBlobBatchingChallenges } from '@aztec/blob-lib';
 import {
-  AVM_PROOF_LENGTH_IN_FIELDS,
-  AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS,
   L1_TO_L2_MSG_SUBTREE_HEIGHT,
   L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
@@ -17,7 +16,8 @@ import { pushTestData } from '@aztec/foundation/testing';
 import { elapsed } from '@aztec/foundation/timer';
 import type { TreeNodeLocation } from '@aztec/foundation/trees';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { L2Block } from '@aztec/stdlib/block';
+import { readAvmMinimalPublicTxInputsFromFile } from '@aztec/simulator/public/fixtures';
+import { EthAddress, L2Block } from '@aztec/stdlib/block';
 import type {
   EpochProver,
   ForkMerkleTreeOperations,
@@ -26,7 +26,6 @@ import type {
   ServerCircuitProver,
 } from '@aztec/stdlib/interfaces/server';
 import { BaseParityInputs } from '@aztec/stdlib/parity';
-import { makeEmptyRecursiveProof } from '@aztec/stdlib/proofs';
 import {
   type BaseRollupHints,
   EmptyBlockRootRollupInputs,
@@ -37,7 +36,6 @@ import {
 import type { CircuitName } from '@aztec/stdlib/stats';
 import { type AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
 import { type BlockHeader, type GlobalVariables, type ProcessedTx, type Tx, toNumBlobFields } from '@aztec/stdlib/tx';
-import { VerificationKeyData } from '@aztec/stdlib/vks';
 import {
   Attributes,
   type TelemetryClient,
@@ -50,11 +48,12 @@ import {
 import { inspect } from 'util';
 
 import {
-  buildBaseRollupHints,
   buildHeaderAndBodyFromTxs,
+  getLastSiblingPath,
   getRootTreeSiblingPath,
   getSubtreeSiblingPath,
   getTreeSnapshot,
+  insertSideEffectsAndBuildBaseRollupHints,
   validatePartialState,
   validateTx,
 } from './block-building-helpers.js';
@@ -90,7 +89,7 @@ export class ProvingOrchestrator implements EpochProver {
   constructor(
     private dbProvider: ForkMerkleTreeOperations,
     private prover: ServerCircuitProver,
-    private readonly proverId: Fr = Fr.ZERO,
+    private readonly proverId: EthAddress,
     telemetryClient: TelemetryClient = getTelemetryClient(),
   ) {
     this.metrics = new ProvingOrchestratorMetrics(telemetryClient, 'ProvingOrchestrator');
@@ -100,7 +99,7 @@ export class ProvingOrchestrator implements EpochProver {
     return this.metrics.tracer;
   }
 
-  public getProverId(): Fr {
+  public getProverId(): EthAddress {
     return this.proverId;
   }
 
@@ -109,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;
   }
 
@@ -127,7 +138,7 @@ export class ProvingOrchestrator implements EpochProver {
    * @returns A proving ticket, containing a promise notifying of proving completion
    */
   @trackSpan('ProvingOrchestrator.startNewBlock', globalVariables => ({
-    [Attributes.BLOCK_NUMBER]: globalVariables.blockNumber.toNumber(),
+    [Attributes.BLOCK_NUMBER]: globalVariables.blockNumber,
   }))
   public async startNewBlock(globalVariables: GlobalVariables, l1ToL2Messages: Fr[], previousBlockHeader: BlockHeader) {
     if (!this.provingState) {
@@ -138,30 +149,36 @@ export class ProvingOrchestrator implements EpochProver {
       throw new Error(`Epoch not accepting further blocks`);
     }
 
-    logger.info(
-      `Starting block ${globalVariables.blockNumber.toNumber()} for slot ${globalVariables.slotNumber.toNumber()}`,
-    );
+    logger.info(`Starting block ${globalVariables.blockNumber} for slot ${globalVariables.slotNumber.toNumber()}`);
 
     // Fork world state at the end of the immediately previous block
-    const db = await this.dbProvider.fork(globalVariables.blockNumber.toNumber() - 1);
-    this.dbs.set(globalVariables.blockNumber.toNumber(), db);
+    const db = await this.dbProvider.fork(globalVariables.blockNumber - 1);
+    this.dbs.set(globalVariables.blockNumber, 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);
+    const lastArchiveSiblingPath = await getLastSiblingPath(MerkleTreeId.ARCHIVE, db);
     const newArchiveSiblingPath = await getRootTreeSiblingPath(MerkleTreeId.ARCHIVE, db);
 
     const blockProvingState = this.provingState!.startNewBlock(
       globalVariables,
       l1ToL2Messages,
+      l1ToL2MessageTreeSnapshot,
       l1ToL2MessageSubtreeSiblingPath,
       l1ToL2MessageTreeSnapshotAfterInsertion,
       lastArchive,
+      lastArchiveSiblingPath,
       newArchiveSiblingPath,
       previousBlockHeader,
+      this.proverId,
     );
 
     // Enqueue base parity circuits for the block
@@ -184,7 +201,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;
     const provingState = this.provingState?.getBlockProvingStateByBlockNumber(blockNumber!);
     if (!provingState) {
       throw new Error(`Block proving state for ${blockNumber} not found`);
@@ -231,18 +248,19 @@ export class ProvingOrchestrator implements EpochProver {
    * Note that if the tube circuits are not started this way, they will be started nontheless after processing.
    */
   @trackSpan('ProvingOrchestrator.startTubeCircuits')
-  public async startTubeCircuits(txs: Tx[]) {
+  public startTubeCircuits(txs: Tx[]) {
     if (!this.provingState?.verifyState()) {
       throw new Error(`Invalid proving state, call startNewEpoch before starting tube circuits`);
     }
     for (const tx of txs) {
-      const txHash = (await tx.getTxHash()).toString();
-      const tubeInputs = new TubeInputs(tx.clientIvcProof);
+      const txHash = tx.getTxHash().toString();
+      const tubeInputs = new TubeInputs(!!tx.data.forPublic, tx.clientIvcProof);
       const tubeProof = promiseWithResolvers<ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>>();
       logger.debug(`Starting tube circuit for tx ${txHash}`);
       this.doEnqueueTube(txHash, tubeInputs, proof => tubeProof.resolve(proof));
       this.provingState?.cachedTubeProofs.set(txHash, tubeProof.promise);
     }
+    return Promise.resolve();
   }
 
   /**
@@ -259,7 +277,7 @@ export class ProvingOrchestrator implements EpochProver {
     }
 
     if (!provingState.spongeBlobState) {
-      // If we are completing an empty block, initialise the provingState.
+      // If we are completing an empty block, initialize the provingState.
       // We will have 0 txs and no blob fields.
       provingState.startNewBlock(0, 0);
     }
@@ -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!;
@@ -318,8 +339,8 @@ export class ProvingOrchestrator implements EpochProver {
 
     await this.verifyBuiltBlockAgainstSyncedState(l2Block, newArchive);
 
-    logger.verbose(`Orchestrator finalised block ${l2Block.number}`);
-    provingState.block = l2Block;
+    logger.verbose(`Orchestrator finalized block ${l2Block.number}`);
+    provingState.setBlock(l2Block);
   }
 
   // Flagged as protected to disable in certain unit tests
@@ -348,9 +369,9 @@ export class ProvingOrchestrator implements EpochProver {
   /**
    * Returns the proof for the current epoch.
    */
-  public async finaliseEpoch() {
+  public async finalizeEpoch() {
     if (!this.provingState || !this.provingPromise) {
-      throw new Error(`Invalid proving state, an epoch must be proven before it can be finalised`);
+      throw new Error(`Invalid proving state, an epoch must be proven before it can be finalized`);
     }
 
     const result = await this.provingPromise!;
@@ -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 finalize`);
+    }
+    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(
-      buildBaseRollupHints(tx, provingState.globalVariables, db, provingState.spongeBlobState),
+      insertSideEffectsAndBuildBaseRollupHints(
+        tx,
+        provingState.globalVariables,
+        provingState.l1ToL2MessageTreeSnapshotAfterInsertion,
+        db,
+        provingState.spongeBlobState,
+      ),
     );
 
     this.metrics.recordBaseRollupInputs(ms);
@@ -531,7 +570,6 @@ export class ProvingOrchestrator implements EpochProver {
         }`,
         {
           [Attributes.TX_HASH]: processedTx.hash.toString(),
-          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
           [Attributes.PROTOCOL_CIRCUIT_NAME]: rollupType,
         },
         signal => {
@@ -601,7 +639,6 @@ export class ProvingOrchestrator implements EpochProver {
         'ProvingOrchestrator.prover.getTubeProof',
         {
           [Attributes.TX_HASH]: txHash,
-          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
           [Attributes.PROTOCOL_CIRCUIT_NAME]: 'tube-circuit' satisfies CircuitName,
         },
         signal => this.prover.getTubeProof(inputs, signal, this.provingState!.epochNumber),
@@ -626,7 +663,6 @@ export class ProvingOrchestrator implements EpochProver {
         this.tracer,
         'ProvingOrchestrator.prover.getMergeRollupProof',
         {
-          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
           [Attributes.PROTOCOL_CIRCUIT_NAME]: 'merge-rollup' satisfies CircuitName,
         },
         signal => this.prover.getMergeRollupProof(inputs, signal, provingState.epochNumber),
@@ -647,7 +683,7 @@ export class ProvingOrchestrator implements EpochProver {
 
     provingState.blockRootRollupStarted = true;
 
-    const { rollupType, inputs } = await provingState.getBlockRootRollupTypeAndInputs(this.proverId);
+    const { rollupType, inputs } = await provingState.getBlockRootRollupTypeAndInputs();
 
     logger.debug(
       `Enqueuing ${rollupType} for block ${provingState.blockNumber} with ${provingState.newL1ToL2Messages.length} l1 to l2 msgs.`,
@@ -659,7 +695,6 @@ export class ProvingOrchestrator implements EpochProver {
         this.tracer,
         'ProvingOrchestrator.prover.getBlockRootRollupProof',
         {
-          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
           [Attributes.PROTOCOL_CIRCUIT_NAME]: rollupType,
         },
         signal => {
@@ -674,12 +709,34 @@ export class ProvingOrchestrator implements EpochProver {
       ),
       async result => {
         provingState.setBlockRootRollupProof(result);
-        const header = await provingState.buildHeaderFromProvingOutputs(logger);
+        const header = await provingState.buildHeaderFromProvingOutputs();
         if (!(await header.hash()).equals(await provingState.block!.header.hash())) {
           logger.error(
-            `Block header mismatch\nCircuit:${inspect(header)}\nComputed:${inspect(provingState.block!.header)}`,
+            `Block header mismatch.\nCircuit: ${inspect(header)}\nComputed: ${inspect(provingState.block!.header)}`,
           );
-          provingState.reject(`Block header hash mismatch`);
+          provingState.reject(`Block header hash mismatch.`);
+        }
+
+        const dbArchiveRoot = provingState.block!.archive.root;
+        const circuitArchiveRoot = result.inputs.newArchive.root;
+        if (!dbArchiveRoot.equals(circuitArchiveRoot)) {
+          logger.error(
+            `New archive root mismatch.\nCircuit: ${result.inputs.newArchive.root}\nComputed: ${dbArchiveRoot}`,
+          );
+          provingState.reject(`New archive root mismatch.`);
+        }
+
+        const endBlobAccumulatorPublicInputs = BlobAccumulatorPublicInputs.fromBatchedBlobAccumulator(
+          provingState.endBlobAccumulator!,
+        );
+        const circuitEndBlobAccumulatorState = result.inputs.blobPublicInputs.endBlobAccumulator;
+        if (!circuitEndBlobAccumulatorState.equals(endBlobAccumulatorPublicInputs)) {
+          logger.error(
+            `Blob accumulator state mismatch.\nCircuit: ${inspect(circuitEndBlobAccumulatorState)}\nComputed: ${inspect(
+              endBlobAccumulatorPublicInputs,
+            )}`,
+          );
+          provingState.reject(`Blob accumulator state mismatch.`);
         }
 
         logger.debug(`Completed ${rollupType} proof for block ${provingState.block!.number}`);
@@ -688,7 +745,7 @@ export class ProvingOrchestrator implements EpochProver {
         const epochProvingState = this.provingState!;
         const leafLocation = epochProvingState.setBlockRootRollupProof(provingState.index, result);
         if (epochProvingState.totalNumBlocks === 1) {
-          await this.enqueueEpochPadding(epochProvingState);
+          this.enqueueEpochPadding(epochProvingState);
         } else {
           this.checkAndEnqueueNextBlockMergeRollup(epochProvingState, leafLocation);
         }
@@ -710,7 +767,6 @@ export class ProvingOrchestrator implements EpochProver {
         this.tracer,
         'ProvingOrchestrator.prover.getBaseParityProof',
         {
-          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
           [Attributes.PROTOCOL_CIRCUIT_NAME]: 'base-parity' satisfies CircuitName,
         },
         signal => this.prover.getBaseParityProof(inputs, signal, provingState.epochNumber),
@@ -746,7 +802,6 @@ export class ProvingOrchestrator implements EpochProver {
         this.tracer,
         'ProvingOrchestrator.prover.getRootParityProof',
         {
-          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
           [Attributes.PROTOCOL_CIRCUIT_NAME]: 'root-parity' satisfies CircuitName,
         },
         signal => this.prover.getRootParityProof(inputs, signal, provingState.epochNumber),
@@ -767,14 +822,12 @@ export class ProvingOrchestrator implements EpochProver {
     }
 
     const inputs = provingState.getBlockMergeRollupInputs(location);
-
     this.deferredProving(
       provingState,
       wrapCallbackInSpan(
         this.tracer,
         'ProvingOrchestrator.prover.getBlockMergeRollupProof',
         {
-          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
           [Attributes.PROTOCOL_CIRCUIT_NAME]: 'block-merge-rollup' satisfies CircuitName,
         },
         signal => this.prover.getBlockMergeRollupProof(inputs, signal, provingState.epochNumber),
@@ -786,26 +839,25 @@ export class ProvingOrchestrator implements EpochProver {
     );
   }
 
-  private async enqueueEpochPadding(provingState: EpochProvingState) {
+  private enqueueEpochPadding(provingState: EpochProvingState) {
     if (!provingState.verifyState()) {
       logger.debug('Not running epoch padding. State no longer valid.');
       return;
     }
 
-    logger.debug('Padding epoch proof with an empty block root proof.');
+    logger.debug('Padding epoch proof with a padding block root proof.');
 
-    const inputs = await provingState.getPaddingBlockRootInputs(this.proverId);
+    const inputs = provingState.getPaddingBlockRootInputs();
 
     this.deferredProving(
       provingState,
       wrapCallbackInSpan(
         this.tracer,
-        'ProvingOrchestrator.prover.getEmptyBlockRootRollupProof',
+        'ProvingOrchestrator.prover.getPaddingBlockRootRollupProof',
         {
-          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
-          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'empty-block-root-rollup' satisfies CircuitName,
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'padding-block-root-rollup' satisfies CircuitName,
         },
-        signal => this.prover.getEmptyBlockRootRollupProof(inputs, signal, provingState.epochNumber),
+        signal => this.prover.getPaddingBlockRootRollupProof(inputs, signal, provingState.epochNumber),
       ),
       result => {
         logger.debug('Completed proof for padding block root.');
@@ -824,7 +876,7 @@ export class ProvingOrchestrator implements EpochProver {
 
     logger.debug(`Preparing root rollup`);
 
-    const inputs = provingState.getRootRollupInputs(this.proverId);
+    const inputs = provingState.getRootRollupInputs();
 
     this.deferredProving(
       provingState,
@@ -832,7 +884,6 @@ export class ProvingOrchestrator implements EpochProver {
         this.tracer,
         'ProvingOrchestrator.prover.getRootRollupProof',
         {
-          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
           [Attributes.PROTOCOL_CIRCUIT_NAME]: 'root-rollup' satisfies CircuitName,
         },
         signal => this.prover.getRootRollupProof(inputs, signal, provingState.epochNumber),
@@ -859,15 +910,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,
@@ -930,21 +983,27 @@ export class ProvingOrchestrator implements EpochProver {
       async (signal: AbortSignal) => {
         const inputs = txProvingState.getAvmInputs();
         try {
-          return await this.prover.getAvmProof(inputs, signal, provingState.epochNumber);
+          // TODO(#14234)[Unconditional PIs validation]: Remove the whole try-catch logic and
+          // just keep the next line but removing the second argument (false).
+          return await this.prover.getAvmProof(inputs, false, signal, provingState.epochNumber);
         } catch (err) {
           if (process.env.AVM_PROVING_STRICT) {
             logger.error(`Error thrown when proving AVM circuit with AVM_PROVING_STRICT on`, err);
             throw err;
           } else {
             logger.warn(
-              `Error thrown when proving AVM circuit but AVM_PROVING_STRICT is off. Faking AVM proof and carrying on. ${inspect(
-                err,
-              )}.`,
+              `Error thrown when proving AVM circuit but AVM_PROVING_STRICT is off. Use snapshotted
+               AVM inputs and carrying on. ${inspect(err)}.`,
             );
-            return {
-              proof: makeEmptyRecursiveProof(AVM_PROOF_LENGTH_IN_FIELDS),
-              verificationKey: VerificationKeyData.makeFake(AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS),
-            };
+
+            try {
+              this.metrics.incAvmFallback();
+              const snapshotAvmPrivateInputs = readAvmMinimalPublicTxInputsFromFile();
+              return await this.prover.getAvmProof(snapshotAvmPrivateInputs, true, signal, provingState.epochNumber);
+            } catch (err) {
+              logger.error(`Error thrown when proving snapshotted AVM inputs.`, err);
+              throw err;
+            }
           }
         }
       },

package/src/orchestrator/orchestrator_metrics.ts

@@ -1,9 +1,17 @@
-import { type Histogram, Metrics, type TelemetryClient, type Tracer, ValueType } from '@aztec/telemetry-client';
+import {
+  type Histogram,
+  Metrics,
+  type TelemetryClient,
+  type Tracer,
+  type UpDownCounter,
+  ValueType,
+} from '@aztec/telemetry-client';
 
 export class ProvingOrchestratorMetrics {
   public readonly tracer: Tracer;
 
   private baseRollupInputsDuration: Histogram;
+  private avmFallbackCount: UpDownCounter;
 
   constructor(client: TelemetryClient, name = 'ProvingOrchestrator') {
     this.tracer = client.getTracer(name);
@@ -14,9 +22,20 @@ export class ProvingOrchestratorMetrics {
       description: 'Duration to build base rollup inputs',
       valueType: ValueType.INT,
     });
+
+    this.avmFallbackCount = meter.createUpDownCounter(Metrics.PROVING_ORCHESTRATOR_AVM_FALLBACK_COUNT, {
+      description: 'How many times the AVM fallback was used',
+      valueType: ValueType.INT,
+    });
+
+    this.avmFallbackCount.add(0);
   }
 
   recordBaseRollupInputs(durationMs: number) {
     this.baseRollupInputsDuration.record(Math.ceil(durationMs));
   }
+
+  incAvmFallback() {
+    this.avmFallbackCount.add(1);
+  }
 }

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

@@ -1,5 +1,11 @@
-import { type AVM_PROOF_LENGTH_IN_FIELDS, AVM_VK_INDEX, type TUBE_PROOF_LENGTH, TUBE_VK_INDEX } from '@aztec/constants';
-import { getVKIndex, getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import {
+  AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
+  AVM_VK_INDEX,
+  PRIVATE_TUBE_VK_INDEX,
+  PUBLIC_TUBE_VK_INDEX,
+  type TUBE_PROOF_LENGTH,
+} from '@aztec/constants';
+import { getVKSiblingPath } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import type { AvmCircuitInputs } from '@aztec/stdlib/avm';
 import type { ProofAndVerificationKey } from '@aztec/stdlib/interfaces/server';
 import {
@@ -16,7 +22,7 @@ import {
 import type { CircuitName } from '@aztec/stdlib/stats';
 import type { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
 import type { ProcessedTx } from '@aztec/stdlib/tx';
-import { VkWitnessData } from '@aztec/stdlib/vks';
+import { VerificationKeyData, VkData } from '@aztec/stdlib/vks';
 
 /**
  * Helper class to manage the proving cycle of a transaction
@@ -25,7 +31,7 @@ import { VkWitnessData } from '@aztec/stdlib/vks';
  */
 export class TxProvingState {
   private tube?: ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>;
-  private avm?: ProofAndVerificationKey<typeof AVM_PROOF_LENGTH_IN_FIELDS>;
+  private avm?: ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>;
 
   constructor(
     public readonly processedTx: ProcessedTx,
@@ -42,7 +48,7 @@ export class TxProvingState {
   }
 
   public getTubeInputs() {
-    return new TubeInputs(this.processedTx.clientIvcProof);
+    return new TubeInputs(!!this.processedTx.data.forPublic, this.processedTx.clientIvcProof);
   }
 
   public getAvmInputs(): AvmCircuitInputs {
@@ -67,7 +73,7 @@ export class TxProvingState {
     this.tube = tubeProofAndVk;
   }
 
-  public setAvmProof(avmProofAndVk: ProofAndVerificationKey<typeof AVM_PROOF_LENGTH_IN_FIELDS>) {
+  public setAvmProof(avmProofAndVk: ProofAndVerificationKey<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>) {
     this.avm = avmProofAndVk;
   }
 
@@ -76,7 +82,7 @@ export class TxProvingState {
       throw new Error('Tx not ready for proving base rollup.');
     }
 
-    const vkData = this.#getTubeVkData();
+    const vkData = this.#getVkData(this.tube!.verificationKey, PRIVATE_TUBE_VK_INDEX);
     const tubeData = new PrivateTubeData(
       this.processedTx.data.toPrivateToRollupKernelCircuitPublicInputs(),
       this.tube.proof,
@@ -103,13 +109,13 @@ export class TxProvingState {
     const tubeData = new PublicTubeData(
       this.processedTx.data.toPrivateToPublicKernelCircuitPublicInputs(),
       this.tube.proof,
-      this.#getTubeVkData(),
+      this.#getVkData(this.tube!.verificationKey, PUBLIC_TUBE_VK_INDEX),
     );
 
     const avmProofData = new AvmProofData(
       this.processedTx.avmProvingRequest.inputs.publicInputs,
       this.avm.proof,
-      this.#getAvmVkData(),
+      this.#getVkData(this.avm!.verificationKey, AVM_VK_INDEX),
     );
 
     if (!(this.baseRollupHints instanceof PublicBaseRollupHints)) {
@@ -119,21 +125,8 @@ export class TxProvingState {
     return new PublicBaseRollupInputs(tubeData, avmProofData, this.baseRollupHints);
   }
 
-  #getTubeVkData() {
-    let vkIndex = TUBE_VK_INDEX;
-    try {
-      vkIndex = getVKIndex(this.tube!.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
-    }
-    const vkPath = getVKSiblingPath(vkIndex);
-
-    return new VkWitnessData(this.tube!.verificationKey, vkIndex, vkPath);
-  }
-
-  #getAvmVkData() {
-    const vkIndex = AVM_VK_INDEX;
+  #getVkData(verificationKey: VerificationKeyData, vkIndex: number) {
     const vkPath = getVKSiblingPath(vkIndex);
-    return new VkWitnessData(this.avm!.verificationKey, AVM_VK_INDEX, vkPath);
+    return new VkData(verificationKey, vkIndex, vkPath);
   }
 }

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

@@ -1,17 +1,18 @@
 import { type ACVMConfig, type BBConfig, BBNativeRollupProver, TestCircuitProver } from '@aztec/bb-prover';
 import { times } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
+import type { EthAddress } from '@aztec/foundation/eth-address';
 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';
 
@@ -48,8 +49,8 @@ export class ProverClient implements EpochProverManager {
     return new ServerEpochProver(facade, orchestrator);
   }
 
-  public getProverId(): Fr {
-    return this.config.proverId ?? Fr.ZERO;
+  public getProverId(): EthAddress {
+    return this.config.proverId;
   }
 
   async updateProverConfig(config: Partial<ProverClientConfig>): Promise<void> {
@@ -87,6 +88,7 @@ export class ProverClient implements EpochProverManager {
     }
     this.running = false;
     await this.stopAgents();
+    await tryStop(this.orchestratorClient);
   }
 
   /**
@@ -154,9 +156,9 @@ export function buildServerCircuitProver(
     return BBNativeRollupProver.new(config, telemetry);
   }
 
-  const simulationProvider = config.acvmBinaryPath
+  const simulator = config.acvmBinaryPath
     ? new NativeACVMSimulator(config.acvmWorkingDirectory, config.acvmBinaryPath)
     : undefined;
 
-  return Promise.resolve(new TestCircuitProver(simulationProvider, config, telemetry));
+  return Promise.resolve(new TestCircuitProver(simulator, config, telemetry));
 }