@aztec/prover-node 0.0.0-test.0

package/src/prover-coordination/factory.ts

@@ -0,0 +1,72 @@
+import type { ArchiveSource, Archiver } from '@aztec/archiver';
+import { BBCircuitVerifier, TestCircuitVerifier } from '@aztec/bb-prover';
+import type { EpochCache } from '@aztec/epoch-cache';
+import { createLogger } from '@aztec/foundation/log';
+import type { DataStoreConfig } from '@aztec/kv-store/config';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
+import { createP2PClient } from '@aztec/p2p';
+import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
+import type { ProverCoordination, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import { P2PClientType } from '@aztec/stdlib/p2p';
+import { getComponentsVersionsFromConfig } from '@aztec/stdlib/versioning';
+import { type TelemetryClient, makeTracedFetch } from '@aztec/telemetry-client';
+
+import type { ProverNodeConfig } from '../config.js';
+
+// We return a reference to the P2P client so that the prover node can stop the service when it shuts down.
+type ProverCoordinationDeps = {
+  aztecNodeTxProvider?: ProverCoordination;
+  worldStateSynchronizer?: WorldStateSynchronizer;
+  archiver?: Archiver | ArchiveSource;
+  telemetry?: TelemetryClient;
+  epochCache?: EpochCache;
+};
+
+/**
+ * Creates a prover coordination service.
+ * If p2p is enabled, prover coordination is done via p2p.
+ * If an Aztec node URL is provided, prover coordination is done via the Aztec node over http.
+ * If an aztec node is provided, it is returned directly.
+ */
+export async function createProverCoordination(
+  config: ProverNodeConfig & DataStoreConfig,
+  deps: ProverCoordinationDeps,
+): Promise<ProverCoordination> {
+  const log = createLogger('prover-node:prover-coordination');
+
+  if (deps.aztecNodeTxProvider) {
+    log.info('Using prover coordination via aztec node');
+    return deps.aztecNodeTxProvider;
+  }
+
+  if (config.p2pEnabled) {
+    log.info('Using prover coordination via p2p');
+
+    if (!deps.archiver || !deps.worldStateSynchronizer || !deps.telemetry || !deps.epochCache) {
+      throw new Error('Missing dependencies for p2p prover coordination');
+    }
+
+    const proofVerifier = config.realProofs ? await BBCircuitVerifier.new(config) : new TestCircuitVerifier();
+    const p2pClient = await createP2PClient(
+      P2PClientType.Prover,
+      config,
+      deps.archiver,
+      proofVerifier,
+      deps.worldStateSynchronizer,
+      deps.epochCache,
+      deps.telemetry,
+    );
+    await p2pClient.start();
+
+    return p2pClient;
+  }
+
+  if (config.proverCoordinationNodeUrl) {
+    log.info('Using prover coordination via node url');
+    const versions = getComponentsVersionsFromConfig(config, protocolContractTreeRoot, getVKTreeRoot());
+    return createAztecNodeClient(config.proverCoordinationNodeUrl, versions, makeTracedFetch([1, 2, 3], false));
+  } else {
+    throw new Error(`Aztec Node URL for Tx Provider is not set.`);
+  }
+}

package/src/prover-coordination/index.ts

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

package/src/prover-node-publisher.ts

@@ -0,0 +1,286 @@
+import { AGGREGATION_OBJECT_LENGTH, AZTEC_MAX_EPOCH_DURATION } from '@aztec/constants';
+import type { L1TxUtils, RollupContract } from '@aztec/ethereum';
+import { makeTuple } from '@aztec/foundation/array';
+import { areArraysEqual, times } from '@aztec/foundation/collection';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
+import { InterruptibleSleep } from '@aztec/foundation/sleep';
+import { Timer } from '@aztec/foundation/timer';
+import { RollupAbi } from '@aztec/l1-artifacts';
+import type { PublisherConfig, TxSenderConfig } from '@aztec/sequencer-client';
+import type { Proof } from '@aztec/stdlib/proofs';
+import type { FeeRecipient, RootRollupPublicInputs } from '@aztec/stdlib/rollup';
+import type { L1PublishProofStats } from '@aztec/stdlib/stats';
+import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
+
+import { type Hex, type TransactionReceipt, encodeFunctionData } from 'viem';
+
+import { ProverNodeMetrics } from './metrics.js';
+
+/**
+ * Stats for a sent transaction.
+ */
+/** Arguments to the submitEpochProof method of the rollup contract */
+export type L1SubmitEpochProofArgs = {
+  epochSize: number;
+  previousArchive: Fr;
+  endArchive: Fr;
+  previousBlockHash: Fr;
+  endBlockHash: Fr;
+  endTimestamp: Fr;
+  outHash: Fr;
+  proverId: Fr;
+  fees: Tuple<FeeRecipient, typeof AZTEC_MAX_EPOCH_DURATION>;
+  proof: Proof;
+};
+
+export class ProverNodePublisher {
+  private interruptibleSleep = new InterruptibleSleep();
+  private sleepTimeMs: number;
+  private interrupted = false;
+  private metrics: ProverNodeMetrics;
+
+  protected log = createLogger('prover-node:l1-tx-publisher');
+
+  protected rollupContract: RollupContract;
+
+  public readonly l1TxUtils: L1TxUtils;
+
+  constructor(
+    config: TxSenderConfig & PublisherConfig,
+    deps: {
+      rollupContract: RollupContract;
+      l1TxUtils: L1TxUtils;
+      telemetry?: TelemetryClient;
+    },
+  ) {
+    this.sleepTimeMs = config?.l1PublishRetryIntervalMS ?? 60_000;
+
+    const telemetry = deps.telemetry ?? getTelemetryClient();
+
+    this.metrics = new ProverNodeMetrics(telemetry, 'ProverNode');
+
+    this.rollupContract = deps.rollupContract;
+    this.l1TxUtils = deps.l1TxUtils;
+  }
+
+  /**
+   * Calling `interrupt` will cause any in progress call to `publishRollup` to return `false` asap.
+   * Be warned, the call may return false even if the tx subsequently gets successfully mined.
+   * In practice this shouldn't matter, as we'll only ever be calling `interrupt` when we know it's going to fail.
+   * A call to `restart` is required before you can continue publishing.
+   */
+  public interrupt() {
+    this.interrupted = true;
+    this.interruptibleSleep.interrupt();
+  }
+
+  /** Restarts the publisher after calling `interrupt`. */
+  public restart() {
+    this.interrupted = false;
+  }
+
+  public getSenderAddress() {
+    return EthAddress.fromString(this.l1TxUtils.getSenderAddress());
+  }
+
+  public async submitEpochProof(args: {
+    epochNumber: number;
+    fromBlock: number;
+    toBlock: number;
+    publicInputs: RootRollupPublicInputs;
+    proof: Proof;
+  }): Promise<boolean> {
+    const { epochNumber, fromBlock, toBlock } = args;
+    const ctx = { epochNumber, fromBlock, toBlock };
+    if (!this.interrupted) {
+      const timer = new Timer();
+
+      // Validate epoch proof range and hashes are correct before submitting
+      await this.validateEpochProofSubmission(args);
+
+      const txReceipt = await this.sendSubmitEpochProofTx(args);
+      if (!txReceipt) {
+        return false;
+      }
+
+      try {
+        this.metrics.recordSenderBalance(await this.l1TxUtils.getSenderBalance(), this.l1TxUtils.getSenderAddress());
+      } catch (err) {
+        this.log.warn(`Failed to record the ETH balance of the prover node: ${err}`);
+      }
+
+      // Tx was mined successfully
+      if (txReceipt.status) {
+        const tx = await this.l1TxUtils.getTransactionStats(txReceipt.transactionHash);
+        const stats: L1PublishProofStats = {
+          gasPrice: txReceipt.effectiveGasPrice,
+          gasUsed: txReceipt.gasUsed,
+          transactionHash: txReceipt.transactionHash,
+          calldataGas: tx!.calldataGas,
+          calldataSize: tx!.calldataSize,
+          sender: tx!.sender,
+          blobDataGas: 0n,
+          blobGasUsed: 0n,
+          eventName: 'proof-published-to-l1',
+        };
+        this.log.info(`Published epoch proof to L1 rollup contract`, { ...stats, ...ctx });
+        this.metrics.recordSubmitProof(timer.ms(), stats);
+        return true;
+      }
+
+      this.metrics.recordFailedTx();
+      this.log.error(`Rollup.submitEpochProof tx status failed: ${txReceipt.transactionHash}`, ctx);
+      await this.sleepOrInterrupted();
+    }
+
+    this.log.verbose('L2 block data syncing interrupted while processing blocks.', ctx);
+    return false;
+  }
+
+  private async validateEpochProofSubmission(args: {
+    fromBlock: number;
+    toBlock: number;
+    publicInputs: RootRollupPublicInputs;
+    proof: Proof;
+  }) {
+    const { fromBlock, toBlock, publicInputs, proof } = args;
+
+    // Check that the block numbers match the expected epoch to be proven
+    const { pendingBlockNumber: pending, provenBlockNumber: proven } = await this.rollupContract.getTips();
+    if (proven !== BigInt(fromBlock) - 1n) {
+      throw new Error(`Cannot submit epoch proof for ${fromBlock}-${toBlock} as proven block is ${proven}`);
+    }
+    if (toBlock > pending) {
+      throw new Error(`Cannot submit epoch proof for ${fromBlock}-${toBlock} as pending block is ${pending}`);
+    }
+
+    // Check the block hash and archive for the immediate block before the epoch
+    const blockLog = await this.rollupContract.getBlock(proven);
+    if (publicInputs.previousArchive.root.toString() !== blockLog.archive) {
+      throw new Error(
+        `Previous archive root mismatch: ${publicInputs.previousArchive.root.toString()} !== ${blockLog.archive}`,
+      );
+    }
+    // TODO: Remove zero check once we inject the proper zero blockhash
+    if (blockLog.blockHash !== Fr.ZERO.toString() && publicInputs.previousBlockHash.toString() !== blockLog.blockHash) {
+      throw new Error(
+        `Previous block hash mismatch: ${publicInputs.previousBlockHash.toString()} !== ${blockLog.blockHash}`,
+      );
+    }
+
+    // Check the block hash and archive for the last block in the epoch
+    const endBlockLog = await this.rollupContract.getBlock(BigInt(toBlock));
+    if (publicInputs.endArchive.root.toString() !== endBlockLog.archive) {
+      throw new Error(
+        `End archive root mismatch: ${publicInputs.endArchive.root.toString()} !== ${endBlockLog.archive}`,
+      );
+    }
+    if (publicInputs.endBlockHash.toString() !== endBlockLog.blockHash) {
+      throw new Error(`End block hash mismatch: ${publicInputs.endBlockHash.toString()} !== ${endBlockLog.blockHash}`);
+    }
+
+    // Compare the public inputs computed by the contract with the ones injected
+    const rollupPublicInputs = await this.rollupContract.getEpochProofPublicInputs(this.getSubmitEpochProofArgs(args));
+    const aggregationObject = proof.isEmpty()
+      ? times(AGGREGATION_OBJECT_LENGTH, Fr.zero)
+      : proof.extractAggregationObject();
+    const argsPublicInputs = [...publicInputs.toFields(), ...aggregationObject];
+
+    if (!areArraysEqual(rollupPublicInputs.map(Fr.fromHexString), argsPublicInputs, (a, b) => a.equals(b))) {
+      const fmt = (inputs: Fr[] | readonly string[]) => inputs.map(x => x.toString()).join(', ');
+      throw new Error(
+        `Root rollup public inputs mismatch:\nRollup:  ${fmt(rollupPublicInputs)}\nComputed:${fmt(argsPublicInputs)}`,
+      );
+    }
+  }
+
+  private async sendSubmitEpochProofTx(args: {
+    fromBlock: number;
+    toBlock: number;
+    publicInputs: RootRollupPublicInputs;
+    proof: Proof;
+  }): Promise<TransactionReceipt | undefined> {
+    const proofHex: Hex = `0x${args.proof.withoutPublicInputs().toString('hex')}`;
+    const argsArray = this.getSubmitEpochProofArgs(args);
+
+    const txArgs = [
+      {
+        start: argsArray[0],
+        end: argsArray[1],
+        args: argsArray[2],
+        fees: argsArray[3],
+        blobPublicInputs: argsArray[4],
+        aggregationObject: argsArray[5],
+        proof: proofHex,
+      },
+    ] as const;
+
+    this.log.info(`SubmitEpochProof proofSize=${args.proof.withoutPublicInputs().length} bytes`);
+    const data = encodeFunctionData({
+      abi: RollupAbi,
+      functionName: 'submitEpochRootProof',
+      args: txArgs,
+    });
+    try {
+      const { receipt } = await this.l1TxUtils.sendAndMonitorTransaction({
+        to: this.rollupContract.address,
+        data,
+      });
+
+      return receipt;
+    } catch (err) {
+      this.log.error(`Rollup submit epoch proof failed`, err);
+      const errorMsg = await this.l1TxUtils.tryGetErrorFromRevertedTx(
+        data,
+        {
+          args: [...txArgs],
+          functionName: 'submitEpochRootProof',
+          abi: RollupAbi,
+          address: this.rollupContract.address,
+        },
+        /*blobInputs*/ undefined,
+        /*stateOverride*/ [],
+      );
+      this.log.error(`Rollup submit epoch proof tx reverted. ${errorMsg}`);
+      return undefined;
+    }
+  }
+
+  private getSubmitEpochProofArgs(args: {
+    fromBlock: number;
+    toBlock: number;
+    publicInputs: RootRollupPublicInputs;
+    proof: Proof;
+  }) {
+    return [
+      BigInt(args.fromBlock),
+      BigInt(args.toBlock),
+      {
+        previousArchive: args.publicInputs.previousArchive.root.toString(),
+        endArchive: args.publicInputs.endArchive.root.toString(),
+        previousBlockHash: args.publicInputs.previousBlockHash.toString(),
+        endBlockHash: args.publicInputs.endBlockHash.toString(),
+        endTimestamp: args.publicInputs.endTimestamp.toBigInt(),
+        outHash: args.publicInputs.outHash.toString(),
+        proverId: EthAddress.fromField(args.publicInputs.proverId).toString(),
+      },
+      makeTuple(AZTEC_MAX_EPOCH_DURATION * 2, i =>
+        i % 2 === 0
+          ? args.publicInputs.fees[i / 2].recipient.toField().toString()
+          : args.publicInputs.fees[(i - 1) / 2].value.toString(),
+      ),
+      `0x${args.publicInputs.blobPublicInputs
+        .filter((_, i) => i < args.toBlock - args.fromBlock + 1)
+        .map(b => b.toString())
+        .join(``)}`,
+      `0x${serializeToBuffer(args.proof.extractAggregationObject()).toString('hex')}`,
+    ] as const;
+  }
+
+  protected async sleepOrInterrupted() {
+    await this.interruptibleSleep.sleep(this.sleepTimeMs);
+  }
+}

package/src/prover-node.ts

@@ -0,0 +1,335 @@
+import { compact } from '@aztec/foundation/collection';
+import { memoize } from '@aztec/foundation/decorators';
+import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import { DateProvider } from '@aztec/foundation/timer';
+import type { Maybe } from '@aztec/foundation/types';
+import type { P2P } from '@aztec/p2p';
+import { PublicProcessorFactory } from '@aztec/simulator/server';
+import type { L2Block, L2BlockSource } from '@aztec/stdlib/block';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import { getTimestampRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
+import {
+  type EpochProverManager,
+  EpochProvingJobTerminalState,
+  type ProverCoordination,
+  type ProverNodeApi,
+  type Service,
+  type WorldStateSynchronizer,
+  tryStop,
+} from '@aztec/stdlib/interfaces/server';
+import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import type { P2PClientType } from '@aztec/stdlib/p2p';
+import type { Tx, TxHash } from '@aztec/stdlib/tx';
+import {
+  Attributes,
+  type TelemetryClient,
+  type Traceable,
+  type Tracer,
+  getTelemetryClient,
+  trackSpan,
+} from '@aztec/telemetry-client';
+
+import { EpochProvingJob, type EpochProvingJobState } from './job/epoch-proving-job.js';
+import { ProverNodeMetrics } from './metrics.js';
+import type { EpochMonitor, EpochMonitorHandler } from './monitors/epoch-monitor.js';
+import type { ProverNodePublisher } from './prover-node-publisher.js';
+
+export type ProverNodeOptions = {
+  pollingIntervalMs: number;
+  maxPendingJobs: number;
+  maxParallelBlocksPerEpoch: number;
+  txGatheringTimeoutMs: number;
+  txGatheringIntervalMs: number;
+  txGatheringMaxParallelRequests: number;
+};
+
+/**
+ * An Aztec Prover Node is a standalone process that monitors the unfinalised chain on L1 for unproven blocks,
+ * submits bids for proving them, and monitors if they are accepted. If so, the prover node fetches the txs
+ * from a tx source in the p2p network or an external node, re-executes their public functions, creates a rollup
+ * proof for the epoch, and submits it to L1.
+ */
+export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable {
+  private log = createLogger('prover-node');
+  private dateProvider = new DateProvider();
+
+  private latestEpochWeAreProving: bigint | undefined;
+  private jobs: Map<string, EpochProvingJob> = new Map();
+  private cachedEpochData: { epochNumber: bigint; blocks: L2Block[]; txs: Tx[] } | undefined = undefined;
+  private options: ProverNodeOptions;
+  private metrics: ProverNodeMetrics;
+
+  private txFetcher: RunningPromise;
+  private lastBlockNumber: number | undefined;
+
+  public readonly tracer: Tracer;
+
+  constructor(
+    protected readonly prover: EpochProverManager,
+    protected readonly publisher: ProverNodePublisher,
+    protected readonly l2BlockSource: L2BlockSource & Maybe<Service>,
+    protected readonly l1ToL2MessageSource: L1ToL2MessageSource,
+    protected readonly contractDataSource: ContractDataSource,
+    protected readonly worldState: WorldStateSynchronizer,
+    protected readonly coordination: ProverCoordination & Maybe<Service>,
+    protected readonly epochsMonitor: EpochMonitor,
+    options: Partial<ProverNodeOptions> = {},
+    protected readonly telemetryClient: TelemetryClient = getTelemetryClient(),
+  ) {
+    this.options = {
+      pollingIntervalMs: 1_000,
+      maxPendingJobs: 100,
+      maxParallelBlocksPerEpoch: 32,
+      txGatheringTimeoutMs: 60_000,
+      txGatheringIntervalMs: 1_000,
+      txGatheringMaxParallelRequests: 100,
+      ...compact(options),
+    };
+
+    this.metrics = new ProverNodeMetrics(telemetryClient, 'ProverNode');
+    this.tracer = telemetryClient.getTracer('ProverNode');
+    this.txFetcher = new RunningPromise(() => this.checkForTxs(), this.log, this.options.txGatheringIntervalMs);
+  }
+
+  public getProverId() {
+    return this.prover.getProverId();
+  }
+
+  public getP2P() {
+    const asP2PClient = this.coordination as P2P<P2PClientType.Prover>;
+    if (typeof asP2PClient.isP2PClient === 'function' && asP2PClient.isP2PClient()) {
+      return asP2PClient;
+    }
+    return undefined;
+  }
+
+  /**
+   * Handles an epoch being completed by starting a proof for it if there are no active jobs for it.
+   * @param epochNumber - The epoch number that was just completed.
+   */
+  async handleEpochReadyToProve(epochNumber: bigint): Promise<void> {
+    try {
+      this.log.debug('jobs', JSON.stringify(this.jobs, null, 2));
+      const activeJobs = await this.getActiveJobsForEpoch(epochNumber);
+      if (activeJobs.length > 0) {
+        this.log.info(`Not starting proof for ${epochNumber} since there are active jobs`);
+        return;
+      }
+      // TODO: we probably want to skip starting a proof if we are too far into the current epoch
+      await this.startProof(epochNumber);
+    } catch (err) {
+      if (err instanceof EmptyEpochError) {
+        this.log.info(`Not starting proof for ${epochNumber} since no blocks were found`);
+      } else {
+        this.log.error(`Error handling epoch completed`, err);
+      }
+    }
+  }
+
+  /**
+   * Starts the prover node so it periodically checks for unproven epochs in the unfinalised chain from L1 and
+   * starts proving jobs for them.
+   */
+  start() {
+    this.txFetcher.start();
+    this.epochsMonitor.start(this);
+    this.log.info('Started ProverNode', this.options);
+  }
+
+  /**
+   * Stops the prover node and all its dependencies.
+   */
+  async stop() {
+    this.log.info('Stopping ProverNode');
+    await this.txFetcher.stop();
+    await this.epochsMonitor.stop();
+    await this.prover.stop();
+    await tryStop(this.l2BlockSource);
+    this.publisher.interrupt();
+    await Promise.all(Array.from(this.jobs.values()).map(job => job.stop()));
+    await this.worldState.stop();
+    await tryStop(this.coordination);
+    await this.telemetryClient.stop();
+    this.log.info('Stopped ProverNode');
+  }
+
+  /**
+   * Creates a proof for a block range. Returns once the proof has been submitted to L1.
+   */
+  public async prove(epochNumber: number | bigint) {
+    const job = await this.createProvingJob(BigInt(epochNumber));
+    return job.run();
+  }
+
+  /**
+   * Starts a proving process and returns immediately.
+   */
+  public async startProof(epochNumber: number | bigint) {
+    const job = await this.createProvingJob(BigInt(epochNumber));
+    void job.run().catch(err => this.log.error(`Error proving epoch ${epochNumber}`, err));
+  }
+
+  /**
+   * Returns the prover instance.
+   */
+  public getProver() {
+    return this.prover;
+  }
+
+  /**
+   * Returns an array of jobs being processed.
+   */
+  public getJobs(): Promise<{ uuid: string; status: EpochProvingJobState; epochNumber: number }[]> {
+    return Promise.resolve(
+      Array.from(this.jobs.entries()).map(([uuid, job]) => ({
+        uuid,
+        status: job.getState(),
+        epochNumber: Number(job.getEpochNumber()),
+      })),
+    );
+  }
+
+  protected async getActiveJobsForEpoch(
+    epochBigInt: bigint,
+  ): Promise<{ uuid: string; status: EpochProvingJobState }[]> {
+    const jobs = await this.getJobs();
+    const epochNumber = Number(epochBigInt);
+    return jobs.filter(job => job.epochNumber === epochNumber && !EpochProvingJobTerminalState.includes(job.status));
+  }
+
+  private checkMaximumPendingJobs() {
+    const { maxPendingJobs } = this.options;
+    return maxPendingJobs === 0 || this.jobs.size < maxPendingJobs;
+  }
+
+  @trackSpan('ProverNode.createProvingJob', epochNumber => ({ [Attributes.EPOCH_NUMBER]: Number(epochNumber) }))
+  private async createProvingJob(epochNumber: bigint) {
+    if (!this.checkMaximumPendingJobs()) {
+      throw new Error(`Maximum pending proving jobs ${this.options.maxPendingJobs} reached. Cannot create new job.`);
+    }
+
+    // Gather blocks for this epoch
+    const cachedEpochData = this.cachedEpochData?.epochNumber === epochNumber ? this.cachedEpochData : undefined;
+    const { blocks, txs } = cachedEpochData ?? (await this.gatherEpochData(epochNumber));
+
+    const fromBlock = blocks[0].number;
+    const toBlock = blocks.at(-1)!.number;
+
+    // Fast forward world state to right before the target block and get a fork
+    this.log.verbose(`Creating proving job for epoch ${epochNumber} for block range ${fromBlock} to ${toBlock}`);
+    await this.worldState.syncImmediate(toBlock);
+
+    // Create a processor using the forked world state
+    const publicProcessorFactory = new PublicProcessorFactory(
+      this.contractDataSource,
+      this.dateProvider,
+      this.telemetryClient,
+    );
+
+    const cleanUp = () => {
+      this.jobs.delete(job.getId());
+      return Promise.resolve();
+    };
+
+    const [_, endTimestamp] = getTimestampRangeForEpoch(epochNumber + 1n, await this.getL1Constants());
+    const deadline = new Date(Number(endTimestamp) * 1000);
+
+    const job = this.doCreateEpochProvingJob(epochNumber, deadline, blocks, txs, publicProcessorFactory, cleanUp);
+    this.jobs.set(job.getId(), job);
+    return job;
+  }
+
+  @memoize
+  private getL1Constants() {
+    return this.l2BlockSource.getL1Constants();
+  }
+
+  /** Monitors for new blocks and requests their txs from the p2p layer to ensure they are available for proving. */
+  @trackSpan('ProverNode.checkForTxs')
+  private async checkForTxs() {
+    const blockNumber = await this.l2BlockSource.getBlockNumber();
+    if (this.lastBlockNumber === undefined || blockNumber > this.lastBlockNumber) {
+      const block = await this.l2BlockSource.getBlock(blockNumber);
+      if (!block) {
+        return;
+      }
+      const txHashes = block.body.txEffects.map(tx => tx.txHash);
+      this.log.verbose(`Fetching ${txHashes.length} tx hashes for block number ${blockNumber} from coordination`);
+      await this.coordination.getTxsByHash(txHashes); // This stores the txs in the tx pool, no need to persist them here
+      this.lastBlockNumber = blockNumber;
+    }
+  }
+
+  @trackSpan('ProverNode.gatherEpochData', epochNumber => ({ [Attributes.EPOCH_NUMBER]: Number(epochNumber) }))
+  private async gatherEpochData(epochNumber: bigint) {
+    // Gather blocks for this epoch and their txs
+    const blocks = await this.gatherBlocks(epochNumber);
+    const txs = await this.gatherTxs(epochNumber, blocks);
+
+    return { blocks, txs };
+  }
+
+  private async gatherBlocks(epochNumber: bigint) {
+    const blocks = await this.l2BlockSource.getBlocksForEpoch(epochNumber);
+    if (blocks.length === 0) {
+      throw new EmptyEpochError(epochNumber);
+    }
+    return blocks;
+  }
+
+  private async gatherTxs(epochNumber: bigint, blocks: L2Block[]) {
+    const txsToFind: TxHash[] = blocks.flatMap(block => block.body.txEffects.map(tx => tx.txHash));
+    const txs = await this.coordination.getTxsByHash(txsToFind);
+
+    if (txs.length === txsToFind.length) {
+      this.log.verbose(`Gathered all ${txs.length} txs for epoch ${epochNumber}`, { epochNumber });
+      return txs;
+    }
+
+    const txHashesFound = await Promise.all(txs.map(tx => tx.getTxHash()));
+    const missingTxHashes = txsToFind
+      .filter(txHashToFind => !txHashesFound.some(txHashFound => txHashToFind.equals(txHashFound)))
+      .join(', ');
+
+    throw new Error(`Txs not found for epoch ${epochNumber}: ${missingTxHashes}`);
+  }
+
+  /** Extracted for testing purposes. */
+  protected doCreateEpochProvingJob(
+    epochNumber: bigint,
+    deadline: Date | undefined,
+    blocks: L2Block[],
+    txs: Tx[],
+    publicProcessorFactory: PublicProcessorFactory,
+    cleanUp: () => Promise<void>,
+  ) {
+    return new EpochProvingJob(
+      this.worldState,
+      epochNumber,
+      blocks,
+      txs,
+      this.prover.createEpochProver(),
+      publicProcessorFactory,
+      this.publisher,
+      this.l2BlockSource,
+      this.l1ToL2MessageSource,
+      this.metrics,
+      deadline,
+      { parallelBlockLimit: this.options.maxParallelBlocksPerEpoch },
+      cleanUp,
+    );
+  }
+
+  /** Extracted for testing purposes. */
+  protected async triggerMonitors() {
+    await this.epochsMonitor.work();
+  }
+}
+
+class EmptyEpochError extends Error {
+  constructor(epochNumber: bigint) {
+    super(`No blocks found for epoch ${epochNumber}`);
+    this.name = 'EmptyEpochError';
+  }
+}