@aztec/prover-client 0.56.0 → 0.57.0

package/src/orchestrator/orchestrator.ts

@@ -1,20 +1,14 @@
 import {
-  BlockProofError,
   Body,
   EncryptedNoteTxL2Logs,
   EncryptedTxL2Logs,
   L2Block,
   MerkleTreeId,
-  PROVING_STATUS,
   type PaddingProcessedTx,
   type ProcessedTx,
-  type ProvingBlockResult,
   ProvingRequestType,
-  type ProvingResult,
-  type ProvingTicket,
   type PublicInputsAndRecursiveProof,
   type ServerCircuitProver,
-  Tx,
   type TxEffect,
   UnencryptedTxL2Logs,
   makeEmptyProcessedTx,
@@ -31,6 +25,7 @@ import {
   type BaseRollupInputs,
   type BlockRootOrBlockMergePublicInputs,
   BlockRootRollupInputs,
+  EmptyBlockRootRollupInputs,
   Fr,
   type GlobalVariables,
   type KernelCircuitPublicInputs,
@@ -83,7 +78,12 @@ import {
   validateTx,
 } from './block-building-helpers.js';
 import { type BlockProvingState, type MergeRollupInputData } from './block-proving-state.js';
-import { type BlockMergeRollupInputData, EpochProvingState, type TreeSnapshots } from './epoch-proving-state.js';
+import {
+  type BlockMergeRollupInputData,
+  EpochProvingState,
+  type ProvingResult,
+  type TreeSnapshots,
+} from './epoch-proving-state.js';
 import { ProvingOrchestratorMetrics } from './orchestrator_metrics.js';
 import { TX_PROVING_CODE, type TxProvingInstruction, TxProvingState } from './tx-proving-state.js';
 
@@ -108,6 +108,7 @@ export class ProvingOrchestrator implements EpochProver {
   private pendingProvingJobs: AbortController[] = [];
   private paddingTx: PaddingProcessedTx | undefined = undefined;
 
+  private provingPromise: Promise<ProvingResult> | undefined = undefined;
   private metrics: ProvingOrchestratorMetrics;
 
   constructor(
@@ -134,26 +135,20 @@ export class ProvingOrchestrator implements EpochProver {
     this.paddingTx = undefined;
   }
 
-  @trackSpan('ProvingOrchestrator.startNewEpoch', (epochNumber, totalNumBlocks) => ({
-    [Attributes.EPOCH_SIZE]: totalNumBlocks,
-    [Attributes.EPOCH_NUMBER]: epochNumber,
-  }))
-  public startNewEpoch(epochNumber: number, totalNumBlocks: number): ProvingTicket {
+  public startNewEpoch(epochNumber: number, totalNumBlocks: number) {
     const { promise: _promise, resolve, reject } = promiseWithResolvers<ProvingResult>();
-    const promise = _promise.catch(
-      (reason): ProvingResult => ({
-        status: PROVING_STATUS.FAILURE,
-        reason,
-      }),
-    );
-
+    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);
-    return { provingPromise: promise };
+    this.provingPromise = promise;
   }
 
   /**
    * Starts off a new block
-   * @param numTxs - The total number of transactions in the block. Must be a power of 2
+   * @param numTxs - The total number of transactions in the block.
    * @param globalVariables - The global variables for the block
    * @param l1ToL2Messages - The l1 to l2 messages for the block
    * @param verificationKeys - The private kernel verification keys
@@ -163,14 +158,9 @@ export class ProvingOrchestrator implements EpochProver {
     [Attributes.BLOCK_SIZE]: numTxs,
     [Attributes.BLOCK_NUMBER]: globalVariables.blockNumber.toNumber(),
   }))
-  public async startNewBlock(
-    numTxs: number,
-    globalVariables: GlobalVariables,
-    l1ToL2Messages: Fr[],
-  ): Promise<ProvingTicket> {
-    // If no proving state, assume we only care about proving this block and initialize a 1-block epoch
+  public async startNewBlock(numTxs: number, globalVariables: GlobalVariables, l1ToL2Messages: Fr[]) {
     if (!this.provingState) {
-      this.startNewEpoch(globalVariables.blockNumber.toNumber(), 1);
+      throw new Error(`Invalid proving state, call startNewEpoch before starting a block`);
     }
 
     if (!this.provingState?.isAcceptingBlocks()) {
@@ -178,10 +168,14 @@ export class ProvingOrchestrator implements EpochProver {
     }
 
     if (!Number.isInteger(numTxs) || numTxs < 2) {
-      throw new Error(`Length of txs for the block should be at least two (got ${numTxs})`);
+      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-node): Store block number in the db itself to make this check more reliable,
+    // 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;
@@ -234,9 +228,6 @@ export class ProvingOrchestrator implements EpochProver {
       BigInt(startArchiveSnapshot.nextAvailableLeafIndex - 1),
     );
 
-    const { promise: _promise, resolve, reject } = promiseWithResolvers<ProvingResult>();
-    const promise = _promise.catch((reason): ProvingResult => ({ status: PROVING_STATUS.FAILURE, reason }));
-
     this.provingState!.startNewBlock(
       numTxs,
       globalVariables,
@@ -247,16 +238,12 @@ export class ProvingOrchestrator implements EpochProver {
       startArchiveSnapshot,
       newArchiveSiblingPath,
       previousBlockHash!,
-      resolve,
-      reject,
     );
 
     // Enqueue base parity circuits for the block
     for (let i = 0; i < baseParityInputs.length; i++) {
       this.enqueueBaseParityCircuit(this.provingState!.currentBlock!, baseParityInputs[i], i);
     }
-
-    return { provingPromise: promise };
   }
 
   /**
@@ -276,6 +263,10 @@ export class ProvingOrchestrator implements EpochProver {
       throw new Error(`Rollup not accepting further transactions`);
     }
 
+    if (!provingState.verifyState()) {
+      throw new Error(`Invalid proving state when adding a tx`);
+    }
+
     validateTx(tx);
 
     logger.info(`Received transaction: ${tx.hash}`);
@@ -289,10 +280,7 @@ export class ProvingOrchestrator implements EpochProver {
     this.enqueueFirstProofs(inputs, treeSnapshots, tx, provingState);
 
     if (provingState.transactionsReceived === provingState.totalNumTxs) {
-      logger.verbose(
-        `All transactions received for block ${provingState.globalVariables.blockNumber}. Assembling header.`,
-      );
-      await this.buildBlockHeader(provingState);
+      logger.verbose(`All transactions received for block ${provingState.globalVariables.blockNumber}.`);
     }
   }
 
@@ -311,53 +299,125 @@ export class ProvingOrchestrator implements EpochProver {
       [Attributes.BLOCK_TXS_COUNT]: block.transactionsReceived,
     };
   })
-  public async setBlockCompleted() {
+  public async setBlockCompleted(): Promise<L2Block> {
     const provingState = this.provingState?.currentBlock;
     if (!provingState) {
       throw new Error(`Invalid proving state, call startNewBlock before adding transactions or completing the block`);
     }
 
-    // we may need to pad the rollup with empty transactions
+    // We may need to pad the rollup with empty transactions
     const paddingTxCount = provingState.totalNumTxs - provingState.transactionsReceived;
-    if (paddingTxCount === 0) {
-      return;
-    } else if (provingState.totalNumTxs > 2) {
+    if (paddingTxCount > 0 && provingState.totalNumTxs > 2) {
       throw new Error(`Block not ready for completion: expecting ${paddingTxCount} more transactions.`);
     }
 
-    logger.debug(`Padding rollup with ${paddingTxCount} empty transactions`);
-    // Make an empty padding transaction
-    // Required for:
-    // 0 (when we want an empty block, largely for testing), or
-    // 1 (we need to pad with one tx as all rollup circuits require a pair of inputs) txs
-    // Insert it into the tree the required number of times to get all of the
-    // base rollup inputs
-    // Then enqueue the proving of all the transactions
-    const unprovenPaddingTx = makeEmptyProcessedTx(
-      this.db.getInitialHeader(),
-      provingState.globalVariables.chainId,
-      provingState.globalVariables.version,
-      getVKTreeRoot(),
-    );
-    const txInputs: Array<{ inputs: BaseRollupInputs; snapshot: TreeSnapshots }> = [];
-    for (let i = 0; i < paddingTxCount; i++) {
-      const [inputs, snapshot] = await this.prepareTransaction(unprovenPaddingTx, provingState);
-      const txInput = {
-        inputs,
-        snapshot,
-      };
-      txInputs.push(txInput);
-    }
+    if (paddingTxCount > 0) {
+      logger.debug(`Padding rollup with ${paddingTxCount} empty transactions`);
+      // Make an empty padding transaction
+      // Required for:
+      // 0 (when we want an empty block, largely for testing), or
+      // 1 (we need to pad with one tx as all rollup circuits require a pair of inputs) txs
+      // Insert it into the tree the required number of times to get all of the
+      // base rollup inputs
+      // Then enqueue the proving of all the transactions
+      const unprovenPaddingTx = makeEmptyProcessedTx(
+        this.db.getInitialHeader(),
+        provingState.globalVariables.chainId,
+        provingState.globalVariables.version,
+        getVKTreeRoot(),
+      );
+      const txInputs: Array<{ inputs: BaseRollupInputs; snapshot: TreeSnapshots }> = [];
+      for (let i = 0; i < paddingTxCount; i++) {
+        const [inputs, snapshot] = await this.prepareTransaction(unprovenPaddingTx, provingState);
+        const txInput = {
+          inputs,
+          snapshot,
+        };
+        txInputs.push(txInput);
+      }
 
-    // Now enqueue the proving
-    this.enqueuePaddingTxs(provingState, txInputs, unprovenPaddingTx);
+      // Now enqueue the proving
+      this.enqueuePaddingTxs(provingState, txInputs, unprovenPaddingTx);
+    }
 
     // And build the block header
-    logger.verbose(`Block ${provingState.globalVariables.blockNumber} padded with empty tx(s). Assembling header.`);
-    await this.buildBlockHeader(provingState);
+    logger.verbose(`Block ${provingState.globalVariables.blockNumber} completed. Assembling header.`);
+    await this.buildBlock(provingState);
+
+    // If the proofs were faster than the block building, then we need to try the block root rollup again here
+    this.checkAndEnqueueBlockRootRollup(provingState);
+    return provingState.block!;
+  }
+
+  /** Returns the block as built for a given index. */
+  public getBlock(index: number): L2Block {
+    const block = this.provingState?.blocks[index].block;
+    if (!block) {
+      throw new Error(`Block at index ${index} not available`);
+    }
+    return block;
   }
 
-  private async buildBlockHeader(provingState: BlockProvingState) {
+  @trackSpan('ProvingOrchestrator.padEpoch', function () {
+    if (!this.provingState) {
+      return {};
+    }
+    return {
+      [Attributes.EPOCH_NUMBER]: this.provingState.epochNumber,
+      [Attributes.EPOCH_SIZE]: this.provingState.totalNumBlocks,
+    };
+  })
+  private padEpoch() {
+    const provingState = this.provingState!;
+    const lastBlock = provingState.currentBlock?.block;
+    if (!lastBlock) {
+      throw new Error(`Epoch needs at least one completed block in order to be padded`);
+    }
+
+    const paddingBlockCount = Math.max(2, provingState.totalNumBlocks) - provingState.blocks.length;
+    if (paddingBlockCount === 0) {
+      return;
+    }
+
+    logger.debug(`Padding epoch proof with ${paddingBlockCount} empty block proofs`);
+
+    const inputs = EmptyBlockRootRollupInputs.from({
+      archive: lastBlock.archive,
+      blockHash: lastBlock.header.hash(),
+      globalVariables: lastBlock.header.globalVariables,
+      vkTreeRoot: getVKTreeRoot(),
+      proverId: this.proverId,
+    });
+
+    logger.debug(`Enqueuing deferred proving for padding block to enqueue ${paddingBlockCount} paddings`);
+    this.deferredProving(
+      provingState,
+      wrapCallbackInSpan(
+        this.tracer,
+        'ProvingOrchestrator.prover.getEmptyBlockRootRollupProof',
+        {
+          [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
+          [Attributes.PROTOCOL_CIRCUIT_NAME]: 'empty-block-root-rollup' satisfies CircuitName,
+        },
+        signal => this.prover.getEmptyBlockRootRollupProof(inputs, signal, provingState.epochNumber),
+      ),
+      result => {
+        logger.debug(`Completed proof for padding block`);
+        const currentLevel = provingState.numMergeLevels + 1n;
+        for (let i = 0; i < paddingBlockCount; i++) {
+          logger.debug(`Enqueuing padding block with index ${provingState.blocks.length + i}`);
+          const index = BigInt(provingState.blocks.length + i);
+          this.storeAndExecuteNextBlockMergeLevel(provingState, currentLevel, index, [
+            result.inputs,
+            result.proof,
+            result.verificationKey.keyAsFields,
+          ]);
+        }
+      },
+    );
+  }
+
+  private async buildBlock(provingState: BlockProvingState) {
     // Collect all new nullifiers, commitments, and contracts from all txs in this block to build body
     const gasFees = provingState.globalVariables.gasFees;
     const nonEmptyTxEffects: TxEffect[] = provingState!.allTxs
@@ -379,7 +439,7 @@ export class ProvingOrchestrator implements EpochProver {
 
     // Assemble the L2 block
     const newArchive = await getTreeSnapshot(MerkleTreeId.ARCHIVE, this.db);
-    const l2Block = L2Block.fromFields({ archive: newArchive, header, body });
+    const l2Block = new L2Block(newArchive, header, body);
 
     if (!l2Block.body.getTxsEffectsHash().equals(header.contentCommitment.txsEffectsHash)) {
       throw new Error(
@@ -499,52 +559,29 @@ export class ProvingOrchestrator implements EpochProver {
   }
 
   /**
-   * Returns the fully proven block. Requires proving to have been completed.
-   * @param index - The index of the block to finalise. Defaults to the last block.
-   * @returns The fully proven block and proof.
+   * Returns the proof for the current epoch.
    */
-  public finaliseBlock(index?: number) {
-    try {
-      const block = this.provingState?.blocks[index ?? this.provingState?.blocks.length - 1];
-
-      if (!block || !block.blockRootRollupPublicInputs || !block.finalProof || !block.block) {
-        throw new Error(`Invalid proving state, a block must be proven before it can be finalised`);
-      }
+  public async finaliseEpoch() {
+    if (!this.provingState || !this.provingPromise) {
+      throw new Error(`Invalid proving state, an epoch must be proven before it can be finalised`);
+    }
 
-      const blockResult: ProvingBlockResult = {
-        proof: block.finalProof,
-        aggregationObject: block.finalProof.extractAggregationObject(),
-        block: block.block!,
-      };
-
-      pushTestData('blockResults', {
-        proverId: this.proverId.toString(),
-        vkTreeRoot: getVKTreeRoot().toString(),
-        block: blockResult.block.toString(),
-        proof: blockResult.proof.toString(),
-        aggregationObject: blockResult.aggregationObject.map(x => x.toString()),
-      });
+    this.padEpoch();
 
-      return Promise.resolve(blockResult);
-    } catch (err) {
-      throw new BlockProofError(
-        err && typeof err === 'object' && 'message' in err ? String(err.message) : String(err),
-        this.provingState?.blocks[index ?? this.provingState?.blocks.length - 1]?.allTxs.map(x =>
-          Tx.getHash(x.processedTx),
-        ) ?? [],
-      );
+    const result = await this.provingPromise!;
+    if (result.status === 'failure') {
+      throw new Error(`Epoch proving failed: ${result.reason}`);
     }
-  }
 
-  /**
-   * Returns the proof for the current epoch.
-   * Requires proving to have been completed.
-   */
-  public finaliseEpoch() {
-    if (!this.provingState || !this.provingState.rootRollupPublicInputs || !this.provingState.finalProof) {
-      throw new Error(`Invalid proving state, an epoch must be proven before it can be finalised`);
+    if (!this.provingState.rootRollupPublicInputs || !this.provingState.finalProof) {
+      throw new Error(`Invalid proving state, missing root rollup public inputs or final proof`);
     }
 
+    pushTestData('epochProofResult', {
+      proof: this.provingState.finalProof.toString(),
+      publicInputs: this.provingState.rootRollupPublicInputs.toString(),
+    });
+
     return { proof: this.provingState.finalProof, publicInputs: this.provingState.rootRollupPublicInputs };
   }
 
@@ -836,11 +873,17 @@ export class ProvingOrchestrator implements EpochProver {
   }
 
   // Executes the block root rollup circuit
-  private enqueueBlockRootRollup(provingState: BlockProvingState | undefined) {
-    if (!provingState?.verifyState()) {
+  private enqueueBlockRootRollup(provingState: BlockProvingState) {
+    if (!provingState.block) {
+      throw new Error(`Invalid proving state for block root rollup, block not available`);
+    }
+
+    if (!provingState.verifyState()) {
       logger.debug('Not running block root rollup, state no longer valid');
       return;
     }
+
+    provingState.blockRootRollupStarted = true;
     const mergeInputData = provingState.getMergeInputs(0);
     const rootParityInput = provingState.finalRootParityInput!;
 
@@ -868,8 +911,6 @@ export class ProvingOrchestrator implements EpochProver {
       proverId: this.proverId,
     });
 
-    const shouldProveEpoch = this.provingState!.totalNumBlocks > 1;
-
     this.deferredProving(
       provingState,
       wrapCallbackInSpan(
@@ -879,10 +920,7 @@ export class ProvingOrchestrator implements EpochProver {
           [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
           [Attributes.PROTOCOL_CIRCUIT_NAME]: 'block-root-rollup' satisfies CircuitName,
         },
-        signal =>
-          shouldProveEpoch
-            ? this.prover.getBlockRootRollupProof(inputs, signal, provingState.epochNumber)
-            : this.prover.getBlockRootRollupFinalProof(inputs, signal, provingState.epochNumber),
+        signal => this.prover.getBlockRootRollupProof(inputs, signal, provingState.epochNumber),
       ),
       result => {
         const header = this.extractBlockHeaderFromPublicInputs(provingState, result.inputs);
@@ -895,17 +933,10 @@ export class ProvingOrchestrator implements EpochProver {
 
         provingState.blockRootRollupPublicInputs = result.inputs;
         provingState.finalProof = result.proof.binaryProof;
-        provingState.resolve({ status: PROVING_STATUS.SUCCESS });
 
         logger.debug(`Completed proof for block root rollup for ${provingState.block?.number}`);
         // validatePartialState(result.inputs.end, tx.treeSnapshots); // TODO(palla/prover)
 
-        // TODO(palla/prover): Remove this once we've dropped the flow for proving single blocks
-        if (!shouldProveEpoch) {
-          logger.verbose(`Skipping epoch rollup, only one block in epoch`);
-          return;
-        }
-
         const currentLevel = this.provingState!.numMergeLevels + 1n;
         this.storeAndExecuteNextBlockMergeLevel(this.provingState!, currentLevel, BigInt(provingState.index), [
           result.inputs,
@@ -1032,18 +1063,23 @@ export class ProvingOrchestrator implements EpochProver {
         signal => this.prover.getRootRollupProof(inputs, signal, provingState.epochNumber),
       ),
       result => {
+        logger.verbose(`Orchestrator completed root rollup for epoch ${provingState.epochNumber}`);
         provingState.rootRollupPublicInputs = result.inputs;
         provingState.finalProof = result.proof.binaryProof;
-        provingState.resolve({ status: PROVING_STATUS.SUCCESS });
+        provingState.resolve({ status: 'success' });
       },
     );
   }
 
-  private checkAndEnqueueBlockRootRollup(provingState: BlockProvingState | undefined) {
+  private checkAndEnqueueBlockRootRollup(provingState: BlockProvingState) {
     if (!provingState?.isReadyForBlockRootRollup()) {
       logger.debug('Not ready for root rollup');
       return;
     }
+    if (provingState.blockRootRollupStarted) {
+      logger.debug('Block root rollup already started');
+      return;
+    }
     this.enqueueBlockRootRollup(provingState);
   }
 

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

@@ -16,6 +16,7 @@ import type {
   BlockMergeRollupInputs,
   BlockRootOrBlockMergePublicInputs,
   BlockRootRollupInputs,
+  EmptyBlockRootRollupInputs,
   KernelCircuitPublicInputs,
   MergeRollupInputs,
   NESTED_RECURSIVE_PROOF_LENGTH,
@@ -351,12 +352,12 @@ export class MemoryProvingQueue implements ServerCircuitProver, ProvingJobSource
     return this.enqueue({ type: ProvingRequestType.BLOCK_ROOT_ROLLUP, inputs: input }, signal, epochNumber);
   }
 
-  getBlockRootRollupFinalProof(
-    input: BlockRootRollupInputs,
+  getEmptyBlockRootRollupProof(
+    input: EmptyBlockRootRollupInputs,
     signal?: AbortSignal,
     epochNumber?: number,
   ): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
-    return this.enqueue({ type: ProvingRequestType.BLOCK_ROOT_ROLLUP_FINAL, inputs: input }, signal, epochNumber);
+    return this.enqueue({ type: ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP, inputs: input }, signal, epochNumber);
   }
 
   /**

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

@@ -181,12 +181,12 @@ export class ProverAgent {
         return this.circuitProver.getMergeRollupProof(inputs);
       }
 
-      case ProvingRequestType.BLOCK_ROOT_ROLLUP: {
-        return this.circuitProver.getBlockRootRollupProof(inputs);
+      case ProvingRequestType.EMPTY_BLOCK_ROOT_ROLLUP: {
+        return this.circuitProver.getEmptyBlockRootRollupProof(inputs);
       }
 
-      case ProvingRequestType.BLOCK_ROOT_ROLLUP_FINAL: {
-        return this.circuitProver.getBlockRootRollupFinalProof(inputs);
+      case ProvingRequestType.BLOCK_ROOT_ROLLUP: {
+        return this.circuitProver.getBlockRootRollupProof(inputs);
       }
 
       case ProvingRequestType.BLOCK_MERGE_ROLLUP: {

package/src/prover-agent/rpc.ts

@@ -9,6 +9,7 @@ import {
   BlockMergeRollupInputs,
   BlockRootOrBlockMergePublicInputs,
   BlockRootRollupInputs,
+  EmptyBlockRootRollupInputs,
   EthAddress,
   Fr,
   Header,
@@ -68,6 +69,7 @@ export function createProvingJobSourceServer(queue: ProvingJobSource): JsonRpcSe
       BlockRootOrBlockMergePublicInputs,
       BlockMergeRollupInputs,
       BlockRootRollupInputs,
+      EmptyBlockRootRollupInputs,
     },
     {},
   );
@@ -109,6 +111,7 @@ export function createProvingJobSourceClient(
       BlockRootOrBlockMergePublicInputs,
       BlockMergeRollupInputs,
       BlockRootRollupInputs,
+      EmptyBlockRootRollupInputs,
     },
     {},
     false,

package/src/test/mock_prover.ts

@@ -78,7 +78,7 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getBlockRootRollupProof(): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
+  getEmptyBlockRootRollupProof(): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeBlockRootOrBlockMergeRollupPublicInputs(),
@@ -88,7 +88,7 @@ export class MockProver implements ServerCircuitProver {
     );
   }
 
-  getBlockRootRollupFinalProof(): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
+  getBlockRootRollupProof(): Promise<PublicInputsAndRecursiveProof<BlockRootOrBlockMergePublicInputs>> {
     return Promise.resolve(
       makePublicInputsAndRecursiveProof(
         makeBlockRootOrBlockMergeRollupPublicInputs(),

package/src/tx-prover/tx-prover.ts

@@ -1,7 +1,7 @@
 import { BBNativeRollupProver, TestCircuitProver } from '@aztec/bb-prover';
 import {
-  type BlockProver,
-  type ProverClient,
+  type EpochProver,
+  type EpochProverManager,
   type ProvingJobSource,
   type ServerCircuitProver,
 } from '@aztec/circuit-types/interfaces';
@@ -19,7 +19,7 @@ import { ProverAgent } from '../prover-agent/prover-agent.js';
  * A prover factory.
  * TODO(palla/prover-node): Rename this class
  */
-export class TxProver implements ProverClient {
+export class TxProver implements EpochProverManager {
   private queue: MemoryProvingQueue;
   private running = false;
 
@@ -33,7 +33,7 @@ export class TxProver implements ProverClient {
     this.queue = new MemoryProvingQueue(telemetry, config.proverJobTimeoutMs, config.proverJobPollIntervalMs);
   }
 
-  public createBlockProver(db: MerkleTreeOperations): BlockProver {
+  public createEpochProver(db: MerkleTreeOperations): EpochProver {
     return new ProvingOrchestrator(db, this.queue, this.telemetry, this.config.proverId);
   }