@aztec/prover-node 0.0.1-commit.e3c1de76 → 0.0.1-commit.e57c76e

package/src/factory.ts

@@ -1,34 +1,36 @@
-import { type Archiver, createArchiver } from '@aztec/archiver';
-import { BBCircuitVerifier, QueuedIVCVerifier, TestCircuitVerifier } from '@aztec/bb-prover';
-import { createBlobClientWithFileStores } from '@aztec/blob-client/client';
-import { EpochCache } from '@aztec/epoch-cache';
+import type { Archiver } from '@aztec/archiver';
+import type { BlobClientInterface } from '@aztec/blob-client/client';
+import { Blob } from '@aztec/blob-lib';
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
 import { createEthereumChain } from '@aztec/ethereum/chain';
+import { makeL1HttpTransport } from '@aztec/ethereum/client';
 import { RollupContract } from '@aztec/ethereum/contracts';
 import { L1TxUtils } from '@aztec/ethereum/l1-tx-utils';
 import { PublisherManager } from '@aztec/ethereum/publisher-manager';
 import { pick } from '@aztec/foundation/collection';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { DateProvider } from '@aztec/foundation/timer';
-import type { DataStoreConfig } from '@aztec/kv-store/config';
-import { type KeyStoreConfig, KeystoreManager, loadKeystores, mergeKeystores } from '@aztec/node-keystore';
-import { trySnapshotSync } from '@aztec/node-lib/actions';
-import {
-  createForwarderL1TxUtilsFromEthSigner,
-  createL1TxUtilsFromEthSignerWithStore,
-} from '@aztec/node-lib/factories';
-import { NodeRpcTxSource, createP2PClient } from '@aztec/p2p';
-import { type ProverClientConfig, createProverClient } from '@aztec/prover-client';
+import { KeystoreManager } from '@aztec/node-keystore';
+import { createForwarderL1TxUtilsFromSigners, createL1TxUtilsFromSigners } from '@aztec/node-lib/factories';
+import { type ProverClientConfig, type ProverClientUserConfig, createProverClient } from '@aztec/prover-client';
 import { createAndStartProvingBroker } from '@aztec/prover-client/broker';
-import type { AztecNode, ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
-import { P2PClientType } from '@aztec/stdlib/p2p';
-import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
-import { getPackageVersion } from '@aztec/stdlib/update-checker';
+import {
+  type ProverPublisherConfig,
+  type ProverTxSenderConfig,
+  getPublisherConfigFromProverConfig,
+} from '@aztec/sequencer-client';
+import type {
+  ITxProvider,
+  ProverConfig,
+  ProvingJobBroker,
+  Service,
+  WorldStateSynchronizer,
+} from '@aztec/stdlib/interfaces/server';
 import { L1Metrics, type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
-import { createWorldStateSynchronizer } from '@aztec/world-state';
 
-import { createPublicClient, fallback, http } from 'viem';
+import { createPublicClient } from 'viem';
 
-import { type ProverNodeConfig, createKeyStoreForProver } from './config.js';
+import type { SpecificProverNodeConfig } from './config.js';
 import { EpochMonitor } from './monitors/epoch-monitor.js';
 import { ProverNode } from './prover-node.js';
 import { ProverPublisherFactory } from './prover-publisher-factory.js';
@@ -36,54 +38,42 @@ import { ProverPublisherFactory } from './prover-publisher-factory.js';
 export type ProverNodeDeps = {
   telemetry?: TelemetryClient;
   log?: Logger;
-  aztecNodeTxProvider?: Pick<AztecNode, 'getTxsByHash'>;
-  archiver?: Archiver;
+  archiver: Archiver;
   publisherFactory?: ProverPublisherFactory;
   broker?: ProvingJobBroker;
   l1TxUtils?: L1TxUtils;
   dateProvider?: DateProvider;
+  worldStateSynchronizer: WorldStateSynchronizer;
+  p2pClient: { getTxProvider(): ITxProvider } & Partial<Service>;
+  epochCache: EpochCacheInterface;
+  blobClient: BlobClientInterface;
+  keyStoreManager?: KeystoreManager;
 };
 
-/** Creates a new prover node given a config. */
+/** Creates a new prover node subsystem given a config and dependencies */
 export async function createProverNode(
-  userConfig: ProverNodeConfig & DataStoreConfig & KeyStoreConfig,
-  deps: ProverNodeDeps = {},
-  options: {
-    prefilledPublicData?: PublicDataTreeLeaf[];
-  } = {},
+  userConfig: SpecificProverNodeConfig &
+    ProverConfig &
+    ProverClientUserConfig &
+    ProverPublisherConfig &
+    ProverTxSenderConfig,
+  deps: ProverNodeDeps,
 ) {
   const config = { ...userConfig };
   const telemetry = deps.telemetry ?? getTelemetryClient();
   const dateProvider = deps.dateProvider ?? new DateProvider();
-  const blobClient = await createBlobClientWithFileStores(config, createLogger('prover-node:blob-client:client'));
-  const log = deps.log ?? createLogger('prover-node');
-
-  // Build a key store from file if given or from environment otherwise
-  let keyStoreManager: KeystoreManager | undefined;
-  const keyStoreProvided = config.keyStoreDirectory !== undefined && config.keyStoreDirectory.length > 0;
-  if (keyStoreProvided) {
-    const keyStores = loadKeystores(config.keyStoreDirectory!);
-    keyStoreManager = new KeystoreManager(mergeKeystores(keyStores));
-  } else {
-    const keyStore = createKeyStoreForProver(config);
-    if (keyStore) {
-      keyStoreManager = new KeystoreManager(keyStore);
-    }
-  }
+  const log = deps.log ?? createLogger('prover');
 
-  await keyStoreManager?.validateSigners();
+  const { p2pClient, archiver, keyStoreManager, worldStateSynchronizer } = deps;
 
   // Extract the prover signers from the key store and verify that we have one.
+  await keyStoreManager?.validateSigners();
   const proverSigners = keyStoreManager?.createProverSigners();
 
   if (proverSigners === undefined) {
     throw new Error('Failed to create prover key store configuration');
   } else if (proverSigners.signers.length === 0) {
     throw new Error('No prover signers found in the key store');
-  } else if (!keyStoreProvided) {
-    log.warn(
-      'KEY STORE CREATED FROM ENVIRONMENT, IT IS RECOMMENDED TO USE A FILE-BASED KEY STORE IN PRODUCTION ENVIRONMENTS',
-    );
   }
 
   log.info(`Creating prover with publishers ${proverSigners.signers.map(signer => signer.address.toString()).join()}`);
@@ -95,27 +85,7 @@ export async function createProverNode(
   const proverId = proverSigners.id ?? proverIdInUserConfig ?? proverSigners.signers[0].address;
 
   // Now create the prover client configuration from this.
-  const proverClientConfig: ProverClientConfig = {
-    ...config,
-    proverId,
-  };
-
-  await trySnapshotSync(config, log);
-
-  const epochCache = await EpochCache.create(config.l1Contracts.rollupAddress, config);
-
-  const archiver =
-    deps.archiver ??
-    (await createArchiver(config, { blobClient, epochCache, telemetry, dateProvider }, { blockUntilSync: true }));
-  log.verbose(`Created archiver and synced to block ${await archiver.getBlockNumber()}`);
-
-  const worldStateSynchronizer = await createWorldStateSynchronizer(
-    config,
-    archiver,
-    options.prefilledPublicData,
-    telemetry,
-  );
-  await worldStateSynchronizer.start();
+  const proverClientConfig: ProverClientConfig = { ...config, proverId };
 
   const broker = deps.broker ?? (await createAndStartProvingBroker(config, telemetry));
 
@@ -126,63 +96,53 @@ export async function createProverNode(
 
   const publicClient = createPublicClient({
     chain: chain.chainInfo,
-    transport: fallback(config.l1RpcUrls.map((url: string) => http(url, { batch: false }))),
+    transport: makeL1HttpTransport(config.l1RpcUrls, { timeout: config.l1HttpTimeoutMS }),
     pollingInterval: config.viemPollingIntervalMS,
   });
 
-  const rollupContract = new RollupContract(publicClient, config.l1Contracts.rollupAddress.toString());
+  const rollupContract = new RollupContract(publicClient, config.rollupAddress.toString());
 
   const l1TxUtils = deps.l1TxUtils
     ? [deps.l1TxUtils]
-    : config.publisherForwarderAddress
-      ? await createForwarderL1TxUtilsFromEthSigner(
+    : config.proverPublisherForwarderAddress
+      ? await createForwarderL1TxUtilsFromSigners(
           publicClient,
           proverSigners.signers,
-          config.publisherForwarderAddress,
+          config.proverPublisherForwarderAddress,
           { ...config, scope: 'prover' },
-          { telemetry, logger: log.createChild('l1-tx-utils'), dateProvider },
+          { telemetry, logger: log.createChild('l1-tx-utils'), dateProvider, kzg: Blob.getViemKzgInstance() },
         )
-      : await createL1TxUtilsFromEthSignerWithStore(
+      : await createL1TxUtilsFromSigners(
           publicClient,
           proverSigners.signers,
           { ...config, scope: 'prover' },
           { telemetry, logger: log.createChild('l1-tx-utils'), dateProvider },
         );
 
+  // Create a funder L1TxUtils from the keystore funding account (if configured)
+  const fundingSigner = keyStoreManager?.createFundingSigner();
+  let funderL1TxUtils: L1TxUtils | undefined;
+  if (fundingSigner) {
+    const [funder] = await createL1TxUtilsFromSigners(
+      publicClient,
+      [fundingSigner],
+      { ...config, scope: 'prover' },
+      { telemetry, logger: log.createChild('l1-tx-utils:funder'), dateProvider },
+    );
+    funderL1TxUtils = funder;
+  }
+
   const publisherFactory =
     deps.publisherFactory ??
     new ProverPublisherFactory(config, {
       rollupContract,
-      publisherManager: new PublisherManager(l1TxUtils, config, log.getBindings()),
+      publisherManager: new PublisherManager(l1TxUtils, getPublisherConfigFromProverConfig(config), {
+        bindings: log.getBindings(),
+        funder: funderL1TxUtils,
+      }),
       telemetry,
     });
 
-  const proofVerifier = new QueuedIVCVerifier(
-    config,
-    config.realProofs || config.debugForceTxProofVerification
-      ? await BBCircuitVerifier.new(config)
-      : new TestCircuitVerifier(config.proverTestVerificationDelayMs),
-  );
-
-  const p2pClient = await createP2PClient(
-    P2PClientType.Prover,
-    config,
-    archiver,
-    proofVerifier,
-    worldStateSynchronizer,
-    epochCache,
-    getPackageVersion() ?? '',
-    dateProvider,
-    telemetry,
-    {
-      txCollectionNodeSources: deps.aztecNodeTxProvider
-        ? [new NodeRpcTxSource(deps.aztecNodeTxProvider, 'TestNode')]
-        : [],
-    },
-  );
-
-  await p2pClient.start();
-
   const proverNodeConfig = {
     ...pick(
       config,
@@ -213,6 +173,9 @@ export async function createProverNode(
     l1TxUtils.map(utils => utils.getSenderAddress()),
   );
 
+  // Extract the shared delayer from the first L1TxUtils instance (all instances share the same delayer)
+  const delayer = l1TxUtils[0]?.delayer;
+
   return new ProverNode(
     prover,
     publisherFactory,
@@ -226,5 +189,7 @@ export async function createProverNode(
     l1Metrics,
     proverNodeConfig,
     telemetry,
+    delayer,
+    dateProvider,
   );
 }

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

@@ -1,11 +1,10 @@
-import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
 import { asyncPool } from '@aztec/foundation/async-pool';
 import { BlockNumber, EpochNumber } from '@aztec/foundation/branded-types';
-import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { RunningPromise, promiseWithResolvers } from '@aztec/foundation/promise';
 import { Timer } from '@aztec/foundation/timer';
+import { AVM_MAX_CONCURRENT_SIMULATIONS } from '@aztec/native';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractsHash } from '@aztec/protocol-contracts';
 import { buildFinalBlobChallenges } from '@aztec/prover-client/helpers';
@@ -19,8 +18,8 @@ import {
   EpochProvingJobTerminalState,
   type ForkMerkleTreeOperations,
 } from '@aztec/stdlib/interfaces/server';
+import { appendL1ToL2MessagesToTree } from '@aztec/stdlib/messaging';
 import { CheckpointConstantData } from '@aztec/stdlib/rollup';
-import { MerkleTreeId } from '@aztec/stdlib/trees';
 import type { ProcessedTx, Tx } from '@aztec/stdlib/tx';
 import { Attributes, type Traceable, type Tracer, trackSpan } from '@aztec/telemetry-client';
 
@@ -47,6 +46,7 @@ export class EpochProvingJob implements Traceable {
   private uuid: string;
 
   private runPromise: Promise<void> | undefined;
+  private abortController = new AbortController();
   private epochCheckPromise: RunningPromise | undefined;
   private deadlineTimeoutHandler: NodeJS.Timeout | undefined;
 
@@ -57,7 +57,7 @@ export class EpochProvingJob implements Traceable {
     private dbProvider: Pick<ForkMerkleTreeOperations, 'fork'>,
     private prover: EpochProver,
     private publicProcessorFactory: PublicProcessorFactory,
-    private publisher: Pick<ProverNodePublisher, 'submitEpochProof'>,
+    private publisher: Pick<ProverNodePublisher, 'submitEpochProof' | 'analyzeEpochProofSubmission'>,
     private l2BlockSource: L2BlockSource | undefined,
     private metrics: ProverNodeJobMetrics,
     private deadline: Date | undefined,
@@ -148,19 +148,32 @@ export class EpochProvingJob implements Traceable {
     this.runPromise = promise;
 
     try {
+      const blobTimer = new Timer();
       const blobFieldsPerCheckpoint = this.checkpoints.map(checkpoint => checkpoint.toBlobFields());
       const finalBlobBatchingChallenges = await buildFinalBlobChallenges(blobFieldsPerCheckpoint);
+      this.metrics.recordBlobProcessing(blobTimer.ms());
 
       this.prover.startNewEpoch(epochNumber, epochSizeCheckpoints, finalBlobBatchingChallenges);
+      const chonkTimer = new Timer();
       await this.prover.startChonkVerifierCircuits(Array.from(this.txs.values()));
+      this.metrics.recordChonkVerifier(chonkTimer.ms());
 
       // Everything in the epoch should have the same chainId and version.
       const { chainId, version } = this.checkpoints[0].blocks[0].header.globalVariables;
 
       const previousBlockHeaders = this.gatherPreviousBlockHeaders();
 
-      await asyncPool(this.config.parallelBlockLimit ?? 32, this.checkpoints, async checkpoint => {
+      const allCheckpointsTimer = new Timer();
+
+      const parallelism = this.config.parallelBlockLimit
+        ? this.config.parallelBlockLimit
+        : AVM_MAX_CONCURRENT_SIMULATIONS > 0
+          ? AVM_MAX_CONCURRENT_SIMULATIONS
+          : this.checkpoints.length;
+
+      await this.processCheckpoints(parallelism, async checkpoint => {
         this.checkState();
+        const checkpointTimer = new Timer();
 
         const checkpointIndex = checkpoint.number - fromCheckpoint;
         const checkpointConstants = CheckpointConstantData.from({
@@ -177,11 +190,12 @@ export class EpochProvingJob implements Traceable {
         const previousHeader = previousBlockHeaders[checkpointIndex];
         const l1ToL2Messages = this.getL1ToL2Messages(checkpoint);
 
-        this.log.verbose(`Starting processing checkpoint ${checkpoint.number}`, {
+        this.log.debug(`Starting processing checkpoint ${checkpoint.number}`, {
           number: checkpoint.number,
           checkpointHash: checkpoint.hash().toString(),
-          lastArchive: checkpoint.header.lastArchiveRoot,
-          previousHeader: previousHeader.hash(),
+          headerHash: checkpoint.header.hash().toString(),
+          numL1ToL2Messages: l1ToL2Messages.length,
+          previousBlockNumber: previousHeader.globalVariables.blockNumber,
           uuid: this.uuid,
         });
 
@@ -193,7 +207,9 @@ export class EpochProvingJob implements Traceable {
           previousHeader,
         );
 
-        for (const block of checkpoint.blocks) {
+        for (let blockIndex = 0; blockIndex < checkpoint.blocks.length; blockIndex++) {
+          const blockTimer = new Timer();
+          const block = checkpoint.blocks[blockIndex];
           const globalVariables = block.header.globalVariables;
           const txs = this.getTxs(block);
 
@@ -211,20 +227,28 @@ export class EpochProvingJob implements Traceable {
           // Start block proving
           await this.prover.startNewBlock(block.number, globalVariables.timestamp, txs.length);
 
-          // Process public fns
-          const db = await this.createFork(BlockNumber(block.number - 1), l1ToL2Messages);
-          const config = PublicSimulatorConfig.from({
-            proverId: this.prover.getProverId().toField(),
-            skipFeeEnforcement: false,
-            collectDebugLogs: false,
-            collectHints: true,
-            collectPublicInputs: true,
-            collectStatistics: false,
-          });
-          const publicProcessor = this.publicProcessorFactory.create(db, globalVariables, config);
-          const processed = await this.processTxs(publicProcessor, txs);
-          await this.prover.addTxs(processed);
-          await db.close();
+          // Process public fns. L1 to L2 messages are only inserted for the first block of a checkpoint,
+          // as the fork for subsequent blocks already includes them from the previous block's synced state.
+          {
+            await using db = await this.createFork(
+              BlockNumber(block.number - 1),
+              blockIndex === 0 ? l1ToL2Messages : undefined,
+            );
+            this.checkState();
+            const config = PublicSimulatorConfig.from({
+              proverId: this.prover.getProverId().toField(),
+              skipFeeEnforcement: false,
+              collectDebugLogs: false,
+              collectHints: true,
+              collectPublicInputs: true,
+              collectStatistics: false,
+            });
+            const publicProcessor = this.publicProcessorFactory.create(db, globalVariables, config);
+            const processed = await this.processTxs(publicProcessor, txs);
+            this.checkState();
+            await this.prover.addTxs(processed);
+          }
+          this.checkState();
           this.log.verbose(`Processed all ${txs.length} txs for block ${block.number}`, {
             blockNumber: block.number,
             blockHash: (await block.hash()).toString(),
@@ -234,8 +258,11 @@ export class EpochProvingJob implements Traceable {
           // Mark block as completed to pad it
           const expectedBlockHeader = block.header;
           await this.prover.setBlockCompleted(block.number, expectedBlockHeader);
+          this.metrics.recordBlockProcessing(blockTimer.ms());
         }
+        this.metrics.recordCheckpointProcessing(checkpointTimer.ms());
       });
+      this.metrics.recordAllCheckpointsProcessing(allCheckpointsTimer.ms());
 
       const executionTime = timer.ms();
 
@@ -247,8 +274,21 @@ export class EpochProvingJob implements Traceable {
 
       if (this.config.skipSubmitProof) {
         this.log.info(
-          `Proof publishing is disabled. Dropping valid proof for epoch ${epochNumber} (checkpoints ${fromCheckpoint} to ${toCheckpoint})`,
+          `Proof publishing is disabled. Analyzing estimated L1 fees for epoch ${epochNumber} (checkpoints ${fromCheckpoint} to ${toCheckpoint})`,
         );
+        try {
+          await this.publisher.analyzeEpochProofSubmission({
+            fromCheckpoint,
+            toCheckpoint,
+            epochNumber,
+            publicInputs,
+            proof,
+            batchedBlobInputs,
+            attestations,
+          });
+        } catch (err) {
+          this.log.warn(`Failed to analyze estimated L1 fees for epoch ${epochNumber}`, err);
+        }
         this.state = 'completed';
         this.metrics.recordProvingJob(executionTime, timer.ms(), epochSizeCheckpoints, epochSizeBlocks, epochSizeTxs);
         return;
@@ -295,25 +335,63 @@ export class EpochProvingJob implements Traceable {
   }
 
   /**
-   * Create a new db fork for tx processing, inserting all L1 to L2.
+   * Create a new db fork for tx processing, optionally inserting L1 to L2 messages.
+   * L1 to L2 messages should only be inserted for the first block in a checkpoint,
+   * as subsequent blocks' synced state already includes them.
    * REFACTOR: The prover already spawns a db fork of its own for each block, so we may be able to do away with just one fork.
    */
-  private async createFork(blockNumber: BlockNumber, l1ToL2Messages: Fr[]) {
-    const db = await this.dbProvider.fork(blockNumber);
-    const l1ToL2MessagesPadded = padArrayEnd<Fr, number>(
-      l1ToL2Messages,
-      Fr.ZERO,
-      NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
-      'Too many L1 to L2 messages',
-    );
-    this.log.verbose(`Creating fork at ${blockNumber} with ${l1ToL2Messages.length} L1 to L2 messages`, {
-      blockNumber,
-      l1ToL2Messages: l1ToL2Messages.map(m => m.toString()),
-    });
-    await db.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
+  private async createFork(blockNumber: BlockNumber, l1ToL2Messages: Fr[] | undefined) {
+    this.log.verbose(`Creating fork at ${blockNumber}`, { blockNumber });
+    // temporary stack to control fork lifetime
+    await using cleanup = new AsyncDisposableStack();
+    const db = cleanup.use(await this.dbProvider.fork(blockNumber));
+
+    if (l1ToL2Messages !== undefined) {
+      this.log.verbose(`Inserting ${l1ToL2Messages.length} L1 to L2 messages in fork`, {
+        blockNumber,
+        l1ToL2Messages: l1ToL2Messages.map(m => m.toString()),
+      });
+      await appendL1ToL2MessagesToTree(db, l1ToL2Messages);
+    }
+
+    // everything run succesfully so we can release this stack and give control of the fork's lifetime to the caller
+    cleanup.move();
     return db;
   }
 
+  private async processCheckpoints(
+    parallelism: number,
+    processCheckpoint: (checkpoint: Checkpoint) => Promise<void>,
+  ): Promise<void> {
+    let hasError = false;
+    let firstError: unknown;
+
+    await asyncPool(Math.max(parallelism, 1), this.checkpoints, async checkpoint => {
+      if (hasError || this.abortController.signal.aborted) {
+        return;
+      }
+
+      try {
+        this.checkState();
+        await processCheckpoint(checkpoint);
+      } catch (err) {
+        if (!hasError) {
+          hasError = true;
+          firstError = err;
+          this.failProcessing();
+        }
+      }
+    });
+
+    if (hasError) {
+      throw firstError;
+    }
+
+    if (this.abortController.signal.aborted) {
+      this.checkState();
+    }
+  }
+
   private progressState(state: EpochProvingJobState) {
     this.checkState();
     this.state = state;
@@ -327,12 +405,24 @@ export class EpochProvingJob implements Traceable {
 
   public async stop(state: EpochProvingJobTerminalState = 'stopped') {
     this.state = state;
-    this.prover.cancel();
+    this.interruptProcessing();
     if (this.runPromise) {
       await this.runPromise;
     }
   }
 
+  private failProcessing() {
+    if (!EpochProvingJobTerminalState.includes(this.state)) {
+      this.state = 'failed';
+    }
+    this.interruptProcessing();
+  }
+
+  private interruptProcessing() {
+    this.abortController.abort();
+    this.prover.cancel();
+  }
+
   private scheduleDeadlineStop() {
     const deadline = this.deadline;
     if (deadline) {
@@ -367,7 +457,9 @@ export class EpochProvingJob implements Traceable {
     const intervalMs = Math.ceil((await l2BlockSource.getL1Constants()).ethereumSlotDuration / 2) * 1000;
     this.epochCheckPromise = new RunningPromise(
       async () => {
-        const blockHeaders = await l2BlockSource.getCheckpointedBlockHeadersForEpoch(this.epochNumber);
+        const blockHeaders = (
+          await l2BlockSource.getBlocksData({ epoch: this.epochNumber, onlyCheckpointed: true })
+        ).map(d => d.header);
         const blockHashes = await Promise.all(blockHeaders.map(header => header.hash()));
         const thisBlocks = this.checkpoints.flatMap(checkpoint => checkpoint.blocks);
         const thisBlockHashes = await Promise.all(thisBlocks.map(block => block.hash()));
@@ -406,7 +498,11 @@ export class EpochProvingJob implements Traceable {
 
   private async processTxs(publicProcessor: PublicProcessor, txs: Tx[]): Promise<ProcessedTx[]> {
     const { deadline } = this;
-    const [processedTxs, failedTxs] = await publicProcessor.process(txs, { deadline });
+    const [processedTxs, failedTxs] = await publicProcessor.process(txs, {
+      deadline,
+      signal: this.abortController.signal,
+    });
+    this.checkState();
 
     if (failedTxs.length) {
       const failedTxHashes = await Promise.all(failedTxs.map(({ tx }) => tx.getTxHash()));

package/src/metrics.ts

@@ -25,6 +25,12 @@ export class ProverNodeJobMetrics {
   provingJobBlocks: Gauge;
   provingJobTransactions: Gauge;
 
+  private blobProcessingDuration: Gauge;
+  private chonkVerifierDuration: Gauge;
+  private blockProcessingDuration: Histogram;
+  private checkpointProcessingDuration: Histogram;
+  private allCheckpointsProcessingDuration: Gauge;
+
   constructor(
     private meter: Meter,
     public readonly tracer: Tracer,
@@ -35,6 +41,14 @@ export class ProverNodeJobMetrics {
     this.provingJobCheckpoints = this.meter.createGauge(Metrics.PROVER_NODE_JOB_CHECKPOINTS);
     this.provingJobBlocks = this.meter.createGauge(Metrics.PROVER_NODE_JOB_BLOCKS);
     this.provingJobTransactions = this.meter.createGauge(Metrics.PROVER_NODE_JOB_TRANSACTIONS);
+
+    this.blobProcessingDuration = this.meter.createGauge(Metrics.PROVER_NODE_BLOB_PROCESSING_LAST_DURATION);
+    this.chonkVerifierDuration = this.meter.createGauge(Metrics.PROVER_NODE_CHONK_VERIFIER_LAST_DURATION);
+    this.blockProcessingDuration = this.meter.createHistogram(Metrics.PROVER_NODE_BLOCK_PROCESSING_DURATION);
+    this.checkpointProcessingDuration = this.meter.createHistogram(Metrics.PROVER_NODE_CHECKPOINT_PROCESSING_DURATION);
+    this.allCheckpointsProcessingDuration = this.meter.createGauge(
+      Metrics.PROVER_NODE_ALL_CHECKPOINTS_PROCESSING_LAST_DURATION,
+    );
   }
 
   public recordProvingJob(
@@ -50,6 +64,26 @@ export class ProverNodeJobMetrics {
     this.provingJobBlocks.record(Math.floor(numBlocks));
     this.provingJobTransactions.record(Math.floor(numTxs));
   }
+
+  public recordBlobProcessing(durationMs: number) {
+    this.blobProcessingDuration.record(Math.ceil(durationMs));
+  }
+
+  public recordChonkVerifier(durationMs: number) {
+    this.chonkVerifierDuration.record(Math.ceil(durationMs));
+  }
+
+  public recordBlockProcessing(durationMs: number) {
+    this.blockProcessingDuration.record(Math.ceil(durationMs));
+  }
+
+  public recordCheckpointProcessing(durationMs: number) {
+    this.checkpointProcessingDuration.record(Math.ceil(durationMs));
+  }
+
+  public recordAllCheckpointsProcessing(durationMs: number) {
+    this.allCheckpointsProcessingDuration.record(Math.ceil(durationMs));
+  }
 }
 
 export class ProverNodeRewardsMetrics {
@@ -106,6 +140,13 @@ export class ProverNodeRewardsMetrics {
   };
 }
 
+export type EstimatedSubmitProofStats = {
+  gasLimit: bigint;
+  baseFeePerGas: bigint;
+  maxPriorityFeePerGas: bigint;
+  estimatedTotalFee: bigint;
+};
+
 export class ProverNodePublisherMetrics {
   gasPrice: Histogram;
   txCount: UpDownCounter;
@@ -117,6 +158,10 @@ export class ProverNodePublisherMetrics {
   txBlobDataGasCost: Histogram;
   txTotalFee: Histogram;
 
+  private txGasEstimated: Histogram;
+  private gasPriceEstimated: Histogram;
+  private txTotalFeeEstimated: Histogram;
+
   private senderBalance: Gauge;
   private meter: Meter;
 
@@ -148,6 +193,12 @@ export class ProverNodePublisherMetrics {
 
     this.txTotalFee = this.meter.createHistogram(Metrics.L1_PUBLISHER_TX_TOTAL_FEE);
 
+    this.txGasEstimated = this.meter.createHistogram(Metrics.PROVER_NODE_ESTIMATED_SUBMISSION_GAS);
+
+    this.gasPriceEstimated = this.meter.createHistogram(Metrics.PROVER_NODE_ESTIMATED_SUBMISSION_GAS_PRICE);
+
+    this.txTotalFeeEstimated = this.meter.createHistogram(Metrics.PROVER_NODE_ESTIMATED_SUBMISSION_TOTAL_FEE);
+
     this.senderBalance = this.meter.createGauge(Metrics.L1_PUBLISHER_BALANCE);
   }
 
@@ -162,6 +213,26 @@ export class ProverNodePublisherMetrics {
     this.recordTx(durationMs, stats);
   }
 
+  public recordEstimatedSubmitProof(stats: EstimatedSubmitProofStats) {
+    const attributes = { [Attributes.L1_TX_TYPE]: 'submitProof' } as const;
+
+    this.txGasEstimated.record(Number(stats.gasLimit), attributes);
+
+    try {
+      this.gasPriceEstimated.record(
+        parseInt(formatEther(stats.baseFeePerGas + stats.maxPriorityFeePerGas, 'gwei'), 10),
+      );
+    } catch {
+      // ignore
+    }
+
+    try {
+      this.txTotalFeeEstimated.record(parseFloat(formatEther(stats.estimatedTotalFee)));
+    } catch {
+      // ignore
+    }
+  }
+
   public recordSenderBalance(wei: bigint, senderAddress: string) {
     const eth = parseFloat(formatEther(wei, 'wei'));
     this.senderBalance.record(eth, {