@aztec/validator-client 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2

package/dest/config.js

@@ -0,0 +1,31 @@
+import { NULL_KEY } from '@aztec/ethereum';
+import { booleanConfigHelper, getConfigFromMappings, numberConfigHelper } from '@aztec/foundation/config';
+export const validatorClientConfigMappings = {
+    validatorPrivateKey: {
+        env: 'VALIDATOR_PRIVATE_KEY',
+        parseEnv: (val)=>val ? `0x${val.replace('0x', '')}` : NULL_KEY,
+        description: 'The private key of the validator participating in attestation duties'
+    },
+    disableValidator: {
+        env: 'VALIDATOR_DISABLED',
+        description: 'Do not run the validator',
+        ...booleanConfigHelper()
+    },
+    attestationPollingIntervalMs: {
+        env: 'VALIDATOR_ATTESTATIONS_POLLING_INTERVAL_MS',
+        description: 'Interval between polling for new attestations',
+        ...numberConfigHelper(200)
+    },
+    validatorReexecute: {
+        env: 'VALIDATOR_REEXECUTE',
+        description: 'Re-execute transactions before attesting',
+        ...booleanConfigHelper(true)
+    }
+};
+/**
+ * Returns the prover configuration from the environment variables.
+ * Note: If an environment variable is not set, the default value is used.
+ * @returns The validator configuration.
+ */ export function getProverEnvVars() {
+    return getConfigFromMappings(validatorClientConfigMappings);
+}

package/dest/duties/validation_service.js

@@ -0,0 +1,35 @@
+import { BlockAttestation, BlockProposal, ConsensusPayload, SignatureDomainSeparator } from '@aztec/circuit-types';
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { keccak256 } from '@aztec/foundation/crypto';
+export class ValidationService {
+    keyStore;
+    constructor(keyStore){
+        this.keyStore = keyStore;
+    }
+    /**
+   * Create a block proposal with the given header, archive, and transactions
+   *
+   * @param header - The block header
+   * @param archive - The archive of the current block
+   * @param txs - TxHash[] ordered list of transactions
+   *
+   * @returns A block proposal signing the above information (not the current implementation!!!)
+   */ createBlockProposal(header, archive, txs) {
+        const payloadSigner = (payload)=>this.keyStore.signMessage(payload);
+        return BlockProposal.createProposalFromSigner(new ConsensusPayload(header, archive, txs), payloadSigner);
+    }
+    /**
+   * Attest to the given block proposal constructed by the current sequencer
+   *
+   * 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
+   */ async attestToProposal(proposal) {
+        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/7961): check that the current validator is correct
+        const buf = Buffer32.fromBuffer(keccak256(await proposal.payload.getPayloadToSign(SignatureDomainSeparator.blockAttestation)));
+        const sig = await this.keyStore.signMessage(buf);
+        return new BlockAttestation(proposal.payload, sig);
+    }
+}

package/dest/errors/index.js

@@ -0,0 +1 @@
+export * from './validator.error.js';

package/dest/errors/validator.error.js

@@ -0,0 +1,45 @@
+export class ValidatorError extends Error {
+    constructor(message){
+        super(`Validator Error: ${message}`);
+    }
+}
+export class InvalidValidatorPrivateKeyError extends ValidatorError {
+    constructor(){
+        super('Invalid validator private key provided');
+    }
+}
+export class AttestationTimeoutError extends ValidatorError {
+    constructor(numberOfRequiredAttestations, slot){
+        super(`Timeout waiting for ${numberOfRequiredAttestations} attestations for slot, ${slot}`);
+    }
+}
+export class TransactionsNotAvailableError extends ValidatorError {
+    constructor(txHashes){
+        super(`Transactions not available: ${txHashes.join(', ')}`);
+    }
+}
+export class FailedToReExecuteTransactionsError extends ValidatorError {
+    constructor(txHashes){
+        super(`Failed to re-execute transactions: ${txHashes.join(', ')}`);
+    }
+}
+export class ReExStateMismatchError extends ValidatorError {
+    constructor(){
+        super('Re-execution state mismatch');
+    }
+}
+export class ReExFailedTxsError extends ValidatorError {
+    constructor(numFailedTxs){
+        super(`Re-execution failed to process ${numFailedTxs} txs`);
+    }
+}
+export class ReExTimeoutError extends ValidatorError {
+    constructor(){
+        super('Re-execution timed out or failed to process all txs in the proposal');
+    }
+}
+export class BlockBuilderNotProvidedError extends ValidatorError {
+    constructor(){
+        super('Block builder not provided');
+    }
+}

package/dest/factory.js

@@ -0,0 +1,11 @@
+import { generatePrivateKey } from 'viem/accounts';
+import { ValidatorClient } from './validator.js';
+export function createValidatorClient(config, deps) {
+    if (config.disableValidator) {
+        return undefined;
+    }
+    if (config.validatorPrivateKey === undefined || config.validatorPrivateKey === '') {
+        config.validatorPrivateKey = generatePrivateKey();
+    }
+    return ValidatorClient.new(config, deps.epochCache, deps.p2pClient, deps.dateProvider, deps.telemetry);
+}

package/dest/index.js

@@ -0,0 +1,3 @@
+export * from './config.js';
+export * from './validator.js';
+export * from './factory.js';

package/dest/key_store/index.js

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

package/dest/key_store/interface.js

@@ -0,0 +1,4 @@
+/** Key Store
+ *
+ * A keystore interface that can be replaced with a local keystore / remote signer service
+ */ export { };

package/dest/key_store/local_key_store.js

@@ -0,0 +1,32 @@
+import { Secp256k1Signer } from '@aztec/foundation/crypto';
+/**
+ * Local Key Store
+ *
+ * An implementation of the Key store using an in memory private key.
+ */ export class LocalKeyStore {
+    signer;
+    constructor(privateKey){
+        this.signer = new Secp256k1Signer(privateKey);
+    }
+    /**
+   * Get the address of the signer
+   *
+   * @returns the address
+   */ getAddress() {
+        return this.signer.address;
+    }
+    /**
+   * Sign a message with the keystore private key
+   *
+   * @param messageBuffer - The message buffer to sign
+   * @return signature
+   */ sign(digest) {
+        const signature = this.signer.sign(digest);
+        return Promise.resolve(signature);
+    }
+    signMessage(message) {
+        // Sign message adds eth sign prefix and hashes before signing
+        const signature = this.signer.signMessage(message);
+        return Promise.resolve(signature);
+    }
+}

package/dest/metrics.js

@@ -0,0 +1,35 @@
+import { Attributes, Metrics, ValueType } from '@aztec/telemetry-client';
+export class ValidatorMetrics {
+    reExecutionTime;
+    failedReexecutionCounter;
+    constructor(telemetryClient){
+        const meter = telemetryClient.getMeter('Validator');
+        this.failedReexecutionCounter = meter.createUpDownCounter(Metrics.VALIDATOR_FAILED_REEXECUTION_COUNT, {
+            description: 'The number of failed re-executions',
+            unit: 'count',
+            valueType: ValueType.INT
+        });
+        this.reExecutionTime = meter.createGauge(Metrics.VALIDATOR_RE_EXECUTION_TIME, {
+            description: 'The time taken to re-execute a transaction',
+            unit: 'ms',
+            valueType: ValueType.DOUBLE
+        });
+    }
+    reExecutionTimer() {
+        const start = performance.now();
+        return ()=>{
+            const end = performance.now();
+            this.recordReExecutionTime(end - start);
+        };
+    }
+    recordReExecutionTime(time) {
+        this.reExecutionTime.record(time);
+    }
+    async recordFailedReexecution(proposal) {
+        this.failedReexecutionCounter.add(1, {
+            [Attributes.STATUS]: 'failed',
+            [Attributes.BLOCK_NUMBER]: proposal.payload.header.globalVariables.blockNumber.toString(),
+            [Attributes.BLOCK_PROPOSER]: (await proposal.getSender())?.toString()
+        });
+    }
+}

package/dest/validator.js

@@ -0,0 +1,246 @@
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import { sleep } from '@aztec/foundation/sleep';
+import { DateProvider } from '@aztec/foundation/timer';
+import { BlockProposalValidator } from '@aztec/p2p/msg_validators';
+import { WithTracer, getTelemetryClient } from '@aztec/telemetry-client';
+import { ValidationService } from './duties/validation_service.js';
+import { AttestationTimeoutError, BlockBuilderNotProvidedError, InvalidValidatorPrivateKeyError, ReExFailedTxsError, ReExStateMismatchError, ReExTimeoutError, TransactionsNotAvailableError } from './errors/validator.error.js';
+import { LocalKeyStore } from './key_store/local_key_store.js';
+import { ValidatorMetrics } from './metrics.js';
+/**
+ * Validator Client
+ */ export class ValidatorClient extends WithTracer {
+    keyStore;
+    epochCache;
+    p2pClient;
+    config;
+    dateProvider;
+    log;
+    validationService;
+    metrics;
+    // Used to check if we are sending the same proposal twice
+    previousProposal;
+    // Callback registered to: sequencer.buildBlock
+    blockBuilder;
+    epochCacheUpdateLoop;
+    blockProposalValidator;
+    constructor(keyStore, epochCache, p2pClient, config, dateProvider = new DateProvider(), telemetry = getTelemetryClient(), log = createLogger('validator')){
+        // Instantiate tracer
+        super(telemetry, 'Validator'), this.keyStore = keyStore, this.epochCache = epochCache, this.p2pClient = p2pClient, this.config = config, this.dateProvider = dateProvider, this.log = log, this.blockBuilder = undefined;
+        this.metrics = new ValidatorMetrics(telemetry);
+        this.validationService = new ValidationService(keyStore);
+        this.blockProposalValidator = new BlockProposalValidator(epochCache);
+        // Refresh epoch cache every second to trigger commiteeChanged event
+        this.epochCacheUpdateLoop = new RunningPromise(()=>this.epochCache.getCommittee().then(()=>{}).catch((err)=>log.error('Error updating validator committee', err)), log, 1000);
+        // Listen to commiteeChanged event to alert operator when their validator has entered the committee
+        this.epochCache.on('committeeChanged', (newCommittee, epochNumber)=>{
+            const me = this.keyStore.getAddress();
+            if (newCommittee.some((addr)=>addr.equals(me))) {
+                this.log.info(`Validator ${me.toString()} is on the validator committee for epoch ${epochNumber}`);
+            } else {
+                this.log.verbose(`Validator ${me.toString()} not on the validator committee for epoch ${epochNumber}`);
+            }
+        });
+        this.log.verbose(`Initialized validator with address ${this.keyStore.getAddress().toString()}`);
+    }
+    static new(config, epochCache, p2pClient, dateProvider = new DateProvider(), telemetry = getTelemetryClient()) {
+        if (!config.validatorPrivateKey) {
+            throw new InvalidValidatorPrivateKeyError();
+        }
+        const privateKey = validatePrivateKey(config.validatorPrivateKey);
+        const localKeyStore = new LocalKeyStore(privateKey);
+        const validator = new ValidatorClient(localKeyStore, epochCache, p2pClient, config, dateProvider, telemetry);
+        validator.registerBlockProposalHandler();
+        return validator;
+    }
+    async start() {
+        // Sync the committee from the smart contract
+        // https://github.com/AztecProtocol/aztec-packages/issues/7962
+        const me = this.keyStore.getAddress();
+        const inCommittee = await this.epochCache.isInCommittee(me);
+        if (inCommittee) {
+            this.log.info(`Started validator with address ${me.toString()} in current validator committee`);
+        } else {
+            this.log.info(`Started validator with address ${me.toString()}`);
+        }
+        this.epochCacheUpdateLoop.start();
+        return Promise.resolve();
+    }
+    async stop() {
+        await this.epochCacheUpdateLoop.stop();
+    }
+    registerBlockProposalHandler() {
+        const handler = (block)=>{
+            return this.attestToProposal(block);
+        };
+        this.p2pClient.registerBlockProposalHandler(handler);
+    }
+    /**
+   * Register a callback function for building a block
+   *
+   * We reuse the sequencer's block building functionality for re-execution
+   */ registerBlockBuilder(blockBuilder) {
+        this.blockBuilder = blockBuilder;
+    }
+    async attestToProposal(proposal) {
+        const slotNumber = proposal.slotNumber.toNumber();
+        const proposalInfo = {
+            slotNumber,
+            blockNumber: proposal.payload.header.globalVariables.blockNumber.toNumber(),
+            archive: proposal.payload.archive.toString(),
+            txCount: proposal.payload.txHashes.length,
+            txHashes: proposal.payload.txHashes.map((txHash)=>txHash.toString())
+        };
+        this.log.verbose(`Received request to attest for slot ${slotNumber}`);
+        // Check that I am in the committee
+        if (!await this.epochCache.isInCommittee(this.keyStore.getAddress())) {
+            this.log.verbose(`Not in the committee, skipping attestation`);
+            return undefined;
+        }
+        // Check that the proposal is from the current proposer, or the next proposer.
+        const invalidProposal = await this.blockProposalValidator.validate(proposal);
+        if (invalidProposal) {
+            this.log.verbose(`Proposal is not valid, skipping attestation`);
+            return undefined;
+        }
+        // Check that all of the tranasctions in the proposal are available in the tx pool before attesting
+        this.log.verbose(`Processing attestation for slot ${slotNumber}`, proposalInfo);
+        try {
+            await this.ensureTransactionsAreAvailable(proposal);
+            if (this.config.validatorReexecute) {
+                this.log.verbose(`Re-executing transactions in the proposal before attesting`);
+                await this.reExecuteTransactions(proposal);
+            }
+        } catch (error) {
+            // If the transactions are not available, then we should not attempt to attest
+            if (error instanceof TransactionsNotAvailableError) {
+                this.log.error(`Transactions not available, skipping attestation`, error, proposalInfo);
+            } else {
+                // This branch most commonly be hit if the transactions are available, but the re-execution fails
+                // Catch all error handler
+                this.log.error(`Failed to attest to proposal`, error, proposalInfo);
+            }
+            return undefined;
+        }
+        // Provided all of the above checks pass, we can attest to the proposal
+        this.log.info(`Attesting to proposal for slot ${slotNumber}`, proposalInfo);
+        // If the above function does not throw an error, then we can attest to the proposal
+        return this.validationService.attestToProposal(proposal);
+    }
+    /**
+   * Re-execute the transactions in the proposal and check that the state updates match the header state
+   * @param proposal - The proposal to re-execute
+   */ async reExecuteTransactions(proposal) {
+        const { header, txHashes } = proposal.payload;
+        const txs = (await Promise.all(txHashes.map((tx)=>this.p2pClient.getTxByHash(tx)))).filter((tx)=>tx !== undefined);
+        // If we cannot request all of the transactions, then we should fail
+        if (txs.length !== txHashes.length) {
+            throw new TransactionsNotAvailableError(txHashes);
+        }
+        // Assertion: This check will fail if re-execution is not enabled
+        if (this.blockBuilder === undefined) {
+            throw new BlockBuilderNotProvidedError();
+        }
+        // Use the sequencer's block building logic to re-execute the transactions
+        const stopTimer = this.metrics.reExecutionTimer();
+        const { block, numFailedTxs } = await this.blockBuilder(txs, header.globalVariables, {
+            validateOnly: true
+        });
+        stopTimer();
+        this.log.verbose(`Transaction re-execution complete`);
+        if (numFailedTxs > 0) {
+            await this.metrics.recordFailedReexecution(proposal);
+            throw new ReExFailedTxsError(numFailedTxs);
+        }
+        if (block.body.txEffects.length !== txHashes.length) {
+            await this.metrics.recordFailedReexecution(proposal);
+            throw new ReExTimeoutError();
+        }
+        // This function will throw an error if state updates do not match
+        if (!block.archive.root.equals(proposal.archive)) {
+            await this.metrics.recordFailedReexecution(proposal);
+            throw new ReExStateMismatchError();
+        }
+    }
+    /**
+   * Ensure that all of the transactions in the proposal are available in the tx pool before attesting
+   *
+   * 1. Check if the local tx pool contains all of the transactions in the proposal
+   * 2. If any transactions are not in the local tx pool, request them from the network
+   * 3. If we cannot retrieve them from the network, throw an error
+   * @param proposal - The proposal to attest to
+   */ async ensureTransactionsAreAvailable(proposal) {
+        const txHashes = proposal.payload.txHashes;
+        const transactionStatuses = await Promise.all(txHashes.map((txHash)=>this.p2pClient.getTxStatus(txHash)));
+        const missingTxs = txHashes.filter((_, index)=>![
+                'pending',
+                'mined'
+            ].includes(transactionStatuses[index] ?? ''));
+        if (missingTxs.length === 0) {
+            return; // All transactions are available
+        }
+        this.log.verbose(`Missing ${missingTxs.length} transactions in the tx pool, requesting from the network`);
+        const requestedTxs = await this.p2pClient.requestTxs(missingTxs);
+        if (requestedTxs.some((tx)=>tx === undefined)) {
+            throw new TransactionsNotAvailableError(missingTxs);
+        }
+    }
+    async createBlockProposal(header, archive, txs) {
+        if (this.previousProposal?.slotNumber.equals(header.globalVariables.slotNumber)) {
+            this.log.verbose(`Already made a proposal for the same slot, skipping proposal`);
+            return Promise.resolve(undefined);
+        }
+        const newProposal = await this.validationService.createBlockProposal(header, archive, txs);
+        this.previousProposal = newProposal;
+        return newProposal;
+    }
+    broadcastBlockProposal(proposal) {
+        this.p2pClient.broadcastProposal(proposal);
+    }
+    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/7962)
+    async collectAttestations(proposal, required, deadline) {
+        // Wait and poll the p2pClient's attestation pool for this block until we have enough attestations
+        const slot = proposal.payload.header.globalVariables.slotNumber.toBigInt();
+        this.log.debug(`Collecting ${required} attestations for slot ${slot} with deadline ${deadline.toISOString()}`);
+        if (+deadline < this.dateProvider.now()) {
+            this.log.error(`Deadline ${deadline.toISOString()} for collecting ${required} attestations for slot ${slot} is in the past`);
+            throw new AttestationTimeoutError(required, slot);
+        }
+        const proposalId = proposal.archive.toString();
+        const myAttestation = await this.validationService.attestToProposal(proposal);
+        let attestations = [];
+        while(true){
+            const collectedAttestations = [
+                myAttestation,
+                ...await this.p2pClient.getAttestationsForSlot(slot, proposalId)
+            ];
+            const oldSenders = await Promise.all(attestations.map((attestation)=>attestation.getSender()));
+            for (const collected of collectedAttestations){
+                const collectedSender = await collected.getSender();
+                if (!oldSenders.some((sender)=>sender.equals(collectedSender))) {
+                    this.log.debug(`Received attestation for slot ${slot} from ${collectedSender.toString()}`);
+                }
+            }
+            attestations = collectedAttestations;
+            if (attestations.length >= required) {
+                this.log.verbose(`Collected all ${required} attestations for slot ${slot}`);
+                return attestations;
+            }
+            if (+deadline < this.dateProvider.now()) {
+                this.log.error(`Timeout ${deadline.toISOString()} waiting for ${required} attestations for slot ${slot}`);
+                throw new AttestationTimeoutError(required, slot);
+            }
+            this.log.debug(`Collected ${attestations.length} attestations so far`);
+            await sleep(this.config.attestationPollingIntervalMs);
+        }
+    }
+}
+function validatePrivateKey(privateKey) {
+    try {
+        return Buffer32.fromString(privateKey);
+    } catch (error) {
+        throw new InvalidValidatorPrivateKeyError();
+    }
+}

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "@aztec/validator-client",
+  "version": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+  "main": "dest/index.js",
+  "type": "module",
+  "exports": {
+    ".": "./dest/index.js",
+    "./config": "./dest/config.js",
+    "./errors": "./dest/errors/index.js"
+  },
+  "bin": "./dest/bin/index.js",
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/index.ts"
+    ],
+    "name": "Aztec validator",
+    "tsconfig": "./tsconfig.json"
+  },
+  "scripts": {
+    "start": "node --no-warnings ./dest/bin",
+    "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",
+    "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
+  },
+  "inherits": [
+    "../package.common.json"
+  ],
+  "jest": {
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.[cm]?js$": "$1"
+    },
+    "testRegex": "./src/.*\\.test\\.(js|mjs|ts)$",
+    "rootDir": "./src",
+    "transform": {
+      "^.+\\.tsx?$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "decorators": true
+            },
+            "transform": {
+              "decoratorVersion": "2022-03"
+            }
+          }
+        }
+      ]
+    },
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ],
+    "reporters": [
+      "default"
+    ],
+    "testTimeout": 30000,
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
+    ]
+  },
+  "dependencies": {
+    "@aztec/circuit-types": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+    "@aztec/circuits.js": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+    "@aztec/epoch-cache": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+    "@aztec/ethereum": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+    "@aztec/foundation": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+    "@aztec/p2p": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+    "@aztec/telemetry-client": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+    "@aztec/types": "0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2",
+    "koa": "^2.14.2",
+    "koa-router": "^12.0.0",
+    "tslib": "^2.4.0",
+    "viem": "2.22.8"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.5.0",
+    "@types/jest": "^29.5.0",
+    "@types/node": "^18.7.23",
+    "jest": "^29.5.0",
+    "jest-mock-extended": "^3.0.7",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.4"
+  },
+  "files": [
+    "dest",
+    "src",
+    "!*.test.*"
+  ],
+  "types": "./dest/index.d.ts",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/config.ts

@@ -0,0 +1,56 @@
+import { NULL_KEY } from '@aztec/ethereum';
+import {
+  type ConfigMappingsType,
+  booleanConfigHelper,
+  getConfigFromMappings,
+  numberConfigHelper,
+} from '@aztec/foundation/config';
+
+/**
+ * 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 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',
+  },
+  disableValidator: {
+    env: 'VALIDATOR_DISABLED',
+    description: 'Do not run the validator',
+    ...booleanConfigHelper(),
+  },
+  attestationPollingIntervalMs: {
+    env: 'VALIDATOR_ATTESTATIONS_POLLING_INTERVAL_MS',
+    description: 'Interval between polling for new attestations',
+    ...numberConfigHelper(200),
+  },
+  validatorReexecute: {
+    env: 'VALIDATOR_REEXECUTE',
+    description: 'Re-execute transactions before attesting',
+    ...booleanConfigHelper(true),
+  },
+};
+
+/**
+ * Returns the prover configuration from the environment variables.
+ * Note: If an environment variable is not set, the default value is used.
+ * @returns The validator configuration.
+ */
+export function getProverEnvVars(): ValidatorClientConfig {
+  return getConfigFromMappings<ValidatorClientConfig>(validatorClientConfigMappings);
+}

package/src/duties/validation_service.ts

@@ -0,0 +1,51 @@
+import {
+  BlockAttestation,
+  BlockProposal,
+  ConsensusPayload,
+  SignatureDomainSeparator,
+  type TxHash,
+} from '@aztec/circuit-types';
+import { type BlockHeader } from '@aztec/circuits.js';
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { keccak256 } from '@aztec/foundation/crypto';
+import { type Fr } from '@aztec/foundation/fields';
+
+import { type ValidatorKeyStore } from '../key_store/interface.js';
+
+export class ValidationService {
+  constructor(private keyStore: ValidatorKeyStore) {}
+
+  /**
+   * Create a block proposal with the given header, archive, and transactions
+   *
+   * @param header - The block header
+   * @param archive - The archive of the current block
+   * @param txs - TxHash[] ordered list of transactions
+   *
+   * @returns A block proposal signing the above information (not the current implementation!!!)
+   */
+  createBlockProposal(header: BlockHeader, archive: Fr, txs: TxHash[]): Promise<BlockProposal> {
+    const payloadSigner = (payload: Buffer32) => this.keyStore.signMessage(payload);
+
+    return BlockProposal.createProposalFromSigner(new ConsensusPayload(header, archive, txs), payloadSigner);
+  }
+
+  /**
+   * Attest to the given block proposal constructed by the current sequencer
+   *
+   * 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
+   */
+  async attestToProposal(proposal: BlockProposal): Promise<BlockAttestation> {
+    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/7961): check that the current validator is correct
+
+    const buf = Buffer32.fromBuffer(
+      keccak256(await proposal.payload.getPayloadToSign(SignatureDomainSeparator.blockAttestation)),
+    );
+    const sig = await this.keyStore.signMessage(buf);
+    return new BlockAttestation(proposal.payload, sig);
+  }
+}

package/src/errors/index.ts

@@ -0,0 +1 @@
+export * from './validator.error.js';

package/src/errors/validator.error.ts

@@ -0,0 +1,55 @@
+import { type TxHash } from '@aztec/circuit-types/tx_hash';
+
+export class ValidatorError extends Error {
+  constructor(message: string) {
+    super(`Validator Error: ${message}`);
+  }
+}
+
+export class InvalidValidatorPrivateKeyError extends ValidatorError {
+  constructor() {
+    super('Invalid validator private key provided');
+  }
+}
+
+export class AttestationTimeoutError extends ValidatorError {
+  constructor(numberOfRequiredAttestations: number, slot: bigint) {
+    super(`Timeout waiting for ${numberOfRequiredAttestations} attestations for slot, ${slot}`);
+  }
+}
+
+export class TransactionsNotAvailableError extends ValidatorError {
+  constructor(txHashes: TxHash[]) {
+    super(`Transactions not available: ${txHashes.join(', ')}`);
+  }
+}
+
+export class FailedToReExecuteTransactionsError extends ValidatorError {
+  constructor(txHashes: TxHash[]) {
+    super(`Failed to re-execute transactions: ${txHashes.join(', ')}`);
+  }
+}
+
+export class ReExStateMismatchError extends ValidatorError {
+  constructor() {
+    super('Re-execution state mismatch');
+  }
+}
+
+export class ReExFailedTxsError extends ValidatorError {
+  constructor(numFailedTxs: number) {
+    super(`Re-execution failed to process ${numFailedTxs} txs`);
+  }
+}
+
+export class ReExTimeoutError extends ValidatorError {
+  constructor() {
+    super('Re-execution timed out or failed to process all txs in the proposal');
+  }
+}
+
+export class BlockBuilderNotProvidedError extends ValidatorError {
+  constructor() {
+    super('Block builder not provided');
+  }
+}

package/src/factory.ts

@@ -0,0 +1,28 @@
+import { type EpochCache } from '@aztec/epoch-cache';
+import { type DateProvider } from '@aztec/foundation/timer';
+import { type P2P } from '@aztec/p2p';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+
+import { generatePrivateKey } from 'viem/accounts';
+
+import { type ValidatorClientConfig } from './config.js';
+import { ValidatorClient } from './validator.js';
+
+export function createValidatorClient(
+  config: ValidatorClientConfig,
+  deps: {
+    p2pClient: P2P;
+    telemetry: TelemetryClient;
+    dateProvider: DateProvider;
+    epochCache: EpochCache;
+  },
+) {
+  if (config.disableValidator) {
+    return undefined;
+  }
+  if (config.validatorPrivateKey === undefined || config.validatorPrivateKey === '') {
+    config.validatorPrivateKey = generatePrivateKey();
+  }
+
+  return ValidatorClient.new(config, deps.epochCache, deps.p2pClient, deps.dateProvider, deps.telemetry);
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './config.js';
+export * from './validator.js';
+export * from './factory.js';

package/src/key_store/index.ts

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

package/src/key_store/interface.ts

@@ -0,0 +1,26 @@
+import { type EthAddress } from '@aztec/circuits.js';
+import { type Buffer32 } from '@aztec/foundation/buffer';
+import { type Signature } from '@aztec/foundation/eth-signature';
+
+/** Key Store
+ *
+ * A keystore interface that can be replaced with a local keystore / remote signer service
+ */
+export interface ValidatorKeyStore {
+  /**
+   * Get the address of the signer
+   *
+   * @returns the address
+   */
+  getAddress(): EthAddress;
+
+  sign(message: Buffer32): Promise<Signature>;
+  /**
+   * Flavor of sign message that followed EIP-712 eth signed message prefix
+   * Note: this is only required when we are using ecdsa signatures over secp256k1
+   *
+   * @param message - The message to sign.
+   * @returns The signature.
+   */
+  signMessage(message: Buffer32): Promise<Signature>;
+}

package/src/key_store/local_key_store.ts

@@ -0,0 +1,46 @@
+import { type Buffer32 } from '@aztec/foundation/buffer';
+import { Secp256k1Signer } from '@aztec/foundation/crypto';
+import { type EthAddress } from '@aztec/foundation/eth-address';
+import { type Signature } from '@aztec/foundation/eth-signature';
+
+import { type ValidatorKeyStore } from './interface.js';
+
+/**
+ * Local Key Store
+ *
+ * An implementation of the Key store using an in memory private key.
+ */
+export class LocalKeyStore implements ValidatorKeyStore {
+  private signer: Secp256k1Signer;
+
+  constructor(privateKey: Buffer32) {
+    this.signer = new Secp256k1Signer(privateKey);
+  }
+
+  /**
+   * Get the address of the signer
+   *
+   * @returns the address
+   */
+  public getAddress(): EthAddress {
+    return this.signer.address;
+  }
+
+  /**
+   * Sign a message with the keystore private key
+   *
+   * @param messageBuffer - The message buffer to sign
+   * @return signature
+   */
+  public sign(digest: Buffer32): Promise<Signature> {
+    const signature = this.signer.sign(digest);
+
+    return Promise.resolve(signature);
+  }
+
+  public signMessage(message: Buffer32): Promise<Signature> {
+    // Sign message adds eth sign prefix and hashes before signing
+    const signature = this.signer.signMessage(message);
+    return Promise.resolve(signature);
+  }
+}

package/src/metrics.ts

@@ -0,0 +1,50 @@
+import { type BlockProposal } from '@aztec/circuit-types';
+import {
+  Attributes,
+  type Gauge,
+  Metrics,
+  type TelemetryClient,
+  type UpDownCounter,
+  ValueType,
+} from '@aztec/telemetry-client';
+
+export class ValidatorMetrics {
+  private reExecutionTime: Gauge;
+  private failedReexecutionCounter: UpDownCounter;
+
+  constructor(telemetryClient: TelemetryClient) {
+    const meter = telemetryClient.getMeter('Validator');
+
+    this.failedReexecutionCounter = meter.createUpDownCounter(Metrics.VALIDATOR_FAILED_REEXECUTION_COUNT, {
+      description: 'The number of failed re-executions',
+      unit: 'count',
+      valueType: ValueType.INT,
+    });
+
+    this.reExecutionTime = meter.createGauge(Metrics.VALIDATOR_RE_EXECUTION_TIME, {
+      description: 'The time taken to re-execute a transaction',
+      unit: 'ms',
+      valueType: ValueType.DOUBLE,
+    });
+  }
+
+  public reExecutionTimer(): () => void {
+    const start = performance.now();
+    return () => {
+      const end = performance.now();
+      this.recordReExecutionTime(end - start);
+    };
+  }
+
+  public recordReExecutionTime(time: number) {
+    this.reExecutionTime.record(time);
+  }
+
+  public async recordFailedReexecution(proposal: BlockProposal) {
+    this.failedReexecutionCounter.add(1, {
+      [Attributes.STATUS]: 'failed',
+      [Attributes.BLOCK_NUMBER]: proposal.payload.header.globalVariables.blockNumber.toString(),
+      [Attributes.BLOCK_PROPOSER]: (await proposal.getSender())?.toString(),
+    });
+  }
+}

package/src/validator.ts

@@ -0,0 +1,361 @@
+import { type BlockAttestation, type BlockProposal, type L2Block, type Tx, type TxHash } from '@aztec/circuit-types';
+import { type BlockHeader, type GlobalVariables } from '@aztec/circuits.js';
+import { type EpochCache } from '@aztec/epoch-cache';
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { type Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import { sleep } from '@aztec/foundation/sleep';
+import { DateProvider, type Timer } from '@aztec/foundation/timer';
+import { type P2P } from '@aztec/p2p';
+import { BlockProposalValidator } from '@aztec/p2p/msg_validators';
+import { type TelemetryClient, WithTracer, getTelemetryClient } from '@aztec/telemetry-client';
+
+import { type ValidatorClientConfig } from './config.js';
+import { ValidationService } from './duties/validation_service.js';
+import {
+  AttestationTimeoutError,
+  BlockBuilderNotProvidedError,
+  InvalidValidatorPrivateKeyError,
+  ReExFailedTxsError,
+  ReExStateMismatchError,
+  ReExTimeoutError,
+  TransactionsNotAvailableError,
+} from './errors/validator.error.js';
+import { type ValidatorKeyStore } from './key_store/interface.js';
+import { LocalKeyStore } from './key_store/local_key_store.js';
+import { ValidatorMetrics } from './metrics.js';
+
+/**
+ * Callback function for building a block
+ *
+ * We reuse the sequencer's block building functionality for re-execution
+ */
+type BlockBuilderCallback = (
+  txs: Iterable<Tx> | AsyncIterableIterator<Tx>,
+  globalVariables: GlobalVariables,
+  opts?: { validateOnly?: boolean },
+) => Promise<{
+  block: L2Block;
+  publicProcessorDuration: number;
+  numTxs: number;
+  numFailedTxs: number;
+  blockBuildingTimer: Timer;
+}>;
+
+export interface Validator {
+  start(): Promise<void>;
+  registerBlockProposalHandler(): void;
+  registerBlockBuilder(blockBuilder: BlockBuilderCallback): void;
+
+  // Block validation responsiblities
+  createBlockProposal(header: BlockHeader, archive: Fr, txs: TxHash[]): Promise<BlockProposal | undefined>;
+  attestToProposal(proposal: BlockProposal): void;
+
+  broadcastBlockProposal(proposal: BlockProposal): void;
+  collectAttestations(proposal: BlockProposal, required: number, deadline: Date): Promise<BlockAttestation[]>;
+}
+
+/**
+ * Validator Client
+ */
+export class ValidatorClient extends WithTracer implements Validator {
+  private validationService: ValidationService;
+  private metrics: ValidatorMetrics;
+
+  // Used to check if we are sending the same proposal twice
+  private previousProposal?: BlockProposal;
+
+  // Callback registered to: sequencer.buildBlock
+  private blockBuilder?: BlockBuilderCallback = undefined;
+
+  private epochCacheUpdateLoop: RunningPromise;
+
+  private blockProposalValidator: BlockProposalValidator;
+
+  constructor(
+    private keyStore: ValidatorKeyStore,
+    private epochCache: EpochCache,
+    private p2pClient: P2P,
+    private config: ValidatorClientConfig,
+    private dateProvider: DateProvider = new DateProvider(),
+    telemetry: TelemetryClient = getTelemetryClient(),
+    private log = createLogger('validator'),
+  ) {
+    // Instantiate tracer
+    super(telemetry, 'Validator');
+    this.metrics = new ValidatorMetrics(telemetry);
+
+    this.validationService = new ValidationService(keyStore);
+
+    this.blockProposalValidator = new BlockProposalValidator(epochCache);
+
+    // Refresh epoch cache every second to trigger commiteeChanged event
+    this.epochCacheUpdateLoop = new RunningPromise(
+      () =>
+        this.epochCache
+          .getCommittee()
+          .then(() => {})
+          .catch(err => log.error('Error updating validator committee', err)),
+      log,
+      1000,
+    );
+
+    // Listen to commiteeChanged event to alert operator when their validator has entered the committee
+    this.epochCache.on('committeeChanged', (newCommittee, epochNumber) => {
+      const me = this.keyStore.getAddress();
+      if (newCommittee.some(addr => addr.equals(me))) {
+        this.log.info(`Validator ${me.toString()} is on the validator committee for epoch ${epochNumber}`);
+      } else {
+        this.log.verbose(`Validator ${me.toString()} not on the validator committee for epoch ${epochNumber}`);
+      }
+    });
+
+    this.log.verbose(`Initialized validator with address ${this.keyStore.getAddress().toString()}`);
+  }
+
+  static new(
+    config: ValidatorClientConfig,
+    epochCache: EpochCache,
+    p2pClient: P2P,
+    dateProvider: DateProvider = new DateProvider(),
+    telemetry: TelemetryClient = getTelemetryClient(),
+  ) {
+    if (!config.validatorPrivateKey) {
+      throw new InvalidValidatorPrivateKeyError();
+    }
+
+    const privateKey = validatePrivateKey(config.validatorPrivateKey);
+    const localKeyStore = new LocalKeyStore(privateKey);
+
+    const validator = new ValidatorClient(localKeyStore, epochCache, p2pClient, config, dateProvider, telemetry);
+    validator.registerBlockProposalHandler();
+    return validator;
+  }
+
+  public async start() {
+    // Sync the committee from the smart contract
+    // https://github.com/AztecProtocol/aztec-packages/issues/7962
+
+    const me = this.keyStore.getAddress();
+    const inCommittee = await this.epochCache.isInCommittee(me);
+    if (inCommittee) {
+      this.log.info(`Started validator with address ${me.toString()} in current validator committee`);
+    } else {
+      this.log.info(`Started validator with address ${me.toString()}`);
+    }
+    this.epochCacheUpdateLoop.start();
+    return Promise.resolve();
+  }
+
+  public async stop() {
+    await this.epochCacheUpdateLoop.stop();
+  }
+
+  public registerBlockProposalHandler() {
+    const handler = (block: BlockProposal): Promise<BlockAttestation | undefined> => {
+      return this.attestToProposal(block);
+    };
+    this.p2pClient.registerBlockProposalHandler(handler);
+  }
+
+  /**
+   * Register a callback function for building a block
+   *
+   * We reuse the sequencer's block building functionality for re-execution
+   */
+  public registerBlockBuilder(blockBuilder: BlockBuilderCallback) {
+    this.blockBuilder = blockBuilder;
+  }
+
+  async attestToProposal(proposal: BlockProposal): Promise<BlockAttestation | undefined> {
+    const slotNumber = proposal.slotNumber.toNumber();
+    const proposalInfo = {
+      slotNumber,
+      blockNumber: proposal.payload.header.globalVariables.blockNumber.toNumber(),
+      archive: proposal.payload.archive.toString(),
+      txCount: proposal.payload.txHashes.length,
+      txHashes: proposal.payload.txHashes.map(txHash => txHash.toString()),
+    };
+    this.log.verbose(`Received request to attest for slot ${slotNumber}`);
+
+    // Check that I am in the committee
+    if (!(await this.epochCache.isInCommittee(this.keyStore.getAddress()))) {
+      this.log.verbose(`Not in the committee, skipping attestation`);
+      return undefined;
+    }
+
+    // Check that the proposal is from the current proposer, or the next proposer.
+    const invalidProposal = await this.blockProposalValidator.validate(proposal);
+    if (invalidProposal) {
+      this.log.verbose(`Proposal is not valid, skipping attestation`);
+      return undefined;
+    }
+
+    // Check that all of the tranasctions in the proposal are available in the tx pool before attesting
+    this.log.verbose(`Processing attestation for slot ${slotNumber}`, proposalInfo);
+    try {
+      await this.ensureTransactionsAreAvailable(proposal);
+
+      if (this.config.validatorReexecute) {
+        this.log.verbose(`Re-executing transactions in the proposal before attesting`);
+        await this.reExecuteTransactions(proposal);
+      }
+    } catch (error: any) {
+      // If the transactions are not available, then we should not attempt to attest
+      if (error instanceof TransactionsNotAvailableError) {
+        this.log.error(`Transactions not available, skipping attestation`, error, proposalInfo);
+      } else {
+        // This branch most commonly be hit if the transactions are available, but the re-execution fails
+        // Catch all error handler
+        this.log.error(`Failed to attest to proposal`, error, proposalInfo);
+      }
+      return undefined;
+    }
+
+    // Provided all of the above checks pass, we can attest to the proposal
+    this.log.info(`Attesting to proposal for slot ${slotNumber}`, proposalInfo);
+
+    // If the above function does not throw an error, then we can attest to the proposal
+    return this.validationService.attestToProposal(proposal);
+  }
+
+  /**
+   * Re-execute the transactions in the proposal and check that the state updates match the header state
+   * @param proposal - The proposal to re-execute
+   */
+  async reExecuteTransactions(proposal: BlockProposal) {
+    const { header, txHashes } = proposal.payload;
+
+    const txs = (await Promise.all(txHashes.map(tx => this.p2pClient.getTxByHash(tx)))).filter(
+      tx => tx !== undefined,
+    ) as Tx[];
+
+    // If we cannot request all of the transactions, then we should fail
+    if (txs.length !== txHashes.length) {
+      throw new TransactionsNotAvailableError(txHashes);
+    }
+
+    // Assertion: This check will fail if re-execution is not enabled
+    if (this.blockBuilder === undefined) {
+      throw new BlockBuilderNotProvidedError();
+    }
+
+    // Use the sequencer's block building logic to re-execute the transactions
+    const stopTimer = this.metrics.reExecutionTimer();
+    const { block, numFailedTxs } = await this.blockBuilder(txs, header.globalVariables, {
+      validateOnly: true,
+    });
+    stopTimer();
+
+    this.log.verbose(`Transaction re-execution complete`);
+
+    if (numFailedTxs > 0) {
+      await this.metrics.recordFailedReexecution(proposal);
+      throw new ReExFailedTxsError(numFailedTxs);
+    }
+
+    if (block.body.txEffects.length !== txHashes.length) {
+      await this.metrics.recordFailedReexecution(proposal);
+      throw new ReExTimeoutError();
+    }
+
+    // This function will throw an error if state updates do not match
+    if (!block.archive.root.equals(proposal.archive)) {
+      await this.metrics.recordFailedReexecution(proposal);
+      throw new ReExStateMismatchError();
+    }
+  }
+
+  /**
+   * Ensure that all of the transactions in the proposal are available in the tx pool before attesting
+   *
+   * 1. Check if the local tx pool contains all of the transactions in the proposal
+   * 2. If any transactions are not in the local tx pool, request them from the network
+   * 3. If we cannot retrieve them from the network, throw an error
+   * @param proposal - The proposal to attest to
+   */
+  async ensureTransactionsAreAvailable(proposal: BlockProposal) {
+    const txHashes: TxHash[] = proposal.payload.txHashes;
+    const transactionStatuses = await Promise.all(txHashes.map(txHash => this.p2pClient.getTxStatus(txHash)));
+
+    const missingTxs = txHashes.filter((_, index) => !['pending', 'mined'].includes(transactionStatuses[index] ?? ''));
+
+    if (missingTxs.length === 0) {
+      return; // All transactions are available
+    }
+
+    this.log.verbose(`Missing ${missingTxs.length} transactions in the tx pool, requesting from the network`);
+
+    const requestedTxs = await this.p2pClient.requestTxs(missingTxs);
+    if (requestedTxs.some(tx => tx === undefined)) {
+      throw new TransactionsNotAvailableError(missingTxs);
+    }
+  }
+
+  async createBlockProposal(header: BlockHeader, archive: Fr, txs: TxHash[]): Promise<BlockProposal | undefined> {
+    if (this.previousProposal?.slotNumber.equals(header.globalVariables.slotNumber)) {
+      this.log.verbose(`Already made a proposal for the same slot, skipping proposal`);
+      return Promise.resolve(undefined);
+    }
+
+    const newProposal = await this.validationService.createBlockProposal(header, archive, txs);
+    this.previousProposal = newProposal;
+    return newProposal;
+  }
+
+  broadcastBlockProposal(proposal: BlockProposal): void {
+    this.p2pClient.broadcastProposal(proposal);
+  }
+
+  // TODO(https://github.com/AztecProtocol/aztec-packages/issues/7962)
+  async collectAttestations(proposal: BlockProposal, required: number, deadline: Date): Promise<BlockAttestation[]> {
+    // Wait and poll the p2pClient's attestation pool for this block until we have enough attestations
+    const slot = proposal.payload.header.globalVariables.slotNumber.toBigInt();
+    this.log.debug(`Collecting ${required} attestations for slot ${slot} with deadline ${deadline.toISOString()}`);
+
+    if (+deadline < this.dateProvider.now()) {
+      this.log.error(
+        `Deadline ${deadline.toISOString()} for collecting ${required} attestations for slot ${slot} is in the past`,
+      );
+      throw new AttestationTimeoutError(required, slot);
+    }
+
+    const proposalId = proposal.archive.toString();
+    const myAttestation = await this.validationService.attestToProposal(proposal);
+
+    let attestations: BlockAttestation[] = [];
+    while (true) {
+      const collectedAttestations = [myAttestation, ...(await this.p2pClient.getAttestationsForSlot(slot, proposalId))];
+      const oldSenders = await Promise.all(attestations.map(attestation => attestation.getSender()));
+      for (const collected of collectedAttestations) {
+        const collectedSender = await collected.getSender();
+        if (!oldSenders.some(sender => sender.equals(collectedSender))) {
+          this.log.debug(`Received attestation for slot ${slot} from ${collectedSender.toString()}`);
+        }
+      }
+      attestations = collectedAttestations;
+
+      if (attestations.length >= required) {
+        this.log.verbose(`Collected all ${required} attestations for slot ${slot}`);
+        return attestations;
+      }
+
+      if (+deadline < this.dateProvider.now()) {
+        this.log.error(`Timeout ${deadline.toISOString()} waiting for ${required} attestations for slot ${slot}`);
+        throw new AttestationTimeoutError(required, slot);
+      }
+
+      this.log.debug(`Collected ${attestations.length} attestations so far`);
+      await sleep(this.config.attestationPollingIntervalMs);
+    }
+  }
+}
+
+function validatePrivateKey(privateKey: string): Buffer32 {
+  try {
+    return Buffer32.fromString(privateKey);
+  } catch (error) {
+    throw new InvalidValidatorPrivateKeyError();
+  }
+}