@aztec/prover-client 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2 → 0.76.0

package/src/orchestrator/block-building-helpers.ts

@@ -16,7 +16,6 @@ import {
   type GlobalVariables,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
-  MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   MembershipWitness,
   MerkleTreeCalculator,
   NOTE_HASH_SUBTREE_HEIGHT,
@@ -42,7 +41,6 @@ import {
   PrivateBaseRollupHints,
   PrivateBaseStateDiffHints,
   PublicBaseRollupHints,
-  PublicBaseStateDiffHints,
 } from '@aztec/circuits.js/rollup';
 import { makeTuple } from '@aztec/foundation/array';
 import { padArrayEnd } from '@aztec/foundation/collection';
@@ -139,39 +137,6 @@ export const buildBaseRollupHints = runInSpan(
     await startSpongeBlob.absorb(tx.txEffect.toBlobFields());
 
     if (tx.avmProvingRequest) {
-      // Build public base rollup hints
-      const stateDiffHints = PublicBaseStateDiffHints.from({
-        nullifierPredecessorPreimages: makeTuple(MAX_NULLIFIERS_PER_TX, i =>
-          i < nullifierWitnessLeaves.length
-            ? (nullifierWitnessLeaves[i].leafPreimage as NullifierLeafPreimage)
-            : NullifierLeafPreimage.empty(),
-        ),
-        nullifierPredecessorMembershipWitnesses: makeTuple(MAX_NULLIFIERS_PER_TX, i =>
-          i < nullifierPredecessorMembershipWitnessesWithoutPadding.length
-            ? nullifierPredecessorMembershipWitnessesWithoutPadding[i]
-            : makeEmptyMembershipWitness(NULLIFIER_TREE_HEIGHT),
-        ),
-        sortedNullifiers: makeTuple(MAX_NULLIFIERS_PER_TX, i => Fr.fromBuffer(sortednullifiers[i])),
-        sortedNullifierIndexes: makeTuple(MAX_NULLIFIERS_PER_TX, i => sortedNewLeavesIndexes[i]),
-        noteHashSubtreeSiblingPath,
-        nullifierSubtreeSiblingPath,
-        lowPublicDataWritesPreimages: padArrayEnd(
-          txPublicDataUpdateRequestInfo.lowPublicDataWritesPreimages,
-          PublicDataTreeLeafPreimage.empty(),
-          MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-        ),
-        lowPublicDataWritesMembershipWitnesses: padArrayEnd(
-          txPublicDataUpdateRequestInfo.lowPublicDataWritesMembershipWitnesses,
-          MembershipWitness.empty(PUBLIC_DATA_TREE_HEIGHT),
-          MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-        ),
-        publicDataTreeSiblingPaths: padArrayEnd(
-          txPublicDataUpdateRequestInfo.publicDataWritesSiblingPaths,
-          makeTuple(PUBLIC_DATA_TREE_HEIGHT, () => Fr.ZERO),
-          MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-        ),
-      });
-
       const blockHash = await tx.constants.historicalHeader.hash();
       const archiveRootMembershipWitness = await getMembershipWitnessFor(
         blockHash,
@@ -181,9 +146,7 @@ export const buildBaseRollupHints = runInSpan(
       );
 
       return PublicBaseRollupHints.from({
-        start,
         startSpongeBlob: inputSpongeBlob,
-        stateDiffHints,
         archiveRootMembershipWitness,
         constants,
       });
@@ -441,7 +404,7 @@ export const getConstantRollupData = runInSpan(
   'getConstantRollupData',
   async (_span, globalVariables: GlobalVariables, db: MerkleTreeReadOperations): Promise<ConstantRollupData> => {
     return ConstantRollupData.from({
-      vkTreeRoot: await getVKTreeRoot(),
+      vkTreeRoot: getVKTreeRoot(),
       protocolContractTreeRoot,
       lastArchive: await getTreeSnapshot(MerkleTreeId.ARCHIVE, db),
       globalVariables,

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

@@ -164,13 +164,13 @@ export class BlockProvingState {
     return this.baseOrMergeProvingOutputs.getParentLocation(location);
   }
 
-  public async getMergeRollupInputs(mergeLocation: TreeNodeLocation) {
+  public getMergeRollupInputs(mergeLocation: TreeNodeLocation) {
     const [left, right] = this.baseOrMergeProvingOutputs.getChildren(mergeLocation);
     if (!left || !right) {
       throw new Error('At lease one child is not ready.');
     }
 
-    return new MergeRollupInputs([await this.#getPreviousRollupData(left), await this.#getPreviousRollupData(right)]);
+    return new MergeRollupInputs([this.#getPreviousRollupData(left), this.#getPreviousRollupData(right)]);
   }
 
   public async getBlockRootRollupTypeAndInputs(proverId: Fr) {
@@ -184,13 +184,13 @@ export class BlockProvingState {
       throw new Error('At lease one child is not ready for the block root.');
     }
 
-    const data = await this.#getBlockRootRollupData(proverId);
+    const data = this.#getBlockRootRollupData(proverId);
 
     if (this.totalNumTxs === 0) {
       const constants = ConstantRollupData.from({
         lastArchive: this.lastArchiveSnapshot,
         globalVariables: this.globalVariables,
-        vkTreeRoot: await getVKTreeRoot(),
+        vkTreeRoot: getVKTreeRoot(),
         protocolContractTreeRoot,
       });
 
@@ -234,7 +234,7 @@ export class BlockProvingState {
     const newArchive = this.blockRootProvingOutput!.inputs.newArchive;
 
     const data = BlockRootRollupData.from({
-      l1ToL2Roots: await this.#getRootParityData(this.rootParityProvingOutput!),
+      l1ToL2Roots: this.#getRootParityData(this.rootParityProvingOutput!),
       l1ToL2MessageSubtreeSiblingPath: this.l1ToL2MessageSubtreeSiblingPath,
       newArchiveSiblingPath: this.newArchiveSiblingPath,
       previousBlockHeader: newBlockHeader,
@@ -244,7 +244,7 @@ export class BlockProvingState {
     const constants = ConstantRollupData.from({
       lastArchive: newArchive,
       globalVariables: this.globalVariables,
-      vkTreeRoot: await getVKTreeRoot(),
+      vkTreeRoot: getVKTreeRoot(),
       protocolContractTreeRoot,
     });
 
@@ -255,12 +255,12 @@ export class BlockProvingState {
     });
   }
 
-  public async getRootParityInputs() {
+  public getRootParityInputs() {
     if (!this.baseParityProvingOutputs.every(p => !!p)) {
       throw new Error('At lease one base parity is not ready.');
     }
 
-    const children = await Promise.all(this.baseParityProvingOutputs.map(p => this.#getRootParityData(p!)));
+    const children = this.baseParityProvingOutputs.map(p => this.#getRootParityData(p!));
     return new RootParityInputs(
       children as Tuple<RootParityInput<typeof RECURSIVE_PROOF_LENGTH>, typeof NUM_BASE_PARITY_PER_ROOT_PARITY>,
     );
@@ -326,9 +326,9 @@ export class BlockProvingState {
     this.parentEpoch.reject(reason);
   }
 
-  async #getBlockRootRollupData(proverId: Fr) {
+  #getBlockRootRollupData(proverId: Fr) {
     return BlockRootRollupData.from({
-      l1ToL2Roots: await this.#getRootParityData(this.rootParityProvingOutput!),
+      l1ToL2Roots: this.#getRootParityData(this.rootParityProvingOutput!),
       l1ToL2MessageSubtreeSiblingPath: this.l1ToL2MessageSubtreeSiblingPath,
       newArchiveSiblingPath: this.newArchiveSiblingPath,
       previousBlockHeader: this.previousBlockHeader,
@@ -358,25 +358,25 @@ export class BlockProvingState {
       : this.baseOrMergeProvingOutputs.getChildren(rootLocation);
   }
 
-  async #getPreviousRollupData({
+  #getPreviousRollupData({
     inputs,
     proof,
     verificationKey,
   }: PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>) {
-    const leafIndex = await getVKIndex(verificationKey.keyAsFields);
+    const leafIndex = getVKIndex(verificationKey.keyAsFields);
     return new PreviousRollupData(
       inputs,
       proof,
       verificationKey.keyAsFields,
-      new MembershipWitness(VK_TREE_HEIGHT, BigInt(leafIndex), await getVKSiblingPath(leafIndex)),
+      new MembershipWitness(VK_TREE_HEIGHT, BigInt(leafIndex), getVKSiblingPath(leafIndex)),
     );
   }
 
-  async #getRootParityData({ inputs, proof, verificationKey }: PublicInputsAndRecursiveProof<ParityPublicInputs>) {
+  #getRootParityData({ inputs, proof, verificationKey }: PublicInputsAndRecursiveProof<ParityPublicInputs>) {
     return new RootParityInput(
       proof,
       verificationKey.keyAsFields,
-      await getVKSiblingPath(await getVKIndex(verificationKey)),
+      getVKSiblingPath(getVKIndex(verificationKey)),
       inputs,
     );
   }

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

@@ -150,26 +150,23 @@ export class EpochProvingState {
     return this.blockRootOrMergeProvingOutputs.getParentLocation(location);
   }
 
-  public async getBlockMergeRollupInputs(mergeLocation: TreeNodeLocation) {
+  public getBlockMergeRollupInputs(mergeLocation: TreeNodeLocation) {
     const [left, right] = this.blockRootOrMergeProvingOutputs.getChildren(mergeLocation);
     if (!left || !right) {
       throw new Error('At lease one child is not ready.');
     }
 
-    return new BlockMergeRollupInputs([
-      await this.#getPreviousRollupData(left),
-      await this.#getPreviousRollupData(right),
-    ]);
+    return new BlockMergeRollupInputs([this.#getPreviousRollupData(left), this.#getPreviousRollupData(right)]);
   }
 
-  public async getRootRollupInputs(proverId: Fr) {
+  public getRootRollupInputs(proverId: Fr) {
     const [left, right] = this.#getChildProofsForRoot();
     if (!left || !right) {
       throw new Error('At lease one child is not ready.');
     }
 
     return RootRollupInputs.from({
-      previousRollupData: [await this.#getPreviousRollupData(left), await this.#getPreviousRollupData(right)],
+      previousRollupData: [this.#getPreviousRollupData(left), this.#getPreviousRollupData(right)],
       proverId,
     });
   }
@@ -241,7 +238,7 @@ export class EpochProvingState {
       : this.blockRootOrMergeProvingOutputs.getChildren(rootLocation);
   }
 
-  async #getPreviousRollupData({
+  #getPreviousRollupData({
     inputs,
     proof,
     verificationKey,
@@ -249,12 +246,12 @@ export class EpochProvingState {
     BlockRootOrBlockMergePublicInputs,
     typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
   >) {
-    const leafIndex = await getVKIndex(verificationKey.keyAsFields);
+    const leafIndex = getVKIndex(verificationKey.keyAsFields);
     return new PreviousRollupBlockData(
       inputs,
       proof,
       verificationKey.keyAsFields,
-      new MembershipWitness(VK_TREE_HEIGHT, BigInt(leafIndex), await getVKSiblingPath(leafIndex)),
+      new MembershipWitness(VK_TREE_HEIGHT, BigInt(leafIndex), getVKSiblingPath(leafIndex)),
     );
   }
 }

package/src/orchestrator/orchestrator.ts

@@ -36,7 +36,7 @@ import {
   SingleTxBlockRootRollupInputs,
   TubeInputs,
 } from '@aztec/circuits.js/rollup';
-import { padArrayEnd, timesParallel } from '@aztec/foundation/collection';
+import { padArrayEnd, times } from '@aztec/foundation/collection';
 import { AbortError } from '@aztec/foundation/error';
 import { createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
@@ -247,7 +247,7 @@ export class ProvingOrchestrator implements EpochProver {
       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 => Promise.resolve(tubeProof.resolve(proof)));
+      this.doEnqueueTube(txHash, tubeInputs, proof => tubeProof.resolve(proof));
       this.provingState?.cachedTubeProofs.set(txHash, tubeProof.promise);
     }
   }
@@ -458,8 +458,8 @@ export class ProvingOrchestrator implements EpochProver {
       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 baseParityInputs = times(NUM_BASE_PARITY_PER_ROOT_PARITY, i =>
+      BaseParityInputs.fromSlice(l1ToL2MessagesPadded, i, getVKTreeRoot()),
     );
 
     const l1ToL2MessageSubtreeSiblingPath = assertLength(
@@ -517,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 async enqueueBaseRollup(provingState: BlockProvingState, txIndex: number) {
+  private enqueueBaseRollup(provingState: BlockProvingState, txIndex: number) {
     if (!provingState.verifyState()) {
       logger.debug('Not running base rollup, state invalid');
       return;
@@ -525,7 +525,7 @@ export class ProvingOrchestrator implements EpochProver {
 
     const txProvingState = provingState.getTxProvingState(txIndex);
     const { processedTx } = txProvingState;
-    const { rollupType, inputs } = await txProvingState.getBaseRollupTypeAndInputs();
+    const { rollupType, inputs } = txProvingState.getBaseRollupTypeAndInputs();
 
     logger.debug(`Enqueuing deferred proving base rollup for ${processedTx.hash.toString()}`);
 
@@ -573,11 +573,11 @@ export class ProvingOrchestrator implements EpochProver {
     const txProvingState = provingState.getTxProvingState(txIndex);
     const txHash = txProvingState.processedTx.hash.toString();
 
-    const handleResult = async (result: ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>) => {
+    const handleResult = (result: ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>) => {
       logger.debug(`Got tube proof for tx index: ${txIndex}`, { txHash });
       txProvingState.setTubeProof(result);
       this.provingState?.cachedTubeProofs.delete(txHash);
-      await this.checkAndEnqueueNextTxCircuit(provingState, txIndex);
+      this.checkAndEnqueueNextTxCircuit(provingState, txIndex);
     };
 
     if (this.provingState?.cachedTubeProofs.has(txHash)) {
@@ -593,7 +593,7 @@ export class ProvingOrchestrator implements EpochProver {
   private doEnqueueTube(
     txHash: string,
     inputs: TubeInputs,
-    handler: (result: ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>) => Promise<void>,
+    handler: (result: ProofAndVerificationKey<typeof TUBE_PROOF_LENGTH>) => void,
     provingState: EpochProvingState | BlockProvingState = this.provingState!,
   ) {
     if (!provingState?.verifyState()) {
@@ -619,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 async enqueueMergeRollup(provingState: BlockProvingState, location: TreeNodeLocation) {
+  private enqueueMergeRollup(provingState: BlockProvingState, location: TreeNodeLocation) {
     if (!provingState.verifyState()) {
       logger.debug('Not running merge rollup. State no longer valid.');
       return;
     }
 
-    const inputs = await provingState.getMergeRollupInputs(location);
+    const inputs = provingState.getMergeRollupInputs(location);
 
     this.deferredProving(
       provingState,
@@ -697,7 +697,7 @@ export class ProvingOrchestrator implements EpochProver {
         if (epochProvingState.totalNumBlocks === 1) {
           await this.enqueueEpochPadding(epochProvingState);
         } else {
-          await this.checkAndEnqueueNextBlockMergeRollup(epochProvingState, leafLocation);
+          this.checkAndEnqueueNextBlockMergeRollup(epochProvingState, leafLocation);
         }
       },
     );
@@ -722,30 +722,30 @@ export class ProvingOrchestrator implements EpochProver {
         },
         signal => this.prover.getBaseParityProof(inputs, signal, provingState.epochNumber),
       ),
-      async provingOutput => {
+      provingOutput => {
         provingState.setBaseParityProof(index, provingOutput);
-        await this.checkAndEnqueueRootParityCircuit(provingState);
+        this.checkAndEnqueueRootParityCircuit(provingState);
       },
     );
   }
 
-  private async checkAndEnqueueRootParityCircuit(provingState: BlockProvingState) {
+  private checkAndEnqueueRootParityCircuit(provingState: BlockProvingState) {
     if (!provingState.isReadyForRootParity()) {
       return;
     }
 
-    await this.enqueueRootParityCircuit(provingState);
+    this.enqueueRootParityCircuit(provingState);
   }
 
   // Runs the root parity circuit ans stored the outputs
   // Enqueues the root rollup proof if all inputs are available
-  private async enqueueRootParityCircuit(provingState: BlockProvingState) {
+  private enqueueRootParityCircuit(provingState: BlockProvingState) {
     if (!provingState.verifyState()) {
       logger.debug('Not running root parity. State no longer valid.');
       return;
     }
 
-    const inputs = await provingState.getRootParityInputs();
+    const inputs = provingState.getRootParityInputs();
 
     this.deferredProving(
       provingState,
@@ -767,13 +767,13 @@ export class ProvingOrchestrator implements EpochProver {
 
   // 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 async enqueueBlockMergeRollup(provingState: EpochProvingState, location: TreeNodeLocation) {
+  private enqueueBlockMergeRollup(provingState: EpochProvingState, location: TreeNodeLocation) {
     if (!provingState.verifyState()) {
       logger.debug('Not running block merge rollup. State no longer valid.');
       return;
     }
 
-    const inputs = await provingState.getBlockMergeRollupInputs(location);
+    const inputs = provingState.getBlockMergeRollupInputs(location);
 
     this.deferredProving(
       provingState,
@@ -786,9 +786,9 @@ export class ProvingOrchestrator implements EpochProver {
         },
         signal => this.prover.getBlockMergeRollupProof(inputs, signal, provingState.epochNumber),
       ),
-      async result => {
+      result => {
         provingState.setBlockMergeRollupProof(location, result);
-        await this.checkAndEnqueueNextBlockMergeRollup(provingState, location);
+        this.checkAndEnqueueNextBlockMergeRollup(provingState, location);
       },
     );
   }
@@ -814,16 +814,16 @@ export class ProvingOrchestrator implements EpochProver {
         },
         signal => this.prover.getEmptyBlockRootRollupProof(inputs, signal, provingState.epochNumber),
       ),
-      async result => {
+      result => {
         logger.debug('Completed proof for padding block root.');
         provingState.setPaddingBlockRootProof(result);
-        await this.checkAndEnqueueRootRollup(provingState);
+        this.checkAndEnqueueRootRollup(provingState);
       },
     );
   }
 
   // Executes the root rollup circuit
-  private async enqueueRootRollup(provingState: EpochProvingState) {
+  private enqueueRootRollup(provingState: EpochProvingState) {
     if (!provingState.verifyState()) {
       logger.debug('Not running root rollup, state no longer valid');
       return;
@@ -831,7 +831,7 @@ export class ProvingOrchestrator implements EpochProver {
 
     logger.debug(`Preparing root rollup`);
 
-    const inputs = await provingState.getRootRollupInputs(this.proverId);
+    const inputs = provingState.getRootRollupInputs(this.proverId);
 
     this.deferredProving(
       provingState,
@@ -861,7 +861,7 @@ export class ProvingOrchestrator implements EpochProver {
     if (parentLocation.level === 0) {
       await this.checkAndEnqueueBlockRootRollup(provingState);
     } else {
-      await this.enqueueMergeRollup(provingState, parentLocation);
+      this.enqueueMergeRollup(provingState, parentLocation);
     }
   }
 
@@ -890,29 +890,26 @@ export class ProvingOrchestrator implements EpochProver {
     await this.enqueueBlockRootRollup(provingState);
   }
 
-  private async checkAndEnqueueNextBlockMergeRollup(
-    provingState: EpochProvingState,
-    currentLocation: TreeNodeLocation,
-  ) {
+  private checkAndEnqueueNextBlockMergeRollup(provingState: EpochProvingState, currentLocation: TreeNodeLocation) {
     if (!provingState.isReadyForBlockMerge(currentLocation)) {
       return;
     }
 
     const parentLocation = provingState.getParentLocation(currentLocation);
     if (parentLocation.level === 0) {
-      await this.checkAndEnqueueRootRollup(provingState);
+      this.checkAndEnqueueRootRollup(provingState);
     } else {
-      await this.enqueueBlockMergeRollup(provingState, parentLocation);
+      this.enqueueBlockMergeRollup(provingState, parentLocation);
     }
   }
 
-  private async checkAndEnqueueRootRollup(provingState: EpochProvingState) {
+  private checkAndEnqueueRootRollup(provingState: EpochProvingState) {
     if (!provingState.isReadyForRootRollup()) {
       logger.debug('Not ready for root rollup');
       return;
     }
 
-    await this.enqueueRootRollup(provingState);
+    this.enqueueRootRollup(provingState);
   }
 
   /**
@@ -960,14 +957,14 @@ export class ProvingOrchestrator implements EpochProver {
       },
     );
 
-    this.deferredProving(provingState, doAvmProving, async proofAndVk => {
+    this.deferredProving(provingState, doAvmProving, proofAndVk => {
       logger.debug(`Proven VM for tx index: ${txIndex}`);
       txProvingState.setAvmProof(proofAndVk);
-      await this.checkAndEnqueueNextTxCircuit(provingState, txIndex);
+      this.checkAndEnqueueNextTxCircuit(provingState, txIndex);
     });
   }
 
-  private async checkAndEnqueueNextTxCircuit(provingState: BlockProvingState, txIndex: number) {
+  private checkAndEnqueueNextTxCircuit(provingState: BlockProvingState, txIndex: number) {
     const txProvingState = provingState.getTxProvingState(txIndex);
     if (!txProvingState.ready()) {
       return;
@@ -976,6 +973,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`);
 
-    await this.enqueueBaseRollup(provingState, txIndex);
+    this.enqueueBaseRollup(provingState, txIndex);
   }
 }

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

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

package/src/proving_broker/rpc.ts

@@ -1,4 +1,5 @@
 import {
+  type ComponentsVersions,
   type GetProvingJobResponse,
   ProofUri,
   ProvingJob,
@@ -8,6 +9,7 @@ import {
   type ProvingJobProducer,
   ProvingJobStatus,
   ProvingRequestType,
+  getVersioningResponseHandler,
 } from '@aztec/circuit-types';
 import { createSafeJsonRpcClient } from '@aztec/foundation/json-rpc/client';
 import { type SafeJsonRpcServer } from '@aztec/foundation/json-rpc/server';
@@ -57,20 +59,38 @@ export function createProvingBrokerServer(broker: ProvingJobBroker): SafeJsonRpc
   return createTracedJsonRpcServer(broker, ProvingJobBrokerSchema);
 }
 
-export function createProvingJobBrokerClient(url: string, fetch = makeTracedFetch([1, 2, 3], false)): ProvingJobBroker {
-  return createSafeJsonRpcClient(url, ProvingJobBrokerSchema, false, 'proverBroker', fetch);
+export function createProvingJobBrokerClient(
+  url: string,
+  versions: Partial<ComponentsVersions>,
+  fetch = makeTracedFetch([1, 2, 3], false),
+): ProvingJobBroker {
+  return createSafeJsonRpcClient(url, ProvingJobBrokerSchema, {
+    namespaceMethods: 'proverBroker',
+    fetch,
+    onResponse: getVersioningResponseHandler(versions),
+  });
 }
 
 export function createProvingJobProducerClient(
   url: string,
+  versions: Partial<ComponentsVersions>,
   fetch = makeTracedFetch([1, 2, 3], false),
 ): ProvingJobProducer {
-  return createSafeJsonRpcClient(url, ProvingJobProducerSchema, false, 'provingJobProducer', fetch);
+  return createSafeJsonRpcClient(url, ProvingJobProducerSchema, {
+    namespaceMethods: 'provingJobProducer',
+    fetch,
+    onResponse: getVersioningResponseHandler(versions),
+  });
 }
 
 export function createProvingJobConsumerClient(
   url: string,
+  versions: Partial<ComponentsVersions>,
   fetch = makeTracedFetch([1, 2, 3], false),
 ): ProvingJobConsumer {
-  return createSafeJsonRpcClient(url, ProvingJobConsumerSchema, false, 'provingJobConsumer', fetch);
+  return createSafeJsonRpcClient(url, ProvingJobConsumerSchema, {
+    namespaceMethods: 'provingJobConsumer',
+    fetch,
+    onResponse: getVersioningResponseHandler(versions),
+  });
 }

package/src/test/mock_prover.ts

@@ -44,14 +44,16 @@ import {
 } from '@aztec/circuits.js/testing';
 import { times } from '@aztec/foundation/collection';
 
+import { BrokerCircuitProverFacade } from '../proving_broker/broker_prover_facade.js';
 import { InlineProofStore, type ProofStore } from '../proving_broker/proof_store/index.js';
 import { ProvingAgent } from '../proving_broker/proving_agent.js';
 import { ProvingBroker } from '../proving_broker/proving_broker.js';
 import { InMemoryBrokerDatabase } from '../proving_broker/proving_broker_database/memory.js';
 
 export class TestBroker implements ProvingJobProducer {
-  private broker = new ProvingBroker(new InMemoryBrokerDatabase());
+  private broker: ProvingBroker;
   private agents: ProvingAgent[];
+  public facade: BrokerCircuitProverFacade;
 
   constructor(
     agentCount: number,
@@ -59,20 +61,24 @@ export class TestBroker implements ProvingJobProducer {
     private proofStore: ProofStore = new InlineProofStore(),
     agentPollInterval = 100,
   ) {
+    this.broker = new ProvingBroker(new InMemoryBrokerDatabase());
     this.agents = times(
       agentCount,
       () => new ProvingAgent(this.broker, proofStore, prover, undefined, agentPollInterval),
     );
+    this.facade = new BrokerCircuitProverFacade(this.broker, proofStore);
   }
 
   public async start() {
     await this.broker.start();
     this.agents.forEach(agent => agent.start());
+    this.facade.start();
   }
 
   public async stop() {
     await Promise.all(this.agents.map(agent => agent.stop()));
     await this.broker.stop();
+    await this.facade.stop();
   }
 
   public getProofStore(): ProofStore {