@aztec-labs/prover-node 6.0.0-nightly.20260829

package/src/config.ts

@@ -0,0 +1,208 @@
+import type { ACVMConfig, BBConfig } from '@aztec-labs/bb-prover/config';
+import {
+  type ConfigMappingsType,
+  booleanConfigHelper,
+  getConfigFromMappings,
+  numberConfigHelper,
+  pickConfigMappings,
+} from '@aztec-labs/foundation/config';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { type KeyStoreConfig, keyStoreConfigMappings } from '@aztec-labs/node-keystore/config';
+import { ethPrivateKeySchema } from '@aztec-labs/node-keystore/schemas';
+import type { KeyStore } from '@aztec-labs/node-keystore/types';
+import { type SharedNodeConfig, sharedNodeConfigMappings } from '@aztec-labs/node-lib/config';
+import {
+  type ProverAgentConfig,
+  type ProverBrokerConfig,
+  proverAgentConfigMappings,
+  proverBrokerConfigMappings,
+} from '@aztec-labs/prover-client/broker/config';
+import {
+  type ProverClientUserConfig,
+  bbConfigMappings,
+  proverClientConfigMappings,
+} from '@aztec-labs/prover-client/config';
+import {
+  type ProverPublisherConfig,
+  type ProverTxSenderConfig,
+  proverPublisherConfigMappings,
+  proverTxSenderConfigMappings,
+} from '@aztec-labs/sequencer-client/config';
+import { type DataStoreConfig, dataConfigMappings } from '@aztec-labs/stdlib/kv-store';
+
+export type ProverNodeConfig = ProverClientUserConfig &
+  ProverPublisherConfig &
+  ProverTxSenderConfig &
+  DataStoreConfig &
+  KeyStoreConfig &
+  SpecificProverNodeConfig &
+  Pick<SharedNodeConfig, 'web3SignerUrl'>;
+
+export type SpecificProverNodeConfig = {
+  proverNodeMaxPendingJobs: number;
+  proverNodePollingIntervalMs: number;
+  proverNodeMaxParallelBlocksPerEpoch: number;
+  proverNodeFailedEpochStore: string | undefined;
+  proverNodeEpochProvingDelayMs: number | undefined;
+  proverNodeDisableProofPublish?: boolean;
+  txGatheringTimeoutMs: number;
+  txGatheringIntervalMs: number;
+  txGatheringBatchSize: number;
+  txGatheringMaxParallelRequestsPerNode: number;
+  proofSubmissionTargetAddress?: EthAddress;
+};
+
+export const specificProverNodeConfigMappings: ConfigMappingsType<SpecificProverNodeConfig> = {
+  proverNodeMaxPendingJobs: {
+    env: 'PROVER_NODE_MAX_PENDING_JOBS',
+    description: 'The maximum number of pending jobs for the prover node',
+    ...numberConfigHelper(10),
+  },
+  proverNodePollingIntervalMs: {
+    env: 'PROVER_NODE_POLLING_INTERVAL_MS',
+    description: 'The interval in milliseconds to poll for new jobs',
+    ...numberConfigHelper(1000),
+  },
+  proverNodeMaxParallelBlocksPerEpoch: {
+    env: 'PROVER_NODE_MAX_PARALLEL_BLOCKS_PER_EPOCH',
+    description: 'The Maximum number of blocks to process in parallel while proving an epoch',
+    ...numberConfigHelper(0),
+  },
+  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 for late-arriving events (e.g. reorgs) to settle before starting top-tree proving for an epoch',
+    defaultValue: undefined,
+  },
+  txGatheringIntervalMs: {
+    env: 'PROVER_NODE_TX_GATHERING_INTERVAL_MS',
+    description: 'How often to check that tx data is available',
+    ...numberConfigHelper(1_000),
+  },
+  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),
+  },
+  proofSubmissionTargetAddress: {
+    env: 'PROVER_NODE_PROOF_SUBMISSION_TARGET_ADDRESS',
+    description:
+      'Optional L1 address the submitEpochRootProof tx is sent to. Must expose the identical submitEpochRootProof ABI ' +
+      'and forward to the rollup. Defaults to the rollup address.',
+    parseEnv: (val: string) => EthAddress.fromString(val),
+    defaultValue: undefined,
+  },
+};
+
+export const proverNodeConfigMappings: ConfigMappingsType<ProverNodeConfig> = {
+  ...dataConfigMappings,
+  ...keyStoreConfigMappings,
+  ...proverClientConfigMappings,
+  ...proverPublisherConfigMappings,
+  ...proverTxSenderConfigMappings,
+  ...specificProverNodeConfigMappings,
+  ...pickConfigMappings(sharedNodeConfigMappings, ['web3SignerUrl']),
+};
+
+export function getProverNodeConfigFromEnv(): ProverNodeConfig {
+  return getConfigFromMappings(proverNodeConfigMappings);
+}
+
+export function getProverNodeBrokerConfigFromEnv(): ProverBrokerConfig {
+  return {
+    ...getConfigFromMappings(proverBrokerConfigMappings),
+  };
+}
+
+export function getProverNodeAgentConfigFromEnv(): ProverAgentConfig & BBConfig & ACVMConfig {
+  return {
+    ...getConfigFromMappings(proverAgentConfigMappings),
+    ...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.proverPublisherAddresses ?? [];
+
+  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.proverPublisherPrivateKeys
+    ? config.proverPublisherPrivateKeys.map((k: { getValue: () => string }) => 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) {
+    const keyStore = createKeyStoreFromWeb3Signer(config);
+    if (keyStore) {
+      return keyStore;
+    }
+  }
+
+  return createKeyStoreFromPublisherKeys(config);
+}

package/src/factory.ts

@@ -0,0 +1,191 @@
+import type { Archiver } from '@aztec-labs/archiver';
+import type { BlobClientInterface } from '@aztec-labs/blob-client/client';
+import { Blob } from '@aztec-labs/blob-lib';
+import type { EpochCacheInterface } from '@aztec-labs/epoch-cache';
+import { createEthereumChain } from '@aztec-labs/ethereum/chain';
+import { makeL1HttpTransport } from '@aztec-labs/ethereum/client';
+import { RollupContract } from '@aztec-labs/ethereum/contracts';
+import { L1TxUtils } from '@aztec-labs/ethereum/l1-tx-utils';
+import { PublisherManager } from '@aztec-labs/ethereum/publisher-manager';
+import { pick } from '@aztec-labs/foundation/collection';
+import { type Logger, createLogger } from '@aztec-labs/foundation/log';
+import { DateProvider } from '@aztec-labs/foundation/timer';
+import { KeystoreManager } from '@aztec-labs/node-keystore';
+import { createForwarderL1TxUtilsFromSigners, createL1TxUtilsFromSigners } from '@aztec-labs/node-lib/factories';
+import { type ProverClientConfig, type ProverClientUserConfig, createProverClient } from '@aztec-labs/prover-client';
+import { createAndStartProvingBroker } from '@aztec-labs/prover-client/broker';
+import {
+  type ProverPublisherConfig,
+  type ProverTxSenderConfig,
+  getPublisherConfigFromProverConfig,
+} from '@aztec-labs/sequencer-client';
+import type { AvmSimulator } from '@aztec-labs/simulator/server';
+import type {
+  ITxProvider,
+  ProverConfig,
+  ProvingJobBroker,
+  Service,
+  WorldStateSynchronizer,
+} from '@aztec-labs/stdlib/interfaces/server';
+import { L1Metrics, type TelemetryClient, getTelemetryClient } from '@aztec-labs/telemetry-client';
+import { createPublicClient } from 'viem';
+
+import type { SpecificProverNodeConfig } from './config.js';
+import { ProverNode } from './prover-node.js';
+import { ProverPublisherFactory } from './prover-publisher-factory.js';
+
+export type ProverNodeDeps = {
+  telemetry?: TelemetryClient;
+  log?: Logger;
+  archiver: Archiver;
+  publisherFactory?: ProverPublisherFactory;
+  broker?: ProvingJobBroker;
+  l1TxUtils?: L1TxUtils;
+  dateProvider?: DateProvider;
+  worldStateSynchronizer: WorldStateSynchronizer;
+  p2pClient: { getTxProvider(): ITxProvider } & Partial<Service>;
+  epochCache: EpochCacheInterface;
+  blobClient: BlobClientInterface;
+  keyStoreManager?: KeystoreManager;
+  /** AVM execution backend (simulator pool + CDB server) for public simulation. */
+  avmSimulator: AvmSimulator;
+};
+
+/** Creates a new prover node subsystem given a config and dependencies */
+export async function createProverNode(
+  userConfig: SpecificProverNodeConfig &
+    ProverConfig &
+    ProverClientUserConfig &
+    ProverPublisherConfig &
+    ProverTxSenderConfig,
+  deps: ProverNodeDeps,
+) {
+  const config = { ...userConfig };
+  const telemetry = deps.telemetry ?? getTelemetryClient();
+  const dateProvider = deps.dateProvider ?? new DateProvider();
+  const log = deps.log ?? createLogger('prover');
+
+  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');
+  }
+
+  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 };
+
+  const broker = deps.broker ?? (await createAndStartProvingBroker(config, telemetry));
+
+  const prover = await createProverClient(proverClientConfig, worldStateSynchronizer, broker, telemetry);
+
+  const { l1RpcUrls: rpcUrls, l1ChainId: chainId } = config;
+  const chain = createEthereumChain(rpcUrls, chainId);
+
+  const publicClient = createPublicClient({
+    chain: chain.chainInfo,
+    transport: makeL1HttpTransport(config.l1RpcUrls, { timeout: config.l1HttpTimeoutMS }),
+    pollingInterval: config.viemPollingIntervalMS,
+  });
+
+  const rollupContract = new RollupContract(publicClient, config.rollupAddress.toString());
+
+  const l1TxUtils = deps.l1TxUtils
+    ? [deps.l1TxUtils]
+    : config.proverPublisherForwarderAddress
+      ? await createForwarderL1TxUtilsFromSigners(
+          publicClient,
+          proverSigners.signers,
+          config.proverPublisherForwarderAddress,
+          { ...config, scope: 'prover' },
+          { telemetry, logger: log.createChild('l1-tx-utils'), dateProvider, kzg: Blob.getViemKzgInstance() },
+        )
+      : 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,
+      proofSubmissionTarget: config.proofSubmissionTargetAddress,
+      publisherManager: new PublisherManager(l1TxUtils, getPublisherConfigFromProverConfig(config), {
+        bindings: log.getBindings(),
+        funder: funderL1TxUtils,
+      }),
+      telemetry,
+    });
+
+  const proverNodeConfig = {
+    ...pick(
+      config,
+      'proverNodeMaxPendingJobs',
+      'proverNodeMaxParallelBlocksPerEpoch',
+      'proverNodePollingIntervalMs',
+      'proverNodeEpochProvingDelayMs',
+      'txGatheringMaxParallelRequests',
+      'txGatheringIntervalMs',
+      'txGatheringTimeoutMs',
+      'proverNodeFailedEpochStore',
+      'proverNodeDisableProofPublish',
+      'dataDirectory',
+      'l1ChainId',
+      'rollupVersion',
+    ),
+  };
+
+  const l1Metrics = new L1Metrics(
+    telemetry.getMeter('ProverNodeL1Metrics'),
+    publicClient,
+    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,
+    archiver,
+    archiver,
+    archiver,
+    worldStateSynchronizer,
+    p2pClient,
+    rollupContract,
+    l1Metrics,
+    deps.avmSimulator,
+    proverNodeConfig,
+    telemetry,
+    delayer,
+    dateProvider,
+  );
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from './actions/index.js';
+export * from './config.js';
+export * from './factory.js';
+export * from './monitors/index.js';
+export * from './proof-publishing-service.js';
+export * from './prover-node-publisher.js';
+export * from './prover-node.js';