@aztec/prover-client 0.0.1-commit.96bb3f7 → 0.0.1-commit.a072138

package/src/orchestrator/orchestrator.ts

@@ -10,7 +10,7 @@ import { BlockNumber, EpochNumber } from '@aztec/foundation/branded-types';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { AbortError } from '@aztec/foundation/error';
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { assertLength } from '@aztec/foundation/serialize';
 import { pushTestData } from '@aztec/foundation/testing';
@@ -71,7 +71,10 @@ import { EpochProvingState, type ProvingResult, type TreeSnapshots } from './epo
 import { ProvingOrchestratorMetrics } from './orchestrator_metrics.js';
 import { TxProvingState } from './tx-proving-state.js';
 
-const logger = createLogger('prover-client:orchestrator');
+type WorldStateFork = {
+  fork: MerkleTreeWriteOperations;
+  cleanupPromise: Promise<void> | undefined;
+};
 
 /**
  * Implements an event driven proving scheduler to build the recursive proof tree. The idea being:
@@ -94,14 +97,18 @@ export class ProvingOrchestrator implements EpochProver {
   private provingPromise: Promise<ProvingResult> | undefined = undefined;
   private metrics: ProvingOrchestratorMetrics;
   // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
-  private dbs: Map<BlockNumber, MerkleTreeWriteOperations> = new Map();
+  private dbs: Map<BlockNumber, WorldStateFork> = new Map();
+  private logger: Logger;
 
   constructor(
     private dbProvider: ReadonlyWorldStateAccess & ForkMerkleTreeOperations,
     private prover: ServerCircuitProver,
     private readonly proverId: EthAddress,
+    private readonly cancelJobsOnStop: boolean = false,
     telemetryClient: TelemetryClient = getTelemetryClient(),
+    bindings?: LoggerBindings,
   ) {
+    this.logger = createLogger('prover-client:orchestrator', bindings);
     this.metrics = new ProvingOrchestratorMetrics(telemetryClient, 'ProvingOrchestrator');
   }
 
@@ -113,6 +120,10 @@ export class ProvingOrchestrator implements EpochProver {
     return this.proverId;
   }
 
+  public getNumActiveForks() {
+    return this.dbs.size;
+  }
+
   public stop(): Promise<void> {
     this.cancel();
     return Promise.resolve();
@@ -131,7 +142,7 @@ export class ProvingOrchestrator implements EpochProver {
 
     const { promise: _promise, resolve, reject } = promiseWithResolvers<ProvingResult>();
     const promise = _promise.catch((reason): ProvingResult => ({ status: 'failure', reason }));
-    logger.info(`Starting epoch ${epochNumber} with ${totalNumCheckpoints} checkpoints.`);
+    this.logger.info(`Starting epoch ${epochNumber} with ${totalNumCheckpoints} checkpoints.`);
     this.provingState = new EpochProvingState(
       epochNumber,
       totalNumCheckpoints,
@@ -143,6 +154,14 @@ export class ProvingOrchestrator implements EpochProver {
     this.provingPromise = promise;
   }
 
+  /**
+   * Starts a new checkpoint.
+   * @param checkpointIndex - The index of the checkpoint in the epoch.
+   * @param constants - The constants for this checkpoint.
+   * @param l1ToL2Messages - The set of L1 to L2 messages to be inserted at the beginning of this checkpoint.
+   * @param totalNumBlocks - The total number of blocks expected in the checkpoint (must be at least one).
+   * @param headerOfLastBlockInPreviousCheckpoint - The header of the last block in the previous checkpoint.
+   */
   public async startNewCheckpoint(
     checkpointIndex: number,
     constants: CheckpointConstantData,
@@ -163,7 +182,7 @@ export class ProvingOrchestrator implements EpochProver {
     const db = await this.dbProvider.fork(lastBlockNumber);
 
     const firstBlockNumber = BlockNumber(lastBlockNumber + 1);
-    this.dbs.set(firstBlockNumber, db);
+    this.dbs.set(firstBlockNumber, { fork: db, cleanupPromise: undefined });
 
     // Get archive sibling path before any block in this checkpoint lands.
     const lastArchiveSiblingPath = await getLastSiblingPath(MerkleTreeId.ARCHIVE, db);
@@ -215,15 +234,15 @@ export class ProvingOrchestrator implements EpochProver {
     }
 
     const constants = checkpointProvingState.constants;
-    logger.info(`Starting block ${blockNumber} for slot ${constants.slotNumber}.`);
+    this.logger.info(`Starting block ${blockNumber} for slot ${constants.slotNumber}.`);
 
     // Fork the db only when it's not already set. The db for the first block is set in `startNewCheckpoint`.
     if (!this.dbs.has(blockNumber)) {
       // Fork world state at the end of the immediately previous block
       const db = await this.dbProvider.fork(BlockNumber(blockNumber - 1));
-      this.dbs.set(blockNumber, db);
+      this.dbs.set(blockNumber, { fork: db, cleanupPromise: undefined });
     }
-    const db = this.dbs.get(blockNumber)!;
+    const db = this.dbs.get(blockNumber)!.fork;
 
     // Get archive snapshot and sibling path before any txs in this block lands.
     const lastArchiveTreeSnapshot = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
@@ -255,7 +274,8 @@ export class ProvingOrchestrator implements EpochProver {
       await endSpongeBlob.absorb(blockEndBlobFields);
       blockProvingState.setEndSpongeBlob(endSpongeBlob);
 
-      // And also try to accumulate the blobs as far as we can:
+      // Try to accumulate the out hashes and blobs as far as we can:
+      await this.provingState.accumulateCheckpointOutHashes();
       await this.provingState.setBlobAccumulators();
     }
   }
@@ -275,7 +295,7 @@ export class ProvingOrchestrator implements EpochProver {
     if (!txs.length) {
       // To avoid an ugly throw below. If we require an empty block, we can just call setBlockCompleted
       // on a block with no txs. We cannot do that here because we cannot find the blockNumber without any txs.
-      logger.warn(`Provided no txs to orchestrator addTxs.`);
+      this.logger.warn(`Provided no txs to orchestrator addTxs.`);
       return;
     }
 
@@ -295,9 +315,9 @@ export class ProvingOrchestrator implements EpochProver {
       throw new Error(`Block ${blockNumber} has been initialized with transactions.`);
     }
 
-    logger.info(`Adding ${txs.length} transactions to block ${blockNumber}`);
+    this.logger.info(`Adding ${txs.length} transactions to block ${blockNumber}`);
 
-    const db = this.dbs.get(blockNumber)!;
+    const db = this.dbs.get(blockNumber)!.fork;
     const lastArchive = provingState.lastArchiveTreeSnapshot;
     const newL1ToL2MessageTreeSnapshot = provingState.newL1ToL2MessageTreeSnapshot;
     const spongeBlobState = provingState.getStartSpongeBlob().clone();
@@ -310,7 +330,7 @@ export class ProvingOrchestrator implements EpochProver {
 
         validateTx(tx);
 
-        logger.debug(`Received transaction: ${tx.hash}`);
+        this.logger.debug(`Received transaction: ${tx.hash}`);
 
         const startSpongeBlob = spongeBlobState.clone();
         const [hints, treeSnapshots] = await this.prepareBaseRollupInputs(
@@ -331,10 +351,10 @@ export class ProvingOrchestrator implements EpochProver {
         const txIndex = provingState.addNewTx(txProvingState);
         if (txProvingState.requireAvmProof) {
           this.getOrEnqueueChonkVerifier(provingState, txIndex);
-          logger.debug(`Enqueueing public VM for tx ${txIndex}`);
+          this.logger.debug(`Enqueueing public VM for tx ${txIndex}`);
           this.enqueueVM(provingState, txIndex);
         } else {
-          logger.debug(`Enqueueing base rollup for private-only tx ${txIndex}`);
+          this.logger.debug(`Enqueueing base rollup for private-only tx ${txIndex}`);
           this.enqueueBaseRollup(provingState, txIndex);
         }
       } catch (err: any) {
@@ -352,7 +372,8 @@ export class ProvingOrchestrator implements EpochProver {
 
     provingState.setEndSpongeBlob(spongeBlobState);
 
-    // Txs have been added to the block. Now try to accumulate the blobs as far as we can:
+    // Txs have been added to the block. Now try to accumulate the out hashes and blobs as far as we can:
+    await this.provingState.accumulateCheckpointOutHashes();
     await this.provingState.setBlobAccumulators();
   }
 
@@ -376,7 +397,7 @@ export class ProvingOrchestrator implements EpochProver {
             typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
           >
         >();
-      logger.debug(`Starting chonk verifier circuit for tx ${txHash}`);
+      this.logger.debug(`Starting chonk verifier circuit for tx ${txHash}`);
       this.doEnqueueChonkVerifier(txHash, privateInputs, proof => {
         tubeProof.resolve(proof);
       });
@@ -416,19 +437,19 @@ export class ProvingOrchestrator implements EpochProver {
     }
 
     // Given we've applied every change from this block, now assemble the block header:
-    logger.verbose(`Block ${blockNumber} completed. Assembling header.`);
+    this.logger.verbose(`Block ${blockNumber} completed. Assembling header.`);
     const header = await provingState.buildBlockHeader();
 
     if (expectedHeader && !header.equals(expectedHeader)) {
-      logger.error(`Block header mismatch: header=${header} expectedHeader=${expectedHeader}`);
+      this.logger.error(`Block header mismatch: header=${header} expectedHeader=${expectedHeader}`);
       throw new Error('Block header mismatch');
     }
 
     // Get db for this block
-    const db = this.dbs.get(provingState.blockNumber)!;
+    const db = this.dbs.get(provingState.blockNumber)!.fork;
 
     // Update the archive tree, so we're ready to start processing the next block:
-    logger.verbose(
+    this.logger.verbose(
       `Updating archive tree with block ${provingState.blockNumber} header ${(await header.hash()).toString()}`,
     );
     await db.updateArchive(header);
@@ -442,31 +463,31 @@ export class ProvingOrchestrator implements EpochProver {
   protected async verifyBuiltBlockAgainstSyncedState(provingState: BlockProvingState) {
     const builtBlockHeader = provingState.getBuiltBlockHeader();
     if (!builtBlockHeader) {
-      logger.debug('Block header not built yet, skipping header check.');
+      this.logger.debug('Block header not built yet, skipping header check.');
       return;
     }
 
     const output = provingState.getBlockRootRollupOutput();
     if (!output) {
-      logger.debug('Block root rollup proof not built yet, skipping header check.');
+      this.logger.debug('Block root rollup proof not built yet, skipping header check.');
       return;
     }
     const header = await buildHeaderFromCircuitOutputs(output);
 
     if (!(await header.hash()).equals(await builtBlockHeader.hash())) {
-      logger.error(`Block header mismatch.\nCircuit: ${inspect(header)}\nComputed: ${inspect(builtBlockHeader)}`);
+      this.logger.error(`Block header mismatch.\nCircuit: ${inspect(header)}\nComputed: ${inspect(builtBlockHeader)}`);
       provingState.reject(`Block header hash mismatch.`);
       return;
     }
 
     // Get db for this block
     const blockNumber = provingState.blockNumber;
-    const db = this.dbs.get(blockNumber)!;
+    const db = this.dbs.get(blockNumber)!.fork;
 
     const newArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
     const syncedArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, this.dbProvider.getSnapshot(blockNumber));
     if (!syncedArchive.equals(newArchive)) {
-      logger.error(
+      this.logger.error(
         `Archive tree mismatch for block ${blockNumber}: world state synced to ${inspect(
           syncedArchive,
         )} but built ${inspect(newArchive)}`,
@@ -477,7 +498,7 @@ export class ProvingOrchestrator implements EpochProver {
 
     const circuitArchive = output.newArchive;
     if (!newArchive.equals(circuitArchive)) {
-      logger.error(`New archive mismatch.\nCircuit: ${output.newArchive}\nComputed: ${newArchive}`);
+      this.logger.error(`New archive mismatch.\nCircuit: ${output.newArchive}\nComputed: ${newArchive}`);
       provingState.reject(`New archive mismatch.`);
       return;
     }
@@ -486,20 +507,19 @@ export class ProvingOrchestrator implements EpochProver {
     // is aborted and never reaches this point, it will leak the fork. We need to add a global cleanup,
     // but have to make sure it only runs once all operations are completed, otherwise some function here
     // will attempt to access the fork after it was closed.
-    logger.debug(`Cleaning up world state fork for ${blockNumber}`);
-    void this.dbs
-      .get(blockNumber)
-      ?.close()
-      .then(() => this.dbs.delete(blockNumber))
-      .catch(err => logger.error(`Error closing db for block ${blockNumber}`, err));
+    void this.cleanupDBFork(blockNumber);
   }
 
   /**
-   * Cancel any further proving
+   * Cancel any further proving.
+   * If cancelJobsOnStop is true, aborts all pending jobs with the broker (which marks them as 'Aborted').
+   * If cancelJobsOnStop is false (default), jobs remain in the broker queue and can be reused on restart/reorg.
    */
   public cancel() {
-    for (const controller of this.pendingProvingJobs) {
-      controller.abort();
+    if (this.cancelJobsOnStop) {
+      for (const controller of this.pendingProvingJobs) {
+        controller.abort();
+      }
     }
 
     this.provingState?.cancel();
@@ -534,6 +554,24 @@ export class ProvingOrchestrator implements EpochProver {
     return epochProofResult;
   }
 
+  private async cleanupDBFork(blockNumber: BlockNumber): Promise<void> {
+    this.logger.debug(`Cleaning up world state fork for ${blockNumber}`);
+    const fork = this.dbs.get(blockNumber);
+    if (!fork) {
+      return;
+    }
+
+    try {
+      if (!fork.cleanupPromise) {
+        fork.cleanupPromise = fork.fork.close();
+      }
+      await fork.cleanupPromise;
+      this.dbs.delete(blockNumber);
+    } catch (err) {
+      this.logger.error(`Error closing db for block ${blockNumber}`, err);
+    }
+  }
+
   /**
    * Enqueue a job to be scheduled
    * @param provingState - The proving state object being operated on
@@ -546,7 +584,7 @@ export class ProvingOrchestrator implements EpochProver {
     callback: (result: T) => void | Promise<void>,
   ) {
     if (!provingState.verifyState()) {
-      logger.debug(`Not enqueuing job, state no longer valid`);
+      this.logger.debug(`Not enqueuing job, state no longer valid`);
       return;
     }
 
@@ -564,7 +602,7 @@ export class ProvingOrchestrator implements EpochProver {
 
         const result = await request(controller.signal);
         if (!provingState.verifyState()) {
-          logger.debug(`State no longer valid, discarding result`);
+          this.logger.debug(`State no longer valid, discarding result`);
           return;
         }
 
@@ -582,7 +620,7 @@ export class ProvingOrchestrator implements EpochProver {
           return;
         }
 
-        logger.error(`Error thrown when proving job`, err);
+        this.logger.error(`Error thrown when proving job`, err);
         provingState!.reject(`${err}`);
       } finally {
         const index = this.pendingProvingJobs.indexOf(controller);
@@ -667,12 +705,12 @@ export class ProvingOrchestrator implements EpochProver {
   // Executes the next level of merge if all inputs are available
   private enqueueBaseRollup(provingState: BlockProvingState, txIndex: number) {
     if (!provingState.verifyState()) {
-      logger.debug('Not running base rollup, state invalid');
+      this.logger.debug('Not running base rollup, state invalid');
       return;
     }
 
     if (!provingState.tryStartProvingBase(txIndex)) {
-      logger.debug(`Base rollup for tx ${txIndex} already started.`);
+      this.logger.debug(`Base rollup for tx ${txIndex} already started.`);
       return;
     }
 
@@ -680,7 +718,7 @@ export class ProvingOrchestrator implements EpochProver {
     const { processedTx } = txProvingState;
     const { rollupType, inputs } = txProvingState.getBaseRollupTypeAndInputs();
 
-    logger.debug(`Enqueuing deferred proving base rollup for ${processedTx.hash.toString()}`);
+    this.logger.debug(`Enqueuing deferred proving base rollup for ${processedTx.hash.toString()}`);
 
     this.deferredProving(
       provingState,
@@ -704,7 +742,7 @@ export class ProvingOrchestrator implements EpochProver {
         },
       ),
       result => {
-        logger.debug(`Completed proof for ${rollupType} for tx ${processedTx.hash.toString()}`);
+        this.logger.debug(`Completed proof for ${rollupType} for tx ${processedTx.hash.toString()}`);
         validatePartialState(result.inputs.endTreeSnapshots, txProvingState.treeSnapshots);
         const leafLocation = provingState.setBaseRollupProof(txIndex, result);
         if (provingState.totalNumTxs === 1) {
@@ -720,7 +758,7 @@ export class ProvingOrchestrator implements EpochProver {
   // Once completed, will enqueue the the public tx base rollup.
   private getOrEnqueueChonkVerifier(provingState: BlockProvingState, txIndex: number) {
     if (!provingState.verifyState()) {
-      logger.debug('Not running chonk verifier circuit, state invalid');
+      this.logger.debug('Not running chonk verifier circuit, state invalid');
       return;
     }
 
@@ -733,19 +771,19 @@ export class ProvingOrchestrator implements EpochProver {
         typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH
       >,
     ) => {
-      logger.debug(`Got chonk verifier proof for tx index: ${txIndex}`, { txHash });
+      this.logger.debug(`Got chonk verifier proof for tx index: ${txIndex}`, { txHash });
       txProvingState.setPublicChonkVerifierProof(result);
       this.provingState?.cachedChonkVerifierProofs.delete(txHash);
       this.checkAndEnqueueBaseRollup(provingState, txIndex);
     };
 
     if (this.provingState?.cachedChonkVerifierProofs.has(txHash)) {
-      logger.debug(`Chonk verifier proof already enqueued for tx index: ${txIndex}`, { txHash });
+      this.logger.debug(`Chonk verifier proof already enqueued for tx index: ${txIndex}`, { txHash });
       void this.provingState!.cachedChonkVerifierProofs.get(txHash)!.then(handleResult);
       return;
     }
 
-    logger.debug(`Enqueuing chonk verifier circuit for tx index: ${txIndex}`);
+    this.logger.debug(`Enqueuing chonk verifier circuit for tx index: ${txIndex}`);
     this.doEnqueueChonkVerifier(txHash, txProvingState.getPublicChonkVerifierPrivateInputs(), handleResult);
   }
 
@@ -761,7 +799,7 @@ export class ProvingOrchestrator implements EpochProver {
     provingState: EpochProvingState | BlockProvingState = this.provingState!,
   ) {
     if (!provingState.verifyState()) {
-      logger.debug('Not running chonk verifier circuit, state invalid');
+      this.logger.debug('Not running chonk verifier circuit, state invalid');
       return;
     }
 
@@ -784,12 +822,12 @@ export class ProvingOrchestrator implements EpochProver {
   // Enqueues the next level of merge if all inputs are available
   private enqueueMergeRollup(provingState: BlockProvingState, location: TreeNodeLocation) {
     if (!provingState.verifyState()) {
-      logger.debug('Not running merge rollup. State no longer valid.');
+      this.logger.debug('Not running merge rollup. State no longer valid.');
       return;
     }
 
     if (!provingState.tryStartProvingMerge(location)) {
-      logger.debug('Merge rollup already started.');
+      this.logger.debug('Merge rollup already started.');
       return;
     }
 
@@ -815,18 +853,18 @@ export class ProvingOrchestrator implements EpochProver {
   // Executes the block root rollup circuit
   private enqueueBlockRootRollup(provingState: BlockProvingState) {
     if (!provingState.verifyState()) {
-      logger.debug('Not running block root rollup, state no longer valid');
+      this.logger.debug('Not running block root rollup, state no longer valid');
       return;
     }
 
     if (!provingState.tryStartProvingBlockRoot()) {
-      logger.debug('Block root rollup already started.');
+      this.logger.debug('Block root rollup already started.');
       return;
     }
 
     const { rollupType, inputs } = provingState.getBlockRootRollupTypeAndInputs();
 
-    logger.debug(`Enqueuing ${rollupType} for block ${provingState.blockNumber}.`);
+    this.logger.debug(`Enqueuing ${rollupType} for block ${provingState.blockNumber}.`);
 
     this.deferredProving(
       provingState,
@@ -851,19 +889,22 @@ export class ProvingOrchestrator implements EpochProver {
         },
       ),
       async result => {
-        // If the proofs were slower than the block header building, then we need to try validating the block header hashes here.
-        await this.verifyBuiltBlockAgainstSyncedState(provingState);
-
-        logger.debug(`Completed ${rollupType} proof for block ${provingState.blockNumber}`);
+        this.logger.debug(`Completed ${rollupType} proof for block ${provingState.blockNumber}`);
 
         const leafLocation = provingState.setBlockRootRollupProof(result);
         const checkpointProvingState = provingState.parentCheckpoint;
 
+        // If the proofs were slower than the block header building, then we need to try validating the block header hashes here.
+        await this.verifyBuiltBlockAgainstSyncedState(provingState);
+
         if (checkpointProvingState.totalNumBlocks === 1) {
           this.checkAndEnqueueCheckpointRootRollup(checkpointProvingState);
         } else {
           this.checkAndEnqueueNextBlockMergeRollup(checkpointProvingState, leafLocation);
         }
+
+        // We are finished with the block at this point, ensure the fork is cleaned up
+        void this.cleanupDBFork(provingState.blockNumber);
       },
     );
   }
@@ -876,12 +917,12 @@ export class ProvingOrchestrator implements EpochProver {
     baseParityIndex: number,
   ) {
     if (!provingState.verifyState()) {
-      logger.debug('Not running base parity. State no longer valid.');
+      this.logger.debug('Not running base parity. State no longer valid.');
       return;
     }
 
     if (!provingState.tryStartProvingBaseParity(baseParityIndex)) {
-      logger.warn(`Base parity ${baseParityIndex} already started.`);
+      this.logger.warn(`Base parity ${baseParityIndex} already started.`);
       return;
     }
 
@@ -916,12 +957,12 @@ export class ProvingOrchestrator implements EpochProver {
   // Enqueues the root rollup proof if all inputs are available
   private enqueueRootParityCircuit(provingState: BlockProvingState) {
     if (!provingState.verifyState()) {
-      logger.debug('Not running root parity. State no longer valid.');
+      this.logger.debug('Not running root parity. State no longer valid.');
       return;
     }
 
     if (!provingState.tryStartProvingRootParity()) {
-      logger.debug('Root parity already started.');
+      this.logger.debug('Root parity already started.');
       return;
     }
 
@@ -948,12 +989,12 @@ export class ProvingOrchestrator implements EpochProver {
   // Enqueues the next level of merge if all inputs are available
   private enqueueBlockMergeRollup(provingState: CheckpointProvingState, location: TreeNodeLocation) {
     if (!provingState.verifyState()) {
-      logger.debug('Not running block merge rollup. State no longer valid.');
+      this.logger.debug('Not running block merge rollup. State no longer valid.');
       return;
     }
 
     if (!provingState.tryStartProvingBlockMerge(location)) {
-      logger.debug('Block merge rollup already started.');
+      this.logger.debug('Block merge rollup already started.');
       return;
     }
 
@@ -977,18 +1018,18 @@ export class ProvingOrchestrator implements EpochProver {
 
   private enqueueCheckpointRootRollup(provingState: CheckpointProvingState) {
     if (!provingState.verifyState()) {
-      logger.debug('Not running checkpoint root rollup. State no longer valid.');
+      this.logger.debug('Not running checkpoint root rollup. State no longer valid.');
       return;
     }
 
     if (!provingState.tryStartProvingCheckpointRoot()) {
-      logger.debug('Checkpoint root rollup already started.');
+      this.logger.debug('Checkpoint root rollup already started.');
       return;
     }
 
     const rollupType = provingState.getCheckpointRootRollupType();
 
-    logger.debug(`Enqueuing ${rollupType} for checkpoint ${provingState.index}.`);
+    this.logger.debug(`Enqueuing ${rollupType} for checkpoint ${provingState.index}.`);
 
     const inputs = provingState.getCheckpointRootRollupInputs();
 
@@ -1012,7 +1053,7 @@ export class ProvingOrchestrator implements EpochProver {
         const computedEndBlobAccumulatorState = provingState.getEndBlobAccumulator()!.toBlobAccumulator();
         const circuitEndBlobAccumulatorState = result.inputs.endBlobAccumulator;
         if (!circuitEndBlobAccumulatorState.equals(computedEndBlobAccumulatorState)) {
-          logger.error(
+          this.logger.error(
             `Blob accumulator state mismatch.\nCircuit: ${inspect(circuitEndBlobAccumulatorState)}\nComputed: ${inspect(
               computedEndBlobAccumulatorState,
             )}`,
@@ -1021,7 +1062,7 @@ export class ProvingOrchestrator implements EpochProver {
           return;
         }
 
-        logger.debug(`Completed ${rollupType} proof for checkpoint ${provingState.index}.`);
+        this.logger.debug(`Completed ${rollupType} proof for checkpoint ${provingState.index}.`);
 
         const leafLocation = provingState.setCheckpointRootRollupProof(result);
         const epochProvingState = provingState.parentEpoch;
@@ -1037,12 +1078,12 @@ export class ProvingOrchestrator implements EpochProver {
 
   private enqueueCheckpointMergeRollup(provingState: EpochProvingState, location: TreeNodeLocation) {
     if (!provingState.verifyState()) {
-      logger.debug('Not running checkpoint merge rollup. State no longer valid.');
+      this.logger.debug('Not running checkpoint merge rollup. State no longer valid.');
       return;
     }
 
     if (!provingState.tryStartProvingCheckpointMerge(location)) {
-      logger.debug('Checkpoint merge rollup already started.');
+      this.logger.debug('Checkpoint merge rollup already started.');
       return;
     }
 
@@ -1059,7 +1100,7 @@ export class ProvingOrchestrator implements EpochProver {
         signal => this.prover.getCheckpointMergeRollupProof(inputs, signal, provingState.epochNumber),
       ),
       result => {
-        logger.debug('Completed proof for checkpoint merge rollup.');
+        this.logger.debug('Completed proof for checkpoint merge rollup.');
         provingState.setCheckpointMergeRollupProof(location, result);
         this.checkAndEnqueueNextCheckpointMergeRollup(provingState, location);
       },
@@ -1068,16 +1109,16 @@ export class ProvingOrchestrator implements EpochProver {
 
   private enqueueEpochPadding(provingState: EpochProvingState) {
     if (!provingState.verifyState()) {
-      logger.debug('Not running epoch padding. State no longer valid.');
+      this.logger.debug('Not running epoch padding. State no longer valid.');
       return;
     }
 
     if (!provingState.tryStartProvingPaddingCheckpoint()) {
-      logger.debug('Padding checkpoint already started.');
+      this.logger.debug('Padding checkpoint already started.');
       return;
     }
 
-    logger.debug('Padding epoch proof with a padding block root proof.');
+    this.logger.debug('Padding epoch proof with a padding block root proof.');
 
     const inputs = provingState.getPaddingCheckpointInputs();
 
@@ -1092,7 +1133,7 @@ export class ProvingOrchestrator implements EpochProver {
         signal => this.prover.getCheckpointPaddingRollupProof(inputs, signal, provingState.epochNumber),
       ),
       result => {
-        logger.debug('Completed proof for padding checkpoint.');
+        this.logger.debug('Completed proof for padding checkpoint.');
         provingState.setCheckpointPaddingProof(result);
         this.checkAndEnqueueRootRollup(provingState);
       },
@@ -1102,11 +1143,11 @@ export class ProvingOrchestrator implements EpochProver {
   // Executes the root rollup circuit
   private enqueueRootRollup(provingState: EpochProvingState) {
     if (!provingState.verifyState()) {
-      logger.debug('Not running root rollup, state no longer valid');
+      this.logger.debug('Not running root rollup, state no longer valid');
       return;
     }
 
-    logger.debug(`Preparing root rollup`);
+    this.logger.debug(`Preparing root rollup`);
 
     const inputs = provingState.getRootRollupInputs();
 
@@ -1121,7 +1162,7 @@ export class ProvingOrchestrator implements EpochProver {
         signal => this.prover.getRootRollupProof(inputs, signal, provingState.epochNumber),
       ),
       result => {
-        logger.verbose(`Orchestrator completed root rollup for epoch ${provingState.epochNumber}`);
+        this.logger.verbose(`Orchestrator completed root rollup for epoch ${provingState.epochNumber}`);
         provingState.setRootRollupProof(result);
         provingState.resolve({ status: 'success' });
       },
@@ -1143,7 +1184,7 @@ export class ProvingOrchestrator implements EpochProver {
 
   private checkAndEnqueueBlockRootRollup(provingState: BlockProvingState) {
     if (!provingState.isReadyForBlockRootRollup()) {
-      logger.debug('Not ready for block root rollup');
+      this.logger.debug('Not ready for block root rollup');
       return;
     }
 
@@ -1186,7 +1227,7 @@ export class ProvingOrchestrator implements EpochProver {
 
   private checkAndEnqueueRootRollup(provingState: EpochProvingState) {
     if (!provingState.isReadyForRootRollup()) {
-      logger.debug('Not ready for root rollup');
+      this.logger.debug('Not ready for root rollup');
       return;
     }
 
@@ -1201,7 +1242,7 @@ export class ProvingOrchestrator implements EpochProver {
    */
   private enqueueVM(provingState: BlockProvingState, txIndex: number) {
     if (!provingState.verifyState()) {
-      logger.debug(`Not running VM circuit as state is no longer valid`);
+      this.logger.debug(`Not running VM circuit as state is no longer valid`);
       return;
     }
 
@@ -1220,7 +1261,7 @@ export class ProvingOrchestrator implements EpochProver {
     );
 
     this.deferredProving(provingState, doAvmProving, proof => {
-      logger.debug(`Proven VM for tx index: ${txIndex}`);
+      this.logger.debug(`Proven VM for tx index: ${txIndex}`);
       txProvingState.setAvmProof(proof);
       this.checkAndEnqueueBaseRollup(provingState, txIndex);
     });
@@ -1233,7 +1274,7 @@ export class ProvingOrchestrator implements EpochProver {
     }
 
     // We must have completed all proving (chonk verifier 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.logger.debug(`Public functions completed for tx ${txIndex} enqueueing base rollup`);
 
     this.enqueueBaseRollup(provingState, txIndex);
   }