@aztec/prover-client 0.71.0 → 0.73.0

package/src/orchestrator/orchestrator.ts

@@ -18,16 +18,13 @@ import {
   AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS,
   type AppendOnlyTreeSnapshot,
   BaseParityInputs,
-  BlockHeader,
-  ContentCommitment,
+  type BlockHeader,
   Fr,
-  GlobalVariables,
+  type GlobalVariables,
   L1_TO_L2_MSG_SUBTREE_HEIGHT,
   L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
   NUM_BASE_PARITY_PER_ROOT_PARITY,
-  PartialStateReference,
-  StateReference,
   type TUBE_PROOF_LENGTH,
   VerificationKeyData,
   makeEmptyRecursiveProof,
@@ -39,12 +36,11 @@ import {
   SingleTxBlockRootRollupInputs,
   TubeInputs,
 } from '@aztec/circuits.js/rollup';
-import { makeTuple } from '@aztec/foundation/array';
-import { padArrayEnd } from '@aztec/foundation/collection';
+import { padArrayEnd, timesParallel } from '@aztec/foundation/collection';
 import { AbortError } from '@aztec/foundation/error';
 import { createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
-import { type Tuple } from '@aztec/foundation/serialize';
+import { assertLength } from '@aztec/foundation/serialize';
 import { pushTestData } from '@aztec/foundation/testing';
 import { elapsed } from '@aztec/foundation/timer';
 import { type TreeNodeLocation } from '@aztec/foundation/trees';
@@ -140,7 +136,7 @@ export class ProvingOrchestrator implements EpochProver {
   @trackSpan('ProvingOrchestrator.startNewBlock', globalVariables => ({
     [Attributes.BLOCK_NUMBER]: globalVariables.blockNumber.toNumber(),
   }))
-  public async startNewBlock(globalVariables: GlobalVariables, l1ToL2Messages: Fr[]) {
+  public async startNewBlock(globalVariables: GlobalVariables, l1ToL2Messages: Fr[], previousBlockHeader: BlockHeader) {
     if (!this.provingState) {
       throw new Error(`Invalid proving state, call startNewEpoch before starting a block`);
     }
@@ -158,70 +154,21 @@ export class ProvingOrchestrator implements EpochProver {
     this.dbs.set(globalVariables.blockNumber.toNumber(), db);
 
     // we start the block by enqueueing all of the base parity circuits
-    let baseParityInputs: BaseParityInputs[] = [];
-    let l1ToL2MessagesPadded: Tuple<Fr, typeof NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP>;
-    try {
-      l1ToL2MessagesPadded = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
-    } catch (err) {
-      throw new Error('Too many L1 to L2 messages');
-    }
-    baseParityInputs = Array.from({ length: NUM_BASE_PARITY_PER_ROOT_PARITY }, (_, i) =>
-      BaseParityInputs.fromSlice(l1ToL2MessagesPadded, i, getVKTreeRoot()),
-    );
-
-    const messageTreeSnapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
-
-    const newL1ToL2MessageTreeRootSiblingPathArray = await getSubtreeSiblingPath(
-      MerkleTreeId.L1_TO_L2_MESSAGE_TREE,
-      L1_TO_L2_MSG_SUBTREE_HEIGHT,
-      db,
-    );
-
-    const newL1ToL2MessageTreeRootSiblingPath = makeTuple(
-      L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
-      i =>
-        i < newL1ToL2MessageTreeRootSiblingPathArray.length ? newL1ToL2MessageTreeRootSiblingPathArray[i] : Fr.ZERO,
-      0,
-    );
-
-    // Update the local trees to include the new l1 to l2 messages
-    await db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
-    const messageTreeSnapshotAfterInsertion = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
+    const { l1ToL2MessageSubtreeSiblingPath, l1ToL2MessageTreeSnapshotAfterInsertion, baseParityInputs } =
+      await this.prepareBaseParityInputs(l1ToL2Messages, db);
 
     // Get archive snapshot before this block lands
-    const startArchiveSnapshot = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
+    const lastArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
     const newArchiveSiblingPath = await getRootTreeSiblingPath(MerkleTreeId.ARCHIVE, db);
-    const previousBlockHash = await db.getLeafValue(
-      MerkleTreeId.ARCHIVE,
-      BigInt(startArchiveSnapshot.nextAvailableLeafIndex - 1),
-    );
-
-    const partial = new PartialStateReference(
-      await getTreeSnapshot(MerkleTreeId.NOTE_HASH_TREE, db),
-      await getTreeSnapshot(MerkleTreeId.NULLIFIER_TREE, db),
-      await getTreeSnapshot(MerkleTreeId.PUBLIC_DATA_TREE, db),
-    );
-    const state = new StateReference(messageTreeSnapshot, partial);
-    // TODO: Construct the full previousBlockHeader.
-    const previousBlockHeader = BlockHeader.from({
-      lastArchive: startArchiveSnapshot,
-      contentCommitment: ContentCommitment.empty(),
-      state,
-      globalVariables: GlobalVariables.empty(),
-      totalFees: Fr.ZERO,
-      totalManaUsed: Fr.ZERO,
-    });
 
     const blockProvingState = this.provingState!.startNewBlock(
       globalVariables,
-      l1ToL2MessagesPadded,
-      messageTreeSnapshot,
-      newL1ToL2MessageTreeRootSiblingPath,
-      messageTreeSnapshotAfterInsertion,
-      startArchiveSnapshot,
+      l1ToL2Messages,
+      l1ToL2MessageSubtreeSiblingPath,
+      l1ToL2MessageTreeSnapshotAfterInsertion,
+      lastArchive,
       newArchiveSiblingPath,
       previousBlockHeader,
-      previousBlockHash!,
     );
 
     // Enqueue base parity circuits for the block
@@ -291,16 +238,16 @@ 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 startTubeCircuits(txs: Tx[]) {
+  public async 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 = tx.getTxHash().toString();
+      const txHash = (await tx.getTxHash()).toString();
       const tubeInputs = new TubeInputs(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.doEnqueueTube(txHash, tubeInputs, proof => Promise.resolve(tubeProof.resolve(proof)));
       this.provingState?.cachedTubeProofs.set(txHash, tubeProof.promise);
     }
   }
@@ -333,7 +280,7 @@ export class ProvingOrchestrator implements EpochProver {
     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);
+    await this.checkAndEnqueueBlockRootRollup(provingState);
     return provingState.block!;
   }
 
@@ -367,7 +314,9 @@ export class ProvingOrchestrator implements EpochProver {
       throw new Error('Block header mismatch');
     }
 
-    logger.verbose(`Updating archive tree with block ${provingState.blockNumber} header ${header.hash().toString()}`);
+    logger.verbose(
+      `Updating archive tree with block ${provingState.blockNumber} header ${(await header.hash()).toString()}`,
+    );
     await db.updateArchive(header);
 
     // Assemble the L2 block
@@ -499,7 +448,34 @@ export class ProvingOrchestrator implements EpochProver {
     };
 
     // let the callstack unwind before adding the job to the queue
-    setImmediate(safeJob);
+    setImmediate(() => void safeJob());
+  }
+
+  private async prepareBaseParityInputs(l1ToL2Messages: Fr[], db: MerkleTreeWriteOperations) {
+    const l1ToL2MessagesPadded = padArrayEnd(
+      l1ToL2Messages,
+      Fr.ZERO,
+      NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
+      'Too many L1 to L2 messages',
+    );
+    const baseParityInputs = await timesParallel(NUM_BASE_PARITY_PER_ROOT_PARITY, async i =>
+      BaseParityInputs.fromSlice(l1ToL2MessagesPadded, i, await getVKTreeRoot()),
+    );
+
+    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,
+    );
+
+    // Update the local trees to include the new l1 to l2 messages
+    await db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
+    const l1ToL2MessageTreeSnapshotAfterInsertion = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
+
+    return {
+      l1ToL2MessageSubtreeSiblingPath,
+      l1ToL2MessageTreeSnapshotAfterInsertion,
+      baseParityInputs,
+    };
   }
 
   // Updates the merkle trees for a transaction. The first enqueued job for a transaction
@@ -541,7 +517,7 @@ export class ProvingOrchestrator implements EpochProver {
 
   // Executes the base rollup circuit and stored the output as intermediate state for the parent merge/root circuit
   // Executes the next level of merge if all inputs are available
-  private enqueueBaseRollup(provingState: BlockProvingState, txIndex: number) {
+  private async enqueueBaseRollup(provingState: BlockProvingState, txIndex: number) {
     if (!provingState.verifyState()) {
       logger.debug('Not running base rollup, state invalid');
       return;
@@ -549,7 +525,7 @@ export class ProvingOrchestrator implements EpochProver {
 
     const txProvingState = provingState.getTxProvingState(txIndex);
     const { processedTx } = txProvingState;
-    const { rollupType, inputs } = txProvingState.getBaseRollupTypeAndInputs();
+    const { rollupType, inputs } = await txProvingState.getBaseRollupTypeAndInputs();
 
     logger.debug(`Enqueuing deferred proving base rollup for ${processedTx.hash.toString()}`);
 
@@ -573,14 +549,14 @@ export class ProvingOrchestrator implements EpochProver {
           }
         },
       ),
-      result => {
+      async result => {
         logger.debug(`Completed proof for ${rollupType} for tx ${processedTx.hash.toString()}`);
         validatePartialState(result.inputs.end, txProvingState.treeSnapshots);
         const leafLocation = provingState.setBaseRollupProof(txIndex, result);
         if (provingState.totalNumTxs === 1) {
-          this.checkAndEnqueueBlockRootRollup(provingState);
+          await this.checkAndEnqueueBlockRootRollup(provingState);
         } else {
-          this.checkAndEnqueueNextMergeRollup(provingState, leafLocation);
+          await this.checkAndEnqueueNextMergeRollup(provingState, leafLocation);
         }
       },
     );
@@ -597,11 +573,11 @@ export class ProvingOrchestrator implements EpochProver {
     const txProvingState = provingState.getTxProvingState(txIndex);
     const txHash = txProvingState.processedTx.hash.toString();
 
-    const handleResult = (result: ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>) => {
+    const handleResult = async (result: ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>) => {
       logger.debug(`Got tube proof for tx index: ${txIndex}`, { txHash });
       txProvingState.setTubeProof(result);
       this.provingState?.cachedTubeProofs.delete(txHash);
-      this.checkAndEnqueueNextTxCircuit(provingState, txIndex);
+      await this.checkAndEnqueueNextTxCircuit(provingState, txIndex);
     };
 
     if (this.provingState?.cachedTubeProofs.has(txHash)) {
@@ -617,7 +593,7 @@ export class ProvingOrchestrator implements EpochProver {
   private doEnqueueTube(
     txHash: string,
     inputs: TubeInputs,
-    handler: (result: ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>) => void,
+    handler: (result: ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>) => Promise<void>,
     provingState: EpochProvingState | BlockProvingState = this.provingState!,
   ) {
     if (!provingState?.verifyState()) {
@@ -643,13 +619,13 @@ export class ProvingOrchestrator implements EpochProver {
 
   // Executes the merge rollup circuit and stored the output as intermediate state for the parent merge/block root circuit
   // Enqueues the next level of merge if all inputs are available
-  private enqueueMergeRollup(provingState: BlockProvingState, location: TreeNodeLocation) {
+  private async enqueueMergeRollup(provingState: BlockProvingState, location: TreeNodeLocation) {
     if (!provingState.verifyState()) {
       logger.debug('Not running merge rollup. State no longer valid.');
       return;
     }
 
-    const inputs = provingState.getMergeRollupInputs(location);
+    const inputs = await provingState.getMergeRollupInputs(location);
 
     this.deferredProving(
       provingState,
@@ -662,15 +638,15 @@ export class ProvingOrchestrator implements EpochProver {
         },
         signal => this.prover.getMergeRollupProof(inputs, signal, provingState.epochNumber),
       ),
-      result => {
+      async result => {
         provingState.setMergeRollupProof(location, result);
-        this.checkAndEnqueueNextMergeRollup(provingState, location);
+        await this.checkAndEnqueueNextMergeRollup(provingState, location);
       },
     );
   }
 
   // Executes the block root rollup circuit
-  private enqueueBlockRootRollup(provingState: BlockProvingState) {
+  private async enqueueBlockRootRollup(provingState: BlockProvingState) {
     if (!provingState.verifyState()) {
       logger.debug('Not running block root rollup, state no longer valid');
       return;
@@ -678,7 +654,7 @@ export class ProvingOrchestrator implements EpochProver {
 
     provingState.blockRootRollupStarted = true;
 
-    const { rollupType, inputs } = provingState.getBlockRootRollupTypeAndInputs(this.proverId);
+    const { rollupType, inputs } = await provingState.getBlockRootRollupTypeAndInputs(this.proverId);
 
     logger.debug(
       `Enqueuing ${rollupType} for block ${provingState.blockNumber} with ${provingState.newL1ToL2Messages.length} l1 to l2 msgs.`,
@@ -703,10 +679,10 @@ export class ProvingOrchestrator implements EpochProver {
           }
         },
       ),
-      result => {
+      async result => {
         provingState.setBlockRootRollupProof(result);
-        const header = provingState.buildHeaderFromProvingOutputs(logger);
-        if (!header.hash().equals(provingState.block!.header.hash())) {
+        const header = await provingState.buildHeaderFromProvingOutputs(logger);
+        if (!(await header.hash()).equals(await provingState.block!.header.hash())) {
           logger.error(
             `Block header mismatch\nCircuit:${inspect(header)}\nComputed:${inspect(provingState.block!.header)}`,
           );
@@ -719,9 +695,9 @@ export class ProvingOrchestrator implements EpochProver {
         const epochProvingState = this.provingState!;
         const leafLocation = epochProvingState.setBlockRootRollupProof(provingState.index, result);
         if (epochProvingState.totalNumBlocks === 1) {
-          this.enqueueEpochPadding(epochProvingState);
+          await this.enqueueEpochPadding(epochProvingState);
         } else {
-          this.checkAndEnqueueNextBlockMergeRollup(epochProvingState, leafLocation);
+          await this.checkAndEnqueueNextBlockMergeRollup(epochProvingState, leafLocation);
         }
       },
     );
@@ -746,30 +722,30 @@ export class ProvingOrchestrator implements EpochProver {
         },
         signal => this.prover.getBaseParityProof(inputs, signal, provingState.epochNumber),
       ),
-      provingOutput => {
+      async provingOutput => {
         provingState.setBaseParityProof(index, provingOutput);
-        this.checkAndEnqueueRootParityCircuit(provingState);
+        await this.checkAndEnqueueRootParityCircuit(provingState);
       },
     );
   }
 
-  private checkAndEnqueueRootParityCircuit(provingState: BlockProvingState) {
+  private async checkAndEnqueueRootParityCircuit(provingState: BlockProvingState) {
     if (!provingState.isReadyForRootParity()) {
       return;
     }
 
-    this.enqueueRootParityCircuit(provingState);
+    await this.enqueueRootParityCircuit(provingState);
   }
 
   // Runs the root parity circuit ans stored the outputs
   // Enqueues the root rollup proof if all inputs are available
-  private enqueueRootParityCircuit(provingState: BlockProvingState) {
+  private async enqueueRootParityCircuit(provingState: BlockProvingState) {
     if (!provingState.verifyState()) {
       logger.debug('Not running root parity. State no longer valid.');
       return;
     }
 
-    const inputs = provingState.getRootParityInputs();
+    const inputs = await provingState.getRootParityInputs();
 
     this.deferredProving(
       provingState,
@@ -782,22 +758,22 @@ export class ProvingOrchestrator implements EpochProver {
         },
         signal => this.prover.getRootParityProof(inputs, signal, provingState.epochNumber),
       ),
-      result => {
+      async result => {
         provingState.setRootParityProof(result);
-        this.checkAndEnqueueBlockRootRollup(provingState);
+        await this.checkAndEnqueueBlockRootRollup(provingState);
       },
     );
   }
 
   // Executes the block merge rollup circuit and stored the output as intermediate state for the parent merge/block root circuit
   // Enqueues the next level of merge if all inputs are available
-  private enqueueBlockMergeRollup(provingState: EpochProvingState, location: TreeNodeLocation) {
+  private async enqueueBlockMergeRollup(provingState: EpochProvingState, location: TreeNodeLocation) {
     if (!provingState.verifyState()) {
       logger.debug('Not running block merge rollup. State no longer valid.');
       return;
     }
 
-    const inputs = provingState.getBlockMergeRollupInputs(location);
+    const inputs = await provingState.getBlockMergeRollupInputs(location);
 
     this.deferredProving(
       provingState,
@@ -810,14 +786,14 @@ export class ProvingOrchestrator implements EpochProver {
         },
         signal => this.prover.getBlockMergeRollupProof(inputs, signal, provingState.epochNumber),
       ),
-      result => {
+      async result => {
         provingState.setBlockMergeRollupProof(location, result);
-        this.checkAndEnqueueNextBlockMergeRollup(provingState, location);
+        await this.checkAndEnqueueNextBlockMergeRollup(provingState, location);
       },
     );
   }
 
-  private enqueueEpochPadding(provingState: EpochProvingState) {
+  private async enqueueEpochPadding(provingState: EpochProvingState) {
     if (!provingState.verifyState()) {
       logger.debug('Not running epoch padding. State no longer valid.');
       return;
@@ -825,7 +801,7 @@ export class ProvingOrchestrator implements EpochProver {
 
     logger.debug('Padding epoch proof with an empty block root proof.');
 
-    const inputs = provingState.getPaddingBlockRootInputs(this.proverId);
+    const inputs = await provingState.getPaddingBlockRootInputs(this.proverId);
 
     this.deferredProving(
       provingState,
@@ -838,16 +814,16 @@ export class ProvingOrchestrator implements EpochProver {
         },
         signal => this.prover.getEmptyBlockRootRollupProof(inputs, signal, provingState.epochNumber),
       ),
-      result => {
+      async result => {
         logger.debug('Completed proof for padding block root.');
         provingState.setPaddingBlockRootProof(result);
-        this.checkAndEnqueueRootRollup(provingState);
+        await this.checkAndEnqueueRootRollup(provingState);
       },
     );
   }
 
   // Executes the root rollup circuit
-  private enqueueRootRollup(provingState: EpochProvingState) {
+  private async enqueueRootRollup(provingState: EpochProvingState) {
     if (!provingState.verifyState()) {
       logger.debug('Not running root rollup, state no longer valid');
       return;
@@ -855,7 +831,7 @@ export class ProvingOrchestrator implements EpochProver {
 
     logger.debug(`Preparing root rollup`);
 
-    const inputs = provingState.getRootRollupInputs(this.proverId);
+    const inputs = await provingState.getRootRollupInputs(this.proverId);
 
     this.deferredProving(
       provingState,
@@ -876,20 +852,20 @@ export class ProvingOrchestrator implements EpochProver {
     );
   }
 
-  private checkAndEnqueueNextMergeRollup(provingState: BlockProvingState, currentLocation: TreeNodeLocation) {
+  private async checkAndEnqueueNextMergeRollup(provingState: BlockProvingState, currentLocation: TreeNodeLocation) {
     if (!provingState.isReadyForMergeRollup(currentLocation)) {
       return;
     }
 
     const parentLocation = provingState.getParentLocation(currentLocation);
     if (parentLocation.level === 0) {
-      this.checkAndEnqueueBlockRootRollup(provingState);
+      await this.checkAndEnqueueBlockRootRollup(provingState);
     } else {
-      this.enqueueMergeRollup(provingState, parentLocation);
+      await this.enqueueMergeRollup(provingState, parentLocation);
     }
   }
 
-  private checkAndEnqueueBlockRootRollup(provingState: BlockProvingState) {
+  private async checkAndEnqueueBlockRootRollup(provingState: BlockProvingState) {
     if (!provingState.isReadyForBlockRootRollup()) {
       logger.debug('Not ready for root rollup');
       return;
@@ -911,29 +887,32 @@ export class ProvingOrchestrator implements EpochProver {
       .then(() => this.dbs.delete(blockNumber))
       .catch(err => logger.error(`Error closing db for block ${blockNumber}`, err));
 
-    this.enqueueBlockRootRollup(provingState);
+    await this.enqueueBlockRootRollup(provingState);
   }
 
-  private checkAndEnqueueNextBlockMergeRollup(provingState: EpochProvingState, currentLocation: TreeNodeLocation) {
+  private async checkAndEnqueueNextBlockMergeRollup(
+    provingState: EpochProvingState,
+    currentLocation: TreeNodeLocation,
+  ) {
     if (!provingState.isReadyForBlockMerge(currentLocation)) {
       return;
     }
 
     const parentLocation = provingState.getParentLocation(currentLocation);
     if (parentLocation.level === 0) {
-      this.checkAndEnqueueRootRollup(provingState);
+      await this.checkAndEnqueueRootRollup(provingState);
     } else {
-      this.enqueueBlockMergeRollup(provingState, parentLocation);
+      await this.enqueueBlockMergeRollup(provingState, parentLocation);
     }
   }
 
-  private checkAndEnqueueRootRollup(provingState: EpochProvingState) {
+  private async checkAndEnqueueRootRollup(provingState: EpochProvingState) {
     if (!provingState.isReadyForRootRollup()) {
       logger.debug('Not ready for root rollup');
       return;
     }
 
-    this.enqueueRootRollup(provingState);
+    await this.enqueueRootRollup(provingState);
   }
 
   /**
@@ -981,14 +960,14 @@ export class ProvingOrchestrator implements EpochProver {
       },
     );
 
-    this.deferredProving(provingState, doAvmProving, proofAndVk => {
+    this.deferredProving(provingState, doAvmProving, async proofAndVk => {
       logger.debug(`Proven VM for tx index: ${txIndex}`);
       txProvingState.setAvmProof(proofAndVk);
-      this.checkAndEnqueueNextTxCircuit(provingState, txIndex);
+      await this.checkAndEnqueueNextTxCircuit(provingState, txIndex);
     });
   }
 
-  private checkAndEnqueueNextTxCircuit(provingState: BlockProvingState, txIndex: number) {
+  private async checkAndEnqueueNextTxCircuit(provingState: BlockProvingState, txIndex: number) {
     const txProvingState = provingState.getTxProvingState(txIndex);
     if (!txProvingState.ready()) {
       return;
@@ -997,6 +976,6 @@ export class ProvingOrchestrator implements EpochProver {
     // We must have completed all proving (tube proof and (if required) vm proof are generated), we now move to the base rollup.
     logger.debug(`Public functions completed for tx ${txIndex} enqueueing base rollup`);
 
-    this.enqueueBaseRollup(provingState, txIndex);
+    await this.enqueueBaseRollup(provingState, txIndex);
   }
 }

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

@@ -52,16 +52,16 @@ export class TxProvingState {
     return this.processedTx.avmProvingRequest!.inputs;
   }
 
-  public getBaseRollupTypeAndInputs() {
+  public async getBaseRollupTypeAndInputs() {
     if (this.requireAvmProof) {
       return {
         rollupType: 'public-base-rollup' satisfies CircuitName,
-        inputs: this.#getPublicBaseInputs(),
+        inputs: await this.#getPublicBaseInputs(),
       };
     } else {
       return {
         rollupType: 'private-base-rollup' satisfies CircuitName,
-        inputs: this.#getPrivateBaseInputs(),
+        inputs: await this.#getPrivateBaseInputs(),
       };
     }
   }
@@ -74,12 +74,12 @@ export class TxProvingState {
     this.avm = avmProofAndVk;
   }
 
-  #getPrivateBaseInputs() {
+  async #getPrivateBaseInputs() {
     if (!this.tube) {
       throw new Error('Tx not ready for proving base rollup.');
     }
 
-    const vkData = this.#getTubeVkData();
+    const vkData = await this.#getTubeVkData();
     const tubeData = new PrivateTubeData(
       this.processedTx.data.toPrivateToRollupKernelCircuitPublicInputs(),
       this.tube.proof,
@@ -92,7 +92,7 @@ export class TxProvingState {
     return new PrivateBaseRollupInputs(tubeData, this.baseRollupHints);
   }
 
-  #getPublicBaseInputs() {
+  async #getPublicBaseInputs() {
     if (!this.processedTx.avmProvingRequest) {
       throw new Error('Should create private base rollup for a tx not requiring avm proof.');
     }
@@ -106,13 +106,13 @@ export class TxProvingState {
     const tubeData = new PublicTubeData(
       this.processedTx.data.toPrivateToPublicKernelCircuitPublicInputs(),
       this.tube.proof,
-      this.#getTubeVkData(),
+      await this.#getTubeVkData(),
     );
 
     const avmProofData = new AvmProofData(
-      this.processedTx.avmProvingRequest.inputs.output,
+      this.processedTx.avmProvingRequest.inputs.publicInputs,
       this.avm.proof,
-      this.#getAvmVkData(),
+      await this.#getAvmVkData(),
     );
 
     if (!(this.baseRollupHints instanceof PublicBaseRollupHints)) {
@@ -122,21 +122,21 @@ export class TxProvingState {
     return new PublicBaseRollupInputs(tubeData, avmProofData, this.baseRollupHints);
   }
 
-  #getTubeVkData() {
+  async #getTubeVkData() {
     let vkIndex = TUBE_VK_INDEX;
     try {
-      vkIndex = getVKIndex(this.tube!.verificationKey);
+      vkIndex = await 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);
+    const vkPath = await getVKSiblingPath(vkIndex);
 
     return new VkWitnessData(this.tube!.verificationKey, vkIndex, vkPath);
   }
 
-  #getAvmVkData() {
+  async #getAvmVkData() {
     const vkIndex = AVM_VK_INDEX;
-    const vkPath = getVKSiblingPath(vkIndex);
+    const vkPath = await getVKSiblingPath(vkIndex);
     return new VkWitnessData(this.avm!.verificationKey, AVM_VK_INDEX, vkPath);
   }
 }

package/src/prover-agent/rpc.ts

@@ -1,14 +1,14 @@
 import { ProverAgentApiSchema, type ProvingJobSource, ProvingJobSourceSchema } from '@aztec/circuit-types';
-import { createSafeJsonRpcClient, makeFetch } from '@aztec/foundation/json-rpc/client';
-import { createSafeJsonRpcServer } from '@aztec/foundation/json-rpc/server';
+import { createSafeJsonRpcClient } from '@aztec/foundation/json-rpc/client';
+import { createTracedJsonRpcServer, makeTracedFetch } from '@aztec/telemetry-client';
 
 import { type ProverAgent } from './prover-agent.js';
 
 export function createProvingJobSourceServer(queue: ProvingJobSource) {
-  return createSafeJsonRpcServer(queue, ProvingJobSourceSchema);
+  return createTracedJsonRpcServer(queue, ProvingJobSourceSchema);
 }
 
-export function createProvingJobSourceClient(url: string, fetch = makeFetch([1, 2, 3], false)): ProvingJobSource {
+export function createProvingJobSourceClient(url: string, fetch = makeTracedFetch([1, 2, 3], false)): ProvingJobSource {
   return createSafeJsonRpcClient(url, ProvingJobSourceSchema, false, 'provingJobSource', fetch);
 }
 
@@ -18,5 +18,5 @@ export function createProvingJobSourceClient(url: string, fetch = makeFetch([1,
  * @returns An JSON-RPC HTTP server
  */
 export function createProverAgentRpcServer(agent: ProverAgent) {
-  return createSafeJsonRpcServer(agent, ProverAgentApiSchema);
+  return createTracedJsonRpcServer(agent, ProverAgentApiSchema);
 }

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

@@ -13,8 +13,8 @@ export class ServerEpochProver implements EpochProver {
     this.orchestrator.startNewEpoch(epochNumber, firstBlockNumber, totalNumBlocks);
     this.facade.start();
   }
-  startTubeCircuits(txs: Tx[]): void {
-    this.orchestrator.startTubeCircuits(txs);
+  startTubeCircuits(txs: Tx[]): Promise<void> {
+    return this.orchestrator.startTubeCircuits(txs);
   }
   setBlockCompleted(blockNumber: number, expectedBlockHeader?: BlockHeader): Promise<L2Block> {
     return this.orchestrator.setBlockCompleted(blockNumber, expectedBlockHeader);
@@ -35,8 +35,12 @@ export class ServerEpochProver implements EpochProver {
     await this.facade.stop();
     await this.orchestrator.stop();
   }
-  startNewBlock(globalVariables: GlobalVariables, l1ToL2Messages: Fr[]): Promise<void> {
-    return this.orchestrator.startNewBlock(globalVariables, l1ToL2Messages);
+  startNewBlock(
+    globalVariables: GlobalVariables,
+    l1ToL2Messages: Fr[],
+    previousBlockHeader: BlockHeader,
+  ): Promise<void> {
+    return this.orchestrator.startNewBlock(globalVariables, l1ToL2Messages, previousBlockHeader);
   }
   addTxs(txs: ProcessedTx[]): Promise<void> {
     return this.orchestrator.addTxs(txs);