@aztec/validator-client 0.87.6 → 1.0.0-nightly.20250604

package/dest/validator.js

@@ -1,11 +1,14 @@
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { Buffer32 } from '@aztec/foundation/buffer';
+import { 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 } from '@aztec/foundation/timer';
 import { TxCollector } from '@aztec/p2p';
 import { BlockProposalValidator } from '@aztec/p2p/msg_validators';
+import { getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import { GlobalVariables } from '@aztec/stdlib/tx';
 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';
@@ -14,6 +17,7 @@ import { ValidatorMetrics } from './metrics.js';
 /**
  * Validator Client
  */ export class ValidatorClient extends WithTracer {
+    blockBuilder;
     keyStore;
     epochCache;
     p2pClient;
@@ -25,34 +29,34 @@ import { ValidatorMetrics } from './metrics.js';
     metrics;
     // Used to check if we are sending the same proposal twice
     previousProposal;
-    // Callback registered to: sequencer.buildBlock
-    blockBuilder;
-    myAddress;
+    myAddresses;
     lastEpoch;
     epochCacheUpdateLoop;
     blockProposalValidator;
     txCollector;
-    constructor(keyStore, epochCache, p2pClient, blockSource, config, dateProvider = new DateProvider(), telemetry = getTelemetryClient(), log = createLogger('validator')){
+    constructor(blockBuilder, keyStore, epochCache, p2pClient, blockSource, config, dateProvider = new DateProvider(), telemetry = getTelemetryClient(), log = createLogger('validator')){
         // Instantiate tracer
-        super(telemetry, 'Validator'), this.keyStore = keyStore, this.epochCache = epochCache, this.p2pClient = p2pClient, this.blockSource = blockSource, this.config = config, this.dateProvider = dateProvider, this.log = log, this.blockBuilder = undefined;
+        super(telemetry, 'Validator'), this.blockBuilder = blockBuilder, this.keyStore = keyStore, this.epochCache = epochCache, this.p2pClient = p2pClient, this.blockSource = blockSource, this.config = config, this.dateProvider = dateProvider, this.log = log;
         this.metrics = new ValidatorMetrics(telemetry);
         this.validationService = new ValidationService(keyStore);
         this.blockProposalValidator = new BlockProposalValidator(epochCache);
         this.txCollector = new TxCollector(p2pClient, this.log);
         // Refresh epoch cache every second to trigger alert if participation in committee changes
-        this.myAddress = this.keyStore.getAddress();
+        this.myAddresses = this.keyStore.getAddresses();
         this.epochCacheUpdateLoop = new RunningPromise(this.handleEpochCommitteeUpdate.bind(this), log, 1000);
-        this.log.verbose(`Initialized validator with address ${this.keyStore.getAddress().toString()}`);
+        this.log.verbose(`Initialized validator with addresses: ${this.myAddresses.map((a)=>a.toString()).join(', ')}`);
     }
     async handleEpochCommitteeUpdate() {
         try {
             const { committee, epoch } = await this.epochCache.getCommittee('now');
             if (epoch !== this.lastEpoch) {
-                const me = this.myAddress;
-                if (committee.some((addr)=>addr.equals(me))) {
-                    this.log.info(`Validator ${me.toString()} is on the validator committee for epoch ${epoch}`);
+                const me = this.myAddresses;
+                const committeeSet = new Set(committee.map((v)=>v.toString()));
+                const inCommittee = me.filter((a)=>committeeSet.has(a.toString()));
+                if (inCommittee.length > 0) {
+                    inCommittee.forEach((a)=>this.log.info(`Validator ${a.toString()} is on the validator committee for epoch ${epoch}`));
                 } else {
-                    this.log.verbose(`Validator ${me.toString()} not on the validator committee for epoch ${epoch}`);
+                    this.log.verbose(`Validators ${me.map((a)=>a.toString()).join(', ')} are not on the validator committee for epoch ${epoch}`);
                 }
                 this.lastEpoch = epoch;
             }
@@ -60,28 +64,30 @@ import { ValidatorMetrics } from './metrics.js';
             this.log.error(`Error updating epoch committee`, err);
         }
     }
-    static new(config, epochCache, p2pClient, blockSource, dateProvider = new DateProvider(), telemetry = getTelemetryClient()) {
-        if (!config.validatorPrivateKey) {
+    static new(config, blockBuilder, epochCache, p2pClient, blockSource, dateProvider = new DateProvider(), telemetry = getTelemetryClient()) {
+        if (!config.validatorPrivateKeys?.length) {
             throw new InvalidValidatorPrivateKeyError();
         }
-        const privateKey = validatePrivateKey(config.validatorPrivateKey);
-        const localKeyStore = new LocalKeyStore(privateKey);
-        const validator = new ValidatorClient(localKeyStore, epochCache, p2pClient, blockSource, config, dateProvider, telemetry);
+        const privateKeys = config.validatorPrivateKeys.map(validatePrivateKey);
+        const localKeyStore = new LocalKeyStore(privateKeys);
+        const validator = new ValidatorClient(blockBuilder, localKeyStore, epochCache, p2pClient, blockSource, config, dateProvider, telemetry);
         validator.registerBlockProposalHandler();
         return validator;
     }
-    getValidatorAddress() {
-        return this.keyStore.getAddress();
+    getValidatorAddresses() {
+        return this.keyStore.getAddresses();
     }
     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`);
+        const myAddresses = this.keyStore.getAddresses();
+        const inCommittee = await this.epochCache.filterInCommittee(myAddresses);
+        if (inCommittee.length > 0) {
+            this.log.info(`Started validator with addresses in current validator committee:
+         ${inCommittee.map((a)=>a.toString()).join(', ')}`);
         } else {
-            this.log.info(`Started validator with address ${me.toString()}`);
+            this.log.info(`Started validator with addresses:
+        ${myAddresses.map((a)=>a.toString()).join(', ')}`);
         }
         this.epochCacheUpdateLoop.start();
         return Promise.resolve();
@@ -95,13 +101,6 @@ import { ValidatorMetrics } from './metrics.js';
         };
         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, proposalSender) {
         const slotNumber = proposal.slotNumber.toNumber();
         const blockNumber = proposal.blockNumber.toNumber();
@@ -118,19 +117,19 @@ import { ValidatorMetrics } from './metrics.js';
         const invalidProposal = await this.blockProposalValidator.validate(proposal);
         if (invalidProposal) {
             this.log.verbose(`Proposal is not valid, skipping attestation`);
-            this.metrics.incFailedAttestations('invalid_proposal');
+            this.metrics.incFailedAttestations(1, 'invalid_proposal');
             return undefined;
         }
         // Check that the parent proposal is a block we know, otherwise reexecution would fail.
         // Q: Should we move this to the block proposal validator? If there, then p2p would check it
-        // before re-broadcasting it. This means that proposals built on top of an L1-reorgd-out block
+        // before re-broadcasting it. This means that proposals built on top of an L1-reorg'ed-out block
         // would not be rebroadcasted. But it also means that nodes that have not fully synced would
         // not rebroadcast the proposal.
         if (blockNumber > INITIAL_L2_BLOCK_NUM) {
             const parentBlock = await this.blockSource.getBlock(blockNumber - 1);
             if (parentBlock === undefined) {
                 this.log.verbose(`Parent block for ${blockNumber} not found, skipping attestation`);
-                this.metrics.incFailedAttestations('parent_block_not_found');
+                this.metrics.incFailedAttestations(1, 'parent_block_not_found');
                 return undefined;
             }
             if (!proposal.payload.header.lastArchiveRoot.equals(parentBlock.archive.root)) {
@@ -139,15 +138,16 @@ import { ValidatorMetrics } from './metrics.js';
                     parentBlockArchiveRoot: parentBlock.archive.root.toString(),
                     ...proposalInfo
                 });
-                this.metrics.incFailedAttestations('parent_block_does_not_match');
+                this.metrics.incFailedAttestations(1, 'parent_block_does_not_match');
                 return undefined;
             }
         }
         // Collect txs from the proposal
         const { missing, txs } = await this.txCollector.collectForBlockProposal(proposal, proposalSender);
-        // Check that I am in the committee before attesting
-        if (!await this.epochCache.isInCommittee(this.keyStore.getAddress())) {
-            this.log.verbose(`Not in the committee, skipping attestation`);
+        // Check that I have any address in current committee before attesting
+        const inCommittee = await this.epochCache.filterInCommittee(this.keyStore.getAddresses());
+        if (inCommittee.length === 0) {
+            this.log.verbose(`No validator in the committee, skipping attestation`);
             return undefined;
         }
         // Check that all of the transactions in the proposal are available in the tx pool before attesting
@@ -156,7 +156,7 @@ import { ValidatorMetrics } from './metrics.js';
                 proposalInfo,
                 missing
             });
-            this.metrics.incFailedAttestations('TransactionsNotAvailableError');
+            this.metrics.incFailedAttestations(1, 'TransactionsNotAvailableError');
             return undefined;
         }
         // Try re-executing the transactions in the proposal
@@ -167,14 +167,20 @@ import { ValidatorMetrics } from './metrics.js';
                 await this.reExecuteTransactions(proposal, txs);
             }
         } catch (error) {
-            this.metrics.incFailedAttestations(error instanceof Error ? error.name : 'unknown');
+            this.metrics.incFailedAttestations(1, error instanceof Error ? error.name : 'unknown');
             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);
-        this.metrics.incAttestations();
-        return this.doAttestToProposal(proposal);
+        this.metrics.incAttestations(inCommittee.length);
+        // If the above function does not throw an error, then we can attest to the proposal
+        return this.doAttestToProposal(proposal, inCommittee);
+    }
+    getReexecutionDeadline(proposal, config) {
+        const nextSlotTimestampSeconds = Number(getTimestampForSlot(proposal.slotNumber.toBigInt() + 1n, config));
+        const msNeededForPropagationAndPublishing = this.config.validatorReexecuteDeadlineMs;
+        return new Date(nextSlotTimestampSeconds * 1000 - msNeededForPropagationAndPublishing);
     }
     /**
    * Re-execute the transactions in the proposal and check that the state updates match the header state
@@ -193,11 +199,20 @@ import { ValidatorMetrics } from './metrics.js';
         }
         // Use the sequencer's block building logic to re-execute the transactions
         const stopTimer = this.metrics.reExecutionTimer();
-        const { block, numFailedTxs } = await this.blockBuilder(proposal.blockNumber, header, txs, {
-            validateOnly: true
+        const config = this.blockBuilder.getConfig();
+        const globalVariables = GlobalVariables.from({
+            ...proposal.payload.header,
+            blockNumber: proposal.blockNumber,
+            timestamp: new Fr(header.timestamp),
+            chainId: new Fr(config.l1ChainId),
+            version: new Fr(config.rollupVersion)
+        });
+        const { block, failedTxs } = await this.blockBuilder.buildBlock(txs, globalVariables, {
+            deadline: this.getReexecutionDeadline(proposal, config)
         });
         stopTimer();
         this.log.verbose(`Transaction re-execution complete`);
+        const numFailedTxs = failedTxs.length;
         if (numFailedTxs > 0) {
             this.metrics.recordFailedReexecution(proposal);
             throw new ReExFailedTxsError(numFailedTxs);
@@ -212,19 +227,18 @@ import { ValidatorMetrics } from './metrics.js';
             throw new ReExStateMismatchError();
         }
     }
-    async createBlockProposal(blockNumber, header, archive, stateReference, txs, options) {
+    async createBlockProposal(blockNumber, header, archive, stateReference, txs, proposerAddress, options) {
         if (this.previousProposal?.slotNumber.equals(header.slotNumber)) {
             this.log.verbose(`Already made a proposal for the same slot, skipping proposal`);
             return Promise.resolve(undefined);
         }
-        const newProposal = await this.validationService.createBlockProposal(blockNumber, header, archive, stateReference, txs, options);
+        const newProposal = await this.validationService.createBlockProposal(blockNumber, header, archive, stateReference, txs, proposerAddress, options);
         this.previousProposal = newProposal;
         return newProposal;
     }
     async broadcastBlockProposal(proposal) {
         await 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.slotNumber.toBigInt();
@@ -234,15 +248,17 @@ import { ValidatorMetrics } from './metrics.js';
             throw new AttestationTimeoutError(required, slot);
         }
         const proposalId = proposal.archive.toString();
-        await this.doAttestToProposal(proposal);
-        const me = this.keyStore.getAddress();
+        // adds attestations for all of my addresses locally
+        const inCommittee = await this.epochCache.filterInCommittee(this.keyStore.getAddresses());
+        await this.doAttestToProposal(proposal, inCommittee);
+        const myAddresses = this.keyStore.getAddresses();
         let attestations = [];
         while(true){
             const collectedAttestations = await this.p2pClient.getAttestationsForSlot(slot, proposalId);
             const oldSenders = attestations.map((attestation)=>attestation.getSender());
             for (const collected of collectedAttestations){
                 const collectedSender = collected.getSender();
-                if (!collectedSender.equals(me) && !oldSenders.some((sender)=>sender.equals(collectedSender))) {
+                if (!myAddresses.some((address)=>address.equals(collectedSender)) && !oldSenders.some((sender)=>sender.equals(collectedSender))) {
                     this.log.debug(`Received attestation for slot ${slot} from ${collectedSender.toString()}`);
                 }
             }
@@ -259,10 +275,10 @@ import { ValidatorMetrics } from './metrics.js';
             await sleep(this.config.attestationPollingIntervalMs);
         }
     }
-    async doAttestToProposal(proposal) {
-        const attestation = await this.validationService.attestToProposal(proposal);
-        await this.p2pClient.addAttestation(attestation);
-        return attestation;
+    async doAttestToProposal(proposal, attestors = []) {
+        const attestations = await this.validationService.attestToProposal(proposal, attestors);
+        await this.p2pClient.addAttestations(attestations);
+        return attestations;
     }
 }
 function validatePrivateKey(privateKey) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/validator-client",
-  "version": "0.87.6",
+  "version": "1.0.0-nightly.20250604",
   "main": "dest/index.js",
   "type": "module",
   "exports": {
@@ -60,13 +60,13 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "0.87.6",
-    "@aztec/epoch-cache": "0.87.6",
-    "@aztec/ethereum": "0.87.6",
-    "@aztec/foundation": "0.87.6",
-    "@aztec/p2p": "0.87.6",
-    "@aztec/stdlib": "0.87.6",
-    "@aztec/telemetry-client": "0.87.6",
+    "@aztec/constants": "1.0.0-nightly.20250604",
+    "@aztec/epoch-cache": "1.0.0-nightly.20250604",
+    "@aztec/ethereum": "1.0.0-nightly.20250604",
+    "@aztec/foundation": "1.0.0-nightly.20250604",
+    "@aztec/p2p": "1.0.0-nightly.20250604",
+    "@aztec/stdlib": "1.0.0-nightly.20250604",
+    "@aztec/telemetry-client": "1.0.0-nightly.20250604",
     "koa": "^2.16.1",
     "koa-router": "^12.0.0",
     "tslib": "^2.4.0",

package/src/config.ts

@@ -1,4 +1,3 @@
-import { NULL_KEY } from '@aztec/ethereum';
 import {
   type ConfigMappingsType,
   booleanConfigHelper,
@@ -10,8 +9,8 @@ import {
  * The Validator Configuration
  */
 export interface ValidatorClientConfig {
-  /** The private key of the validator participating in attestation duties */
-  validatorPrivateKey?: string;
+  /** The private keys of the validators participating in attestation duties */
+  validatorPrivateKeys?: `0x${string}`[];
 
   /** Do not run the validator */
   disableValidator: boolean;
@@ -21,13 +20,16 @@ export interface ValidatorClientConfig {
 
   /** Re-execute transactions before attesting */
   validatorReexecute: boolean;
+
+  /** Will re-execute until this many milliseconds are left in the slot */
+  validatorReexecuteDeadlineMs: number;
 }
 
 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',
+    parseEnv: (val: string) => val.split(',').map(key => `0x${key.replace('0x', '')}`),
+    description: 'List of private keys of the validators participating in attestation duties',
   },
   disableValidator: {
     env: 'VALIDATOR_DISABLED',
@@ -44,6 +46,11 @@ 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),
+  },
 };
 
 /**

package/src/duties/validation_service.ts

@@ -1,5 +1,6 @@
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { keccak256 } from '@aztec/foundation/crypto';
+import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { Fr } from '@aztec/foundation/fields';
 import {
   BlockAttestation,
@@ -31,9 +32,10 @@ export class ValidationService {
     archive: Fr,
     stateReference: StateReference,
     txs: Tx[],
+    proposerAttesterAddress: EthAddress,
     options: BlockProposalOptions,
   ): Promise<BlockProposal> {
-    const payloadSigner = (payload: Buffer32) => this.keyStore.signMessage(payload);
+    const payloadSigner = (payload: Buffer32) => this.keyStore.signMessageWithAddress(proposerAttesterAddress, payload);
     // TODO: check if this is calculated earlier / can not be recomputed
     const txHashes = await Promise.all(txs.map(tx => tx.getTxHash()));
 
@@ -46,21 +48,23 @@ export class ValidationService {
   }
 
   /**
-   * Attest to the given block proposal constructed by the current sequencer
+   * Attest with selection of validators 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
+   * @param attestors - The validators to attest with
+   * @returns attestations
    */
-  async attestToProposal(proposal: BlockProposal): Promise<BlockAttestation> {
-    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/7961): check that the current validator is correct
-
+  async attestToProposal(proposal: BlockProposal, attestors: EthAddress[]): Promise<BlockAttestation[]> {
     const buf = Buffer32.fromBuffer(
       keccak256(proposal.payload.getPayloadToSign(SignatureDomainSeparator.blockAttestation)),
     );
-    const sig = await this.keyStore.signMessage(buf);
-    return new BlockAttestation(proposal.blockNumber, proposal.payload, sig);
+    const signatures = await Promise.all(
+      attestors.map(attestor => this.keyStore.signMessageWithAddress(attestor, buf)),
+    );
+    //await this.keyStore.signMessage(buf);
+    return signatures.map(sig => new BlockAttestation(proposal.blockNumber, proposal.payload, sig));
   }
 }

package/src/factory.ts

@@ -2,6 +2,7 @@ import type { EpochCache } from '@aztec/epoch-cache';
 import type { DateProvider } from '@aztec/foundation/timer';
 import type { P2P } from '@aztec/p2p';
 import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { IFullNodeBlockBuilder } from '@aztec/stdlib/interfaces/server';
 import type { TelemetryClient } from '@aztec/telemetry-client';
 
 import { generatePrivateKey } from 'viem/accounts';
@@ -12,6 +13,7 @@ import { ValidatorClient } from './validator.js';
 export function createValidatorClient(
   config: ValidatorClientConfig,
   deps: {
+    blockBuilder: IFullNodeBlockBuilder;
     p2pClient: P2P;
     blockSource: L2BlockSource;
     telemetry: TelemetryClient;
@@ -22,12 +24,13 @@ export function createValidatorClient(
   if (config.disableValidator) {
     return undefined;
   }
-  if (config.validatorPrivateKey === undefined || config.validatorPrivateKey === '') {
-    config.validatorPrivateKey = generatePrivateKey();
+  if (config.validatorPrivateKeys === undefined || !config.validatorPrivateKeys?.length) {
+    config.validatorPrivateKeys = [generatePrivateKey()];
   }
 
   return ValidatorClient.new(
     config,
+    deps.blockBuilder,
     deps.epochCache,
     deps.p2pClient,
     deps.blockSource,

package/src/key_store/interface.ts

@@ -8,19 +8,29 @@ import type { Signature } from '@aztec/foundation/eth-signature';
  */
 export interface ValidatorKeyStore {
   /**
-   * Get the address of the signer
+   * Get the address of a signer by index
    *
+   * @param index - The index of the signer
    * @returns the address
    */
-  getAddress(): EthAddress;
+  getAddress(index: number): EthAddress;
 
-  sign(message: Buffer32): Promise<Signature>;
+  /**
+   * Get all addresses
+   *
+   * @returns all addresses
+   */
+  getAddresses(): EthAddress[];
+
+  sign(message: Buffer32): Promise<Signature[]>;
+  signWithAddress(address: EthAddress, 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.
+   * @returns The signatures.
    */
-  signMessage(message: Buffer32): Promise<Signature>;
+  signMessage(message: Buffer32): Promise<Signature[]>;
+  signMessageWithAddress(address: EthAddress, message: Buffer32): Promise<Signature>;
 }

package/src/key_store/local_key_store.ts

@@ -8,39 +8,85 @@ import type { ValidatorKeyStore } from './interface.js';
 /**
  * Local Key Store
  *
- * An implementation of the Key store using an in memory private key.
+ * An implementation of the Key store using in memory private keys.
  */
 export class LocalKeyStore implements ValidatorKeyStore {
-  private signer: Secp256k1Signer;
+  private signers: Secp256k1Signer[];
+  private signersByAddress: Map<`0x${string}`, Secp256k1Signer>;
 
-  constructor(privateKey: Buffer32) {
-    this.signer = new Secp256k1Signer(privateKey);
+  constructor(privateKeys: Buffer32[]) {
+    this.signers = privateKeys.map(privateKey => new Secp256k1Signer(privateKey));
+    this.signersByAddress = new Map(this.signers.map(signer => [signer.address.toString(), signer]));
   }
 
   /**
-   * Get the address of the signer
+   * Get the address of a signer by index
    *
+   * @param index - The index of the signer
    * @returns the address
    */
-  public getAddress(): EthAddress {
-    return this.signer.address;
+  public getAddress(index: number): EthAddress {
+    if (index >= this.signers.length) {
+      throw new Error(`Index ${index} is out of bounds.`);
+    }
+    return this.signers[index].address;
   }
 
   /**
-   * Sign a message with the keystore private key
+   * Get the addresses of all signers
    *
-   * @param messageBuffer - The message buffer to sign
+   * @returns the addresses
+   */
+  public getAddresses(): EthAddress[] {
+    return this.signers.map(signer => signer.address);
+  }
+
+  /**
+   * Sign a message with all keystore private keys
+   * @param digest - The message buffer to sign
    * @return signature
    */
-  public sign(digest: Buffer32): Promise<Signature> {
-    const signature = this.signer.sign(digest);
+  public sign(digest: Buffer32): Promise<Signature[]> {
+    return Promise.all(this.signers.map(signer => signer.sign(digest)));
+  }
+
+  /**
+   * Sign a message with a specific address's private key
+   * @param address - The address of the signer to use
+   * @param digest - The message buffer to sign
+   * @returns signature for the specified address
+   * @throws Error if the address is not found in the keystore
+   */
+  public signWithAddress(address: EthAddress, digest: Buffer32): Promise<Signature> {
+    const signer = this.signersByAddress.get(address.toString());
+    if (!signer) {
+      throw new Error(`No signer found for address ${address.toString()}`);
+    }
+    return Promise.resolve(signer.sign(digest));
+  }
 
-    return Promise.resolve(signature);
+  /**
+   * Sign a message with all keystore private keys
+   *
+   * @param message - The message to sign
+   * @return signatures
+   */
+  public signMessage(message: Buffer32): Promise<Signature[]> {
+    return Promise.all(this.signers.map(signer => signer.signMessage(message)));
   }
 
-  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);
+  /**
+   * Sign a message with a specific address's private key
+   * @param address - The address of the signer to use
+   * @param message - The message to sign
+   * @returns signature for the specified address
+   * @throws Error if the address is not found in the keystore
+   */
+  public signMessageWithAddress(address: EthAddress, message: Buffer32): Promise<Signature> {
+    const signer = this.signersByAddress.get(address.toString());
+    if (!signer) {
+      throw new Error(`No signer found for address ${address.toString()}`);
+    }
+    return Promise.resolve(signer.signMessage(message));
   }
 }

package/src/metrics.ts

@@ -59,12 +59,12 @@ export class ValidatorMetrics {
     });
   }
 
-  public incAttestations() {
-    this.attestationsCount.add(1);
+  public incAttestations(num: number) {
+    this.attestationsCount.add(num);
   }
 
-  public incFailedAttestations(reason: string) {
-    this.failedAttestationsCount.add(1, {
+  public incFailedAttestations(num: number, reason: string) {
+    this.failedAttestationsCount.add(num, {
       [Attributes.ERROR_TYPE]: reason,
     });
   }