@aztec/prover-node 0.0.0-test.1 → 0.0.1-commit.b655e406

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

@@ -0,0 +1,61 @@
+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,
+    { skipEpochCheck: true },
+  );
+
+  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()}`);
+  return 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/bin/run-failed-epoch.ts

@@ -0,0 +1,77 @@
+/* eslint-disable no-console */
+import type { L1ContractAddresses } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { jsonParseWithSchema, jsonStringify } from '@aztec/foundation/json-rpc';
+import { createLogger } from '@aztec/foundation/log';
+import { downloadEpochProvingJob, getProverNodeConfigFromEnv, rerunEpochProvingJob } from '@aztec/prover-node';
+import { type UploadSnapshotMetadata, UploadSnapshotMetadataSchema } from '@aztec/stdlib/snapshots';
+
+import { existsSync, mkdirSync } from 'fs';
+import { readFile, writeFile } from 'fs/promises';
+import { basename, join } from 'path';
+
+const logger = createLogger('prover-node:run-failed-epoch');
+
+function printUsage() {
+  console.error('Usage: run-failed-epoch <proof-uri> [out-dir=./data]');
+}
+
+async function rerunFailedEpoch(provingJobUrl: string, baseLocalDir: string) {
+  const localDir = join(baseLocalDir, basename(provingJobUrl));
+  const jobPath = join(localDir, 'data.bin');
+  const dataDir = join(localDir, 'state');
+
+  const env = getProverNodeConfigFromEnv();
+  const config = {
+    ...getProverNodeConfigFromEnv(),
+    dataDirectory: dataDir,
+    dataStoreMapSizeKb: env.dataStoreMapSizeKb ?? 1024 * 1024,
+    proverId: env.proverId ?? EthAddress.random(),
+  };
+
+  let metadata: UploadSnapshotMetadata;
+  const metadataPath = join(localDir, 'metadata.json');
+  if (existsSync(metadataPath)) {
+    logger.info(`Using downloaded data`);
+    metadata = jsonParseWithSchema(await readFile(metadataPath, 'utf-8'), UploadSnapshotMetadataSchema);
+  } else {
+    logger.info(`Downloading epoch proving job data and state from ${provingJobUrl} to ${localDir}`);
+    metadata = await downloadEpochProvingJob(provingJobUrl!, logger, {
+      jobDataDownloadPath: jobPath,
+      dataDirectory: dataDir,
+    });
+    await writeFile(metadataPath, jsonStringify(metadata, true));
+    logger.info(`Download to ${localDir} complete`);
+  }
+
+  logger.info(`Rerunning proving job from ${jobPath} with state from ${dataDir}`, metadata);
+  const result = await rerunEpochProvingJob(jobPath, logger, {
+    ...config,
+    l1Contracts: { rollupAddress: metadata.rollupAddress } as L1ContractAddresses,
+    rollupVersion: metadata.rollupVersion,
+  });
+
+  console.error(`Epoch proving job complete with result ${result}`);
+}
+
+async function main() {
+  if (process.argv[2] === '--help') {
+    printUsage();
+    return;
+  }
+
+  const uri = process.argv[2];
+  const outDir = process.argv[3] || './data';
+  if (!uri) {
+    printUsage();
+    throw new Error('Missing URL to epoch proving job');
+  }
+
+  mkdirSync(outDir, { recursive: true });
+  await rerunFailedEpoch(uri, outDir);
+}
+
+main().catch(err => {
+  console.error(err);
+  process.exit(1);
+});

package/src/config.ts

@@ -1,5 +1,6 @@
 import { type ArchiverConfig, archiverConfigMappings } from '@aztec/archiver/config';
 import type { ACVMConfig, BBConfig } from '@aztec/bb-prover/config';
+import { type GenesisStateConfig, genesisStateConfigMappings } from '@aztec/ethereum';
 import {
   type ConfigMappingsType,
   booleanConfigHelper,
@@ -7,6 +8,8 @@ import {
   numberConfigHelper,
 } from '@aztec/foundation/config';
 import { type DataStoreConfig, dataConfigMappings } from '@aztec/kv-store/config';
+import { type KeyStore, type KeyStoreConfig, ethPrivateKeySchema, keyStoreConfigMappings } from '@aztec/node-keystore';
+import { type SharedNodeConfig, sharedNodeConfigMappings } from '@aztec/node-lib/config';
 import { type P2PConfig, p2pConfigMappings } from '@aztec/p2p/config';
 import {
   type ProverAgentConfig,
@@ -14,7 +17,7 @@ import {
   proverAgentConfigMappings,
   proverBrokerConfigMappings,
 } from '@aztec/prover-client/broker';
-import { type ProverClientConfig, bbConfigMappings, proverClientConfigMappings } from '@aztec/prover-client/config';
+import { type ProverClientUserConfig, bbConfigMappings, proverClientConfigMappings } from '@aztec/prover-client/config';
 import {
   type PublisherConfig,
   type TxSenderConfig,
@@ -23,28 +26,29 @@ import {
 } from '@aztec/sequencer-client/config';
 import { type WorldStateConfig, worldStateConfigMappings } from '@aztec/world-state/config';
 
-import { type ProverCoordinationConfig, proverCoordinationConfigMappings } from './prover-coordination/config.js';
-
 export type ProverNodeConfig = ArchiverConfig &
-  ProverClientConfig &
+  ProverClientUserConfig &
   P2PConfig &
   WorldStateConfig &
   PublisherConfig &
   TxSenderConfig &
   DataStoreConfig &
-  ProverCoordinationConfig &
-  SpecificProverNodeConfig & {
-    /** Whether to populate the genesis state with initial fee juice for the test accounts */
-    testAccounts: boolean;
-  };
+  KeyStoreConfig &
+  SharedNodeConfig &
+  SpecificProverNodeConfig &
+  GenesisStateConfig;
 
-type SpecificProverNodeConfig = {
+export type SpecificProverNodeConfig = {
   proverNodeMaxPendingJobs: number;
   proverNodePollingIntervalMs: number;
   proverNodeMaxParallelBlocksPerEpoch: number;
+  proverNodeFailedEpochStore: string | undefined;
+  proverNodeEpochProvingDelayMs: number | undefined;
+  proverNodeDisableProofPublish?: boolean;
   txGatheringTimeoutMs: number;
   txGatheringIntervalMs: number;
-  txGatheringMaxParallelRequests: number;
+  txGatheringBatchSize: number;
+  txGatheringMaxParallelRequestsPerNode: number;
 };
 
 const specificProverNodeConfigMappings: ConfigMappingsType<SpecificProverNodeConfig> = {
@@ -63,38 +67,54 @@ 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,
+  },
+  proverNodeEpochProvingDelayMs: {
+    description: 'Optional delay in milliseconds to wait before proving a new epoch',
+    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),
   },
+  txGatheringTimeoutMs: {
+    env: 'PROVER_NODE_TX_GATHERING_TIMEOUT_MS',
+    description: 'How long to wait for tx data to be available before giving up',
+    ...numberConfigHelper(120_000),
+  },
+  proverNodeDisableProofPublish: {
+    env: 'PROVER_NODE_DISABLE_PROOF_PUBLISH',
+    description: 'Whether the prover node skips publishing proofs to L1',
+    ...booleanConfigHelper(false),
+  },
 };
 
 export const proverNodeConfigMappings: ConfigMappingsType<ProverNodeConfig> = {
   ...dataConfigMappings,
+  ...keyStoreConfigMappings,
   ...archiverConfigMappings,
   ...proverClientConfigMappings,
   ...p2pConfigMappings,
   ...worldStateConfigMappings,
   ...getPublisherConfigMappings('PROVER'),
   ...getTxSenderConfigMappings('PROVER'),
-  ...proverCoordinationConfigMappings,
   ...specificProverNodeConfigMappings,
-  testAccounts: {
-    env: 'TEST_ACCOUNTS',
-    description: 'Whether to populate the genesis state with initial fee juice for the test accounts.',
-    ...booleanConfigHelper(false),
-  },
+  ...genesisStateConfigMappings,
+  ...sharedNodeConfigMappings,
 };
 
 export function getProverNodeConfigFromEnv(): ProverNodeConfig {
@@ -113,3 +133,67 @@ export function getProverNodeAgentConfigFromEnv(): ProverAgentConfig & BBConfig
     ...getConfigFromMappings(bbConfigMappings),
   };
 }
+
+function createKeyStoreFromWeb3Signer(config: ProverNodeConfig): KeyStore | undefined {
+  // If we don't have a valid prover Id then we can't build a valid key store with remote signers
+  if (config.proverId === undefined) {
+    return undefined;
+  }
+
+  // Also, we need at least one publisher address.
+  const publishers = config.publisherAddresses ?? [];
+
+  if (publishers.length === 0) {
+    return undefined;
+  }
+
+  const keyStore: KeyStore = {
+    schemaVersion: 1,
+    slasher: undefined,
+    prover: {
+      id: config.proverId,
+      publisher: publishers,
+    },
+    remoteSigner: config.web3SignerUrl,
+    validators: undefined,
+  };
+  return keyStore;
+}
+
+function createKeyStoreFromPublisherKeys(config: ProverNodeConfig): KeyStore | undefined {
+  // Extract the publisher keys from the provided config.
+  const publisherKeys = config.publisherPrivateKeys
+    ? config.publisherPrivateKeys.map(k => ethPrivateKeySchema.parse(k.getValue()))
+    : [];
+
+  // There must be at least 1.
+  if (publisherKeys.length === 0) {
+    return undefined;
+  }
+
+  // If we have a valid proverId then create a prover key store of the form { id, publisher: [publisherKeys] }
+  // Otherwise create one of the form ("0x12345678....." as EthAccount).
+
+  const keyStore: KeyStore = {
+    schemaVersion: 1,
+    slasher: undefined,
+    prover:
+      config.proverId === undefined
+        ? publisherKeys[0]
+        : {
+            id: config.proverId,
+            publisher: publisherKeys,
+          },
+    remoteSigner: undefined,
+    validators: undefined,
+  };
+  return keyStore;
+}
+
+export function createKeyStoreForProver(config: ProverNodeConfig): KeyStore | undefined {
+  if (config.web3SignerUrl !== undefined && config.web3SignerUrl.length > 0) {
+    return createKeyStoreFromWeb3Signer(config);
+  }
+
+  return createKeyStoreFromPublisherKeys(config);
+}

package/src/factory.ts

@@ -1,43 +1,108 @@
 import { type Archiver, createArchiver } from '@aztec/archiver';
+import { BBCircuitVerifier, QueuedIVCVerifier, TestCircuitVerifier } from '@aztec/bb-prover';
 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, PublisherManager, RollupContract, createEthereumChain } from '@aztec/ethereum';
+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 { createProverClient } from '@aztec/prover-client';
+import { type KeyStoreConfig, KeystoreManager, loadKeystores, mergeKeystores } from '@aztec/node-keystore';
+import { trySnapshotSync } from '@aztec/node-lib/actions';
+import { createL1TxUtilsFromEthSignerWithStore } from '@aztec/node-lib/factories';
+import { NodeRpcTxSource, createP2PClient } from '@aztec/p2p';
+import { type ProverClientConfig, createProverClient } from '@aztec/prover-client';
 import { createAndStartProvingBroker } from '@aztec/prover-client/broker';
-import type { ProverCoordination, ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
+import type { AztecNode, ProvingJobBroker } from '@aztec/stdlib/interfaces/server';
+import { P2PClientType } from '@aztec/stdlib/p2p';
 import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
-import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
+import { getPackageVersion } from '@aztec/stdlib/update-checker';
+import { L1Metrics, type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 import { createWorldStateSynchronizer } from '@aztec/world-state';
 
-import type { ProverNodeConfig } from './config.js';
+import { createPublicClient, fallback, http } from 'viem';
+
+import { type ProverNodeConfig, createKeyStoreForProver } from './config.js';
 import { EpochMonitor } from './monitors/epoch-monitor.js';
-import { createProverCoordination } from './prover-coordination/factory.js';
-import { ProverNodePublisher } from './prover-node-publisher.js';
-import { ProverNode, type ProverNodeOptions } from './prover-node.js';
+import { ProverNode } from './prover-node.js';
+import { ProverPublisherFactory } from './prover-publisher-factory.js';
+
+export type ProverNodeDeps = {
+  telemetry?: TelemetryClient;
+  log?: Logger;
+  aztecNodeTxProvider?: Pick<AztecNode, 'getTxsByHash'>;
+  archiver?: Archiver;
+  publisherFactory?: ProverPublisherFactory;
+  blobSinkClient?: BlobSinkClientInterface;
+  broker?: ProvingJobBroker;
+  l1TxUtils?: L1TxUtils;
+  dateProvider?: DateProvider;
+};
 
 /** Creates a new prover node given a config. */
 export async function createProverNode(
-  config: ProverNodeConfig & DataStoreConfig,
-  deps: {
-    telemetry?: TelemetryClient;
-    log?: Logger;
-    aztecNodeTxProvider?: ProverCoordination;
-    archiver?: Archiver;
-    publisher?: ProverNodePublisher;
-    blobSinkClient?: BlobSinkClientInterface;
-    broker?: ProvingJobBroker;
-    l1TxUtils?: L1TxUtils;
-  } = {},
+  userConfig: ProverNodeConfig & DataStoreConfig & KeyStoreConfig,
+  deps: ProverNodeDeps = {},
   options: {
     prefilledPublicData?: PublicDataTreeLeaf[];
   } = {},
 ) {
+  const config = { ...userConfig };
   const telemetry = deps.telemetry ?? getTelemetryClient();
-  const blobSinkClient = deps.blobSinkClient ?? createBlobSinkClient(config);
+  const dateProvider = deps.dateProvider ?? new DateProvider();
+  const blobSinkClient =
+    deps.blobSinkClient ?? createBlobSinkClient(config, { logger: createLogger('prover-node:blob-sink:client') });
   const log = deps.log ?? createLogger('prover-node');
-  const archiver = deps.archiver ?? (await createArchiver(config, blobSinkClient, { blockUntilSync: true }, telemetry));
+
+  // 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);
+    }
+  }
+
+  await keyStoreManager?.validateSigners();
+
+  // Extract the prover signers from the key store and verify that we have one.
+  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()}`);
+
+  // Only consider user provided config if it is valid
+  const proverIdInUserConfig = config.proverId === undefined || config.proverId.isZero() ? undefined : config.proverId;
+
+  // ProverId: Take from key store if provided, otherwise from user config if valid, otherwise address of first signer
+  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, { blobSinkClient, epochCache, telemetry, dateProvider }, { blockUntilSync: true }));
   log.verbose(`Created archiver and synced to block ${await archiver.getBlockNumber()}`);
 
   const worldStateConfig = { ...config, worldStateProvenBlocksOnly: false };
@@ -50,49 +115,102 @@ export async function createProverNode(
   await worldStateSynchronizer.start();
 
   const broker = deps.broker ?? (await createAndStartProvingBroker(config, telemetry));
-  const prover = await createProverClient(config, worldStateSynchronizer, broker, telemetry);
 
-  const { l1RpcUrls: rpcUrls, l1ChainId: chainId, publisherPrivateKey } = config;
+  const prover = await createProverClient(proverClientConfig, worldStateSynchronizer, broker, telemetry);
+
+  const { l1RpcUrls: rpcUrls, l1ChainId: chainId } = config;
   const chain = createEthereumChain(rpcUrls, chainId);
-  const { publicClient, walletClient } = createL1Clients(rpcUrls, publisherPrivateKey, chain.chainInfo);
+
+  const publicClient = createPublicClient({
+    chain: chain.chainInfo,
+    transport: fallback(config.l1RpcUrls.map((url: string) => http(url))),
+    pollingInterval: config.viemPollingIntervalMS,
+  });
 
   const rollupContract = new RollupContract(publicClient, config.l1Contracts.rollupAddress.toString());
 
-  const l1TxUtils = deps.l1TxUtils ?? new L1TxUtils(publicClient, walletClient, log, config);
-  const publisher = deps.publisher ?? new ProverNodePublisher(config, { telemetry, rollupContract, l1TxUtils });
+  const l1TxUtils = deps.l1TxUtils
+    ? [deps.l1TxUtils]
+    : await createL1TxUtilsFromEthSignerWithStore(
+        publicClient,
+        proverSigners.signers,
+        { ...config, scope: 'prover' },
+        { telemetry, logger: log.createChild('l1-tx-utils'), dateProvider },
+      );
 
-  const epochCache = await EpochCache.create(config.l1Contracts.rollupAddress, config);
+  const publisherFactory =
+    deps.publisherFactory ??
+    new ProverPublisherFactory(config, {
+      rollupContract,
+      publisherManager: new PublisherManager(l1TxUtils, config),
+      telemetry,
+    });
 
-  // If config.p2pEnabled is true, createProverCoordination will create a p2p client where txs are requested
-  // If config.p2pEnabled is false, createProverCoordination request information from the AztecNode
-  const proverCoordination = await createProverCoordination(config, {
-    aztecNodeTxProvider: deps.aztecNodeTxProvider,
-    worldStateSynchronizer,
+  const proofVerifier = new QueuedIVCVerifier(
+    config,
+    config.realProofs ? await BBCircuitVerifier.new(config) : new TestCircuitVerifier(),
+  );
+
+  const p2pClient = await createP2PClient(
+    P2PClientType.Prover,
+    config,
     archiver,
+    proofVerifier,
+    worldStateSynchronizer,
     epochCache,
+    getPackageVersion() ?? '',
+    dateProvider,
     telemetry,
-  });
+    {
+      txCollectionNodeSources: deps.aztecNodeTxProvider
+        ? [new NodeRpcTxSource(deps.aztecNodeTxProvider, 'TestNode')]
+        : [],
+    },
+  );
 
-  const proverNodeConfig: ProverNodeOptions = {
-    maxPendingJobs: config.proverNodeMaxPendingJobs,
-    pollingIntervalMs: config.proverNodePollingIntervalMs,
-    maxParallelBlocksPerEpoch: config.proverNodeMaxParallelBlocksPerEpoch,
-    txGatheringMaxParallelRequests: config.txGatheringMaxParallelRequests,
-    txGatheringIntervalMs: config.txGatheringIntervalMs,
-    txGatheringTimeoutMs: config.txGatheringTimeoutMs,
+  await p2pClient.start();
+
+  const proverNodeConfig = {
+    ...pick(
+      config,
+      'proverNodeMaxPendingJobs',
+      'proverNodeMaxParallelBlocksPerEpoch',
+      'proverNodePollingIntervalMs',
+      'proverNodeEpochProvingDelayMs',
+      'txGatheringMaxParallelRequests',
+      'txGatheringIntervalMs',
+      'txGatheringTimeoutMs',
+      'proverNodeFailedEpochStore',
+      'proverNodeDisableProofPublish',
+      'dataDirectory',
+      'l1ChainId',
+      'rollupVersion',
+    ),
   };
 
-  const epochMonitor = await EpochMonitor.create(archiver, proverNodeConfig, telemetry);
+  const epochMonitor = await EpochMonitor.create(
+    archiver,
+    { pollingIntervalMs: config.proverNodePollingIntervalMs, provingDelayMs: config.proverNodeEpochProvingDelayMs },
+    telemetry,
+  );
+
+  const l1Metrics = new L1Metrics(
+    telemetry.getMeter('ProverNodeL1Metrics'),
+    publicClient,
+    l1TxUtils.map(utils => utils.getSenderAddress()),
+  );
 
   return new ProverNode(
     prover,
-    publisher,
+    publisherFactory,
     archiver,
     archiver,
     archiver,
     worldStateSynchronizer,
-    proverCoordination,
+    p2pClient,
     epochMonitor,
+    rollupContract,
+    l1Metrics,
     proverNodeConfig,
     telemetry,
   );