@aztec/prover-client 0.75.0 → 0.76.1

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "@aztec/prover-client",
-  "version": "0.75.0",
+  "version": "0.76.1",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
     "./block-builder": "./dest/block_builder/index.js",
     "./broker": "./dest/proving_broker/index.js",
-    "./prover-agent": "./dest/prover-agent/index.js",
     "./orchestrator": "./dest/orchestrator/index.js",
     "./helpers": "./dest/orchestrator/block-building-helpers.js",
     "./config": "./dest/config.js"
@@ -67,16 +66,17 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb-prover": "0.75.0",
-    "@aztec/circuit-types": "0.75.0",
-    "@aztec/circuits.js": "0.75.0",
-    "@aztec/foundation": "0.75.0",
-    "@aztec/kv-store": "0.75.0",
-    "@aztec/noir-protocol-circuits-types": "0.75.0",
-    "@aztec/protocol-contracts": "0.75.0",
-    "@aztec/simulator": "0.75.0",
-    "@aztec/telemetry-client": "0.75.0",
-    "@aztec/world-state": "0.75.0",
+    "@aztec/bb-prover": "0.76.1",
+    "@aztec/blob-lib": "0.76.1",
+    "@aztec/circuit-types": "0.76.1",
+    "@aztec/circuits.js": "0.76.1",
+    "@aztec/foundation": "0.76.1",
+    "@aztec/kv-store": "0.76.1",
+    "@aztec/noir-protocol-circuits-types": "0.76.1",
+    "@aztec/protocol-contracts": "0.76.1",
+    "@aztec/simulator": "0.76.1",
+    "@aztec/telemetry-client": "0.76.1",
+    "@aztec/world-state": "0.76.1",
     "@google-cloud/storage": "^7.15.0",
     "@iarna/toml": "^2.2.5",
     "@noir-lang/types": "portal:../../noir/packages/types",

package/src/mocks/test_context.ts

@@ -27,7 +27,6 @@ import {
   WASMSimulatorWithBlobs,
   type WorldStateDB,
 } from '@aztec/simulator/server';
-import { getTelemetryClient } from '@aztec/telemetry-client';
 import { type MerkleTreeAdminDatabase } from '@aztec/world-state';
 import { NativeWorldStateService } from '@aztec/world-state/native';
 
@@ -40,8 +39,7 @@ import { AvmFinalizedCallResult } from '../../../simulator/src/avm/avm_contract_
 import { type AvmPersistableStateManager } from '../../../simulator/src/avm/journal/journal.js';
 import { buildBlock } from '../block_builder/light.js';
 import { ProvingOrchestrator } from '../orchestrator/index.js';
-import { MemoryProvingQueue } from '../prover-agent/memory-proving-queue.js';
-import { ProverAgent } from '../prover-agent/prover-agent.js';
+import { TestBroker } from '../test/mock_prover.js';
 import { getEnvironmentConfig, getSimulationProvider, makeGlobals, updateExpectedTreesFromTxs } from './fixtures.js';
 
 export class TestContext {
@@ -54,7 +52,7 @@ export class TestContext {
     public simulationProvider: SimulationProvider,
     public globalVariables: GlobalVariables,
     public prover: ServerCircuitProver,
-    public proverAgent: ProverAgent,
+    public broker: TestBroker,
     public orchestrator: TestProvingOrchestrator,
     public blockNumber: number,
     public directoriesToCleanup: string[],
@@ -115,12 +113,10 @@ export class TestContext {
       directoriesToCleanup.push(config.directoryToCleanup);
     }
 
-    const queue = new MemoryProvingQueue(getTelemetryClient());
-    const orchestrator = new TestProvingOrchestrator(ws, queue, Fr.ZERO);
-    const agent = new ProverAgent(localProver, proverCount, undefined);
+    const broker = new TestBroker(proverCount, localProver);
+    const orchestrator = new TestProvingOrchestrator(ws, broker.facade, Fr.ZERO);
 
-    queue.start();
-    agent.start(queue);
+    await broker.start();
 
     return new this(
       publicTxSimulator,
@@ -129,7 +125,7 @@ export class TestContext {
       simulationProvider,
       globalVariables,
       localProver,
-      agent,
+      broker,
       orchestrator,
       blockNumber,
       directoriesToCleanup,
@@ -152,7 +148,7 @@ export class TestContext {
   }
 
   async cleanup() {
-    await this.proverAgent.stop();
+    await this.broker.stop();
     for (const dir of this.directoriesToCleanup.filter(x => x !== '')) {
       await fs.rm(dir, { recursive: true, force: true });
     }
@@ -160,15 +156,13 @@ export class TestContext {
 
   public makeProcessedTx(opts?: Parameters<typeof makeBloatedProcessedTx>[0]): Promise<ProcessedTx>;
   public makeProcessedTx(seed?: number): Promise<ProcessedTx>;
-  public async makeProcessedTx(
-    seedOrOpts?: Parameters<typeof makeBloatedProcessedTx>[0] | number,
-  ): Promise<ProcessedTx> {
+  public makeProcessedTx(seedOrOpts?: Parameters<typeof makeBloatedProcessedTx>[0] | number): Promise<ProcessedTx> {
     const opts = typeof seedOrOpts === 'number' ? { seed: seedOrOpts } : seedOrOpts;
     const blockNum = (opts?.globalVariables ?? this.globalVariables).blockNumber.toNumber();
     const header = this.getBlockHeader(blockNum - 1);
     return makeBloatedProcessedTx({
       header,
-      vkTreeRoot: await getVKTreeRoot(),
+      vkTreeRoot: getVKTreeRoot(),
       protocolContractTreeRoot,
       globalVariables: this.globalVariables,
       ...opts,
@@ -189,7 +183,7 @@ export class TestContext {
     const txs = await timesParallel(numTxs, i =>
       this.makeProcessedTx({ seed: i + blockNum * 1000, globalVariables, ...makeProcessedTxOpts(i) }),
     );
-    await this.setEndTreeRoots(txs);
+    await this.setTreeRoots(txs);
 
     const block = await buildBlock(txs, globalVariables, msgs, db);
     this.headers.set(blockNum, block.header);
@@ -226,17 +220,24 @@ export class TestContext {
     );
   }
 
-  public async setEndTreeRoots(txs: ProcessedTx[]) {
+  public async setTreeRoots(txs: ProcessedTx[]) {
     const db = await this.worldState.fork();
     for (const tx of txs) {
+      const startStateReference = await db.getStateReference();
       await updateExpectedTreesFromTxs(db, [tx]);
-      const stateReference = await db.getStateReference();
+      const endStateReference = await db.getStateReference();
       if (tx.avmProvingRequest) {
+        tx.avmProvingRequest.inputs.publicInputs.startTreeSnapshots = new TreeSnapshots(
+          startStateReference.l1ToL2MessageTree,
+          startStateReference.partial.noteHashTree,
+          startStateReference.partial.nullifierTree,
+          startStateReference.partial.publicDataTree,
+        );
         tx.avmProvingRequest.inputs.publicInputs.endTreeSnapshots = new TreeSnapshots(
-          stateReference.l1ToL2MessageTree,
-          stateReference.partial.noteHashTree,
-          stateReference.partial.nullifierTree,
-          stateReference.partial.publicDataTree,
+          endStateReference.l1ToL2MessageTree,
+          endStateReference.partial.noteHashTree,
+          endStateReference.partial.nullifierTree,
+          endStateReference.partial.publicDataTree,
         );
       }
     }

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

@@ -1,3 +1,4 @@
+import { Blob } from '@aztec/blob-lib';
 import {
   Body,
   MerkleTreeId,
@@ -15,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,
@@ -41,10 +41,8 @@ import {
   PrivateBaseRollupHints,
   PrivateBaseStateDiffHints,
   PublicBaseRollupHints,
-  PublicBaseStateDiffHints,
 } from '@aztec/circuits.js/rollup';
 import { makeTuple } from '@aztec/foundation/array';
-import { Blob } from '@aztec/foundation/blob';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { sha256Trunc } from '@aztec/foundation/crypto';
 import { type Logger } from '@aztec/foundation/log';
@@ -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);
   }
 }