@aztec/validator-client 0.0.0-test.1 → 0.0.1-commit.1142ef1

package/src/checkpoint_builder.ts

@@ -0,0 +1,267 @@
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import { merge, pick } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { createLogger } from '@aztec/foundation/log';
+import { bufferToHex } from '@aztec/foundation/string';
+import { DateProvider, Timer, elapsed } from '@aztec/foundation/timer';
+import { getDefaultAllowedSetupFunctions } from '@aztec/p2p/msg_validators';
+import { LightweightCheckpointBuilder } from '@aztec/prover-client/light';
+import {
+  GuardedMerkleTreeOperations,
+  PublicContractsDB,
+  PublicProcessor,
+  createPublicTxSimulatorForBlockBuilding,
+} from '@aztec/simulator/server';
+import { L2BlockNew } from '@aztec/stdlib/block';
+import { Checkpoint } from '@aztec/stdlib/checkpoint';
+import type { ContractDataSource } from '@aztec/stdlib/contract';
+import { Gas } from '@aztec/stdlib/gas';
+import {
+  type FullNodeBlockBuilderConfig,
+  FullNodeBlockBuilderConfigKeys,
+  type MerkleTreeWriteOperations,
+  type PublicProcessorLimits,
+} from '@aztec/stdlib/interfaces/server';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { type CheckpointGlobalVariables, type FailedTx, GlobalVariables, StateReference, Tx } from '@aztec/stdlib/tx';
+import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
+
+import { createValidatorForBlockBuilding } from './tx_validator/tx_validator_factory.js';
+
+const log = createLogger('checkpoint-builder');
+
+export interface BuildBlockInCheckpointResult {
+  block: L2BlockNew;
+  publicGas: Gas;
+  publicProcessorDuration: number;
+  numTxs: number;
+  failedTxs: FailedTx[];
+  blockBuildingTimer: Timer;
+  usedTxs: Tx[];
+}
+
+/**
+ * Builder for a single checkpoint. Handles building blocks within the checkpoint
+ * and completing it.
+ */
+export class CheckpointBuilder {
+  constructor(
+    private checkpointBuilder: LightweightCheckpointBuilder,
+    private fork: MerkleTreeWriteOperations,
+    private config: FullNodeBlockBuilderConfig,
+    private contractDataSource: ContractDataSource,
+    private dateProvider: DateProvider,
+    private telemetryClient: TelemetryClient,
+  ) {}
+
+  getConstantData(): CheckpointGlobalVariables {
+    return this.checkpointBuilder.constants;
+  }
+
+  /**
+   * Builds a single block within this checkpoint.
+   */
+  async buildBlock(
+    pendingTxs: Iterable<Tx> | AsyncIterable<Tx>,
+    blockNumber: BlockNumber,
+    timestamp: bigint,
+    opts: PublicProcessorLimits & { expectedEndState?: StateReference },
+  ): Promise<BuildBlockInCheckpointResult> {
+    const blockBuildingTimer = new Timer();
+    const slot = this.checkpointBuilder.constants.slotNumber;
+
+    log.verbose(`Building block ${blockNumber} for slot ${slot} within checkpoint`, { slot, blockNumber, ...opts });
+
+    const constants = this.checkpointBuilder.constants;
+    const globalVariables = GlobalVariables.from({
+      chainId: constants.chainId,
+      version: constants.version,
+      blockNumber,
+      slotNumber: constants.slotNumber,
+      timestamp,
+      coinbase: constants.coinbase,
+      feeRecipient: constants.feeRecipient,
+      gasFees: constants.gasFees,
+    });
+    const { processor, validator } = await this.makeBlockBuilderDeps(globalVariables, this.fork);
+
+    const [publicProcessorDuration, [processedTxs, failedTxs, usedTxs]] = await elapsed(() =>
+      processor.process(pendingTxs, opts, validator),
+    );
+
+    // Add block to checkpoint
+    const block = await this.checkpointBuilder.addBlock(globalVariables, processedTxs, {
+      expectedEndState: opts.expectedEndState,
+    });
+
+    // How much public gas was processed
+    const publicGas = processedTxs.reduce((acc, tx) => acc.add(tx.gasUsed.publicGas), Gas.empty());
+
+    const res = {
+      block,
+      publicGas,
+      publicProcessorDuration,
+      numTxs: processedTxs.length,
+      failedTxs,
+      blockBuildingTimer,
+      usedTxs,
+    };
+    log.debug('Built block within checkpoint', res.block.header);
+    return res;
+  }
+
+  /** Completes the checkpoint and returns it. */
+  async completeCheckpoint(): Promise<Checkpoint> {
+    const checkpoint = await this.checkpointBuilder.completeCheckpoint();
+
+    log.verbose(`Completed checkpoint ${checkpoint.number}`, {
+      checkpointNumber: checkpoint.number,
+      numBlocks: checkpoint.blocks.length,
+      archiveRoot: checkpoint.archive.root.toString(),
+    });
+
+    return checkpoint;
+  }
+
+  /** Gets the checkpoint currently in progress. */
+  getCheckpoint(): Promise<Checkpoint> {
+    return this.checkpointBuilder.clone().completeCheckpoint();
+  }
+
+  protected async makeBlockBuilderDeps(globalVariables: GlobalVariables, fork: MerkleTreeWriteOperations) {
+    const txPublicSetupAllowList = this.config.txPublicSetupAllowList ?? (await getDefaultAllowedSetupFunctions());
+    const contractsDB = new PublicContractsDB(this.contractDataSource);
+    const guardedFork = new GuardedMerkleTreeOperations(fork);
+
+    const publicTxSimulator = createPublicTxSimulatorForBlockBuilding(
+      guardedFork,
+      contractsDB,
+      globalVariables,
+      this.telemetryClient,
+    );
+
+    const processor = new PublicProcessor(
+      globalVariables,
+      guardedFork,
+      contractsDB,
+      publicTxSimulator,
+      this.dateProvider,
+      this.telemetryClient,
+      undefined,
+      this.config,
+    );
+
+    const validator = createValidatorForBlockBuilding(
+      fork,
+      this.contractDataSource,
+      globalVariables,
+      txPublicSetupAllowList,
+    );
+
+    return {
+      processor,
+      validator,
+    };
+  }
+}
+
+/**
+ * Factory for creating checkpoint builders.
+ */
+export class FullNodeCheckpointsBuilder {
+  constructor(
+    private config: FullNodeBlockBuilderConfig,
+    private contractDataSource: ContractDataSource,
+    private dateProvider: DateProvider,
+    private telemetryClient: TelemetryClient = getTelemetryClient(),
+  ) {}
+
+  public getConfig(): FullNodeBlockBuilderConfig {
+    return this.config;
+  }
+
+  public updateConfig(config: Partial<FullNodeBlockBuilderConfig>) {
+    this.config = merge(this.config, pick(config, ...FullNodeBlockBuilderConfigKeys));
+  }
+
+  /**
+   * Starts a new checkpoint and returns a CheckpointBuilder to build blocks within it.
+   */
+  async startCheckpoint(
+    checkpointNumber: CheckpointNumber,
+    constants: CheckpointGlobalVariables,
+    l1ToL2Messages: Fr[],
+    fork: MerkleTreeWriteOperations,
+  ): Promise<CheckpointBuilder> {
+    const stateReference = await fork.getStateReference();
+    const archiveTree = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
+
+    log.verbose(`Building new checkpoint ${checkpointNumber}`, {
+      checkpointNumber,
+      msgCount: l1ToL2Messages.length,
+      initialStateReference: stateReference.toInspect(),
+      initialArchiveRoot: bufferToHex(archiveTree.root),
+      constants,
+    });
+
+    const lightweightBuilder = await LightweightCheckpointBuilder.startNewCheckpoint(
+      checkpointNumber,
+      constants,
+      l1ToL2Messages,
+      fork,
+    );
+
+    return new CheckpointBuilder(
+      lightweightBuilder,
+      fork,
+      this.config,
+      this.contractDataSource,
+      this.dateProvider,
+      this.telemetryClient,
+    );
+  }
+
+  /**
+   * Opens a checkpoint, either starting fresh or resuming from existing blocks.
+   */
+  async openCheckpoint(
+    checkpointNumber: CheckpointNumber,
+    constants: CheckpointGlobalVariables,
+    l1ToL2Messages: Fr[],
+    fork: MerkleTreeWriteOperations,
+    existingBlocks: L2BlockNew[] = [],
+  ): Promise<CheckpointBuilder> {
+    const stateReference = await fork.getStateReference();
+    const archiveTree = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
+
+    if (existingBlocks.length === 0) {
+      return this.startCheckpoint(checkpointNumber, constants, l1ToL2Messages, fork);
+    }
+
+    log.verbose(`Resuming checkpoint ${checkpointNumber} with ${existingBlocks.length} existing blocks`, {
+      checkpointNumber,
+      msgCount: l1ToL2Messages.length,
+      existingBlockCount: existingBlocks.length,
+      initialStateReference: stateReference.toInspect(),
+      initialArchiveRoot: bufferToHex(archiveTree.root),
+      constants,
+    });
+
+    const lightweightBuilder = await LightweightCheckpointBuilder.resumeCheckpoint(
+      checkpointNumber,
+      constants,
+      l1ToL2Messages,
+      fork,
+      existingBlocks,
+    );
+
+    return new CheckpointBuilder(
+      lightweightBuilder,
+      fork,
+      this.config,
+      this.contractDataSource,
+      this.dateProvider,
+      this.telemetryClient,
+    );
+  }
+}

package/src/config.ts

@@ -1,38 +1,47 @@
-import { NULL_KEY } from '@aztec/ethereum';
 import {
   type ConfigMappingsType,
   booleanConfigHelper,
   getConfigFromMappings,
   numberConfigHelper,
+  secretValueConfigHelper,
 } from '@aztec/foundation/config';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { ValidatorClientConfig } from '@aztec/stdlib/interfaces/server';
 
-/**
- * The Validator Configuration
- */
-export interface ValidatorClientConfig {
-  /** The private key of the validator participating in attestation duties */
-  validatorPrivateKey?: string;
-
-  /** Do not run the validator */
-  disableValidator: boolean;
-
-  /** Interval between polling for new attestations from peers */
-  attestationPollingIntervalMs: number;
-
-  /** Re-execute transactions before attesting */
-  validatorReexecute: boolean;
-}
+export type { ValidatorClientConfig };
 
 export const validatorClientConfigMappings: ConfigMappingsType<ValidatorClientConfig> = {
-  validatorPrivateKey: {
-    env: 'VALIDATOR_PRIVATE_KEY',
-    parseEnv: (val: string) => (val ? `0x${val.replace('0x', '')}` : NULL_KEY),
-    description: 'The private key of the validator participating in attestation duties',
+  validatorPrivateKeys: {
+    env: 'VALIDATOR_PRIVATE_KEYS',
+    description: 'List of private keys of the validators participating in attestation duties',
+    ...secretValueConfigHelper<`0x${string}`[]>(val =>
+      val ? val.split(',').map<`0x${string}`>(key => `0x${key.replace('0x', '')}`) : [],
+    ),
+    fallback: ['VALIDATOR_PRIVATE_KEY'],
+  },
+  validatorAddresses: {
+    env: 'VALIDATOR_ADDRESSES',
+    description: 'List of addresses of the validators to use with remote signers',
+    parseEnv: (val: string) =>
+      val
+        .split(',')
+        .filter(address => address && address.trim().length > 0)
+        .map(address => EthAddress.fromString(address.trim())),
+    defaultValue: [],
   },
   disableValidator: {
     env: 'VALIDATOR_DISABLED',
     description: 'Do not run the validator',
-    ...booleanConfigHelper(),
+    ...booleanConfigHelper(false),
+  },
+  disabledValidators: {
+    description: 'Temporarily disable these specific validator addresses',
+    parseEnv: (val: string) =>
+      val
+        .split(',')
+        .filter(address => address && address.trim().length > 0)
+        .map(address => EthAddress.fromString(address.trim())),
+    defaultValue: [],
   },
   attestationPollingIntervalMs: {
     env: 'VALIDATOR_ATTESTATIONS_POLLING_INTERVAL_MS',
@@ -44,6 +53,33 @@ export const validatorClientConfigMappings: ConfigMappingsType<ValidatorClientCo
     description: 'Re-execute transactions before attesting',
     ...booleanConfigHelper(true),
   },
+  validatorReexecuteDeadlineMs: {
+    env: 'VALIDATOR_REEXECUTE_DEADLINE_MS',
+    description: 'Will re-execute until this many milliseconds are left in the slot',
+    ...numberConfigHelper(6000),
+  },
+  alwaysReexecuteBlockProposals: {
+    env: 'ALWAYS_REEXECUTE_BLOCK_PROPOSALS',
+    description:
+      'Whether to always reexecute block proposals, even for non-validator nodes (useful for monitoring network status).',
+    ...booleanConfigHelper(false),
+  },
+  fishermanMode: {
+    env: 'FISHERMAN_MODE',
+    description:
+      'Whether to run in fisherman mode: validates all proposals and attestations but does not broadcast attestations or participate in consensus.',
+    ...booleanConfigHelper(false),
+  },
+  // TODO(palla/mbps): Change default to false once checkpoint validation is stable
+  skipCheckpointProposalValidation: {
+    description: 'Skip checkpoint proposal validation and always attest (default: true)',
+    defaultValue: true,
+  },
+  // TODO(palla/mbps): Change default to false once block sync is stable
+  skipPushProposedBlocksToArchiver: {
+    description: 'Skip pushing re-executed blocks to archiver (default: true)',
+    defaultValue: true,
+  },
 };
 
 /**

package/src/duties/validation_service.ts

@@ -1,45 +1,151 @@
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { keccak256 } from '@aztec/foundation/crypto';
-import type { Fr } from '@aztec/foundation/fields';
-import { BlockAttestation, BlockProposal, ConsensusPayload, SignatureDomainSeparator } from '@aztec/stdlib/p2p';
-import type { BlockHeader, TxHash } from '@aztec/stdlib/tx';
+import { keccak256 } from '@aztec/foundation/crypto/keccak';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { Signature } from '@aztec/foundation/eth-signature';
+import { createLogger } from '@aztec/foundation/log';
+import type { CommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
+import type { CreateCheckpointProposalLastBlockData } from '@aztec/stdlib/interfaces/server';
+import {
+  BlockProposal,
+  type BlockProposalOptions,
+  CheckpointAttestation,
+  CheckpointProposal,
+  type CheckpointProposalCore,
+  type CheckpointProposalOptions,
+  ConsensusPayload,
+  SignatureDomainSeparator,
+} from '@aztec/stdlib/p2p';
+import type { CheckpointHeader } from '@aztec/stdlib/rollup';
+import type { BlockHeader, Tx } from '@aztec/stdlib/tx';
 
 import type { ValidatorKeyStore } from '../key_store/interface.js';
 
 export class ValidationService {
-  constructor(private keyStore: ValidatorKeyStore) {}
+  constructor(
+    private keyStore: ValidatorKeyStore,
+    private log = createLogger('validator:validation-service'),
+  ) {}
 
   /**
    * Create a block proposal with the given header, archive, and transactions
    *
-   * @param header - The block header
+   * @param blockHeader - The block header
+   * @param indexWithinCheckpoint - Index of this block within the checkpoint (0-indexed)
+   * @param inHash - Hash of L1 to L2 messages for this checkpoint
    * @param archive - The archive of the current block
    * @param txs - TxHash[] ordered list of transactions
+   * @param options - Block proposal options (including broadcastInvalidBlockProposal for testing)
    *
-   * @returns A block proposal signing the above information (not the current implementation!!!)
+   * @returns A block proposal signing the above information
    */
-  createBlockProposal(header: BlockHeader, archive: Fr, txs: TxHash[]): Promise<BlockProposal> {
-    const payloadSigner = (payload: Buffer32) => this.keyStore.signMessage(payload);
+  public createBlockProposal(
+    blockHeader: BlockHeader,
+    indexWithinCheckpoint: number,
+    inHash: Fr,
+    archive: Fr,
+    txs: Tx[],
+    proposerAttesterAddress: EthAddress | undefined,
+    options: BlockProposalOptions,
+  ): Promise<BlockProposal> {
+    const payloadSigner = this.getPayloadSigner(proposerAttesterAddress);
 
-    return BlockProposal.createProposalFromSigner(new ConsensusPayload(header, archive, txs), payloadSigner);
+    // For testing: change the new archive to trigger state_mismatch validation failure
+    if (options.broadcastInvalidBlockProposal) {
+      archive = Fr.random();
+      this.log.warn(`Creating INVALID block proposal for slot ${blockHeader.globalVariables.slotNumber}`);
+    }
+
+    return BlockProposal.createProposalFromSigner(
+      blockHeader,
+      indexWithinCheckpoint,
+      inHash,
+      archive,
+      txs.map(tx => tx.getTxHash()),
+      options.publishFullTxs ? txs : undefined,
+      payloadSigner,
+    );
   }
 
   /**
-   * Attest to the given block proposal constructed by the current sequencer
+   * Create a checkpoint proposal with the last block header and checkpoint header
+   *
+   * @param checkpointHeader - The checkpoint header containing aggregated data
+   * @param archive - The archive of the checkpoint
+   * @param lastBlockInfo - Info about the last block (header, index, txs) or undefined
+   * @param proposerAttesterAddress - The address of the proposer
+   * @param options - Checkpoint proposal options
+   *
+   * @returns A checkpoint proposal signing the above information
+   */
+  public createCheckpointProposal(
+    checkpointHeader: CheckpointHeader,
+    archive: Fr,
+    lastBlockInfo: CreateCheckpointProposalLastBlockData | undefined,
+    proposerAttesterAddress: EthAddress | undefined,
+    options: CheckpointProposalOptions,
+  ): Promise<CheckpointProposal> {
+    const payloadSigner = this.getPayloadSigner(proposerAttesterAddress);
+
+    // For testing: change the archive to trigger state_mismatch validation failure
+    if (options.broadcastInvalidCheckpointProposal) {
+      archive = Fr.random();
+      this.log.warn(`Creating INVALID checkpoint proposal for slot ${checkpointHeader.slotNumber}`);
+    }
+
+    // Last block to include in the proposal
+    const lastBlock = lastBlockInfo && {
+      blockHeader: lastBlockInfo.blockHeader,
+      indexWithinCheckpoint: lastBlockInfo.indexWithinCheckpoint,
+      txHashes: lastBlockInfo.txs.map(tx => tx.getTxHash()),
+      txs: options.publishFullTxs ? lastBlockInfo.txs : undefined,
+    };
+
+    return CheckpointProposal.createProposalFromSigner(checkpointHeader, archive, lastBlock, payloadSigner);
+  }
+
+  private getPayloadSigner(proposerAttesterAddress: EthAddress | undefined): (payload: Buffer32) => Promise<Signature> {
+    if (proposerAttesterAddress !== undefined) {
+      return (payload: Buffer32) => this.keyStore.signMessageWithAddress(proposerAttesterAddress, payload);
+    } else {
+      // if there is no proposer attester address, just use the first signer
+      const signer = this.keyStore.getAddress(0);
+      return (payload: Buffer32) => this.keyStore.signMessageWithAddress(signer, payload);
+    }
+  }
+
+  /**
+   * Attest with selection of validators to the given checkpoint proposal
    *
    * NOTE: This is just a blind signing.
    *       We assume that the proposal is valid and DA guarantees have been checked previously.
    *
-   * @param proposal - The proposal to attest to
-   * @returns attestation
+   * @param proposal - The checkpoint proposal (core version without lastBlock) to attest to
+   * @param attestors - The validators to attest with
+   * @returns checkpoint attestations
    */
-  async attestToProposal(proposal: BlockProposal): Promise<BlockAttestation> {
-    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/7961): check that the current validator is correct
+  async attestToCheckpointProposal(
+    proposal: CheckpointProposalCore,
+    attestors: EthAddress[],
+  ): Promise<CheckpointAttestation[]> {
+    // Create the attestation payload from the checkpoint proposal
+    const payload = new ConsensusPayload(proposal.checkpointHeader, proposal.archive);
+    const buf = Buffer32.fromBuffer(
+      keccak256(payload.getPayloadToSign(SignatureDomainSeparator.checkpointAttestation)),
+    );
+    const signatures = await Promise.all(
+      attestors.map(attestor => this.keyStore.signMessageWithAddress(attestor, buf)),
+    );
+    return signatures.map(sig => new CheckpointAttestation(payload, sig, proposal.signature));
+  }
 
+  async signAttestationsAndSigners(
+    attestationsAndSigners: CommitteeAttestationsAndSigners,
+    proposer: EthAddress,
+  ): Promise<Signature> {
     const buf = Buffer32.fromBuffer(
-      keccak256(await proposal.payload.getPayloadToSign(SignatureDomainSeparator.blockAttestation)),
+      keccak256(attestationsAndSigners.getPayloadToSign(SignatureDomainSeparator.attestationsAndSigners)),
     );
-    const sig = await this.keyStore.signMessage(buf);
-    return new BlockAttestation(proposal.payload, sig);
+    return await this.keyStore.signMessageWithAddress(proposer, buf);
   }
 }

package/src/factory.ts

@@ -1,28 +1,81 @@
+import type { BlobClientInterface } from '@aztec/blob-client/client';
 import type { EpochCache } from '@aztec/epoch-cache';
 import type { DateProvider } from '@aztec/foundation/timer';
-import type { P2P } from '@aztec/p2p';
+import type { KeystoreManager } from '@aztec/node-keystore';
+import { BlockProposalValidator, type P2PClient } from '@aztec/p2p';
+import type { L2BlockSink, L2BlockSource } from '@aztec/stdlib/block';
+import type { ValidatorClientFullConfig, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 import type { TelemetryClient } from '@aztec/telemetry-client';
 
-import { generatePrivateKey } from 'viem/accounts';
-
-import type { ValidatorClientConfig } from './config.js';
+import { BlockProposalHandler } from './block_proposal_handler.js';
+import type { FullNodeCheckpointsBuilder } from './checkpoint_builder.js';
+import { ValidatorMetrics } from './metrics.js';
 import { ValidatorClient } from './validator.js';
 
+export function createBlockProposalHandler(
+  config: ValidatorClientFullConfig,
+  deps: {
+    checkpointsBuilder: FullNodeCheckpointsBuilder;
+    worldState: WorldStateSynchronizer;
+    blockSource: L2BlockSource & L2BlockSink;
+    l1ToL2MessageSource: L1ToL2MessageSource;
+    p2pClient: P2PClient;
+    epochCache: EpochCache;
+    dateProvider: DateProvider;
+    telemetry: TelemetryClient;
+  },
+) {
+  const metrics = new ValidatorMetrics(deps.telemetry);
+  const blockProposalValidator = new BlockProposalValidator(deps.epochCache, {
+    txsPermitted: !config.disableTransactions,
+  });
+  return new BlockProposalHandler(
+    deps.checkpointsBuilder,
+    deps.worldState,
+    deps.blockSource,
+    deps.l1ToL2MessageSource,
+    deps.p2pClient.getTxProvider(),
+    blockProposalValidator,
+    config,
+    metrics,
+    deps.dateProvider,
+    deps.telemetry,
+  );
+}
+
 export function createValidatorClient(
-  config: ValidatorClientConfig,
+  config: ValidatorClientFullConfig,
   deps: {
-    p2pClient: P2P;
+    checkpointsBuilder: FullNodeCheckpointsBuilder;
+    worldState: WorldStateSynchronizer;
+    p2pClient: P2PClient;
+    blockSource: L2BlockSource & L2BlockSink;
+    l1ToL2MessageSource: L1ToL2MessageSource;
     telemetry: TelemetryClient;
     dateProvider: DateProvider;
     epochCache: EpochCache;
+    keyStoreManager: KeystoreManager | undefined;
+    blobClient: BlobClientInterface;
   },
 ) {
-  if (config.disableValidator) {
+  if (config.disableValidator || !deps.keyStoreManager) {
     return undefined;
   }
-  if (config.validatorPrivateKey === undefined || config.validatorPrivateKey === '') {
-    config.validatorPrivateKey = generatePrivateKey();
-  }
 
-  return ValidatorClient.new(config, deps.epochCache, deps.p2pClient, deps.dateProvider, deps.telemetry);
+  const txProvider = deps.p2pClient.getTxProvider();
+  return ValidatorClient.new(
+    config,
+    deps.checkpointsBuilder,
+    deps.worldState,
+    deps.epochCache,
+    deps.p2pClient,
+    deps.blockSource,
+    deps.l1ToL2MessageSource,
+    txProvider,
+    deps.keyStoreManager,
+    deps.blobClient,
+    deps.dateProvider,
+    deps.telemetry,
+  );
 }

package/src/index.ts

@@ -1,3 +1,7 @@
+export * from './block_proposal_handler.js';
+export * from './checkpoint_builder.js';
 export * from './config.js';
-export * from './validator.js';
 export * from './factory.js';
+export * from './validator.js';
+export * from './key_store/index.js';
+export * from './tx_validator/index.js';

package/src/key_store/index.ts

@@ -1,2 +1,4 @@
 export * from './interface.js';
 export * from './local_key_store.js';
+export * from './node_keystore_adapter.js';
+export * from './web3signer_key_store.js';