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

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,104 @@ 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(config.proverTestVerificationDelayMs),
+  );
+
+  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,
   );

package/src/index.ts

@@ -1,5 +1,5 @@
+export * from './actions/index.js';
 export * from './config.js';
 export * from './factory.js';
-export * from './http.js';
 export * from './prover-node-publisher.js';
 export * from './prover-node.js';

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

@@ -0,0 +1,77 @@
+import { EpochNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { CommitteeAttestation, L2Block } from '@aztec/stdlib/block';
+import { BlockHeader, Tx } from '@aztec/stdlib/tx';
+
+/** All data from an epoch used in proving. */
+export type EpochProvingJobData = {
+  epochNumber: EpochNumber;
+  blocks: L2Block[];
+  txs: Map<string, Tx>;
+  l1ToL2Messages: Record<number, Fr[]>;
+  previousBlockHeader: BlockHeader;
+  attestations: CommitteeAttestation[];
+};
+
+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 = Array.from(data.txs.values()).map(tx => tx.toBuffer());
+  const l1ToL2Messages = Object.entries(data.l1ToL2Messages).map(([blockNumber, messages]) => [
+    Number(blockNumber),
+    messages.length,
+    ...messages,
+  ]);
+  const attestations = data.attestations.map(attestation => attestation.toBuffer());
+
+  return serializeToBuffer(
+    data.epochNumber,
+    data.previousBlockHeader,
+    blocks.length,
+    ...blocks,
+    txs.length,
+    ...txs,
+    l1ToL2Messages.length,
+    ...l1ToL2Messages,
+    attestations.length,
+    ...attestations,
+  );
+}
+
+export function deserializeEpochProvingJobData(buf: Buffer): EpochProvingJobData {
+  const reader = BufferReader.asReader(buf);
+  const epochNumber = EpochNumber(reader.readNumber());
+  const previousBlockHeader = reader.readObject(BlockHeader);
+  const blocks = reader.readVector(L2Block);
+  const txArray = 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;
+  }
+
+  const attestations = reader.readVector(CommitteeAttestation);
+
+  const txs = new Map<string, Tx>(txArray.map(tx => [tx.getTxHash().toString(), tx]));
+
+  return { epochNumber, previousBlockHeader, blocks, txs, l1ToL2Messages, attestations };
+}