@aztec/validator-client 0.87.7 → 1.0.0-nightly.20250605

package/src/validator.ts

@@ -6,12 +6,15 @@ 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, type Timer } from '@aztec/foundation/timer';
-import { type P2P, type PeerId, TxCollector } from '@aztec/p2p';
+import { DateProvider } from '@aztec/foundation/timer';
+import type { P2P, PeerId } from '@aztec/p2p';
+import { TxCollector } from '@aztec/p2p';
 import { BlockProposalValidator } from '@aztec/p2p/msg_validators';
-import type { L2Block, L2BlockSource } from '@aztec/stdlib/block';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import { getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import type { IFullNodeBlockBuilder } from '@aztec/stdlib/interfaces/server';
 import type { BlockAttestation, BlockProposal, BlockProposalOptions } from '@aztec/stdlib/p2p';
-import type { ProposedBlockHeader, StateReference, Tx } from '@aztec/stdlib/tx';
+import { GlobalVariables, type ProposedBlockHeader, type StateReference, type Tx } from '@aztec/stdlib/tx';
 import { type TelemetryClient, WithTracer, getTelemetryClient } from '@aztec/telemetry-client';
 
 import type { ValidatorClientConfig } from './config.js';
@@ -29,28 +32,9 @@ 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 = (
-  blockNumber: Fr,
-  header: ProposedBlockHeader,
-  txs: Iterable<Tx> | AsyncIterableIterator<Tx>,
-  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 responsibilities
   createBlockProposal(
@@ -59,9 +43,10 @@ export interface Validator {
     archive: Fr,
     stateReference: StateReference,
     txs: Tx[],
+    proposerAddress: EthAddress,
     options: BlockProposalOptions,
   ): Promise<BlockProposal | undefined>;
-  attestToProposal(proposal: BlockProposal, sender: PeerId): Promise<BlockAttestation | undefined>;
+  attestToProposal(proposal: BlockProposal, sender: PeerId): Promise<BlockAttestation[] | undefined>;
 
   broadcastBlockProposal(proposal: BlockProposal): Promise<void>;
   collectAttestations(proposal: BlockProposal, required: number, deadline: Date): Promise<BlockAttestation[]>;
@@ -77,10 +62,7 @@ export class ValidatorClient extends WithTracer implements Validator {
   // Used to check if we are sending the same proposal twice
   private previousProposal?: BlockProposal;
 
-  // Callback registered to: sequencer.buildBlock
-  private blockBuilder?: BlockBuilderCallback = undefined;
-
-  private myAddress: EthAddress;
+  private myAddresses: EthAddress[];
   private lastEpoch: bigint | undefined;
   private epochCacheUpdateLoop: RunningPromise;
 
@@ -88,6 +70,7 @@ export class ValidatorClient extends WithTracer implements Validator {
   private txCollector: TxCollector;
 
   constructor(
+    private blockBuilder: IFullNodeBlockBuilder,
     private keyStore: ValidatorKeyStore,
     private epochCache: EpochCache,
     private p2pClient: P2P,
@@ -108,21 +91,27 @@ export class ValidatorClient extends WithTracer implements Validator {
     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(', ')}`);
   }
 
   private 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;
       }
@@ -133,20 +122,22 @@ export class ValidatorClient extends WithTracer implements Validator {
 
   static new(
     config: ValidatorClientConfig,
+    blockBuilder: IFullNodeBlockBuilder,
     epochCache: EpochCache,
     p2pClient: P2P,
     blockSource: L2BlockSource,
     dateProvider: DateProvider = new DateProvider(),
     telemetry: TelemetryClient = getTelemetryClient(),
   ) {
-    if (!config.validatorPrivateKey) {
+    if (!config.validatorPrivateKeys?.length) {
       throw new InvalidValidatorPrivateKeyError();
     }
 
-    const privateKey = validatePrivateKey(config.validatorPrivateKey);
-    const localKeyStore = new LocalKeyStore(privateKey);
+    const privateKeys = config.validatorPrivateKeys.map(validatePrivateKey);
+    const localKeyStore = new LocalKeyStore(privateKeys);
 
     const validator = new ValidatorClient(
+      blockBuilder,
       localKeyStore,
       epochCache,
       p2pClient,
@@ -159,20 +150,25 @@ export class ValidatorClient extends WithTracer implements Validator {
     return validator;
   }
 
-  public getValidatorAddress() {
-    return this.keyStore.getAddress();
+  public getValidatorAddresses() {
+    return this.keyStore.getAddresses();
   }
 
   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`);
+    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();
@@ -183,22 +179,13 @@ export class ValidatorClient extends WithTracer implements Validator {
   }
 
   public registerBlockProposalHandler() {
-    const handler = (block: BlockProposal, proposalSender: any): Promise<BlockAttestation | undefined> => {
+    const handler = (block: BlockProposal, proposalSender: PeerId): Promise<BlockAttestation[] | undefined> => {
       return this.attestToProposal(block, proposalSender);
     };
     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, proposalSender: PeerId): Promise<BlockAttestation | undefined> {
+  async attestToProposal(proposal: BlockProposal, proposalSender: PeerId): Promise<BlockAttestation[] | undefined> {
     const slotNumber = proposal.slotNumber.toNumber();
     const blockNumber = proposal.blockNumber.toNumber();
     const proposalInfo = {
@@ -215,20 +202,20 @@ export class ValidatorClient extends WithTracer implements Validator {
     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)) {
@@ -237,7 +224,7 @@ export class ValidatorClient extends WithTracer implements Validator {
           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;
       }
     }
@@ -245,9 +232,10 @@ export class ValidatorClient extends WithTracer implements Validator {
     // 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;
     }
 
@@ -258,7 +246,7 @@ export class ValidatorClient extends WithTracer implements Validator {
         undefined,
         { proposalInfo, missing },
       );
-      this.metrics.incFailedAttestations('TransactionsNotAvailableError');
+      this.metrics.incFailedAttestations(1, 'TransactionsNotAvailableError');
       return undefined;
     }
 
@@ -270,15 +258,26 @@ export class ValidatorClient extends WithTracer implements Validator {
         await this.reExecuteTransactions(proposal, txs);
       }
     } catch (error: any) {
-      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);
+  }
+
+  private getReexecutionDeadline(
+    proposal: BlockProposal,
+    config: { l1GenesisTime: bigint; slotDuration: number },
+  ): Date {
+    const nextSlotTimestampSeconds = Number(getTimestampForSlot(proposal.slotNumber.toBigInt() + 1n, config));
+    const msNeededForPropagationAndPublishing = this.config.validatorReexecuteDeadlineMs;
+    return new Date(nextSlotTimestampSeconds * 1000 - msNeededForPropagationAndPublishing);
   }
 
   /**
@@ -302,12 +301,22 @@ export class ValidatorClient extends WithTracer implements Validator {
 
     // 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);
@@ -332,6 +341,7 @@ export class ValidatorClient extends WithTracer implements Validator {
     archive: Fr,
     stateReference: StateReference,
     txs: Tx[],
+    proposerAddress: EthAddress,
     options: BlockProposalOptions,
   ): Promise<BlockProposal | undefined> {
     if (this.previousProposal?.slotNumber.equals(header.slotNumber)) {
@@ -345,6 +355,7 @@ export class ValidatorClient extends WithTracer implements Validator {
       archive,
       stateReference,
       txs,
+      proposerAddress,
       options,
     );
     this.previousProposal = newProposal;
@@ -355,7 +366,6 @@ export class ValidatorClient extends WithTracer implements Validator {
     await 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.slotNumber.toBigInt();
@@ -369,8 +379,11 @@ export class ValidatorClient extends WithTracer implements Validator {
     }
 
     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: BlockAttestation[] = [];
     while (true) {
@@ -378,7 +391,10 @@ export class ValidatorClient extends WithTracer implements Validator {
       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()}`);
         }
       }
@@ -399,10 +415,10 @@ export class ValidatorClient extends WithTracer implements Validator {
     }
   }
 
-  private async doAttestToProposal(proposal: BlockProposal): Promise<BlockAttestation> {
-    const attestation = await this.validationService.attestToProposal(proposal);
-    await this.p2pClient.addAttestation(attestation);
-    return attestation;
+  private async doAttestToProposal(proposal: BlockProposal, attestors: EthAddress[] = []): Promise<BlockAttestation[]> {
+    const attestations = await this.validationService.attestToProposal(proposal, attestors);
+    await this.p2pClient.addAttestations(attestations);
+    return attestations;
   }
 }