@aztec/prover-node 0.85.0 → 0.86.0-nightly.20250425

package/src/metrics.ts

@@ -1,107 +1,187 @@
+import type { RollupContract } from '@aztec/ethereum';
+import type { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import type { L1PublishProofStats, L1PublishStats } from '@aztec/stdlib/stats';
 import {
   Attributes,
+  type BatchObservableResult,
   type Gauge,
   type Histogram,
+  type Meter,
   Metrics,
+  type ObservableGauge,
   type TelemetryClient,
+  type Tracer,
   type UpDownCounter,
   ValueType,
 } from '@aztec/telemetry-client';
 
-import { formatEther } from 'viem';
+import { formatEther, formatUnits } from 'viem';
 
-export class ProverNodeMetrics {
+export class ProverNodeJobMetrics {
   proverEpochExecutionDuration: Histogram;
   provingJobDuration: Histogram;
   provingJobBlocks: Gauge;
   provingJobTransactions: Gauge;
 
-  gasPrice: Histogram;
-  txCount: UpDownCounter;
-  txDuration: Histogram;
-  txGas: Histogram;
-  txCalldataSize: Histogram;
-  txCalldataGas: Histogram;
-  txBlobDataGasUsed: Histogram;
-  txBlobDataGasCost: Histogram;
-  txTotalFee: Histogram;
-
-  private senderBalance: Gauge;
-
   constructor(
-    public readonly client: TelemetryClient,
-    name = 'ProverNode',
+    private meter: Meter,
+    public readonly tracer: Tracer,
     private logger = createLogger('prover-node:publisher:metrics'),
   ) {
-    const meter = client.getMeter(name);
-    this.proverEpochExecutionDuration = meter.createHistogram(Metrics.PROVER_NODE_EXECUTION_DURATION, {
+    this.proverEpochExecutionDuration = this.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, {
+    this.provingJobDuration = this.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, {
+    this.provingJobBlocks = this.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, {
+    this.provingJobTransactions = this.meter.createGauge(Metrics.PROVER_NODE_JOB_TRANSACTIONS, {
       description: 'Number of transactions in a proven epoch',
       valueType: ValueType.INT,
     });
+  }
+
+  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));
+  }
+}
+
+export class ProverNodeRewardsMetrics {
+  private rewards: ObservableGauge;
+  private accumulatedRewards: UpDownCounter;
+  private prevEpoch = -1n;
+  private proofSubmissionWindow = 0n;
+
+  constructor(
+    private meter: Meter,
+    private coinbase: EthAddress,
+    private rollup: RollupContract,
+    private logger = createLogger('prover-node:publisher:metrics'),
+  ) {
+    this.rewards = this.meter.createObservableGauge(Metrics.PROVER_NODE_REWARDS_PER_EPOCH, {
+      valueType: ValueType.DOUBLE,
+      description: 'The rewards earned',
+    });
+
+    this.accumulatedRewards = this.meter.createUpDownCounter(Metrics.PROVER_NODE_REWARDS_TOTAL, {
+      valueType: ValueType.DOUBLE,
+      description: 'The rewards earned (total)',
+    });
+  }
+
+  public async start() {
+    this.proofSubmissionWindow = await this.rollup.getProofSubmissionWindow();
+    this.meter.addBatchObservableCallback(this.observe, [this.rewards]);
+  }
+
+  public stop() {
+    this.meter.removeBatchObservableCallback(this.observe, [this.rewards]);
+  }
+
+  private observe = async (observer: BatchObservableResult): Promise<void> => {
+    const slot = await this.rollup.getSlotNumber();
+
+    // look at the prev epoch so that we get an accurate value, after proof submission window has closed
+    if (slot > this.proofSubmissionWindow) {
+      const closedEpoch = await this.rollup.getEpochNumberForSlotNumber(slot - this.proofSubmissionWindow);
+      const rewards = await this.rollup.getSpecificProverRewardsForEpoch(closedEpoch, this.coinbase);
+
+      const fmt = parseFloat(formatUnits(rewards, 18));
+
+      observer.observe(this.rewards, fmt, {
+        [Attributes.COINBASE]: this.coinbase.toString(),
+      });
+
+      // only accumulate once per epoch
+      if (closedEpoch > this.prevEpoch) {
+        this.prevEpoch = closedEpoch;
+        this.accumulatedRewards.add(fmt, {
+          [Attributes.COINBASE]: this.coinbase.toString(),
+        });
+      }
+    }
+  };
+}
 
-    this.gasPrice = meter.createHistogram(Metrics.L1_PUBLISHER_GAS_PRICE, {
+export class ProverNodePublisherMetrics {
+  gasPrice: Histogram;
+  txCount: UpDownCounter;
+  txDuration: Histogram;
+  txGas: Histogram;
+  txCalldataSize: Histogram;
+  txCalldataGas: Histogram;
+  txBlobDataGasUsed: Histogram;
+  txBlobDataGasCost: Histogram;
+  txTotalFee: Histogram;
+
+  private senderBalance: Gauge;
+  private meter: Meter;
+
+  constructor(
+    public readonly client: TelemetryClient,
+    name = 'ProverNode',
+    private logger = createLogger('prover-node:publisher:metrics'),
+  ) {
+    this.meter = client.getMeter(name);
+
+    this.gasPrice = this.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, {
+    this.txCount = this.meter.createUpDownCounter(Metrics.L1_PUBLISHER_TX_COUNT, {
       description: 'The number of transactions processed',
     });
 
-    this.txDuration = meter.createHistogram(Metrics.L1_PUBLISHER_TX_DURATION, {
+    this.txDuration = this.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, {
+    this.txGas = this.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, {
+    this.txCalldataSize = this.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, {
+    this.txCalldataGas = this.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, {
+    this.txBlobDataGasUsed = this.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, {
+    this.txBlobDataGasCost = this.meter.createHistogram(Metrics.L1_PUBLISHER_TX_BLOBDATA_GAS_COST, {
       description: 'The gas cost of blobs in transactions',
       unit: 'gwei',
       valueType: ValueType.INT,
     });
 
-    this.txTotalFee = meter.createHistogram(Metrics.L1_PUBLISHER_TX_TOTAL_FEE, {
+    this.txTotalFee = this.meter.createHistogram(Metrics.L1_PUBLISHER_TX_TOTAL_FEE, {
       description: 'How much L1 tx costs',
       unit: 'gwei',
       valueType: ValueType.DOUBLE,
@@ -112,7 +192,7 @@ export class ProverNodeMetrics {
       },
     });
 
-    this.senderBalance = meter.createGauge(Metrics.L1_PUBLISHER_BALANCE, {
+    this.senderBalance = this.meter.createGauge(Metrics.L1_PUBLISHER_BALANCE, {
       unit: 'eth',
       description: 'The balance of the sender address',
       valueType: ValueType.DOUBLE,
@@ -130,13 +210,6 @@ export class ProverNodeMetrics {
     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, {

package/src/monitors/epoch-monitor.ts

@@ -11,7 +11,7 @@ import {
 } from '@aztec/telemetry-client';
 
 export interface EpochMonitorHandler {
-  handleEpochReadyToProve(epochNumber: bigint): Promise<void>;
+  handleEpochReadyToProve(epochNumber: bigint): Promise<boolean>;
 }
 
 /**
@@ -71,6 +71,7 @@ export class EpochMonitor implements Traceable {
   @trackSpan('EpochMonitor.work')
   public async work() {
     const { epochToProve, blockNumber, slotNumber } = await this.getEpochNumberToProve();
+    this.log.debug(`Epoch to prove: ${epochToProve}`, { blockNumber, slotNumber });
     if (epochToProve === undefined) {
       this.log.trace(`Next block to prove ${blockNumber} not yet mined`, { blockNumber });
       return;
@@ -87,8 +88,9 @@ export class EpochMonitor implements Traceable {
     }
 
     this.log.debug(`Epoch ${epochToProve} is ready to be proven`);
-    await this.handler?.handleEpochReadyToProve(epochToProve);
-    this.latestEpochNumber = epochToProve;
+    if (await this.handler?.handleEpochReadyToProve(epochToProve)) {
+      this.latestEpochNumber = epochToProve;
+    }
   }
 
   private async getEpochNumberToProve() {

package/src/prover-coordination/combined-prover-coordination.ts

@@ -0,0 +1,160 @@
+import { asyncPool } from '@aztec/foundation/async-pool';
+import { createLogger } from '@aztec/foundation/log';
+import type { P2P } from '@aztec/p2p';
+import type { P2PClient, ProverCoordination } from '@aztec/stdlib/interfaces/server';
+import { type Tx, TxHash } from '@aztec/stdlib/tx';
+
+export type CombinedCoordinationOptions = {
+  // These options apply to http tx gathering only
+  txGatheringBatchSize: number;
+  txGatheringMaxParallelRequestsPerNode: number;
+};
+
+interface CoordinationPool {
+  getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]>;
+  hasTxsInPool(txHashes: TxHash[]): Promise<boolean[]>;
+  getTxsByHashFromPool(txHashes: TxHash[]): Promise<(Tx | undefined)[]>;
+  addTxs(txs: Tx[]): Promise<void>;
+}
+
+export interface TxSource {
+  getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]>;
+}
+
+// Wraps the p2p client into a coordination pool
+class P2PCoordinationPool implements CoordinationPool {
+  constructor(private readonly p2p: P2P) {}
+  getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
+    return this.p2p.getTxsByHash(txHashes);
+  }
+  hasTxsInPool(txHashes: TxHash[]): Promise<boolean[]> {
+    return this.p2p.hasTxsInPool(txHashes);
+  }
+  getTxsByHashFromPool(txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
+    return this.p2p.getTxsByHashFromPool(txHashes);
+  }
+  addTxs(txs: Tx[]): Promise<void> {
+    return this.p2p.addTxs(txs);
+  }
+}
+
+// Wraps an in memory tx pool into a coordination pool. Used for testing when no p2p/tx pool is available.
+class InMemoryCoordinationPool implements CoordinationPool {
+  private txs: Map<string, Tx> = new Map();
+  getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
+    return Promise.resolve(txHashes.map(hash => this.txs.get(hash.toString())));
+  }
+  hasTxsInPool(txHashes: TxHash[]): Promise<boolean[]> {
+    return Promise.resolve(txHashes.map(hash => this.txs.has(hash.toString())));
+  }
+  getTxsByHashFromPool(txHashes: TxHash[]): Promise<(Tx | undefined)[]> {
+    return this.getTxsByHash(txHashes);
+  }
+  async addTxs(txs: Tx[]): Promise<void> {
+    const hashes = await Promise.all(txs.map(tx => tx.getTxHash()));
+    txs.forEach((tx, index) => this.txs.set(hashes[index].toString(), tx));
+  }
+}
+
+// Class to implement combined transaction retrieval from p2p and any available nodes
+export class CombinedProverCoordination implements ProverCoordination {
+  constructor(
+    public readonly p2p: P2P | undefined,
+    public readonly aztecNodes: TxSource[],
+    private readonly options: CombinedCoordinationOptions = {
+      txGatheringBatchSize: 10,
+      txGatheringMaxParallelRequestsPerNode: 10,
+    },
+    private readonly log = createLogger('prover-node:combined-prover-coordination'),
+  ) {}
+
+  public getP2PClient(): P2PClient | undefined {
+    return this.p2p;
+  }
+
+  public async getTxsByHash(txHashes: TxHash[]): Promise<Tx[]> {
+    const pool = this.p2p ? new P2PCoordinationPool(this.p2p) : new InMemoryCoordinationPool();
+    await this.#gatherTxs(txHashes, pool);
+    const availability = await pool.hasTxsInPool(txHashes);
+    const notFound = txHashes.filter((_, index) => !availability[index]);
+    if (notFound.length > 0) {
+      throw new Error(`Could not find txs: ${notFound.map(tx => tx.toString())}`);
+    }
+    const txs = await pool.getTxsByHashFromPool(txHashes);
+    return txs.filter(tx => tx !== undefined) as Tx[];
+  }
+
+  public async gatherTxs(txHashes: TxHash[]): Promise<void> {
+    const pool = this.p2p ? new P2PCoordinationPool(this.p2p) : new InMemoryCoordinationPool();
+    await this.#gatherTxs(txHashes, pool);
+  }
+
+  async #gatherTxs(txHashes: TxHash[], pool: CoordinationPool): Promise<void> {
+    const availability = await pool.hasTxsInPool(txHashes);
+    const notFound = txHashes.filter((_, index) => !availability[index]);
+    const txsToFind = new Set(notFound.map(tx => tx.toString()));
+    if (txsToFind.size === 0) {
+      this.log.info(`Check for ${txHashes.length} txs found all in the pool}`);
+      return;
+    }
+    this.log.info(`Check for ${txHashes.length} txs found ${txsToFind.size} missing. Will gather from nodes and p2p`);
+    const originalToFind = txsToFind.size;
+    await this.#gatherTxsFromAllNodes(txsToFind, pool);
+    if (txsToFind.size === 0) {
+      this.log.info(`Found all ${originalToFind} txs directly from nodes`);
+      return;
+    }
+    const toFindFromP2P = txsToFind.size;
+    this.log.verbose(`Gathering ${toFindFromP2P} txs from p2p network`);
+    const foundFromP2P = await pool.getTxsByHash([...txsToFind].map(tx => TxHash.fromString(tx)));
+    const numFoundFromNodes = originalToFind - toFindFromP2P;
+    const numNotFound = toFindFromP2P - foundFromP2P.length;
+    if (numNotFound === 0) {
+      this.log.info(
+        `Found all ${originalToFind} txs. ${numFoundFromNodes} from nodes, ${foundFromP2P.length} from p2p`,
+      );
+      return;
+    }
+    this.log.warn(
+      `Failed to find ${numNotFound} txs from any source. Found ${foundFromP2P.length} from p2p and ${numFoundFromNodes} from nodes`,
+    );
+  }
+
+  async #gatherTxsFromAllNodes(txsToFind: Set<string>, pool: CoordinationPool) {
+    if (txsToFind.size === 0 || this.aztecNodes.length === 0) {
+      return;
+    }
+    await Promise.all(this.aztecNodes.map(aztecNode => this.#gatherTxsFromNode(txsToFind, aztecNode, pool)));
+  }
+
+  async #gatherTxsFromNode(txsToFind: Set<string>, aztecNode: TxSource, pool: CoordinationPool) {
+    const totalTxsRequired = txsToFind.size;
+
+    // It's possible that the set is empty as we already found the txs
+    if (totalTxsRequired === 0) {
+      return;
+    }
+    let totalTxsGathered = 0;
+
+    const batches: string[][] = [];
+    const allTxs: string[] = [...txsToFind];
+    while (allTxs.length) {
+      const batch = allTxs.splice(0, this.options.txGatheringBatchSize);
+      batches.push(batch);
+    }
+
+    await asyncPool(this.options.txGatheringMaxParallelRequestsPerNode, batches, async batch => {
+      try {
+        const txs = (await aztecNode.getTxsByHash(batch.map(b => TxHash.fromString(b)))).filter((tx): tx is Tx => !!tx);
+        const hashes = await Promise.all(txs.map(tx => tx.getTxHash()));
+        await pool.addTxs(txs);
+        hashes.forEach(hash => txsToFind.delete(hash.toString()));
+        totalTxsGathered += txs.length;
+      } catch (err) {
+        this.log.error(`Error gathering txs from aztec node: ${err}`);
+        return;
+      }
+    });
+    this.log.verbose(`Gathered ${totalTxsGathered} of ${totalTxsRequired} txs from a node`);
+  }
+}

package/src/prover-coordination/config.ts

@@ -1,14 +1,15 @@
 import { type ConfigMappingsType, getConfigFromMappings } from '@aztec/foundation/config';
 
 export type ProverCoordinationConfig = {
-  proverCoordinationNodeUrl: string | undefined;
+  proverCoordinationNodeUrls: string[];
 };
 
 export const proverCoordinationConfigMappings: ConfigMappingsType<ProverCoordinationConfig> = {
-  proverCoordinationNodeUrl: {
-    env: 'PROVER_COORDINATION_NODE_URL',
-    description: 'The URL of the tx provider node',
-    parseEnv: (val: string) => val,
+  proverCoordinationNodeUrls: {
+    env: 'PROVER_COORDINATION_NODE_URLS',
+    description: 'The URLs of the tx provider nodes',
+    parseEnv: (val: string) => val.split(',').map(url => url.trim().replace(/\/$/, '')),
+    defaultValue: [],
   },
 };
 

package/src/prover-coordination/factory.ts

@@ -6,21 +6,26 @@ 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 AztecNode, 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';
+import {
+  type CombinedCoordinationOptions,
+  CombinedProverCoordination,
+  type TxSource,
+} from './combined-prover-coordination.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;
+  aztecNodeTxProvider?: TxSource;
+  worldStateSynchronizer: WorldStateSynchronizer;
+  archiver: Archiver | ArchiveSource;
   telemetry?: TelemetryClient;
-  epochCache?: EpochCache;
+  epochCache: EpochCache;
 };
 
 /**
@@ -35,9 +40,14 @@ export async function createProverCoordination(
 ): Promise<ProverCoordination> {
   const log = createLogger('prover-node:prover-coordination');
 
+  const coordinationConfig: CombinedCoordinationOptions = {
+    txGatheringBatchSize: config.txGatheringBatchSize ?? 10,
+    txGatheringMaxParallelRequestsPerNode: config.txGatheringMaxParallelRequestsPerNode ?? 10,
+  };
+
   if (deps.aztecNodeTxProvider) {
     log.info('Using prover coordination via aztec node');
-    return deps.aztecNodeTxProvider;
+    return new CombinedProverCoordination(undefined, [deps.aztecNodeTxProvider!], coordinationConfig);
   }
 
   if (config.p2pEnabled) {
@@ -46,27 +56,28 @@ export async function createProverCoordination(
     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');
+  let nodes: AztecNode[] = [];
+  if (config.proverCoordinationNodeUrls && config.proverCoordinationNodeUrls.length > 0) {
+    log.info('Using prover coordination via node urls');
     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.`);
+    nodes = config.proverCoordinationNodeUrls.map(url =>
+      createAztecNodeClient(url, versions, makeTracedFetch([1, 2, 3], false)),
+    );
   }
+
+  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 new CombinedProverCoordination(p2pClient, nodes, coordinationConfig);
 }

package/src/prover-node-publisher.ts

@@ -17,7 +17,7 @@ import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-clien
 
 import { type Hex, type TransactionReceipt, encodeFunctionData } from 'viem';
 
-import { ProverNodeMetrics } from './metrics.js';
+import { ProverNodePublisherMetrics } from './metrics.js';
 
 /**
  * Stats for a sent transaction.
@@ -27,8 +27,6 @@ export type L1SubmitEpochProofArgs = {
   epochSize: number;
   previousArchive: Fr;
   endArchive: Fr;
-  previousBlockHash: Fr;
-  endBlockHash: Fr;
   endTimestamp: Fr;
   outHash: Fr;
   proverId: Fr;
@@ -40,7 +38,7 @@ export class ProverNodePublisher {
   private interruptibleSleep = new InterruptibleSleep();
   private sleepTimeMs: number;
   private interrupted = false;
-  private metrics: ProverNodeMetrics;
+  private metrics: ProverNodePublisherMetrics;
 
   protected log = createLogger('prover-node:l1-tx-publisher');
 
@@ -60,12 +58,16 @@ export class ProverNodePublisher {
 
     const telemetry = deps.telemetry ?? getTelemetryClient();
 
-    this.metrics = new ProverNodeMetrics(telemetry, 'ProverNode');
+    this.metrics = new ProverNodePublisherMetrics(telemetry, 'ProverNode');
 
     this.rollupContract = deps.rollupContract;
     this.l1TxUtils = deps.l1TxUtils;
   }
 
+  public getRollupContract() {
+    return this.rollupContract;
+  }
+
   /**
    * 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.
@@ -158,30 +160,21 @@ export class ProverNodePublisher {
       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
+    // Check the archive for the immediate block before the epoch
     const blockLog = await this.rollupContract.getBlock(BigInt(fromBlock - 1));
     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
+    // Check the 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));
@@ -258,8 +251,6 @@ export class ProverNodePublisher {
       {
         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(),