@aztec/prover-node 0.0.0-test.0

package/src/factory.ts

@@ -0,0 +1,99 @@
+import { type Archiver, createArchiver } from '@aztec/archiver';
+import { type BlobSinkClientInterface, createBlobSinkClient } from '@aztec/blob-sink/client';
+import { EpochCache } from '@aztec/epoch-cache';
+import { L1TxUtils, RollupContract, createEthereumChain, createL1Clients } from '@aztec/ethereum';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import type { DataStoreConfig } from '@aztec/kv-store/config';
+import { createProverClient } from '@aztec/prover-client';
+import { createAndStartProvingBroker } from '@aztec/prover-client/broker';
+import type { ProverCoordination, ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
+import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
+import { createWorldStateSynchronizer } from '@aztec/world-state';
+
+import type { ProverNodeConfig } from './config.js';
+import { EpochMonitor } from './monitors/epoch-monitor.js';
+import { createProverCoordination } from './prover-coordination/factory.js';
+import { ProverNodePublisher } from './prover-node-publisher.js';
+import { ProverNode, type ProverNodeOptions } from './prover-node.js';
+
+/** Creates a new prover node given a config. */
+export async function createProverNode(
+  config: ProverNodeConfig & DataStoreConfig,
+  deps: {
+    telemetry?: TelemetryClient;
+    log?: Logger;
+    aztecNodeTxProvider?: ProverCoordination;
+    archiver?: Archiver;
+    publisher?: ProverNodePublisher;
+    blobSinkClient?: BlobSinkClientInterface;
+    broker?: ProvingJobBroker;
+    l1TxUtils?: L1TxUtils;
+  } = {},
+  options: {
+    prefilledPublicData?: PublicDataTreeLeaf[];
+  } = {},
+) {
+  const telemetry = deps.telemetry ?? getTelemetryClient();
+  const blobSinkClient = deps.blobSinkClient ?? createBlobSinkClient(config);
+  const log = deps.log ?? createLogger('prover-node');
+  const archiver = deps.archiver ?? (await createArchiver(config, blobSinkClient, { blockUntilSync: true }, telemetry));
+  log.verbose(`Created archiver and synced to block ${await archiver.getBlockNumber()}`);
+
+  const worldStateConfig = { ...config, worldStateProvenBlocksOnly: false };
+  const worldStateSynchronizer = await createWorldStateSynchronizer(
+    worldStateConfig,
+    archiver,
+    options.prefilledPublicData,
+    telemetry,
+  );
+  await worldStateSynchronizer.start();
+
+  const broker = deps.broker ?? (await createAndStartProvingBroker(config, telemetry));
+  const prover = await createProverClient(config, worldStateSynchronizer, broker, telemetry);
+
+  const { l1RpcUrls: rpcUrls, l1ChainId: chainId, publisherPrivateKey } = config;
+  const chain = createEthereumChain(rpcUrls, chainId);
+  const { publicClient, walletClient } = createL1Clients(rpcUrls, publisherPrivateKey, chain.chainInfo);
+
+  const rollupContract = new RollupContract(publicClient, config.l1Contracts.rollupAddress.toString());
+
+  const l1TxUtils = deps.l1TxUtils ?? new L1TxUtils(publicClient, walletClient, log, config);
+  const publisher = deps.publisher ?? new ProverNodePublisher(config, { telemetry, rollupContract, l1TxUtils });
+
+  const epochCache = await EpochCache.create(config.l1Contracts.rollupAddress, config);
+
+  // If config.p2pEnabled is true, createProverCoordination will create a p2p client where txs are requested
+  // If config.p2pEnabled is false, createProverCoordination request information from the AztecNode
+  const proverCoordination = await createProverCoordination(config, {
+    aztecNodeTxProvider: deps.aztecNodeTxProvider,
+    worldStateSynchronizer,
+    archiver,
+    epochCache,
+    telemetry,
+  });
+
+  const proverNodeConfig: ProverNodeOptions = {
+    maxPendingJobs: config.proverNodeMaxPendingJobs,
+    pollingIntervalMs: config.proverNodePollingIntervalMs,
+    maxParallelBlocksPerEpoch: config.proverNodeMaxParallelBlocksPerEpoch,
+    txGatheringMaxParallelRequests: config.txGatheringMaxParallelRequests,
+    txGatheringIntervalMs: config.txGatheringIntervalMs,
+    txGatheringTimeoutMs: config.txGatheringTimeoutMs,
+  };
+
+  const epochMonitor = await EpochMonitor.create(archiver, proverNodeConfig, telemetry);
+
+  return new ProverNode(
+    prover,
+    publisher,
+    archiver,
+    archiver,
+    archiver,
+    worldStateSynchronizer,
+    proverCoordination,
+    epochMonitor,
+    proverNodeConfig,
+    telemetry,
+  );
+}

package/src/http.ts

@@ -0,0 +1,13 @@
+import { ProverNodeApiSchema } from '@aztec/stdlib/interfaces/server';
+import { createTracedJsonRpcServer } from '@aztec/telemetry-client';
+
+import type { ProverNode } from './prover-node.js';
+
+/**
+ * Wrap a ProverNode instance with a JSON RPC HTTP server.
+ * @param node - The ProverNode
+ * @returns An JSON-RPC HTTP server
+ */
+export function createProverNodeRpcServer(node: ProverNode) {
+  return createTracedJsonRpcServer(node, ProverNodeApiSchema);
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './config.js';
+export * from './factory.js';
+export * from './http.js';
+export * from './prover-node-publisher.js';
+export * from './prover-node.js';

package/src/job/epoch-proving-job.ts

@@ -0,0 +1,255 @@
+import { asyncPool } from '@aztec/foundation/async-pool';
+import { createLogger } from '@aztec/foundation/log';
+import { promiseWithResolvers } from '@aztec/foundation/promise';
+import { Timer } from '@aztec/foundation/timer';
+import type { PublicProcessor, PublicProcessorFactory } from '@aztec/simulator/server';
+import type { L2Block, L2BlockSource } from '@aztec/stdlib/block';
+import {
+  type EpochProver,
+  type EpochProvingJobState,
+  EpochProvingJobTerminalState,
+  type ForkMerkleTreeOperations,
+} from '@aztec/stdlib/interfaces/server';
+import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import type { ProcessedTx, Tx } from '@aztec/stdlib/tx';
+import { Attributes, type Traceable, type Tracer, trackSpan } from '@aztec/telemetry-client';
+
+import * as crypto from 'node:crypto';
+
+import type { ProverNodeMetrics } from '../metrics.js';
+import type { ProverNodePublisher } from '../prover-node-publisher.js';
+
+/**
+ * Job that grabs a range of blocks from the unfinalised chain from L1, gets their txs given their hashes,
+ * re-executes their public calls, generates a rollup proof, and submits it to L1. This job will update the
+ * world state as part of public call execution via the public processor.
+ */
+export class EpochProvingJob implements Traceable {
+  private state: EpochProvingJobState = 'initialized';
+  private log = createLogger('prover-node:epoch-proving-job');
+  private uuid: string;
+
+  private runPromise: Promise<void> | undefined;
+  private deadlineTimeoutHandler: NodeJS.Timeout | undefined;
+
+  public readonly tracer: Tracer;
+
+  constructor(
+    private dbProvider: ForkMerkleTreeOperations,
+    private epochNumber: bigint,
+    private blocks: L2Block[],
+    private txs: Tx[],
+    private prover: EpochProver,
+    private publicProcessorFactory: PublicProcessorFactory,
+    private publisher: ProverNodePublisher,
+    private l2BlockSource: L2BlockSource,
+    private l1ToL2MessageSource: L1ToL2MessageSource,
+    private metrics: ProverNodeMetrics,
+    private deadline: Date | undefined,
+    private config: { parallelBlockLimit: number } = { parallelBlockLimit: 32 },
+    private cleanUp: (job: EpochProvingJob) => Promise<void> = () => Promise.resolve(),
+  ) {
+    this.uuid = crypto.randomUUID();
+    this.tracer = metrics.client.getTracer('EpochProvingJob');
+  }
+
+  public getId(): string {
+    return this.uuid;
+  }
+
+  public getState(): EpochProvingJobState {
+    return this.state;
+  }
+
+  public getEpochNumber(): bigint {
+    return this.epochNumber;
+  }
+
+  /**
+   * Proves the given epoch and submits the proof to L1.
+   */
+  @trackSpan('EpochProvingJob.run', function () {
+    return { [Attributes.EPOCH_NUMBER]: Number(this.epochNumber) };
+  })
+  public async run() {
+    this.scheduleDeadlineStop();
+
+    const epochNumber = Number(this.epochNumber);
+    const epochSizeBlocks = this.blocks.length;
+    const epochSizeTxs = this.blocks.reduce((total, current) => total + current.body.txEffects.length, 0);
+    const [fromBlock, toBlock] = [this.blocks[0].number, this.blocks.at(-1)!.number];
+    this.log.info(`Starting epoch ${epochNumber} proving job with blocks ${fromBlock} to ${toBlock}`, {
+      fromBlock,
+      toBlock,
+      epochSizeBlocks,
+      epochNumber,
+      uuid: this.uuid,
+    });
+
+    this.progressState('processing');
+    const timer = new Timer();
+    const { promise, resolve } = promiseWithResolvers<void>();
+    this.runPromise = promise;
+
+    try {
+      this.prover.startNewEpoch(epochNumber, fromBlock, epochSizeBlocks);
+      await this.prover.startTubeCircuits(this.txs);
+
+      await asyncPool(this.config.parallelBlockLimit, this.blocks, async block => {
+        this.checkState();
+
+        const globalVariables = block.header.globalVariables;
+        const txs = await this.getTxs(block);
+        const l1ToL2Messages = await this.getL1ToL2Messages(block);
+        const previousHeader = (await this.getBlockHeader(block.number - 1))!;
+
+        this.log.verbose(`Starting processing block ${block.number}`, {
+          number: block.number,
+          blockHash: (await block.hash()).toString(),
+          lastArchive: block.header.lastArchive.root,
+          noteHashTreeRoot: block.header.state.partial.noteHashTree.root,
+          nullifierTreeRoot: block.header.state.partial.nullifierTree.root,
+          publicDataTreeRoot: block.header.state.partial.publicDataTree.root,
+          previousHeader: previousHeader.hash(),
+          uuid: this.uuid,
+          ...globalVariables,
+        });
+
+        // Start block proving
+        await this.prover.startNewBlock(globalVariables, l1ToL2Messages, previousHeader);
+
+        // Process public fns
+        const db = await this.dbProvider.fork(block.number - 1);
+        const publicProcessor = this.publicProcessorFactory.create(db, globalVariables, true);
+        const processed = await this.processTxs(publicProcessor, txs);
+        await this.prover.addTxs(processed);
+        await db.close();
+        this.log.verbose(`Processed all ${txs.length} txs for block ${block.number}`, {
+          blockNumber: block.number,
+          blockHash: (await block.hash()).toString(),
+          uuid: this.uuid,
+        });
+
+        // Mark block as completed to pad it
+        await this.prover.setBlockCompleted(block.number, block.header);
+      });
+
+      const executionTime = timer.ms();
+
+      this.progressState('awaiting-prover');
+      const { publicInputs, proof } = await this.prover.finaliseEpoch();
+      this.log.info(`Finalised proof for epoch ${epochNumber}`, { epochNumber, uuid: this.uuid, duration: timer.ms() });
+
+      this.progressState('publishing-proof');
+      const success = await this.publisher.submitEpochProof({ fromBlock, toBlock, epochNumber, publicInputs, proof });
+      if (!success) {
+        throw new Error('Failed to submit epoch proof to L1');
+      }
+
+      this.log.info(`Submitted proof for epoch ${epochNumber} (blocks ${fromBlock} to ${toBlock})`, {
+        epochNumber,
+        uuid: this.uuid,
+      });
+      this.state = 'completed';
+      this.metrics.recordProvingJob(executionTime, timer.ms(), epochSizeBlocks, epochSizeTxs);
+    } catch (err: any) {
+      if (err && err.name === 'HaltExecutionError') {
+        this.log.warn(`Halted execution of epoch ${epochNumber} prover job`, { uuid: this.uuid, epochNumber });
+        return;
+      }
+      this.log.error(`Error running epoch ${epochNumber} prover job`, err, { uuid: this.uuid, epochNumber });
+      this.state = 'failed';
+    } finally {
+      clearTimeout(this.deadlineTimeoutHandler);
+      await this.cleanUp(this);
+      await this.prover.stop();
+      resolve();
+    }
+  }
+
+  private progressState(state: EpochProvingJobState) {
+    this.checkState();
+    this.state = state;
+  }
+
+  private checkState() {
+    if (this.state === 'timed-out' || this.state === 'stopped' || this.state === 'failed') {
+      throw new HaltExecutionError(this.state);
+    }
+  }
+
+  public async stop(state: EpochProvingJobState = 'stopped') {
+    this.state = state;
+    this.prover.cancel();
+    // TODO(palla/prover): Stop the publisher as well
+    if (this.runPromise) {
+      await this.runPromise;
+    }
+  }
+
+  private scheduleDeadlineStop() {
+    const deadline = this.deadline;
+    if (deadline) {
+      const timeout = deadline.getTime() - Date.now();
+      if (timeout <= 0) {
+        throw new Error('Cannot start job with deadline in the past');
+      }
+
+      this.deadlineTimeoutHandler = setTimeout(() => {
+        if (EpochProvingJobTerminalState.includes(this.state)) {
+          return;
+        }
+        this.log.warn('Stopping job due to deadline hit', { uuid: this.uuid, epochNumber: this.epochNumber });
+        this.stop('timed-out').catch(err => {
+          this.log.error('Error stopping job', err, { uuid: this.uuid, epochNumber: this.epochNumber });
+        });
+      }, timeout);
+    }
+  }
+
+  /* Returns the header for the given block number, or the genesis block for block zero. */
+  private async getBlockHeader(blockNumber: number) {
+    if (blockNumber === 0) {
+      return (await this.dbProvider.fork()).getInitialHeader();
+    }
+    return this.l2BlockSource.getBlockHeader(blockNumber);
+  }
+
+  private async getTxs(block: L2Block): Promise<Tx[]> {
+    const txHashes = block.body.txEffects.map(tx => tx.txHash.toBigInt());
+    const txsAndHashes = await Promise.all(this.txs.map(async tx => ({ tx, hash: await tx.getTxHash() })));
+    return txsAndHashes
+      .filter(txAndHash => txHashes.includes(txAndHash.hash.toBigInt()))
+      .map(txAndHash => txAndHash.tx);
+  }
+
+  private getL1ToL2Messages(block: L2Block) {
+    return this.l1ToL2MessageSource.getL1ToL2Messages(BigInt(block.number));
+  }
+
+  private async processTxs(publicProcessor: PublicProcessor, txs: Tx[]): Promise<ProcessedTx[]> {
+    const { deadline } = this;
+    const [processedTxs, failedTxs] = await publicProcessor.process(txs, { deadline });
+
+    if (failedTxs.length) {
+      throw new Error(
+        `Txs failed processing: ${failedTxs.map(({ tx, error }) => `${tx.getTxHash()} (${error})`).join(', ')}`,
+      );
+    }
+
+    if (processedTxs.length !== txs.length) {
+      throw new Error(`Failed to process all txs: processed ${processedTxs.length} out of ${txs.length}`);
+    }
+
+    return processedTxs;
+  }
+}
+
+class HaltExecutionError extends Error {
+  constructor(state: EpochProvingJobState) {
+    super(`Halted execution due to state ${state}`);
+    this.name = 'HaltExecutionError';
+  }
+}
+
+export { type EpochProvingJobState };

package/src/metrics.ts

@@ -0,0 +1,164 @@
+import { createLogger } from '@aztec/foundation/log';
+import type { L1PublishProofStats, L1PublishStats } from '@aztec/stdlib/stats';
+import {
+  Attributes,
+  type Gauge,
+  type Histogram,
+  Metrics,
+  type TelemetryClient,
+  type UpDownCounter,
+  ValueType,
+} from '@aztec/telemetry-client';
+
+import { formatEther } from 'viem';
+
+export class ProverNodeMetrics {
+  proverEpochExecutionDuration: Histogram;
+  provingJobDuration: Histogram;
+  provingJobBlocks: Gauge;
+  provingJobTransactions: Gauge;
+
+  gasPrice: Histogram;
+  txCount: UpDownCounter;
+  txDuration: Histogram;
+  txGas: Histogram;
+  txCalldataSize: Histogram;
+  txCalldataGas: Histogram;
+  txBlobDataGasUsed: Histogram;
+  txBlobDataGasCost: Histogram;
+
+  private senderBalance: Gauge;
+
+  constructor(
+    public readonly client: TelemetryClient,
+    name = 'ProverNode',
+    private logger = createLogger('prover-node:publisher:metrics'),
+  ) {
+    const meter = client.getMeter(name);
+    this.proverEpochExecutionDuration = meter.createHistogram(Metrics.PROVER_NODE_EXECUTION_DURATION, {
+      description: 'Duration of execution of an epoch by the prover',
+      unit: 'ms',
+      valueType: ValueType.INT,
+    });
+    this.provingJobDuration = meter.createHistogram(Metrics.PROVER_NODE_JOB_DURATION, {
+      description: 'Duration of proving job',
+      unit: 's',
+      valueType: ValueType.DOUBLE,
+    });
+    this.provingJobBlocks = meter.createGauge(Metrics.PROVER_NODE_JOB_BLOCKS, {
+      description: 'Number of blocks in a proven epoch',
+      valueType: ValueType.INT,
+    });
+    this.provingJobTransactions = meter.createGauge(Metrics.PROVER_NODE_JOB_TRANSACTIONS, {
+      description: 'Number of transactions in a proven epoch',
+      valueType: ValueType.INT,
+    });
+
+    this.gasPrice = meter.createHistogram(Metrics.L1_PUBLISHER_GAS_PRICE, {
+      description: 'The gas price used for transactions',
+      unit: 'gwei',
+      valueType: ValueType.DOUBLE,
+    });
+
+    this.txCount = meter.createUpDownCounter(Metrics.L1_PUBLISHER_TX_COUNT, {
+      description: 'The number of transactions processed',
+    });
+
+    this.txDuration = meter.createHistogram(Metrics.L1_PUBLISHER_TX_DURATION, {
+      description: 'The duration of transaction processing',
+      unit: 'ms',
+      valueType: ValueType.INT,
+    });
+
+    this.txGas = meter.createHistogram(Metrics.L1_PUBLISHER_TX_GAS, {
+      description: 'The gas consumed by transactions',
+      unit: 'gas',
+      valueType: ValueType.INT,
+    });
+
+    this.txCalldataSize = meter.createHistogram(Metrics.L1_PUBLISHER_TX_CALLDATA_SIZE, {
+      description: 'The size of the calldata in transactions',
+      unit: 'By',
+      valueType: ValueType.INT,
+    });
+
+    this.txCalldataGas = meter.createHistogram(Metrics.L1_PUBLISHER_TX_CALLDATA_GAS, {
+      description: 'The gas consumed by the calldata in transactions',
+      unit: 'gas',
+      valueType: ValueType.INT,
+    });
+
+    this.txBlobDataGasUsed = meter.createHistogram(Metrics.L1_PUBLISHER_TX_BLOBDATA_GAS_USED, {
+      description: 'The amount of blob gas used in transactions',
+      unit: 'gas',
+      valueType: ValueType.INT,
+    });
+
+    this.txBlobDataGasCost = meter.createHistogram(Metrics.L1_PUBLISHER_TX_BLOBDATA_GAS_COST, {
+      description: 'The gas cost of blobs in transactions',
+      unit: 'gwei',
+      valueType: ValueType.INT,
+    });
+
+    this.senderBalance = meter.createGauge(Metrics.L1_PUBLISHER_BALANCE, {
+      unit: 'eth',
+      description: 'The balance of the sender address',
+      valueType: ValueType.DOUBLE,
+    });
+  }
+
+  recordFailedTx() {
+    this.txCount.add(1, {
+      [Attributes.L1_TX_TYPE]: 'submitProof',
+      [Attributes.OK]: false,
+    });
+  }
+
+  recordSubmitProof(durationMs: number, stats: L1PublishProofStats) {
+    this.recordTx(durationMs, stats);
+  }
+
+  public recordProvingJob(executionTimeMs: number, totalTimeMs: number, numBlocks: number, numTxs: number) {
+    this.proverEpochExecutionDuration.record(Math.ceil(executionTimeMs));
+    this.provingJobDuration.record(totalTimeMs / 1000);
+    this.provingJobBlocks.record(Math.floor(numBlocks));
+    this.provingJobTransactions.record(Math.floor(numTxs));
+  }
+
+  public recordSenderBalance(wei: bigint, senderAddress: string) {
+    const eth = parseFloat(formatEther(wei, 'wei'));
+    this.senderBalance.record(eth, {
+      [Attributes.SENDER_ADDRESS]: senderAddress,
+    });
+  }
+
+  private recordTx(durationMs: number, stats: L1PublishStats) {
+    const attributes = {
+      [Attributes.L1_TX_TYPE]: 'submitProof',
+      [Attributes.L1_SENDER]: stats.sender,
+    } as const;
+
+    this.txCount.add(1, {
+      ...attributes,
+      [Attributes.OK]: true,
+    });
+
+    this.txDuration.record(Math.ceil(durationMs), attributes);
+    this.txGas.record(
+      // safe to downcast - total block limit is 30M gas which fits in a JS number
+      Number(stats.gasUsed),
+      attributes,
+    );
+    this.txCalldataGas.record(stats.calldataGas, attributes);
+    this.txCalldataSize.record(stats.calldataSize, attributes);
+
+    this.txBlobDataGasCost.record(Number(stats.blobDataGas), attributes);
+    this.txBlobDataGasUsed.record(Number(stats.blobGasUsed), attributes);
+
+    try {
+      this.gasPrice.record(parseInt(formatEther(stats.gasPrice, 'gwei'), 10));
+    } catch (e) {
+      // ignore
+    }
+  }
+}

package/src/monitors/epoch-monitor.ts

@@ -0,0 +1,106 @@
+import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import { type L1RollupConstants, getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
+import {
+  type TelemetryClient,
+  type Traceable,
+  type Tracer,
+  getTelemetryClient,
+  trackSpan,
+} from '@aztec/telemetry-client';
+
+export interface EpochMonitorHandler {
+  handleEpochReadyToProve(epochNumber: bigint): Promise<void>;
+}
+
+/**
+ * Fires an event when a new epoch ready to prove is detected.
+ *
+ * We define an epoch as ready to prove when:
+ * - The epoch is complete
+ * - Its blocks have not been reorg'd out due to a missing L2 proof
+ * - Its first block is the immediate successor of the last proven block
+ *
+ * This class periodically hits the L2BlockSource.
+ * On start it will trigger the event for the last epoch ready to prove.
+ */
+export class EpochMonitor implements Traceable {
+  private runningPromise: RunningPromise;
+  private log = createLogger('prover-node:epoch-monitor');
+  public readonly tracer: Tracer;
+
+  private handler: EpochMonitorHandler | undefined;
+  private latestEpochNumber: bigint | undefined;
+
+  constructor(
+    private readonly l2BlockSource: L2BlockSource,
+    private readonly l1Constants: Pick<L1RollupConstants, 'epochDuration'>,
+    private options: { pollingIntervalMs: number },
+    telemetry: TelemetryClient = getTelemetryClient(),
+  ) {
+    this.tracer = telemetry.getTracer('EpochMonitor');
+    this.runningPromise = new RunningPromise(this.work.bind(this), this.log, this.options.pollingIntervalMs);
+  }
+
+  public static async create(
+    l2BlockSource: L2BlockSource,
+    options: { pollingIntervalMs: number },
+    telemetry: TelemetryClient = getTelemetryClient(),
+  ): Promise<EpochMonitor> {
+    const l1Constants = await l2BlockSource.getL1Constants();
+    return new EpochMonitor(l2BlockSource, l1Constants, options, telemetry);
+  }
+
+  public start(handler: EpochMonitorHandler) {
+    this.handler = handler;
+    this.runningPromise.start();
+    this.log.info('Started EpochMonitor', this.options);
+  }
+
+  /** Exposed for testing */
+  public setHandler(handler: EpochMonitorHandler) {
+    this.handler = handler;
+  }
+
+  public async stop() {
+    await this.runningPromise.stop();
+    this.log.info('Stopped EpochMonitor');
+  }
+
+  @trackSpan('EpochMonitor.work')
+  public async work() {
+    const { epochToProve, blockNumber, slotNumber } = await this.getEpochNumberToProve();
+    if (epochToProve === undefined) {
+      this.log.trace(`Next block to prove ${blockNumber} not yet mined`, { blockNumber });
+      return;
+    }
+    if (this.latestEpochNumber !== undefined && epochToProve <= this.latestEpochNumber) {
+      this.log.trace(`Epoch ${epochToProve} already processed`, { epochToProve, blockNumber, slotNumber });
+      return;
+    }
+
+    const isCompleted = await this.l2BlockSource.isEpochComplete(epochToProve);
+    if (!isCompleted) {
+      this.log.trace(`Epoch ${epochToProve} is not complete`, { epochToProve, blockNumber, slotNumber });
+      return;
+    }
+
+    this.log.debug(`Epoch ${epochToProve} is ready to be proven`);
+    await this.handler?.handleEpochReadyToProve(epochToProve);
+    this.latestEpochNumber = epochToProve;
+  }
+
+  private async getEpochNumberToProve() {
+    const lastBlockProven = await this.l2BlockSource.getProvenBlockNumber();
+    const firstBlockToProve = lastBlockProven + 1;
+    const firstBlockHeaderToProve = await this.l2BlockSource.getBlockHeader(firstBlockToProve);
+    if (!firstBlockHeaderToProve) {
+      return { epochToProve: undefined, blockNumber: firstBlockToProve };
+    }
+
+    const firstSlotOfEpochToProve = firstBlockHeaderToProve.getSlot();
+    const epochToProve = getEpochAtSlot(firstSlotOfEpochToProve, this.l1Constants);
+    return { epochToProve, blockNumber: firstBlockToProve, slotNumber: firstSlotOfEpochToProve };
+  }
+}

package/src/monitors/index.ts

@@ -0,0 +1 @@
+export * from './epoch-monitor.js';

package/src/prover-coordination/config.ts

@@ -0,0 +1,17 @@
+import { type ConfigMappingsType, getConfigFromMappings } from '@aztec/foundation/config';
+
+export type ProverCoordinationConfig = {
+  proverCoordinationNodeUrl: string | undefined;
+};
+
+export const proverCoordinationConfigMappings: ConfigMappingsType<ProverCoordinationConfig> = {
+  proverCoordinationNodeUrl: {
+    env: 'PROVER_COORDINATION_NODE_URL',
+    description: 'The URL of the tx provider node',
+    parseEnv: (val: string) => val,
+  },
+};
+
+export function getTxProviderConfigFromEnv(): ProverCoordinationConfig {
+  return getConfigFromMappings<ProverCoordinationConfig>(proverCoordinationConfigMappings);
+}