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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/prover-node",
-  "version": "0.85.0",
+  "version": "0.86.0-nightly.20250425",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -14,8 +14,6 @@
     "build": "yarn clean && tsc -b",
     "build:dev": "tsc -b --watch",
     "clean": "rm -rf ./dest .tsbuildinfo",
-    "formatting": "run -T prettier --check ./src && run -T eslint ./src",
-    "formatting:fix": "run -T eslint --fix ./src && run -T prettier -w ./src",
     "bb": "node --no-warnings ./dest/bb/index.js",
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
   },
@@ -53,25 +51,25 @@
     ]
   },
   "dependencies": {
-    "@aztec/archiver": "0.85.0",
-    "@aztec/bb-prover": "0.85.0",
-    "@aztec/blob-sink": "0.85.0",
-    "@aztec/constants": "0.85.0",
-    "@aztec/epoch-cache": "0.85.0",
-    "@aztec/ethereum": "0.85.0",
-    "@aztec/foundation": "0.85.0",
-    "@aztec/kv-store": "0.85.0",
-    "@aztec/l1-artifacts": "0.85.0",
-    "@aztec/node-lib": "0.85.0",
-    "@aztec/noir-protocol-circuits-types": "0.85.0",
-    "@aztec/p2p": "0.85.0",
-    "@aztec/protocol-contracts": "0.85.0",
-    "@aztec/prover-client": "0.85.0",
-    "@aztec/sequencer-client": "0.85.0",
-    "@aztec/simulator": "0.85.0",
-    "@aztec/stdlib": "0.85.0",
-    "@aztec/telemetry-client": "0.85.0",
-    "@aztec/world-state": "0.85.0",
+    "@aztec/archiver": "0.86.0-nightly.20250425",
+    "@aztec/bb-prover": "0.86.0-nightly.20250425",
+    "@aztec/blob-sink": "0.86.0-nightly.20250425",
+    "@aztec/constants": "0.86.0-nightly.20250425",
+    "@aztec/epoch-cache": "0.86.0-nightly.20250425",
+    "@aztec/ethereum": "0.86.0-nightly.20250425",
+    "@aztec/foundation": "0.86.0-nightly.20250425",
+    "@aztec/kv-store": "0.86.0-nightly.20250425",
+    "@aztec/l1-artifacts": "0.86.0-nightly.20250425",
+    "@aztec/node-lib": "0.86.0-nightly.20250425",
+    "@aztec/noir-protocol-circuits-types": "0.86.0-nightly.20250425",
+    "@aztec/p2p": "0.86.0-nightly.20250425",
+    "@aztec/protocol-contracts": "0.86.0-nightly.20250425",
+    "@aztec/prover-client": "0.86.0-nightly.20250425",
+    "@aztec/sequencer-client": "0.86.0-nightly.20250425",
+    "@aztec/simulator": "0.86.0-nightly.20250425",
+    "@aztec/stdlib": "0.86.0-nightly.20250425",
+    "@aztec/telemetry-client": "0.86.0-nightly.20250425",
+    "@aztec/world-state": "0.86.0-nightly.20250425",
     "source-map-support": "^0.5.21",
     "tslib": "^2.4.0",
     "viem": "2.23.7"

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

@@ -0,0 +1,46 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { jsonParseWithSchemaSync } from '@aztec/foundation/json-rpc';
+import type { Logger } from '@aztec/foundation/log';
+import { snapshotSync } from '@aztec/node-lib/actions';
+import { createReadOnlyFileStore } from '@aztec/stdlib/file-store';
+import { UploadSnapshotMetadataSchema, makeSnapshotPaths } from '@aztec/stdlib/snapshots';
+
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+import { deserializeEpochProvingJobData } from '../job/epoch-proving-job-data.js';
+
+/**
+ * Given a location returned by `uploadEpochProofFailure`, downloads the world state and archiver snapshots
+ * and the proving job data, so we can re-run the job later using `rerunEpochProvingJob`. This is decoupled
+ * from actually proving so we can download once and run multiple times.
+ */
+export async function downloadEpochProvingJob(
+  location: string,
+  log: Logger,
+  config: {
+    dataDirectory: string;
+    rollupAddress: EthAddress;
+    jobDataDownloadPath: string;
+    rollupVersion: number;
+    l1ChainId: number;
+  },
+) {
+  log.info(`Downloading epoch proving job data from ${location}`);
+  const fileStore = await createReadOnlyFileStore(location);
+  const metadataUrl = join(location, 'metadata.json');
+  const metadataRaw = await fileStore.read(metadataUrl);
+  const metadata = jsonParseWithSchemaSync(metadataRaw.toString(), UploadSnapshotMetadataSchema);
+
+  const dataUrls = makeSnapshotPaths(location);
+  log.info(`Downloading state snapshot from ${location} to local data directory`, { metadata, dataUrls });
+  await snapshotSync({ dataUrls }, log, { ...config, snapshotsUrl: location });
+
+  const dataPath = join(location, 'data.bin');
+  const localPath = config.jobDataDownloadPath;
+  log.info(`Downloading epoch proving job data from ${dataPath} to ${localPath}`);
+  await fileStore.download(dataPath, localPath);
+
+  const jobData = deserializeEpochProvingJobData(readFileSync(localPath));
+  log.info(`Epoch proving job data for epoch ${jobData.epochNumber} downloaded successfully`);
+}

package/src/actions/index.ts

@@ -0,0 +1,2 @@
+export * from './download-epoch-proving-job.js';
+export * from './rerun-epoch-proving-job.js';

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

@@ -0,0 +1,59 @@
+import { createArchiverStore } from '@aztec/archiver';
+import type { Logger } from '@aztec/foundation/log';
+import type { DataStoreConfig } from '@aztec/kv-store/config';
+import { type ProverClientConfig, createProverClient } from '@aztec/prover-client';
+import { ProverBrokerConfig, createAndStartProvingBroker } from '@aztec/prover-client/broker';
+import { PublicProcessorFactory } from '@aztec/simulator/server';
+import { getTelemetryClient } from '@aztec/telemetry-client';
+import { createWorldState } from '@aztec/world-state';
+
+import { readFileSync } from 'fs';
+
+import { deserializeEpochProvingJobData } from '../job/epoch-proving-job-data.js';
+import { EpochProvingJob } from '../job/epoch-proving-job.js';
+import { ProverNodeJobMetrics } from '../metrics.js';
+
+/**
+ * Given a local folder where `downloadEpochProvingJob` was called, creates a new archiver and world state
+ * using the state snapshots, and creates a new epoch proving job to prove the downloaded proving job.
+ * Proving is done with a local proving broker and agents as specified by the config.
+ */
+export async function rerunEpochProvingJob(
+  localPath: string,
+  log: Logger,
+  config: DataStoreConfig & ProverBrokerConfig & ProverClientConfig,
+) {
+  const jobData = deserializeEpochProvingJobData(readFileSync(localPath));
+  log.info(`Loaded proving job data for epoch ${jobData.epochNumber}`);
+
+  const telemetry = getTelemetryClient();
+  const metrics = new ProverNodeJobMetrics(telemetry.getMeter('prover-job'), telemetry.getTracer('prover-job'));
+  const worldState = await createWorldState(config);
+  const archiver = await createArchiverStore(config);
+  const publicProcessorFactory = new PublicProcessorFactory(archiver);
+
+  const publisher = { submitEpochProof: () => Promise.resolve(true) };
+  const l2BlockSourceForReorgDetection = undefined;
+  const deadline = undefined;
+
+  // This starts a local proving broker that does not get exposed as a service. This should be good enough for
+  // smallish epochs to be proven if we run on a large machine, but as epochs grow larger, we may want to switch
+  // this out for a live proving broker with multiple agents that we can connect to.
+  const broker = await createAndStartProvingBroker(config, telemetry);
+  const prover = await createProverClient(config, worldState, broker, telemetry);
+
+  const provingJob = new EpochProvingJob(
+    jobData,
+    worldState,
+    prover.createEpochProver(),
+    publicProcessorFactory,
+    publisher,
+    l2BlockSourceForReorgDetection,
+    metrics,
+    deadline,
+  );
+
+  log.info(`Rerunning epoch proving job for epoch ${jobData.epochNumber}`);
+  await provingJob.run();
+  log.info(`Completed job for epoch ${jobData.epochNumber} with status ${provingJob.getState()}`);
+}

package/src/actions/upload-epoch-proof-failure.ts

@@ -0,0 +1,88 @@
+import { ARCHIVER_DB_VERSION, type Archiver } from '@aztec/archiver';
+import { tryRmDir } from '@aztec/foundation/fs';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+import type { Logger } from '@aztec/foundation/log';
+import { isoDate } from '@aztec/foundation/string';
+import type { DataStoreConfig } from '@aztec/kv-store/config';
+import { buildSnapshotMetadata, createBackups } from '@aztec/node-lib/actions';
+import type { ChainConfig } from '@aztec/stdlib/config';
+import { type FileStore, createFileStore } from '@aztec/stdlib/file-store';
+import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import { type UploadSnapshotMetadata, getBasePath, uploadSnapshotData } from '@aztec/stdlib/snapshots';
+import { WORLD_STATE_DB_VERSION } from '@aztec/world-state';
+
+import { mkdtemp } from 'fs/promises';
+import { tmpdir } from 'os';
+import { dirname, join } from 'path';
+
+import { type EpochProvingJobData, serializeEpochProvingJobData } from '../job/epoch-proving-job-data.js';
+
+type UploadEpochProofConfig = Pick<ChainConfig, 'l1ChainId' | 'rollupVersion'> & Pick<DataStoreConfig, 'dataDirectory'>;
+
+/** Whether uploaded data to the file store should be of public access. */
+const PUBLIC_UPLOADS = true;
+
+/**
+ * Uploads a snapshot of world state and archiver (requires pausing them) along with the proving job data,
+ * so we can download and re-run the job later under the same conditions.
+ * @param location The location to upload the data to (used to create the `FileStore`).
+ */
+export async function uploadEpochProofFailure(
+  location: string,
+  jobId: string,
+  jobData: EpochProvingJobData,
+  archiver: Archiver,
+  worldState: WorldStateSynchronizer,
+  config: UploadEpochProofConfig,
+  log: Logger,
+) {
+  const epochNumber = jobData.epochNumber;
+  log.warn(`Uploading epoch proof failure for ${epochNumber} to ${location}`, { epochNumber, jobId, location });
+
+  const backupDir = await mkdtemp(join(config.dataDirectory ?? tmpdir(), 'epoch-proof-data-'));
+  const store = await createFileStore(location);
+  if (!store) {
+    throw new Error(`Failed to create file store for epoch proof failure upload for location ${location}.`);
+  }
+
+  try {
+    const versions = { archiver: ARCHIVER_DB_VERSION, worldState: WORLD_STATE_DB_VERSION };
+    const uploadMetadata = await buildSnapshotMetadata(archiver, config);
+    const paths = await createBackups(backupDir, archiver, worldState, log);
+
+    const basePath = `${getBasePath(uploadMetadata)}/${epochNumber}-${isoDate()}-${jobId}`;
+    const pathFor = (key: string) => `${basePath}/${key}.db`;
+    const [metadata, dataUrl, metadataUrl] = await Promise.all([
+      uploadSnapshotData(paths, versions, uploadMetadata, store, { pathFor, private: !PUBLIC_UPLOADS }),
+      uploadJobData(jobData, store, basePath),
+      uploadSnapshotMetadata(uploadMetadata, store, basePath),
+    ] as const);
+
+    const baseUrl = dirname(metadataUrl);
+    log.warn(`Uploaded epoch ${epochNumber} proof failure data to ${baseUrl}`, {
+      epochNumber,
+      location,
+      basePath,
+      metadataUrl,
+      dataUrl,
+      metadata,
+      jobId,
+    });
+    return baseUrl;
+  } finally {
+    log.info(`Cleaning up backup dir ${backupDir}`);
+    await tryRmDir(backupDir, log);
+  }
+}
+
+async function uploadJobData(jobData: EpochProvingJobData, store: FileStore, basePath: string) {
+  const data = serializeEpochProvingJobData(jobData);
+  const path = `${basePath}/data.bin`;
+  return await store.save(path, data, { compress: true, public: PUBLIC_UPLOADS });
+}
+
+async function uploadSnapshotMetadata(metadata: UploadSnapshotMetadata, store: FileStore, basePath: string) {
+  const data = Buffer.from(jsonStringify(metadata), 'utf-8');
+  const path = `${basePath}/metadata.json`;
+  return await store.save(path, data, { compress: false, public: PUBLIC_UPLOADS });
+}

package/src/config.ts

@@ -40,13 +40,14 @@ export type ProverNodeConfig = ArchiverConfig &
   SpecificProverNodeConfig &
   GenesisStateConfig;
 
-type SpecificProverNodeConfig = {
+export type SpecificProverNodeConfig = {
   proverNodeMaxPendingJobs: number;
   proverNodePollingIntervalMs: number;
   proverNodeMaxParallelBlocksPerEpoch: number;
-  txGatheringTimeoutMs: number;
+  proverNodeFailedEpochStore: string | undefined;
   txGatheringIntervalMs: number;
-  txGatheringMaxParallelRequests: number;
+  txGatheringBatchSize: number;
+  txGatheringMaxParallelRequestsPerNode: number;
 };
 
 const specificProverNodeConfigMappings: ConfigMappingsType<SpecificProverNodeConfig> = {
@@ -65,19 +66,24 @@ const specificProverNodeConfigMappings: ConfigMappingsType<SpecificProverNodeCon
     description: 'The Maximum number of blocks to process in parallel while proving an epoch',
     ...numberConfigHelper(32),
   },
-  txGatheringTimeoutMs: {
-    env: 'PROVER_NODE_TX_GATHERING_TIMEOUT_MS',
-    description: 'The maximum amount of time to wait for tx data to be available',
-    ...numberConfigHelper(60_000),
+  proverNodeFailedEpochStore: {
+    env: 'PROVER_NODE_FAILED_EPOCH_STORE',
+    description: 'File store where to upload node state when an epoch fails to be proven',
+    defaultValue: undefined,
   },
   txGatheringIntervalMs: {
     env: 'PROVER_NODE_TX_GATHERING_INTERVAL_MS',
     description: 'How often to check that tx data is available',
     ...numberConfigHelper(1_000),
   },
-  txGatheringMaxParallelRequests: {
-    env: 'PROVER_NODE_TX_GATHERING_MAX_PARALLEL_REQUESTS',
-    description: 'How many txs to load up a time',
+  txGatheringBatchSize: {
+    env: 'PROVER_NODE_TX_GATHERING_BATCH_SIZE',
+    description: 'How many transactions to gather from a node in a single request',
+    ...numberConfigHelper(10),
+  },
+  txGatheringMaxParallelRequestsPerNode: {
+    env: 'PROVER_NODE_TX_GATHERING_MAX_PARALLEL_REQUESTS_PER_NODE',
+    description: 'How many tx requests to make in parallel to each node',
     ...numberConfigHelper(100),
   },
 };

package/src/factory.ts

@@ -1,22 +1,24 @@
 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 { L1TxUtils, RollupContract, createEthereumChain, createExtendedL1Client } from '@aztec/ethereum';
+import { pick } from '@aztec/foundation/collection';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { trySnapshotSync } from '@aztec/node-lib/actions';
 import { createProverClient } from '@aztec/prover-client';
 import { createAndStartProvingBroker } from '@aztec/prover-client/broker';
-import type { ProverCoordination, ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
+import type { 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, resolveConfig } from './config.js';
 import { EpochMonitor } from './monitors/epoch-monitor.js';
+import type { TxSource } from './prover-coordination/combined-prover-coordination.js';
 import { createProverCoordination } from './prover-coordination/factory.js';
 import { ProverNodePublisher } from './prover-node-publisher.js';
-import { ProverNode, type ProverNodeOptions } from './prover-node.js';
+import { ProverNode } from './prover-node.js';
 
 /** Creates a new prover node given a config. */
 export async function createProverNode(
@@ -24,7 +26,7 @@ export async function createProverNode(
   deps: {
     telemetry?: TelemetryClient;
     log?: Logger;
-    aztecNodeTxProvider?: ProverCoordination;
+    aztecNodeTxProvider?: TxSource;
     archiver?: Archiver;
     publisher?: ProverNodePublisher;
     blobSinkClient?: BlobSinkClientInterface;
@@ -37,7 +39,8 @@ export async function createProverNode(
 ) {
   const config = resolveConfig(userConfig);
   const telemetry = deps.telemetry ?? getTelemetryClient();
-  const blobSinkClient = deps.blobSinkClient ?? createBlobSinkClient(config);
+  const blobSinkClient =
+    deps.blobSinkClient ?? createBlobSinkClient(config, { logger: createLogger('prover-node:blob-sink:client') });
   const log = deps.log ?? createLogger('prover-node');
 
   await trySnapshotSync(config, log);
@@ -59,17 +62,17 @@ export async function createProverNode(
 
   const { l1RpcUrls: rpcUrls, l1ChainId: chainId, publisherPrivateKey } = config;
   const chain = createEthereumChain(rpcUrls, chainId);
-  const { publicClient, walletClient } = createL1Clients(rpcUrls, publisherPrivateKey, chain.chainInfo);
+  const l1Client = createExtendedL1Client(rpcUrls, publisherPrivateKey, chain.chainInfo);
 
-  const rollupContract = new RollupContract(publicClient, config.l1Contracts.rollupAddress.toString());
+  const rollupContract = new RollupContract(l1Client, config.l1Contracts.rollupAddress.toString());
 
-  const l1TxUtils = deps.l1TxUtils ?? new L1TxUtils(publicClient, walletClient, log, config);
+  const l1TxUtils = deps.l1TxUtils ?? new L1TxUtils(l1Client, 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
+  // If config.proverCoordinationNodeUrls is not empty, createProverCoordination will create set of aztec node clients from which txs are requested
   const proverCoordination = await createProverCoordination(config, {
     aztecNodeTxProvider: deps.aztecNodeTxProvider,
     worldStateSynchronizer,
@@ -78,16 +81,27 @@ export async function createProverNode(
     telemetry,
   });
 
-  const proverNodeConfig: ProverNodeOptions = {
-    maxPendingJobs: config.proverNodeMaxPendingJobs,
-    pollingIntervalMs: config.proverNodePollingIntervalMs,
-    maxParallelBlocksPerEpoch: config.proverNodeMaxParallelBlocksPerEpoch,
-    txGatheringMaxParallelRequests: config.txGatheringMaxParallelRequests,
-    txGatheringIntervalMs: config.txGatheringIntervalMs,
-    txGatheringTimeoutMs: config.txGatheringTimeoutMs,
+  const proverNodeConfig = {
+    ...pick(
+      config,
+      'proverNodeMaxPendingJobs',
+      'proverNodeMaxParallelBlocksPerEpoch',
+      'proverNodePollingIntervalMs',
+      'txGatheringMaxParallelRequests',
+      'txGatheringIntervalMs',
+      'txGatheringTimeoutMs',
+      'proverNodeFailedEpochStore',
+      'dataDirectory',
+      'l1ChainId',
+      'rollupVersion',
+    ),
   };
 
-  const epochMonitor = await EpochMonitor.create(archiver, proverNodeConfig, telemetry);
+  const epochMonitor = await EpochMonitor.create(
+    archiver,
+    { pollingIntervalMs: config.proverNodePollingIntervalMs },
+    telemetry,
+  );
 
   return new ProverNode(
     prover,

package/src/index.ts

@@ -1,3 +1,4 @@
+export * from './actions/index.js';
 export * from './config.js';
 export * from './factory.js';
 export * from './http.js';

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

@@ -0,0 +1,68 @@
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { L2Block } from '@aztec/stdlib/block';
+import { BlockHeader, Tx } from '@aztec/stdlib/tx';
+
+/** All data from an epoch used in proving. */
+export type EpochProvingJobData = {
+  epochNumber: bigint;
+  blocks: L2Block[];
+  txs: Tx[];
+  l1ToL2Messages: Record<number, Fr[]>;
+  previousBlockHeader: BlockHeader;
+};
+
+export function validateEpochProvingJobData(data: EpochProvingJobData) {
+  if (data.blocks.length > 0 && data.previousBlockHeader.getBlockNumber() + 1 !== data.blocks[0].number) {
+    throw new Error(
+      `Initial block number ${
+        data.blocks[0].number
+      } does not match previous block header ${data.previousBlockHeader.getBlockNumber()}`,
+    );
+  }
+
+  for (const blockNumber of data.blocks.map(block => block.number)) {
+    if (!(blockNumber in data.l1ToL2Messages)) {
+      throw new Error(`Missing L1 to L2 messages for block number ${blockNumber}`);
+    }
+  }
+}
+
+export function serializeEpochProvingJobData(data: EpochProvingJobData): Buffer {
+  const blocks = data.blocks.map(block => block.toBuffer());
+  const txs = data.txs.map(tx => tx.toBuffer());
+  const l1ToL2Messages = Object.entries(data.l1ToL2Messages).map(([blockNumber, messages]) => [
+    Number(blockNumber),
+    messages.length,
+    ...messages,
+  ]);
+
+  return serializeToBuffer(
+    Number(data.epochNumber),
+    data.previousBlockHeader,
+    blocks.length,
+    ...blocks,
+    txs.length,
+    ...txs,
+    l1ToL2Messages.length,
+    ...l1ToL2Messages,
+  );
+}
+
+export function deserializeEpochProvingJobData(buf: Buffer): EpochProvingJobData {
+  const reader = BufferReader.asReader(buf);
+  const epochNumber = BigInt(reader.readNumber());
+  const previousBlockHeader = reader.readObject(BlockHeader);
+  const blocks = reader.readVector(L2Block);
+  const txs = reader.readVector(Tx);
+
+  const l1ToL2MessageBlockCount = reader.readNumber();
+  const l1ToL2Messages: Record<number, Fr[]> = {};
+  for (let i = 0; i < l1ToL2MessageBlockCount; i++) {
+    const blockNumber = reader.readNumber();
+    const messages = reader.readVector(Fr);
+    l1ToL2Messages[blockNumber] = messages;
+  }
+
+  return { epochNumber, previousBlockHeader, blocks, txs, l1ToL2Messages };
+}

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

@@ -10,14 +10,14 @@ import {
   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 { ProverNodeJobMetrics } from '../metrics.js';
 import type { ProverNodePublisher } from '../prover-node-publisher.js';
+import { type EpochProvingJobData, validateEpochProvingJobData } from './epoch-proving-job-data.js';
 
 /**
  * Job that grabs a range of blocks from the unfinalised chain from L1, gets their txs given their hashes,
@@ -36,21 +36,19 @@ export class EpochProvingJob implements Traceable {
   public readonly tracer: Tracer;
 
   constructor(
-    private dbProvider: ForkMerkleTreeOperations,
-    private epochNumber: bigint,
-    private blocks: L2Block[],
-    private txs: Tx[],
+    private data: EpochProvingJobData,
+    private dbProvider: Pick<ForkMerkleTreeOperations, 'fork'>,
     private prover: EpochProver,
     private publicProcessorFactory: PublicProcessorFactory,
-    private publisher: ProverNodePublisher,
-    private l2BlockSource: L2BlockSource,
-    private l1ToL2MessageSource: L1ToL2MessageSource,
-    private metrics: ProverNodeMetrics,
+    private publisher: Pick<ProverNodePublisher, 'submitEpochProof'>,
+    private l2BlockSource: L2BlockSource | undefined,
+    private metrics: ProverNodeJobMetrics,
     private deadline: Date | undefined,
     private config: { parallelBlockLimit: number } = { parallelBlockLimit: 32 },
   ) {
+    validateEpochProvingJobData(data);
     this.uuid = crypto.randomUUID();
-    this.tracer = metrics.client.getTracer('EpochProvingJob');
+    this.tracer = metrics.tracer;
   }
 
   public getId(): string {
@@ -62,18 +60,34 @@ export class EpochProvingJob implements Traceable {
   }
 
   public getEpochNumber(): bigint {
-    return this.epochNumber;
+    return this.data.epochNumber;
   }
 
   public getDeadline(): Date | undefined {
     return this.deadline;
   }
 
+  public getProvingData(): EpochProvingJobData {
+    return this.data;
+  }
+
+  private get epochNumber() {
+    return this.data.epochNumber;
+  }
+
+  private get blocks() {
+    return this.data.blocks;
+  }
+
+  private get txs() {
+    return this.data.txs;
+  }
+
   /**
    * Proves the given epoch and submits the proof to L1.
    */
   @trackSpan('EpochProvingJob.run', function () {
-    return { [Attributes.EPOCH_NUMBER]: Number(this.epochNumber) };
+    return { [Attributes.EPOCH_NUMBER]: Number(this.data.epochNumber) };
   })
   public async run() {
     this.scheduleDeadlineStop();
@@ -105,8 +119,8 @@ export class EpochProvingJob implements Traceable {
 
         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))!;
+        const l1ToL2Messages = this.getL1ToL2Messages(block);
+        const previousHeader = this.getBlockHeader(block.number - 1)!;
 
         this.log.verbose(`Starting processing block ${block.number}`, {
           number: block.number,
@@ -221,10 +235,16 @@ export class EpochProvingJob implements Traceable {
    * If those change, stops the proving job with a `rerun` state, so the node re-enqueues it.
    */
   private async scheduleEpochCheck() {
-    const intervalMs = Math.ceil((await this.l2BlockSource.getL1Constants()).ethereumSlotDuration / 2) * 1000;
+    const l2BlockSource = this.l2BlockSource;
+    if (!l2BlockSource) {
+      this.log.warn(`No L2 block source available, skipping epoch check`);
+      return;
+    }
+
+    const intervalMs = Math.ceil((await l2BlockSource.getL1Constants()).ethereumSlotDuration / 2) * 1000;
     this.epochCheckPromise = new RunningPromise(
       async () => {
-        const blocks = await this.l2BlockSource.getBlockHeadersForEpoch(this.epochNumber);
+        const blocks = await l2BlockSource.getBlockHeadersForEpoch(this.epochNumber);
         const blockHashes = await Promise.all(blocks.map(block => block.hash()));
         const thisBlockHashes = await Promise.all(this.blocks.map(block => block.hash()));
         if (
@@ -246,12 +266,22 @@ export class EpochProvingJob implements Traceable {
     this.log.verbose(`Scheduled epoch check for epoch ${this.epochNumber} every ${intervalMs}ms`);
   }
 
-  /* 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();
+  /* Returns the header for the given block number based on the epoch proving job data. */
+  private getBlockHeader(blockNumber: number) {
+    const block = this.blocks.find(b => b.number === blockNumber);
+    if (block) {
+      return block.header;
     }
-    return this.l2BlockSource.getBlockHeader(blockNumber);
+
+    if (blockNumber === Number(this.data.previousBlockHeader.getBlockNumber())) {
+      return this.data.previousBlockHeader;
+    }
+
+    throw new Error(
+      `Block header not found for block number ${blockNumber} (got ${this.blocks
+        .map(b => b.number)
+        .join(', ')} and previous header ${this.data.previousBlockHeader.getBlockNumber()})`,
+    );
   }
 
   private async getTxs(block: L2Block): Promise<Tx[]> {
@@ -263,7 +293,7 @@ export class EpochProvingJob implements Traceable {
   }
 
   private getL1ToL2Messages(block: L2Block) {
-    return this.l1ToL2MessageSource.getL1ToL2Messages(BigInt(block.number));
+    return this.data.l1ToL2Messages[block.number];
   }
 
   private async processTxs(publicProcessor: PublicProcessor, txs: Tx[]): Promise<ProcessedTx[]> {