@aztec/prover-node 0.85.0 → 0.86.0

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.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(),

package/src/prover-node.ts

@@ -1,10 +1,11 @@
+import type { ViemPublicClient } from '@aztec/ethereum';
 import { compact } from '@aztec/foundation/collection';
 import { memoize } from '@aztec/foundation/decorators';
+import { EthAddress } from '@aztec/foundation/eth-address';
 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';
@@ -20,7 +21,6 @@ import {
   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,
@@ -33,7 +33,7 @@ import {
 } from '@aztec/telemetry-client';
 
 import { EpochProvingJob, type EpochProvingJobState } from './job/epoch-proving-job.js';
-import { ProverNodeMetrics } from './metrics.js';
+import { ProverNodeJobMetrics, ProverNodeRewardsMetrics } from './metrics.js';
 import type { EpochMonitor, EpochMonitorHandler } from './monitors/epoch-monitor.js';
 import type { ProverNodePublisher } from './prover-node-publisher.js';
 
@@ -41,9 +41,7 @@ export type ProverNodeOptions = {
   pollingIntervalMs: number;
   maxPendingJobs: number;
   maxParallelBlocksPerEpoch: number;
-  txGatheringTimeoutMs: number;
   txGatheringIntervalMs: number;
-  txGatheringMaxParallelRequests: number;
 };
 
 /**
@@ -58,7 +56,8 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
 
   private jobs: Map<string, EpochProvingJob> = new Map();
   private options: ProverNodeOptions;
-  private metrics: ProverNodeMetrics;
+  private jobMetrics: ProverNodeJobMetrics;
+  private rewardsMetrics: ProverNodeRewardsMetrics;
   private l1Metrics: L1Metrics;
 
   private txFetcher: RunningPromise;
@@ -73,27 +72,36 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
     protected readonly l1ToL2MessageSource: L1ToL2MessageSource,
     protected readonly contractDataSource: ContractDataSource,
     protected readonly worldState: WorldStateSynchronizer,
-    protected readonly coordination: ProverCoordination & Maybe<Service>,
+    protected readonly coordination: ProverCoordination,
     protected readonly epochsMonitor: EpochMonitor,
     options: Partial<ProverNodeOptions> = {},
     protected readonly telemetryClient: TelemetryClient = getTelemetryClient(),
   ) {
-    this.l1Metrics = new L1Metrics(telemetryClient.getMeter('ProverNodeL1Metrics'), publisher.l1TxUtils.publicClient, [
-      publisher.getSenderAddress(),
-    ]);
+    this.l1Metrics = new L1Metrics(
+      telemetryClient.getMeter('ProverNodeL1Metrics'),
+      publisher.l1TxUtils.client as unknown as ViemPublicClient,
+      [publisher.getSenderAddress()],
+    );
 
     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');
+    const meter = telemetryClient.getMeter('ProverNode');
     this.tracer = telemetryClient.getTracer('ProverNode');
+
+    this.jobMetrics = new ProverNodeJobMetrics(meter, telemetryClient.getTracer('EpochProvingJob'));
+
+    this.rewardsMetrics = new ProverNodeRewardsMetrics(
+      meter,
+      EthAddress.fromField(this.prover.getProverId()),
+      this.publisher.getRollupContract(),
+    );
+
     this.txFetcher = new RunningPromise(() => this.checkForTxs(), this.log, this.options.txGatheringIntervalMs);
   }
 
@@ -102,18 +110,15 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
   }
 
   public getP2P() {
-    const asP2PClient = this.coordination as P2P<P2PClientType.Prover>;
-    if (typeof asP2PClient.isP2PClient === 'function' && asP2PClient.isP2PClient()) {
-      return asP2PClient;
-    }
-    return undefined;
+    return this.coordination.getP2PClient();
   }
 
   /**
    * 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.
+   * @returns false if there is an error, true otherwise
    */
-  async handleEpochReadyToProve(epochNumber: bigint): Promise<void> {
+  async handleEpochReadyToProve(epochNumber: bigint): Promise<boolean> {
     try {
       this.log.debug(`Running jobs as ${epochNumber} is ready to prove`, {
         jobs: Array.from(this.jobs.values()).map(job => `${job.getEpochNumber()}:${job.getId()}`),
@@ -123,15 +128,17 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
         this.log.warn(`Not starting proof for ${epochNumber} since there are active jobs for the epoch`, {
           activeJobs: activeJobs.map(job => job.uuid),
         });
-        return;
+        return true;
       }
       await this.startProof(epochNumber);
+      return true;
     } 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);
       }
+      return false;
     }
   }
 
@@ -139,10 +146,11 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
    * Starts the prover node so it periodically checks for unproven epochs in the unfinalised chain from L1 and
    * starts proving jobs for them.
    */
-  start() {
+  async start() {
     this.txFetcher.start();
     this.epochsMonitor.start(this);
     this.l1Metrics.start();
+    await this.rewardsMetrics.start();
     this.log.info(`Started Prover Node with prover id ${this.prover.getProverId().toString()}`, this.options);
   }
 
@@ -160,13 +168,15 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
     await this.worldState.stop();
     await tryStop(this.coordination);
     this.l1Metrics.stop();
+    this.rewardsMetrics.stop();
     await this.telemetryClient.stop();
     this.log.info('Stopped ProverNode');
   }
 
   /** Returns world state status. */
-  public getWorldStateSyncStatus(): Promise<WorldStateSyncStatus> {
-    return this.worldState.status().then(s => s.syncSummary);
+  public async getWorldStateSyncStatus(): Promise<WorldStateSyncStatus> {
+    const { syncSummary } = await this.worldState.status();
+    return syncSummary;
   }
 
   /** Returns archiver status. */
@@ -279,7 +289,7 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
       }
       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
+      await this.coordination.gatherTxs(txHashes); // This stores the txs in the tx pool, no need to persist them here
       this.lastBlockNumber = blockNumber;
     }
   }
@@ -336,7 +346,7 @@ export class ProverNode implements EpochMonitorHandler, ProverNodeApi, Traceable
       this.publisher,
       this.l2BlockSource,
       this.l1ToL2MessageSource,
-      this.metrics,
+      this.jobMetrics,
       deadline,
       { parallelBlockLimit: this.options.maxParallelBlocksPerEpoch },
     );