@aztec/prover-client 0.0.1-commit.d431d1c → 0.0.1-commit.e3c1de76

package/dest/orchestrator/orchestrator.js

@@ -389,7 +389,6 @@ import { buildHeaderFromCircuitOutputs, getLastSiblingPath, getPublicChonkVerifi
 import { EpochProvingState } from './epoch-proving-state.js';
 import { ProvingOrchestratorMetrics } from './orchestrator_metrics.js';
 import { TxProvingState } from './tx-proving-state.js';
-const logger = createLogger('prover-client:orchestrator');
 _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
         [Attributes.BLOCK_NUMBER]: blockNumber
     })), _dec1 = trackSpan('ProvingOrchestrator.addTxs', (txs)=>({
@@ -414,6 +413,7 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
     dbProvider;
     prover;
     proverId;
+    cancelJobsOnStop;
     static{
         ({ e: [_initProto] } = _apply_decs_2203_r(this, [
             [
@@ -449,14 +449,17 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
     metrics;
     // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
     dbs;
-    constructor(dbProvider, prover, proverId, telemetryClient = getTelemetryClient()){
+    logger;
+    constructor(dbProvider, prover, proverId, cancelJobsOnStop = false, telemetryClient = getTelemetryClient(), bindings){
         this.dbProvider = dbProvider;
         this.prover = prover;
         this.proverId = proverId;
+        this.cancelJobsOnStop = cancelJobsOnStop;
         this.provingState = (_initProto(this), undefined);
         this.pendingProvingJobs = [];
         this.provingPromise = undefined;
         this.dbs = new Map();
+        this.logger = createLogger('prover-client:orchestrator', bindings);
         this.metrics = new ProvingOrchestratorMetrics(telemetryClient, 'ProvingOrchestrator');
     }
     get tracer() {
@@ -481,7 +484,7 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
                 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, finalBlobBatchingChallenges, (provingState)=>this.checkAndEnqueueCheckpointRootRollup(provingState), resolve, reject);
         this.provingPromise = promise;
     }
@@ -503,7 +506,10 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
         const lastBlockNumber = headerOfLastBlockInPreviousCheckpoint.globalVariables.blockNumber;
         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);
         // Insert all the l1 to l2 messages into the db. And get the states before and after the insertion.
@@ -528,14 +534,17 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
             throw new Error(`Checkpoint not accepting further blocks.`);
         }
         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);
         const lastArchiveSiblingPath = await getRootTreeSiblingPath(MerkleTreeId.ARCHIVE, db);
@@ -570,7 +579,7 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
         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;
         }
         const blockNumber = BlockNumber(txs[0].globalVariables.blockNumber);
@@ -584,8 +593,8 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
         if (!provingState.isAcceptingTxs()) {
             throw new Error(`Block ${blockNumber} has been initialized with transactions.`);
         }
-        logger.info(`Adding ${txs.length} transactions to block ${blockNumber}`);
-        const db = this.dbs.get(blockNumber);
+        this.logger.info(`Adding ${txs.length} transactions to block ${blockNumber}`);
+        const db = this.dbs.get(blockNumber).fork;
         const lastArchive = provingState.lastArchiveTreeSnapshot;
         const newL1ToL2MessageTreeSnapshot = provingState.newL1ToL2MessageTreeSnapshot;
         const spongeBlobState = provingState.getStartSpongeBlob().clone();
@@ -595,7 +604,7 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
                     throw new Error(`Invalid proving state when adding a tx`);
                 }
                 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(tx, lastArchive, newL1ToL2MessageTreeSnapshot, startSpongeBlob, db);
                 if (!provingState.verifyState()) {
@@ -606,10 +615,10 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
                 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) {
@@ -639,7 +648,7 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
             const txHash = tx.getTxHash().toString();
             const privateInputs = getPublicChonkVerifierPrivateInputsFromTx(tx, this.proverId.toField());
             const tubeProof = promiseWithResolvers();
-            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);
             });
@@ -668,16 +677,16 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
             throw new Error(`Block ${blockNumber} is still accepting txs. Call setBlockCompleted after all txs have been added.`);
         }
         // 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(`Updating archive tree with block ${provingState.blockNumber} header ${(await header.hash()).toString()}`);
+        this.logger.verbose(`Updating archive tree with block ${provingState.blockNumber} header ${(await header.hash()).toString()}`);
         await db.updateArchive(header);
         await this.verifyBuiltBlockAgainstSyncedState(provingState);
         return header;
@@ -686,33 +695,33 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
     async verifyBuiltBlockAgainstSyncedState(provingState) {
         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(`Archive tree mismatch for block ${blockNumber}: world state synced to ${inspect(syncedArchive)} but built ${inspect(newArchive)}`);
+            this.logger.error(`Archive tree mismatch for block ${blockNumber}: world state synced to ${inspect(syncedArchive)} but built ${inspect(newArchive)}`);
             provingState.reject(`Archive tree mismatch.`);
             return;
         }
         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;
         }
@@ -723,10 +732,14 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
         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.
    */ cancel() {
-        for (const controller of this.pendingProvingJobs){
-            controller.abort();
+        if (this.cancelJobsOnStop) {
+            for (const controller of this.pendingProvingJobs){
+                controller.abort();
+            }
         }
         this.provingState?.cancel();
     }
@@ -749,16 +762,19 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
         return epochProofResult;
     }
     async cleanupDBFork(blockNumber) {
-        logger.debug(`Cleaning up world state fork for ${blockNumber}`);
+        this.logger.debug(`Cleaning up world state fork for ${blockNumber}`);
         const fork = this.dbs.get(blockNumber);
         if (!fork) {
             return;
         }
         try {
-            await fork.close();
+            if (!fork.cleanupPromise) {
+                fork.cleanupPromise = fork.fork.close();
+            }
+            await fork.cleanupPromise;
             this.dbs.delete(blockNumber);
         } catch (err) {
-            logger.error(`Error closing db for block ${blockNumber}`, err);
+            this.logger.error(`Error closing db for block ${blockNumber}`, err);
         }
     }
     /**
@@ -768,7 +784,7 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
    * @param job - The actual job, returns a promise notifying of the job's completion
    */ deferredProving(provingState, request, callback) {
         if (!provingState.verifyState()) {
-            logger.debug(`Not enqueuing job, state no longer valid`);
+            this.logger.debug(`Not enqueuing job, state no longer valid`);
             return;
         }
         const controller = new AbortController();
@@ -783,7 +799,7 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
                 }
                 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;
                 }
                 // we could have been cancelled whilst waiting for the result
@@ -798,7 +814,7 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
                     // drop this result
                     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);
@@ -854,17 +870,17 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
     // Executes the next level of merge if all inputs are available
     enqueueBaseRollup(provingState, txIndex) {
         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;
         }
         const txProvingState = provingState.getTxProvingState(txIndex);
         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, wrapCallbackInSpan(this.tracer, `ProvingOrchestrator.prover.${inputs instanceof PrivateTxBaseRollupPrivateInputs ? 'getPrivateTxBaseRollupProof' : 'getPublicTxBaseRollupProof'}`, {
             [Attributes.TX_HASH]: processedTx.hash.toString(),
             [Attributes.PROTOCOL_CIRCUIT_NAME]: rollupType
@@ -875,7 +891,7 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
                 return this.prover.getPublicTxBaseRollupProof(inputs, signal, provingState.epochNumber);
             }
         }), (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) {
@@ -889,14 +905,14 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
     // Once completed, will enqueue the the public tx base rollup.
     getOrEnqueueChonkVerifier(provingState, txIndex) {
         if (!provingState.verifyState()) {
-            logger.debug('Not running chonk verifier circuit, state invalid');
+            this.logger.debug('Not running chonk verifier circuit, state invalid');
             return;
         }
         const txProvingState = provingState.getTxProvingState(txIndex);
         const txHash = txProvingState.processedTx.hash.toString();
         NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH;
         const handleResult = (result)=>{
-            logger.debug(`Got chonk verifier proof for tx index: ${txIndex}`, {
+            this.logger.debug(`Got chonk verifier proof for tx index: ${txIndex}`, {
                 txHash
             });
             txProvingState.setPublicChonkVerifierProof(result);
@@ -904,18 +920,18 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
             this.checkAndEnqueueBaseRollup(provingState, txIndex);
         };
         if (this.provingState?.cachedChonkVerifierProofs.has(txHash)) {
-            logger.debug(`Chonk verifier proof already enqueued for tx index: ${txIndex}`, {
+            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);
     }
     doEnqueueChonkVerifier(txHash, inputs, handler, provingState = 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;
         }
         this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getPublicChonkVerifierProof', {
@@ -927,11 +943,11 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
     // Enqueues the next level of merge if all inputs are available
     enqueueMergeRollup(provingState, location) {
         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;
         }
         const inputs = provingState.getMergeRollupInputs(location);
@@ -945,15 +961,15 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
     // Executes the block root rollup circuit
     enqueueBlockRootRollup(provingState) {
         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, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getBlockRootRollupProof', {
             [Attributes.PROTOCOL_CIRCUIT_NAME]: rollupType
         }, (signal)=>{
@@ -969,7 +985,7 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
                 return this.prover.getBlockRootRollupProof(inputs, signal, provingState.epochNumber);
             }
         }), async (result)=>{
-            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.
@@ -987,11 +1003,11 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
     // Enqueues the root parity circuit if all inputs are available
     enqueueBaseParityCircuit(checkpointProvingState, provingState, baseParityIndex) {
         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;
         }
         const inputs = checkpointProvingState.getBaseParityInputs(baseParityIndex);
@@ -1012,11 +1028,11 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
     // Enqueues the root rollup proof if all inputs are available
     enqueueRootParityCircuit(provingState) {
         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;
         }
         const inputs = provingState.getParityRootInputs();
@@ -1031,11 +1047,11 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
     // Enqueues the next level of merge if all inputs are available
     enqueueBlockMergeRollup(provingState, location) {
         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;
         }
         const inputs = provingState.getBlockMergeRollupInputs(location);
@@ -1048,15 +1064,15 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
     }
     enqueueCheckpointRootRollup(provingState) {
         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();
         this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getCheckpointRootRollupProof', {
             [Attributes.PROTOCOL_CIRCUIT_NAME]: rollupType
@@ -1070,11 +1086,11 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
             const computedEndBlobAccumulatorState = provingState.getEndBlobAccumulator().toBlobAccumulator();
             const circuitEndBlobAccumulatorState = result.inputs.endBlobAccumulator;
             if (!circuitEndBlobAccumulatorState.equals(computedEndBlobAccumulatorState)) {
-                logger.error(`Blob accumulator state mismatch.\nCircuit: ${inspect(circuitEndBlobAccumulatorState)}\nComputed: ${inspect(computedEndBlobAccumulatorState)}`);
+                this.logger.error(`Blob accumulator state mismatch.\nCircuit: ${inspect(circuitEndBlobAccumulatorState)}\nComputed: ${inspect(computedEndBlobAccumulatorState)}`);
                 provingState.reject(`Blob accumulator state mismatch.`);
                 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;
             if (epochProvingState.totalNumCheckpoints === 1) {
@@ -1086,37 +1102,37 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
     }
     enqueueCheckpointMergeRollup(provingState, location) {
         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;
         }
         const inputs = provingState.getCheckpointMergeRollupInputs(location);
         this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getCheckpointMergeRollupProof', {
             [Attributes.PROTOCOL_CIRCUIT_NAME]: 'rollup-checkpoint-merge'
         }, (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);
         });
     }
     enqueueEpochPadding(provingState) {
         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();
         this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getCheckpointPaddingRollupProof', {
             [Attributes.PROTOCOL_CIRCUIT_NAME]: 'rollup-checkpoint-padding'
         }, (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);
         });
@@ -1124,15 +1140,15 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
     // Executes the root rollup circuit
     enqueueRootRollup(provingState) {
         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();
         this.deferredProving(provingState, wrapCallbackInSpan(this.tracer, 'ProvingOrchestrator.prover.getRootRollupProof', {
             [Attributes.PROTOCOL_CIRCUIT_NAME]: 'rollup-root'
         }, (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'
@@ -1152,7 +1168,7 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
     }
     checkAndEnqueueBlockRootRollup(provingState) {
         if (!provingState.isReadyForBlockRootRollup()) {
-            logger.debug('Not ready for block root rollup');
+            this.logger.debug('Not ready for block root rollup');
             return;
         }
         this.enqueueBlockRootRollup(provingState);
@@ -1187,7 +1203,7 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
     }
     checkAndEnqueueRootRollup(provingState) {
         if (!provingState.isReadyForRootRollup()) {
-            logger.debug('Not ready for root rollup');
+            this.logger.debug('Not ready for root rollup');
             return;
         }
         this.enqueueRootRollup(provingState);
@@ -1199,7 +1215,7 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
    * @param txIndex - The index of the transaction being proven
    */ enqueueVM(provingState, txIndex) {
         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;
         }
         const txProvingState = provingState.getTxProvingState(txIndex);
@@ -1210,7 +1226,7 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
             return await this.prover.getAvmProof(inputs, signal, provingState.epochNumber);
         });
         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);
         });
@@ -1221,7 +1237,7 @@ _dec = trackSpan('ProvingOrchestrator.startNewBlock', (blockNumber)=>({
             return;
         }
         // 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);
     }
 }

package/dest/prover-client/prover-client.d.ts

@@ -39,4 +39,4 @@ export declare class ProverClient implements EpochProverManager {
     private stopAgents;
 }
 export declare function buildServerCircuitProver(config: ActualProverConfig & ACVMConfig & BBConfig, telemetry: TelemetryClient): Promise<ServerCircuitProver>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmVyLWNsaWVudC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Byb3Zlci1jbGllbnQvcHJvdmVyLWNsaWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxVQUFVLEVBQUUsS0FBSyxRQUFRLEVBQTJDLE1BQU0sa0JBQWtCLENBQUM7QUFFM0csT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFHaEUsT0FBTyxFQUNMLEtBQUssa0JBQWtCLEVBQ3ZCLEtBQUssV0FBVyxFQUNoQixLQUFLLGtCQUFrQixFQUN2QixLQUFLLHdCQUF3QixFQUM3QixLQUFLLGdCQUFnQixFQUNyQixLQUFLLGtCQUFrQixFQUV2QixLQUFLLHdCQUF3QixFQUM3QixLQUFLLG1CQUFtQixFQUV6QixNQUFNLGlDQUFpQyxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxLQUFLLGVBQWUsRUFBc0IsTUFBTSx5QkFBeUIsQ0FBQztBQUVuRixPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQU92RCxzSEFBc0g7QUFDdEgscUJBQWEsWUFBYSxZQUFXLGtCQUFrQjtJQVFuRCxPQUFPLENBQUMsTUFBTTtJQUNkLE9BQU8sQ0FBQyxVQUFVO0lBQ2xCLE9BQU8sQ0FBQyxrQkFBa0I7SUFDMUIsT0FBTyxDQUFDLFdBQVcsQ0FBQztJQUNwQixPQUFPLENBQUMsU0FBUztJQUNqQixPQUFPLENBQUMsR0FBRztJQVpiLE9BQU8sQ0FBQyxPQUFPLENBQVM7SUFDeEIsT0FBTyxDQUFDLE1BQU0sQ0FBc0I7SUFFcEMsT0FBTyxDQUFDLFVBQVUsQ0FBYTtJQUMvQixPQUFPLENBQUMsZ0JBQWdCLENBQXlCO0lBRWpELE9BQU8sZUFVTjtJQUVNLGlCQUFpQixJQUFJLFdBQVcsQ0FJdEM7SUFFTSxXQUFXLElBQUksVUFBVSxDQUUvQjtJQUVLLGtCQUFrQixDQUFDLE1BQU0sRUFBRSxPQUFPLENBQUMsa0JBQWtCLENBQUMsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBWTNFO0lBRUQ7O09BRUc7SUFDVSxLQUFLLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQU9sQztJQUVEOztPQUVHO0lBQ1UsSUFBSSxrQkFPaEI7SUFFRDs7Ozs7T0FLRztJQUNILE9BQW9CLEdBQUcsQ0FDckIsTUFBTSxFQUFFLGtCQUFrQixFQUMxQixVQUFVLEVBQUUsd0JBQXdCLEdBQUcsd0JBQXdCLEVBQy9ELE1BQU0sRUFBRSxnQkFBZ0IsRUFDeEIsU0FBUyxHQUFFLGVBQXNDLHlCQUtsRDtJQUVNLG1CQUFtQixJQUFJLGtCQUFrQixDQU0vQztZQUVhLG9CQUFvQjtZQW1CcEIsVUFBVTtDQUd6QjtBQUVELHdCQUFnQix3QkFBd0IsQ0FDdEMsTUFBTSxFQUFFLGtCQUFrQixHQUFHLFVBQVUsR0FBRyxRQUFRLEVBQ2xELFNBQVMsRUFBRSxlQUFlLEdBQ3pCLE9BQU8sQ0FBQyxtQkFBbUIsQ0FBQyxDQVU5QiJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmVyLWNsaWVudC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Byb3Zlci1jbGllbnQvcHJvdmVyLWNsaWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxVQUFVLEVBQUUsS0FBSyxRQUFRLEVBQTJDLE1BQU0sa0JBQWtCLENBQUM7QUFFM0csT0FBTyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFHaEUsT0FBTyxFQUNMLEtBQUssa0JBQWtCLEVBQ3ZCLEtBQUssV0FBVyxFQUNoQixLQUFLLGtCQUFrQixFQUN2QixLQUFLLHdCQUF3QixFQUM3QixLQUFLLGdCQUFnQixFQUNyQixLQUFLLGtCQUFrQixFQUV2QixLQUFLLHdCQUF3QixFQUM3QixLQUFLLG1CQUFtQixFQUV6QixNQUFNLGlDQUFpQyxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxLQUFLLGVBQWUsRUFBc0IsTUFBTSx5QkFBeUIsQ0FBQztBQUVuRixPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQU92RCxzSEFBc0g7QUFDdEgscUJBQWEsWUFBYSxZQUFXLGtCQUFrQjtJQVFuRCxPQUFPLENBQUMsTUFBTTtJQUNkLE9BQU8sQ0FBQyxVQUFVO0lBQ2xCLE9BQU8sQ0FBQyxrQkFBa0I7SUFDMUIsT0FBTyxDQUFDLFdBQVcsQ0FBQztJQUNwQixPQUFPLENBQUMsU0FBUztJQUNqQixPQUFPLENBQUMsR0FBRztJQVpiLE9BQU8sQ0FBQyxPQUFPLENBQVM7SUFDeEIsT0FBTyxDQUFDLE1BQU0sQ0FBc0I7SUFFcEMsT0FBTyxDQUFDLFVBQVUsQ0FBYTtJQUMvQixPQUFPLENBQUMsZ0JBQWdCLENBQXlCO0lBRWpELE9BQU8sZUFVTjtJQUVNLGlCQUFpQixJQUFJLFdBQVcsQ0FrQnRDO0lBRU0sV0FBVyxJQUFJLFVBQVUsQ0FFL0I7SUFFSyxrQkFBa0IsQ0FBQyxNQUFNLEVBQUUsT0FBTyxDQUFDLGtCQUFrQixDQUFDLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQVkzRTtJQUVEOztPQUVHO0lBQ1UsS0FBSyxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FPbEM7SUFFRDs7T0FFRztJQUNVLElBQUksa0JBT2hCO0lBRUQ7Ozs7O09BS0c7SUFDSCxPQUFvQixHQUFHLENBQ3JCLE1BQU0sRUFBRSxrQkFBa0IsRUFDMUIsVUFBVSxFQUFFLHdCQUF3QixHQUFHLHdCQUF3QixFQUMvRCxNQUFNLEVBQUUsZ0JBQWdCLEVBQ3hCLFNBQVMsR0FBRSxlQUFzQyx5QkFLbEQ7SUFFTSxtQkFBbUIsSUFBSSxrQkFBa0IsQ0FNL0M7WUFFYSxvQkFBb0I7WUFxQnBCLFVBQVU7Q0FHekI7QUFFRCx3QkFBZ0Isd0JBQXdCLENBQ3RDLE1BQU0sRUFBRSxrQkFBa0IsR0FBRyxVQUFVLEdBQUcsUUFBUSxFQUNsRCxTQUFTLEVBQUUsZUFBZSxHQUN6QixPQUFPLENBQUMsbUJBQW1CLENBQUMsQ0FXOUIifQ==

package/dest/prover-client/prover-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prover-client.d.ts","sourceRoot":"","sources":["../../src/prover-client/prover-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,QAAQ,EAA2C,MAAM,kBAAkB,CAAC;AAE3G,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAGhE,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EAEvB,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EAEzB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAEnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAOvD,sHAAsH;AACtH,qBAAa,YAAa,YAAW,kBAAkB;IAQnD,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,WAAW,CAAC;IACpB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,GAAG;IAZb,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,MAAM,CAAsB;IAEpC,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,gBAAgB,CAAyB;IAEjD,OAAO,eAUN;IAEM,iBAAiB,IAAI,WAAW,CAItC;IAEM,WAAW,IAAI,UAAU,CAE/B;IAEK,kBAAkB,CAAC,MAAM,EAAE,OAAO,CAAC,kBAAkB,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAY3E;IAED;;OAEG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAOlC;IAED;;OAEG;IACU,IAAI,kBAOhB;IAED;;;;;OAKG;IACH,OAAoB,GAAG,CACrB,MAAM,EAAE,kBAAkB,EAC1B,UAAU,EAAE,wBAAwB,GAAG,wBAAwB,EAC/D,MAAM,EAAE,gBAAgB,EACxB,SAAS,GAAE,eAAsC,yBAKlD;IAEM,mBAAmB,IAAI,kBAAkB,CAM/C;YAEa,oBAAoB;YAmBpB,UAAU;CAGzB;AAED,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,kBAAkB,GAAG,UAAU,GAAG,QAAQ,EAClD,SAAS,EAAE,eAAe,GACzB,OAAO,CAAC,mBAAmB,CAAC,CAU9B"}
+{"version":3,"file":"prover-client.d.ts","sourceRoot":"","sources":["../../src/prover-client/prover-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,QAAQ,EAA2C,MAAM,kBAAkB,CAAC;AAE3G,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAGhE,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EAEvB,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EAEzB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAEnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAOvD,sHAAsH;AACtH,qBAAa,YAAa,YAAW,kBAAkB;IAQnD,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,WAAW,CAAC;IACpB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,GAAG;IAZb,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,MAAM,CAAsB;IAEpC,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,gBAAgB,CAAyB;IAEjD,OAAO,eAUN;IAEM,iBAAiB,IAAI,WAAW,CAkBtC;IAEM,WAAW,IAAI,UAAU,CAE/B;IAEK,kBAAkB,CAAC,MAAM,EAAE,OAAO,CAAC,kBAAkB,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAY3E;IAED;;OAEG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAOlC;IAED;;OAEG;IACU,IAAI,kBAOhB;IAED;;;;;OAKG;IACH,OAAoB,GAAG,CACrB,MAAM,EAAE,kBAAkB,EAC1B,UAAU,EAAE,wBAAwB,GAAG,wBAAwB,EAC/D,MAAM,EAAE,gBAAgB,EACxB,SAAS,GAAE,eAAsC,yBAKlD;IAEM,mBAAmB,IAAI,kBAAkB,CAM/C;YAEa,oBAAoB;YAqBpB,UAAU;CAGzB;AAED,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,kBAAkB,GAAG,UAAU,GAAG,QAAQ,EAClD,SAAS,EAAE,eAAe,GACzB,OAAO,CAAC,mBAAmB,CAAC,CAW9B"}

package/dest/prover-client/prover-client.js

@@ -33,8 +33,9 @@ import { ServerEpochProver } from './server-epoch-prover.js';
         this.failedProofStore = this.config.failedProofStore ? createProofStore(this.config.failedProofStore) : undefined;
     }
     createEpochProver() {
-        const facade = new BrokerCircuitProverFacade(this.orchestratorClient, this.proofStore, this.failedProofStore);
-        const orchestrator = new ProvingOrchestrator(this.worldState, facade, this.config.proverId, this.telemetry);
+        const bindings = this.log.getBindings();
+        const facade = new BrokerCircuitProverFacade(this.orchestratorClient, this.proofStore, this.failedProofStore, undefined, bindings);
+        const orchestrator = new ProvingOrchestrator(this.worldState, facade, this.config.proverId, this.config.cancelJobsOnStop, this.telemetry, bindings);
         return new ServerEpochProver(facade, orchestrator);
     }
     getProverId() {
@@ -95,7 +96,8 @@ import { ServerEpochProver } from './server-epoch-prover.js';
         }
         const proofStore = new InlineProofStore();
         const prover = await buildServerCircuitProver(this.config, this.telemetry);
-        this.agents = times(this.config.proverAgentCount, ()=>new ProvingAgent(this.agentClient, proofStore, prover, [], this.config.proverAgentPollIntervalMs));
+        const bindings = this.log.getBindings();
+        this.agents = times(this.config.proverAgentCount, ()=>new ProvingAgent(this.agentClient, proofStore, prover, [], this.config.proverAgentPollIntervalMs, bindings));
         await Promise.all(this.agents.map((agent)=>agent.start()));
     }
     async stopAgents() {
@@ -106,6 +108,7 @@ export function buildServerCircuitProver(config, telemetry) {
     if (config.realProofs) {
         return BBNativeRollupProver.new(config, telemetry);
     }
-    const simulator = config.acvmBinaryPath ? new NativeACVMSimulator(config.acvmWorkingDirectory, config.acvmBinaryPath) : undefined;
+    const logger = createLogger('prover-client:acvm-native');
+    const simulator = config.acvmBinaryPath ? new NativeACVMSimulator(config.acvmWorkingDirectory, config.acvmBinaryPath, undefined, logger) : undefined;
     return Promise.resolve(new TestCircuitProver(simulator, config, telemetry));
 }