@aztec/prover-client 0.65.2 → 0.67.0

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

@@ -50,20 +50,16 @@ export class EpochProvingState {
   private mergeRollupInputs: BlockMergeRollupInputData[] = [];
   public rootRollupPublicInputs: RootRollupPublicInputs | undefined;
   public finalProof: Proof | undefined;
-  public blocks: BlockProvingState[] = [];
+  public blocks: (BlockProvingState | undefined)[] = [];
 
   constructor(
     public readonly epochNumber: number,
+    public readonly firstBlockNumber: number,
     public readonly totalNumBlocks: number,
     private completionCallback: (result: ProvingResult) => void,
     private rejectionCallback: (reason: string) => void,
   ) {}
 
-  /** Returns the current block proving state */
-  public get currentBlock(): BlockProvingState | undefined {
-    return this.blocks.at(-1);
-  }
-
   // Returns the number of levels of merge rollups
   public get numMergeLevels() {
     const totalLeaves = Math.max(2, this.totalNumBlocks);
@@ -110,9 +106,10 @@ export class EpochProvingState {
     archiveTreeSnapshot: AppendOnlyTreeSnapshot,
     archiveTreeRootSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
     previousBlockHash: Fr,
-  ) {
+  ): BlockProvingState {
+    const index = globalVariables.blockNumber.toNumber() - this.firstBlockNumber;
     const block = new BlockProvingState(
-      this.blocks.length,
+      index,
       numTxs,
       globalVariables,
       padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP),
@@ -124,11 +121,11 @@ export class EpochProvingState {
       previousBlockHash,
       this,
     );
-    this.blocks.push(block);
-    if (this.blocks.length === this.totalNumBlocks) {
+    this.blocks[index] = block;
+    if (this.blocks.filter(b => !!b).length === this.totalNumBlocks) {
       this.provingStateLifecycle = PROVING_STATE_LIFECYCLE.PROVING_STATE_FULL;
     }
-    return this.blocks.length - 1;
+    return block;
   }
 
   // Returns true if this proving state is still valid, false otherwise
@@ -180,8 +177,8 @@ export class EpochProvingState {
   }
 
   // Returns a specific transaction proving state
-  public getBlockProvingState(index: number) {
-    return this.blocks[index];
+  public getBlockProvingStateByBlockNumber(blockNumber: number) {
+    return this.blocks.find(block => block?.blockNumber === blockNumber);
   }
 
   // Returns a set of merge rollup inputs

package/src/orchestrator/orchestrator.ts

@@ -7,6 +7,7 @@ import {
 } from '@aztec/circuit-types';
 import {
   type EpochProver,
+  type ForkMerkleTreeOperations,
   type MerkleTreeWriteOperations,
   type ProofAndVerificationKey,
 } from '@aztec/circuit-types/interfaces';
@@ -14,15 +15,16 @@ import { type CircuitName } from '@aztec/circuit-types/stats';
 import {
   AVM_PROOF_LENGTH_IN_FIELDS,
   AVM_VERIFICATION_KEY_LENGTH_IN_FIELDS,
+  type AppendOnlyTreeSnapshot,
   type BaseOrMergeRollupPublicInputs,
   BaseParityInputs,
   type BaseRollupHints,
+  type BlockHeader,
   type BlockRootOrBlockMergePublicInputs,
   BlockRootRollupInputs,
   EmptyBlockRootRollupInputs,
   Fr,
   type GlobalVariables,
-  type Header,
   L1_TO_L2_MSG_SUBTREE_HEIGHT,
   L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH,
   type NESTED_RECURSIVE_PROOF_LENGTH,
@@ -38,9 +40,9 @@ import {
   makeEmptyRecursiveProof,
 } from '@aztec/circuits.js';
 import { makeTuple } from '@aztec/foundation/array';
-import { padArrayEnd } from '@aztec/foundation/collection';
+import { maxBy, padArrayEnd } from '@aztec/foundation/collection';
 import { AbortError } from '@aztec/foundation/error';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { type Tuple } from '@aztec/foundation/serialize';
 import { pushTestData } from '@aztec/foundation/testing';
@@ -75,7 +77,7 @@ import {
 import { ProvingOrchestratorMetrics } from './orchestrator_metrics.js';
 import { TxProvingState } from './tx-proving-state.js';
 
-const logger = createDebugLogger('aztec:prover:proving-orchestrator');
+const logger = createLogger('prover-client:orchestrator');
 
 /**
  * Implements an event driven proving scheduler to build the recursive proof tree. The idea being:
@@ -98,9 +100,10 @@ export class ProvingOrchestrator implements EpochProver {
 
   private provingPromise: Promise<ProvingResult> | undefined = undefined;
   private metrics: ProvingOrchestratorMetrics;
+  private dbs: Map<number, MerkleTreeWriteOperations> = new Map();
 
   constructor(
-    private db: MerkleTreeWriteOperations,
+    private dbProvider: ForkMerkleTreeOperations,
     private prover: ServerCircuitProver,
     telemetryClient: TelemetryClient,
     private readonly proverId: Fr = Fr.ZERO,
@@ -123,14 +126,14 @@ export class ProvingOrchestrator implements EpochProver {
     this.paddingTxProof = undefined;
   }
 
-  public startNewEpoch(epochNumber: number, totalNumBlocks: number) {
+  public startNewEpoch(epochNumber: number, firstBlockNumber: number, totalNumBlocks: number) {
     const { promise: _promise, resolve, reject } = promiseWithResolvers<ProvingResult>();
     const promise = _promise.catch((reason): ProvingResult => ({ status: 'failure', reason }));
     if (totalNumBlocks <= 0 || !Number.isInteger(totalNumBlocks)) {
       throw new Error(`Invalid number of blocks for epoch (got ${totalNumBlocks})`);
     }
     logger.info(`Starting epoch ${epochNumber} with ${totalNumBlocks} blocks`);
-    this.provingState = new EpochProvingState(epochNumber, totalNumBlocks, resolve, reject);
+    this.provingState = new EpochProvingState(epochNumber, firstBlockNumber, totalNumBlocks, resolve, reject);
     this.provingPromise = promise;
   }
 
@@ -159,24 +162,14 @@ export class ProvingOrchestrator implements EpochProver {
       throw new Error(`Invalid number of txs for block (got ${numTxs})`);
     }
 
-    if (this.provingState.currentBlock && !this.provingState.currentBlock.block) {
-      throw new Error(`Must end previous block before starting a new one`);
-    }
-
-    // TODO(palla/prover): Store block number in the db itself to make this check more reliable,
-    // and turn this warning into an exception that we throw.
-    const { blockNumber } = globalVariables;
-    const dbBlockNumber = (await this.db.getTreeInfo(MerkleTreeId.ARCHIVE)).size - 1n;
-    if (dbBlockNumber !== blockNumber.toBigInt() - 1n) {
-      logger.warn(
-        `Database is at wrong block number (starting block ${blockNumber.toBigInt()} with db at ${dbBlockNumber})`,
-      );
-    }
-
     logger.info(
-      `Starting block ${globalVariables.blockNumber} for slot ${globalVariables.slotNumber} with ${numTxs} transactions`,
+      `Starting block ${globalVariables.blockNumber.toNumber()} for slot ${globalVariables.slotNumber.toNumber()} with ${numTxs} transactions`,
     );
 
+    // Fork world state at the end of the immediately previous block
+    const db = await this.dbProvider.fork(globalVariables.blockNumber.toNumber() - 1);
+    this.dbs.set(globalVariables.blockNumber.toNumber(), db);
+
     // we start the block by enqueueing all of the base parity circuits
     let baseParityInputs: BaseParityInputs[] = [];
     let l1ToL2MessagesPadded: Tuple<Fr, typeof NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP>;
@@ -189,12 +182,12 @@ export class ProvingOrchestrator implements EpochProver {
       BaseParityInputs.fromSlice(l1ToL2MessagesPadded, i, getVKTreeRoot()),
     );
 
-    const messageTreeSnapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, this.db);
+    const messageTreeSnapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
 
     const newL1ToL2MessageTreeRootSiblingPathArray = await getSubtreeSiblingPath(
       MerkleTreeId.L1_TO_L2_MESSAGE_TREE,
       L1_TO_L2_MSG_SUBTREE_HEIGHT,
-      this.db,
+      db,
     );
 
     const newL1ToL2MessageTreeRootSiblingPath = makeTuple(
@@ -205,18 +198,18 @@ export class ProvingOrchestrator implements EpochProver {
     );
 
     // Update the local trees to include the new l1 to l2 messages
-    await this.db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
-    const messageTreeSnapshotAfterInsertion = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, this.db);
+    await db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
+    const messageTreeSnapshotAfterInsertion = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, db);
 
     // Get archive snapshot before this block lands
-    const startArchiveSnapshot = await getTreeSnapshot(MerkleTreeId.ARCHIVE, this.db);
-    const newArchiveSiblingPath = await getRootTreeSiblingPath(MerkleTreeId.ARCHIVE, this.db);
-    const previousBlockHash = await this.db.getLeafValue(
+    const startArchiveSnapshot = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
+    const newArchiveSiblingPath = await getRootTreeSiblingPath(MerkleTreeId.ARCHIVE, db);
+    const previousBlockHash = await db.getLeafValue(
       MerkleTreeId.ARCHIVE,
       BigInt(startArchiveSnapshot.nextAvailableLeafIndex - 1),
     );
 
-    this.provingState!.startNewBlock(
+    const blockProvingState = this.provingState!.startNewBlock(
       numTxs,
       globalVariables,
       l1ToL2MessagesPadded,
@@ -230,7 +223,7 @@ export class ProvingOrchestrator implements EpochProver {
 
     // Enqueue base parity circuits for the block
     for (let i = 0; i < baseParityInputs.length; i++) {
-      this.enqueueBaseParityCircuit(this.provingState!.currentBlock!, baseParityInputs[i], i);
+      this.enqueueBaseParityCircuit(blockProvingState, baseParityInputs[i], i);
     }
   }
 
@@ -242,33 +235,40 @@ export class ProvingOrchestrator implements EpochProver {
     [Attributes.TX_HASH]: tx.hash.toString(),
   }))
   public async addNewTx(tx: ProcessedTx): Promise<void> {
-    const provingState = this?.provingState?.currentBlock;
-    if (!provingState) {
-      throw new Error(`Invalid proving state, call startNewBlock before adding transactions`);
-    }
+    const blockNumber = tx.constants.globalVariables.blockNumber.toNumber();
+    try {
+      const provingState = this.provingState?.getBlockProvingStateByBlockNumber(blockNumber);
+      if (!provingState) {
+        throw new Error(`Block proving state for ${blockNumber} not found`);
+      }
 
-    if (!provingState.isAcceptingTransactions()) {
-      throw new Error(`Rollup not accepting further transactions`);
-    }
+      if (!provingState.isAcceptingTransactions()) {
+        throw new Error(`Rollup not accepting further transactions`);
+      }
 
-    if (!provingState.verifyState()) {
-      throw new Error(`Invalid proving state when adding a tx`);
-    }
+      if (!provingState.verifyState()) {
+        throw new Error(`Invalid proving state when adding a tx`);
+      }
 
-    validateTx(tx);
+      validateTx(tx);
 
-    logger.info(`Received transaction: ${tx.hash}`);
+      logger.info(`Received transaction: ${tx.hash}`);
 
-    if (tx.isEmpty) {
-      logger.warn(`Ignoring empty transaction ${tx.hash} - it will not be added to this block`);
-      return;
-    }
+      if (tx.isEmpty) {
+        logger.warn(`Ignoring empty transaction ${tx.hash} - it will not be added to this block`);
+        return;
+      }
 
-    const [hints, treeSnapshots] = await this.prepareTransaction(tx, provingState);
-    this.enqueueFirstProofs(hints, treeSnapshots, tx, provingState);
+      const [hints, treeSnapshots] = await this.prepareTransaction(tx, provingState);
+      this.enqueueFirstProofs(hints, treeSnapshots, tx, provingState);
 
-    if (provingState.transactionsReceived === provingState.totalNumTxs) {
-      logger.verbose(`All transactions received for block ${provingState.globalVariables.blockNumber}.`);
+      if (provingState.transactionsReceived === provingState.totalNumTxs) {
+        logger.verbose(`All transactions received for block ${provingState.globalVariables.blockNumber}.`);
+      }
+    } catch (err: any) {
+      throw new Error(`Error adding transaction ${tx.hash.toString()} to block ${blockNumber}: ${err.message}`, {
+        cause: err,
+      });
     }
   }
 
@@ -276,21 +276,13 @@ export class ProvingOrchestrator implements EpochProver {
    * Marks the block as full and pads it if required, no more transactions will be accepted.
    * Computes the block header and updates the archive tree.
    */
-  @trackSpan('ProvingOrchestrator.setBlockCompleted', function () {
-    const block = this.provingState?.currentBlock;
-    if (!block) {
-      return {};
-    }
-    return {
-      [Attributes.BLOCK_NUMBER]: block.globalVariables.blockNumber.toNumber(),
-      [Attributes.BLOCK_SIZE]: block.totalNumTxs,
-      [Attributes.BLOCK_TXS_COUNT]: block.transactionsReceived,
-    };
-  })
-  public async setBlockCompleted(expectedHeader?: Header): Promise<L2Block> {
-    const provingState = this.provingState?.currentBlock;
+  @trackSpan('ProvingOrchestrator.setBlockCompleted', (blockNumber: number) => ({
+    [Attributes.BLOCK_NUMBER]: blockNumber,
+  }))
+  public async setBlockCompleted(blockNumber: number, expectedHeader?: BlockHeader): Promise<L2Block> {
+    const provingState = this.provingState?.getBlockProvingStateByBlockNumber(blockNumber);
     if (!provingState) {
-      throw new Error(`Invalid proving state, call startNewBlock before adding transactions or completing the block`);
+      throw new Error(`Block proving state for ${blockNumber} not found`);
     }
 
     if (!provingState.verifyState()) {
@@ -313,7 +305,7 @@ export class ProvingOrchestrator implements EpochProver {
       // base rollup inputs
       // Then enqueue the proving of all the transactions
       const unprovenPaddingTx = makeEmptyProcessedTx(
-        this.db.getInitialHeader(),
+        this.dbs.get(blockNumber)!.getInitialHeader(),
         provingState.globalVariables.chainId,
         provingState.globalVariables.version,
         getVKTreeRoot(),
@@ -344,7 +336,7 @@ export class ProvingOrchestrator implements EpochProver {
 
   /** Returns the block as built for a given index. */
   public getBlock(index: number): L2Block {
-    const block = this.provingState?.blocks[index].block;
+    const block = this.provingState?.blocks[index]?.block;
     if (!block) {
       throw new Error(`Block at index ${index} not available`);
     }
@@ -362,7 +354,10 @@ export class ProvingOrchestrator implements EpochProver {
   })
   private padEpoch(): Promise<void> {
     const provingState = this.provingState!;
-    const lastBlock = provingState.currentBlock?.block;
+    const lastBlock = maxBy(
+      provingState.blocks.filter(b => !!b),
+      b => b!.blockNumber,
+    )?.block;
     if (!lastBlock) {
       return Promise.reject(new Error(`Epoch needs at least one completed block in order to be padded`));
     }
@@ -412,17 +407,20 @@ export class ProvingOrchestrator implements EpochProver {
     return Promise.resolve();
   }
 
-  private async buildBlock(provingState: BlockProvingState, expectedHeader?: Header) {
+  private async buildBlock(provingState: BlockProvingState, expectedHeader?: BlockHeader) {
     // Collect all new nullifiers, commitments, and contracts from all txs in this block to build body
     const txs = provingState!.allTxs.map(a => a.processedTx);
 
+    // Get db for this block
+    const db = this.dbs.get(provingState.blockNumber)!;
+
     // Given we've applied every change from this block, now assemble the block header
     // and update the archive tree, so we're ready to start processing the next block
     const { header, body } = await buildHeaderAndBodyFromTxs(
       txs,
       provingState.globalVariables,
       provingState.newL1ToL2Messages,
-      this.db,
+      db,
     );
 
     if (expectedHeader && !header.equals(expectedHeader)) {
@@ -431,10 +429,10 @@ export class ProvingOrchestrator implements EpochProver {
     }
 
     logger.verbose(`Updating archive tree with block ${provingState.blockNumber} header ${header.hash().toString()}`);
-    await this.db.updateArchive(header);
+    await db.updateArchive(header);
 
     // Assemble the L2 block
-    const newArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, this.db);
+    const newArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, db);
     const l2Block = new L2Block(newArchive, header, body);
 
     if (!l2Block.body.getTxsEffectsHash().equals(header.contentCommitment.txsEffectsHash)) {
@@ -445,10 +443,24 @@ export class ProvingOrchestrator implements EpochProver {
       );
     }
 
+    await this.verifyBuiltBlockAgainstSyncedState(l2Block, newArchive);
+
     logger.verbose(`Orchestrator finalised block ${l2Block.number}`);
     provingState.block = l2Block;
   }
 
+  // Flagged as protected to disable in certain unit tests
+  protected async verifyBuiltBlockAgainstSyncedState(l2Block: L2Block, newArchive: AppendOnlyTreeSnapshot) {
+    const syncedArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, this.dbProvider.getSnapshot(l2Block.number));
+    if (!syncedArchive.equals(newArchive)) {
+      throw new Error(
+        `Archive tree mismatch for block ${l2Block.number}: world state synced to ${inspect(
+          syncedArchive,
+        )} but built ${inspect(newArchive)}`,
+      );
+    }
+  }
+
   // Enqueues the proving of the required padding transactions
   // If the fully proven padding transaction is not available, this will first be proven
   private enqueuePaddingTxs(
@@ -602,13 +614,6 @@ export class ProvingOrchestrator implements EpochProver {
     provingState: BlockProvingState,
   ) {
     const txProvingState = new TxProvingState(tx, hints, treeSnapshots);
-
-    const rejectReason = txProvingState.verifyStateOrReject();
-    if (rejectReason) {
-      provingState.reject(rejectReason);
-      return;
-    }
-
     const txIndex = provingState.addNewTx(txProvingState);
     this.enqueueTube(provingState, txIndex);
     if (txProvingState.requireAvmProof) {
@@ -692,9 +697,11 @@ export class ProvingOrchestrator implements EpochProver {
       return;
     }
 
+    const db = this.dbs.get(provingState.blockNumber)!;
+
     // We build the base rollup inputs using a mock proof and verification key.
     // These will be overwritten later once we have proven the tube circuit and any public kernels
-    const [ms, hints] = await elapsed(buildBaseRollupHints(tx, provingState.globalVariables, this.db));
+    const [ms, hints] = await elapsed(buildBaseRollupHints(tx, provingState.globalVariables, db));
 
     if (!tx.isEmpty) {
       this.metrics.recordBaseRollupInputs(ms);
@@ -702,7 +709,7 @@ export class ProvingOrchestrator implements EpochProver {
 
     const promises = [MerkleTreeId.NOTE_HASH_TREE, MerkleTreeId.NULLIFIER_TREE, MerkleTreeId.PUBLIC_DATA_TREE].map(
       async (id: MerkleTreeId) => {
-        return { key: id, value: await getTreeSnapshot(id, this.db) };
+        return { key: id, value: await getTreeSnapshot(id, db) };
       },
     );
     const treeSnapshots: TreeSnapshots = new Map((await Promise.all(promises)).map(obj => [obj.key, obj.value]));
@@ -1055,6 +1062,19 @@ export class ProvingOrchestrator implements EpochProver {
       logger.debug('Block root rollup already started');
       return;
     }
+    const blockNumber = provingState.blockNumber;
+
+    // TODO(palla/prover): This closes the fork only on the happy path. If this epoch orchestrator
+    // 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));
+
     this.enqueueBlockRootRollup(provingState);
   }
 

package/src/orchestrator/orchestrator_metrics.ts

@@ -1,11 +1,4 @@
-import {
-  type Histogram,
-  Metrics,
-  type TelemetryClient,
-  type Tracer,
-  ValueType,
-  millisecondBuckets,
-} from '@aztec/telemetry-client';
+import { type Histogram, Metrics, type TelemetryClient, type Tracer, ValueType } from '@aztec/telemetry-client';
 
 export class ProvingOrchestratorMetrics {
   public readonly tracer: Tracer;
@@ -20,9 +13,6 @@ export class ProvingOrchestratorMetrics {
       unit: 'ms',
       description: 'Duration to build base rollup inputs',
       valueType: ValueType.INT,
-      advice: {
-        explicitBucketBoundaries: millisecondBuckets(1), // 10ms -> ~327s
-      },
     });
   }
 

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

@@ -1,18 +1,10 @@
-import {
-  EncryptedNoteTxL2Logs,
-  EncryptedTxL2Logs,
-  type MerkleTreeId,
-  type ProcessedTx,
-  type ProofAndVerificationKey,
-  UnencryptedTxL2Logs,
-} from '@aztec/circuit-types';
+import { type MerkleTreeId, type ProcessedTx, type ProofAndVerificationKey } from '@aztec/circuit-types';
 import {
   type AVM_PROOF_LENGTH_IN_FIELDS,
   AVM_VK_INDEX,
   type AppendOnlyTreeSnapshot,
   AvmProofData,
   type BaseRollupHints,
-  Fr,
   PrivateBaseRollupHints,
   PrivateBaseRollupInputs,
   PrivateTubeData,
@@ -112,53 +104,6 @@ export class TxProvingState {
     this.avm = avmProofAndVk;
   }
 
-  public verifyStateOrReject(): string | undefined {
-    const txEffect = this.processedTx.txEffect;
-    const fromPrivate = this.processedTx.data;
-
-    const noteEncryptedLogsHashes = [
-      fromPrivate.forRollup?.end.noteEncryptedLogsHashes || [],
-      fromPrivate.forPublic?.nonRevertibleAccumulatedData.noteEncryptedLogsHashes || [],
-      fromPrivate.forPublic?.revertibleAccumulatedData.noteEncryptedLogsHashes || [],
-    ].flat();
-    const txNoteEncryptedLogsHash = EncryptedNoteTxL2Logs.hashNoteLogs(
-      noteEncryptedLogsHashes.filter(log => !log.isEmpty()).map(log => log.value.toBuffer()),
-    );
-    if (!txNoteEncryptedLogsHash.equals(txEffect.noteEncryptedLogs.hash())) {
-      return `Note encrypted logs hash mismatch: ${Fr.fromBuffer(txNoteEncryptedLogsHash)} === ${Fr.fromBuffer(
-        txEffect.noteEncryptedLogs.hash(),
-      )}`;
-    }
-
-    const encryptedLogsHashes = [
-      fromPrivate.forRollup?.end.encryptedLogsHashes || [],
-      fromPrivate.forPublic?.nonRevertibleAccumulatedData.encryptedLogsHashes || [],
-      fromPrivate.forPublic?.revertibleAccumulatedData.encryptedLogsHashes || [],
-    ].flat();
-    const txEncryptedLogsHash = EncryptedTxL2Logs.hashSiloedLogs(
-      encryptedLogsHashes.filter(log => !log.isEmpty()).map(log => log.getSiloedHash()),
-    );
-    if (!txEncryptedLogsHash.equals(txEffect.encryptedLogs.hash())) {
-      // @todo This rejection messages is never seen. Never making it out to the logs
-      return `Encrypted logs hash mismatch: ${Fr.fromBuffer(txEncryptedLogsHash)} === ${Fr.fromBuffer(
-        txEffect.encryptedLogs.hash(),
-      )}`;
-    }
-
-    const avmOutput = this.processedTx.avmProvingRequest?.inputs.output;
-    const unencryptedLogsHashes = avmOutput
-      ? avmOutput.accumulatedData.unencryptedLogsHashes
-      : fromPrivate.forRollup!.end.unencryptedLogsHashes;
-    const txUnencryptedLogsHash = UnencryptedTxL2Logs.hashSiloedLogs(
-      unencryptedLogsHashes.filter(log => !log.isEmpty()).map(log => log.getSiloedHash()),
-    );
-    if (!txUnencryptedLogsHash.equals(txEffect.unencryptedLogs.hash())) {
-      return `Unencrypted logs hash mismatch: ${Fr.fromBuffer(txUnencryptedLogsHash)} === ${Fr.fromBuffer(
-        txEffect.unencryptedLogs.hash(),
-      )}`;
-    }
-  }
-
   private getTubeVkData() {
     let vkIndex = TUBE_VK_INDEX;
     try {

package/src/prover-agent/memory-proving-queue.ts

@@ -32,7 +32,7 @@ import type {
 } from '@aztec/circuits.js';
 import { randomBytes } from '@aztec/foundation/crypto';
 import { AbortError, TimeoutError } from '@aztec/foundation/error';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 import { type PromiseWithResolvers, RunningPromise, promiseWithResolvers } from '@aztec/foundation/promise';
 import { PriorityMemoryQueue } from '@aztec/foundation/queue';
 import { type TelemetryClient } from '@aztec/telemetry-client';
@@ -57,7 +57,7 @@ const defaultTimeSource = () => Date.now();
  * The queue accumulates jobs and provides them to agents prioritized by block number.
  */
 export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource {
-  private log = createDebugLogger('aztec:prover-client:prover-pool:queue');
+  private log = createLogger('prover-client:prover-pool:queue');
   private queue = new PriorityMemoryQueue<ProvingJobWithResolvers>(
     (a, b) => (a.epochNumber ?? 0) - (b.epochNumber ?? 0),
   );
@@ -120,6 +120,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
         id: job.id,
         type: job.type,
         inputsUri: job.inputsUri,
+        epochNumber: job.epochNumber,
       };
     } catch (err) {
       if (err instanceof TimeoutError) {
@@ -244,7 +245,7 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
       reject,
       attempts: 1,
       heartbeat: 0,
-      epochNumber,
+      epochNumber: epochNumber ?? 0,
     };
 
     if (signal) {

package/src/prover-agent/prover-agent.ts

@@ -8,7 +8,7 @@ import {
   type ServerCircuitProver,
   makeProvingRequestResult,
 } from '@aztec/circuit-types';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 import { elapsed } from '@aztec/foundation/timer';
 
@@ -38,7 +38,7 @@ export class ProverAgent implements ProverAgentApi {
     private maxConcurrency = 1,
     /** How long to wait between jobs */
     private pollIntervalMs = 100,
-    private log = createDebugLogger('aztec:prover-client:prover-agent'),
+    private log = createLogger('prover-client:prover-agent'),
   ) {}
 
   setMaxConcurrency(maxConcurrency: number): Promise<void> {

package/src/{tx-prover → prover-client}/factory.ts

@@ -1,14 +1,15 @@
-import { type ProvingJobBroker } from '@aztec/circuit-types';
+import { type ForkMerkleTreeOperations, type ProvingJobBroker } from '@aztec/circuit-types';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
 
 import { type ProverClientConfig } from '../config.js';
-import { TxProver } from './tx-prover.js';
+import { ProverClient } from './prover-client.js';
 
 export function createProverClient(
   config: ProverClientConfig,
+  worldState: ForkMerkleTreeOperations,
   broker: ProvingJobBroker,
   telemetry: TelemetryClient = new NoopTelemetryClient(),
 ) {
-  return TxProver.new(config, broker, telemetry);
+  return ProverClient.new(config, worldState, broker, telemetry);
 }

package/src/prover-client/index.ts

@@ -0,0 +1,2 @@
+export * from './factory.js';
+export * from './prover-client.js';