@aztec/validator-client 0.0.1-commit.1142ef1 → 0.0.1-commit.18ccd8f0

package/src/checkpoint_builder.ts

@@ -1,7 +1,7 @@
 import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import { merge, pick } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { bufferToHex } from '@aztec/foundation/string';
 import { DateProvider, Timer, elapsed } from '@aztec/foundation/timer';
 import { getDefaultAllowedSetupFunctions } from '@aztec/p2p/msg_validators';
@@ -12,39 +12,42 @@ import {
   PublicProcessor,
   createPublicTxSimulatorForBlockBuilding,
 } from '@aztec/simulator/server';
-import { L2BlockNew } from '@aztec/stdlib/block';
+import { L2Block } from '@aztec/stdlib/block';
 import { Checkpoint } from '@aztec/stdlib/checkpoint';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
+import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import { Gas } from '@aztec/stdlib/gas';
 import {
+  type BuildBlockInCheckpointResult,
   type FullNodeBlockBuilderConfig,
   FullNodeBlockBuilderConfigKeys,
+  type ICheckpointBlockBuilder,
+  type ICheckpointsBuilder,
   type MerkleTreeWriteOperations,
   type PublicProcessorLimits,
+  type WorldStateSynchronizer,
 } from '@aztec/stdlib/interfaces/server';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
-import { type CheckpointGlobalVariables, type FailedTx, GlobalVariables, StateReference, Tx } from '@aztec/stdlib/tx';
+import { type CheckpointGlobalVariables, GlobalVariables, StateReference, Tx } from '@aztec/stdlib/tx';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import { createValidatorForBlockBuilding } from './tx_validator/tx_validator_factory.js';
 
-const log = createLogger('checkpoint-builder');
+// Re-export for backward compatibility
+export type { BuildBlockInCheckpointResult } from '@aztec/stdlib/interfaces/server';
 
-export interface BuildBlockInCheckpointResult {
-  block: L2BlockNew;
-  publicGas: Gas;
-  publicProcessorDuration: number;
-  numTxs: number;
-  failedTxs: FailedTx[];
+/** Result of building a block within a checkpoint. Extends the base interface with timer. */
+export interface BuildBlockInCheckpointResultWithTimer extends BuildBlockInCheckpointResult {
   blockBuildingTimer: Timer;
-  usedTxs: Tx[];
 }
 
 /**
  * Builder for a single checkpoint. Handles building blocks within the checkpoint
  * and completing it.
  */
-export class CheckpointBuilder {
+export class CheckpointBuilder implements ICheckpointBlockBuilder {
+  private log: Logger;
+
   constructor(
     private checkpointBuilder: LightweightCheckpointBuilder,
     private fork: MerkleTreeWriteOperations,
@@ -52,7 +55,13 @@ export class CheckpointBuilder {
     private contractDataSource: ContractDataSource,
     private dateProvider: DateProvider,
     private telemetryClient: TelemetryClient,
-  ) {}
+    bindings?: LoggerBindings,
+  ) {
+    this.log = createLogger('checkpoint-builder', {
+      ...bindings,
+      instanceId: `checkpoint-${checkpointBuilder.checkpointNumber}`,
+    });
+  }
 
   getConstantData(): CheckpointGlobalVariables {
     return this.checkpointBuilder.constants;
@@ -65,12 +74,17 @@ export class CheckpointBuilder {
     pendingTxs: Iterable<Tx> | AsyncIterable<Tx>,
     blockNumber: BlockNumber,
     timestamp: bigint,
-    opts: PublicProcessorLimits & { expectedEndState?: StateReference },
-  ): Promise<BuildBlockInCheckpointResult> {
+    opts: PublicProcessorLimits & { expectedEndState?: StateReference } = {},
+  ): Promise<BuildBlockInCheckpointResultWithTimer> {
     const blockBuildingTimer = new Timer();
     const slot = this.checkpointBuilder.constants.slotNumber;
 
-    log.verbose(`Building block ${blockNumber} for slot ${slot} within checkpoint`, { slot, blockNumber, ...opts });
+    this.log.verbose(`Building block ${blockNumber} for slot ${slot} within checkpoint`, {
+      slot,
+      blockNumber,
+      ...opts,
+      currentTime: new Date(this.dateProvider.now()),
+    });
 
     const constants = this.checkpointBuilder.constants;
     const globalVariables = GlobalVariables.from({
@@ -85,7 +99,7 @@ export class CheckpointBuilder {
     });
     const { processor, validator } = await this.makeBlockBuilderDeps(globalVariables, this.fork);
 
-    const [publicProcessorDuration, [processedTxs, failedTxs, usedTxs]] = await elapsed(() =>
+    const [publicProcessorDuration, [processedTxs, failedTxs, usedTxs, _, usedTxBlobFields]] = await elapsed(() =>
       processor.process(pendingTxs, opts, validator),
     );
 
@@ -105,8 +119,9 @@ export class CheckpointBuilder {
       failedTxs,
       blockBuildingTimer,
       usedTxs,
+      usedTxBlobFields,
     };
-    log.debug('Built block within checkpoint', res.block.header);
+    this.log.debug('Built block within checkpoint', res.block.header);
     return res;
   }
 
@@ -114,7 +129,7 @@ export class CheckpointBuilder {
   async completeCheckpoint(): Promise<Checkpoint> {
     const checkpoint = await this.checkpointBuilder.completeCheckpoint();
 
-    log.verbose(`Completed checkpoint ${checkpoint.number}`, {
+    this.log.verbose(`Completed checkpoint ${checkpoint.number}`, {
       checkpointNumber: checkpoint.number,
       numBlocks: checkpoint.blocks.length,
       archiveRoot: checkpoint.archive.root.toString(),
@@ -130,14 +145,16 @@ export class CheckpointBuilder {
 
   protected async makeBlockBuilderDeps(globalVariables: GlobalVariables, fork: MerkleTreeWriteOperations) {
     const txPublicSetupAllowList = this.config.txPublicSetupAllowList ?? (await getDefaultAllowedSetupFunctions());
-    const contractsDB = new PublicContractsDB(this.contractDataSource);
+    const contractsDB = new PublicContractsDB(this.contractDataSource, this.log.getBindings());
     const guardedFork = new GuardedMerkleTreeOperations(fork);
 
+    const bindings = this.log.getBindings();
     const publicTxSimulator = createPublicTxSimulatorForBlockBuilding(
       guardedFork,
       contractsDB,
       globalVariables,
       this.telemetryClient,
+      bindings,
     );
 
     const processor = new PublicProcessor(
@@ -147,7 +164,7 @@ export class CheckpointBuilder {
       publicTxSimulator,
       this.dateProvider,
       this.telemetryClient,
-      undefined,
+      createLogger('simulator:public-processor', bindings),
       this.config,
     );
 
@@ -156,6 +173,7 @@ export class CheckpointBuilder {
       this.contractDataSource,
       globalVariables,
       txPublicSetupAllowList,
+      this.log.getBindings(),
     );
 
     return {
@@ -165,16 +183,19 @@ export class CheckpointBuilder {
   }
 }
 
-/**
- * Factory for creating checkpoint builders.
- */
-export class FullNodeCheckpointsBuilder {
+/** Factory for creating checkpoint builders. */
+export class FullNodeCheckpointsBuilder implements ICheckpointsBuilder {
+  private log: Logger;
+
   constructor(
-    private config: FullNodeBlockBuilderConfig,
+    private config: FullNodeBlockBuilderConfig & Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'>,
+    private worldState: WorldStateSynchronizer,
     private contractDataSource: ContractDataSource,
     private dateProvider: DateProvider,
     private telemetryClient: TelemetryClient = getTelemetryClient(),
-  ) {}
+  ) {
+    this.log = createLogger('checkpoint-builder');
+  }
 
   public getConfig(): FullNodeBlockBuilderConfig {
     return this.config;
@@ -191,12 +212,14 @@ export class FullNodeCheckpointsBuilder {
     checkpointNumber: CheckpointNumber,
     constants: CheckpointGlobalVariables,
     l1ToL2Messages: Fr[],
+    previousCheckpointOutHashes: Fr[],
     fork: MerkleTreeWriteOperations,
+    bindings?: LoggerBindings,
   ): Promise<CheckpointBuilder> {
     const stateReference = await fork.getStateReference();
     const archiveTree = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
 
-    log.verbose(`Building new checkpoint ${checkpointNumber}`, {
+    this.log.verbose(`Building new checkpoint ${checkpointNumber}`, {
       checkpointNumber,
       msgCount: l1ToL2Messages.length,
       initialStateReference: stateReference.toInspect(),
@@ -208,7 +231,9 @@ export class FullNodeCheckpointsBuilder {
       checkpointNumber,
       constants,
       l1ToL2Messages,
+      previousCheckpointOutHashes,
       fork,
+      bindings,
     );
 
     return new CheckpointBuilder(
@@ -218,6 +243,7 @@ export class FullNodeCheckpointsBuilder {
       this.contractDataSource,
       this.dateProvider,
       this.telemetryClient,
+      bindings,
     );
   }
 
@@ -228,17 +254,26 @@ export class FullNodeCheckpointsBuilder {
     checkpointNumber: CheckpointNumber,
     constants: CheckpointGlobalVariables,
     l1ToL2Messages: Fr[],
+    previousCheckpointOutHashes: Fr[],
     fork: MerkleTreeWriteOperations,
-    existingBlocks: L2BlockNew[] = [],
+    existingBlocks: L2Block[] = [],
+    bindings?: LoggerBindings,
   ): Promise<CheckpointBuilder> {
     const stateReference = await fork.getStateReference();
     const archiveTree = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
 
     if (existingBlocks.length === 0) {
-      return this.startCheckpoint(checkpointNumber, constants, l1ToL2Messages, fork);
+      return this.startCheckpoint(
+        checkpointNumber,
+        constants,
+        l1ToL2Messages,
+        previousCheckpointOutHashes,
+        fork,
+        bindings,
+      );
     }
 
-    log.verbose(`Resuming checkpoint ${checkpointNumber} with ${existingBlocks.length} existing blocks`, {
+    this.log.verbose(`Resuming checkpoint ${checkpointNumber} with ${existingBlocks.length} existing blocks`, {
       checkpointNumber,
       msgCount: l1ToL2Messages.length,
       existingBlockCount: existingBlocks.length,
@@ -251,8 +286,10 @@ export class FullNodeCheckpointsBuilder {
       checkpointNumber,
       constants,
       l1ToL2Messages,
+      previousCheckpointOutHashes,
       fork,
       existingBlocks,
+      bindings,
     );
 
     return new CheckpointBuilder(
@@ -262,6 +299,12 @@ export class FullNodeCheckpointsBuilder {
       this.contractDataSource,
       this.dateProvider,
       this.telemetryClient,
+      bindings,
     );
   }
+
+  /** Returns a fork of the world state at the given block number. */
+  getFork(blockNumber: BlockNumber): Promise<MerkleTreeWriteOperations> {
+    return this.worldState.fork(blockNumber);
+  }
 }

package/src/config.ts

@@ -7,6 +7,7 @@ import {
 } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { ValidatorClientConfig } from '@aztec/stdlib/interfaces/server';
+import { validatorHASignerConfigMappings } from '@aztec/validator-ha-signer/config';
 
 export type { ValidatorClientConfig };
 
@@ -53,16 +54,10 @@ export const validatorClientConfigMappings: ConfigMappingsType<ValidatorClientCo
     description: 'Re-execute transactions before attesting',
     ...booleanConfigHelper(true),
   },
-  validatorReexecuteDeadlineMs: {
-    env: 'VALIDATOR_REEXECUTE_DEADLINE_MS',
-    description: 'Will re-execute until this many milliseconds are left in the slot',
-    ...numberConfigHelper(6000),
-  },
   alwaysReexecuteBlockProposals: {
-    env: 'ALWAYS_REEXECUTE_BLOCK_PROPOSALS',
     description:
       'Whether to always reexecute block proposals, even for non-validator nodes (useful for monitoring network status).',
-    ...booleanConfigHelper(false),
+    defaultValue: true,
   },
   fishermanMode: {
     env: 'FISHERMAN_MODE',
@@ -70,16 +65,15 @@ export const validatorClientConfigMappings: ConfigMappingsType<ValidatorClientCo
       'Whether to run in fisherman mode: validates all proposals and attestations but does not broadcast attestations or participate in consensus.',
     ...booleanConfigHelper(false),
   },
-  // TODO(palla/mbps): Change default to false once checkpoint validation is stable
   skipCheckpointProposalValidation: {
-    description: 'Skip checkpoint proposal validation and always attest (default: true)',
-    defaultValue: true,
+    description: 'Skip checkpoint proposal validation and always attest (default: false)',
+    defaultValue: false,
   },
-  // TODO(palla/mbps): Change default to false once block sync is stable
   skipPushProposedBlocksToArchiver: {
-    description: 'Skip pushing re-executed blocks to archiver (default: true)',
-    defaultValue: true,
+    description: 'Skip pushing re-executed blocks to archiver (default: false)',
+    defaultValue: false,
   },
+  ...validatorHASignerConfigMappings,
 };
 
 /**

package/src/duties/validation_service.ts

@@ -1,3 +1,9 @@
+import {
+  BlockNumber,
+  type CheckpointNumber,
+  IndexWithinCheckpoint,
+  type SlotNumber,
+} from '@aztec/foundation/branded-types';
 import { Buffer32 } from '@aztec/foundation/buffer';
 import { keccak256 } from '@aztec/foundation/crypto/keccak';
 import { Fr } from '@aztec/foundation/curves/bn254';
@@ -18,6 +24,8 @@ import {
 } from '@aztec/stdlib/p2p';
 import type { CheckpointHeader } from '@aztec/stdlib/rollup';
 import type { BlockHeader, Tx } from '@aztec/stdlib/tx';
+import { DutyAlreadySignedError, SlashingProtectionError } from '@aztec/validator-ha-signer/errors';
+import { DutyType, type SigningContext } from '@aztec/validator-ha-signer/types';
 
 import type { ValidatorKeyStore } from '../key_store/interface.js';
 
@@ -31,34 +39,40 @@ export class ValidationService {
    * Create a block proposal with the given header, archive, and transactions
    *
    * @param blockHeader - The block header
-   * @param indexWithinCheckpoint - Index of this block within the checkpoint (0-indexed)
+   * @param blockIndexWithinCheckpoint - The block index within checkpoint for HA signing context
    * @param inHash - Hash of L1 to L2 messages for this checkpoint
    * @param archive - The archive of the current block
-   * @param txs - TxHash[] ordered list of transactions
+   * @param txs - Ordered list of transactions (Tx[])
+   * @param proposerAttesterAddress - The address of the proposer/attester, or undefined
    * @param options - Block proposal options (including broadcastInvalidBlockProposal for testing)
    *
    * @returns A block proposal signing the above information
+   * @throws DutyAlreadySignedError if HA signer indicates duty already signed by another node
+   * @throws SlashingProtectionError if attempting to sign different data for same slot
    */
   public createBlockProposal(
     blockHeader: BlockHeader,
-    indexWithinCheckpoint: number,
+    blockIndexWithinCheckpoint: IndexWithinCheckpoint,
     inHash: Fr,
     archive: Fr,
     txs: Tx[],
     proposerAttesterAddress: EthAddress | undefined,
     options: BlockProposalOptions,
   ): Promise<BlockProposal> {
-    const payloadSigner = this.getPayloadSigner(proposerAttesterAddress);
-
     // For testing: change the new archive to trigger state_mismatch validation failure
     if (options.broadcastInvalidBlockProposal) {
       archive = Fr.random();
       this.log.warn(`Creating INVALID block proposal for slot ${blockHeader.globalVariables.slotNumber}`);
     }
 
+    // Create a signer that uses the appropriate address
+    const address = proposerAttesterAddress ?? this.keyStore.getAddress(0);
+    const payloadSigner = (payload: Buffer32, context: SigningContext) =>
+      this.keyStore.signMessageWithAddress(address, payload, context);
+
     return BlockProposal.createProposalFromSigner(
       blockHeader,
-      indexWithinCheckpoint,
+      blockIndexWithinCheckpoint,
       inHash,
       archive,
       txs.map(tx => tx.getTxHash()),
@@ -85,14 +99,18 @@ export class ValidationService {
     proposerAttesterAddress: EthAddress | undefined,
     options: CheckpointProposalOptions,
   ): Promise<CheckpointProposal> {
-    const payloadSigner = this.getPayloadSigner(proposerAttesterAddress);
-
     // For testing: change the archive to trigger state_mismatch validation failure
     if (options.broadcastInvalidCheckpointProposal) {
       archive = Fr.random();
       this.log.warn(`Creating INVALID checkpoint proposal for slot ${checkpointHeader.slotNumber}`);
     }
 
+    // Create a signer that takes payload and context, and uses the appropriate address
+    const payloadSigner = (payload: Buffer32, context: SigningContext) => {
+      const address = proposerAttesterAddress ?? this.keyStore.getAddress(0);
+      return this.keyStore.signMessageWithAddress(address, payload, context);
+    };
+
     // Last block to include in the proposal
     const lastBlock = lastBlockInfo && {
       blockHeader: lastBlockInfo.blockHeader,
@@ -104,16 +122,6 @@ export class ValidationService {
     return CheckpointProposal.createProposalFromSigner(checkpointHeader, archive, lastBlock, payloadSigner);
   }
 
-  private getPayloadSigner(proposerAttesterAddress: EthAddress | undefined): (payload: Buffer32) => Promise<Signature> {
-    if (proposerAttesterAddress !== undefined) {
-      return (payload: Buffer32) => this.keyStore.signMessageWithAddress(proposerAttesterAddress, payload);
-    } else {
-      // if there is no proposer attester address, just use the first signer
-      const signer = this.keyStore.getAddress(0);
-      return (payload: Buffer32) => this.keyStore.signMessageWithAddress(signer, payload);
-    }
-  }
-
   /**
    * Attest with selection of validators to the given checkpoint proposal
    *
@@ -133,19 +141,79 @@ export class ValidationService {
     const buf = Buffer32.fromBuffer(
       keccak256(payload.getPayloadToSign(SignatureDomainSeparator.checkpointAttestation)),
     );
-    const signatures = await Promise.all(
-      attestors.map(attestor => this.keyStore.signMessageWithAddress(attestor, buf)),
+
+    // TODO(spy/ha): Use checkpointNumber instead of blockNumber once CheckpointHeader includes it.
+    // Currently using lastBlock.blockNumber as a proxy for checkpoint identification in HA signing.
+    // blockNumber is NOT used for the primary key so it's safe to use here.
+    // See CheckpointHeader TODO and SigningContext types documentation.
+    let blockNumber: BlockNumber;
+    try {
+      blockNumber = proposal.blockNumber;
+    } catch {
+      // Checkpoint proposal may not have lastBlock, use 0 as fallback
+      blockNumber = BlockNumber(0);
+    }
+    const context: SigningContext = {
+      slot: proposal.slotNumber,
+      blockNumber,
+      dutyType: DutyType.ATTESTATION,
+    };
+
+    // Sign each attestor in parallel, catching HA errors per-attestor
+    const results = await Promise.allSettled(
+      attestors.map(async attestor => {
+        const sig = await this.keyStore.signMessageWithAddress(attestor, buf, context);
+        // return new BlockAttestation(proposal.payload, sig, proposal.signature);
+        return new CheckpointAttestation(payload, sig, proposal.signature);
+      }),
     );
-    return signatures.map(sig => new CheckpointAttestation(payload, sig, proposal.signature));
+
+    const attestations: CheckpointAttestation[] = [];
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      if (result.status === 'fulfilled') {
+        attestations.push(result.value);
+      } else {
+        const error = result.reason;
+        if (error instanceof DutyAlreadySignedError || error instanceof SlashingProtectionError) {
+          this.log.info(
+            `Attestation for slot ${proposal.slotNumber} by ${attestors[i]} already signed by another High-Availability node`,
+          );
+          // Continue with remaining attestors
+        } else {
+          throw error;
+        }
+      }
+    }
+
+    return attestations;
   }
 
-  async signAttestationsAndSigners(
+  /**
+   * Sign attestations and signers payload
+   * @param attestationsAndSigners - The attestations and signers to sign
+   * @param proposer - The proposer address to sign with
+   * @param slot - The slot number for HA signing context
+   * @param blockNumber - The block or checkpoint number for HA signing context
+   * @returns signature
+   * @throws DutyAlreadySignedError if already signed by another HA node
+   * @throws SlashingProtectionError if attempting to sign different data for same slot
+   */
+  signAttestationsAndSigners(
     attestationsAndSigners: CommitteeAttestationsAndSigners,
     proposer: EthAddress,
+    slot: SlotNumber,
+    blockNumber: BlockNumber | CheckpointNumber,
   ): Promise<Signature> {
+    const context: SigningContext = {
+      slot,
+      blockNumber,
+      dutyType: DutyType.ATTESTATIONS_AND_SIGNERS,
+    };
+
     const buf = Buffer32.fromBuffer(
       keccak256(attestationsAndSigners.getPayloadToSign(SignatureDomainSeparator.attestationsAndSigners)),
     );
-    return await this.keyStore.signMessageWithAddress(proposer, buf);
+    return this.keyStore.signMessageWithAddress(proposer, buf, context);
   }
 }

package/src/factory.ts

@@ -37,6 +37,7 @@ export function createBlockProposalHandler(
     deps.l1ToL2MessageSource,
     deps.p2pClient.getTxProvider(),
     blockProposalValidator,
+    deps.epochCache,
     config,
     metrics,
     deps.dateProvider,