@aztec/validator-client 0.0.1-commit.3469e52 → 0.0.1-commit.54489865

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,7 +12,7 @@ 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';
@@ -36,8 +36,6 @@ import { createValidatorForBlockBuilding } from './tx_validator/tx_validator_fac
 // Re-export for backward compatibility
 export type { BuildBlockInCheckpointResult } from '@aztec/stdlib/interfaces/server';
 
-const log = createLogger('checkpoint-builder');
-
 /** Result of building a block within a checkpoint. Extends the base interface with timer. */
 export interface BuildBlockInCheckpointResultWithTimer extends BuildBlockInCheckpointResult {
   blockBuildingTimer: Timer;
@@ -48,6 +46,8 @@ export interface BuildBlockInCheckpointResultWithTimer extends BuildBlockInCheck
  * and completing it.
  */
 export class CheckpointBuilder implements ICheckpointBlockBuilder {
+  private log: Logger;
+
   constructor(
     private checkpointBuilder: LightweightCheckpointBuilder,
     private fork: MerkleTreeWriteOperations,
@@ -55,7 +55,13 @@ export class CheckpointBuilder implements ICheckpointBlockBuilder {
     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;
@@ -68,12 +74,12 @@ export class CheckpointBuilder implements ICheckpointBlockBuilder {
     pendingTxs: Iterable<Tx> | AsyncIterable<Tx>,
     blockNumber: BlockNumber,
     timestamp: bigint,
-    opts: PublicProcessorLimits & { expectedEndState?: StateReference },
+    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`, {
+    this.log.verbose(`Building block ${blockNumber} for slot ${slot} within checkpoint`, {
       slot,
       blockNumber,
       ...opts,
@@ -115,7 +121,7 @@ export class CheckpointBuilder implements ICheckpointBlockBuilder {
       usedTxs,
       usedTxBlobFields,
     };
-    log.debug('Built block within checkpoint', res.block.header);
+    this.log.debug('Built block within checkpoint', res.block.header);
     return res;
   }
 
@@ -123,7 +129,7 @@ export class CheckpointBuilder implements ICheckpointBlockBuilder {
   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(),
@@ -139,14 +145,16 @@ export class CheckpointBuilder implements ICheckpointBlockBuilder {
 
   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(
@@ -156,7 +164,7 @@ export class CheckpointBuilder implements ICheckpointBlockBuilder {
       publicTxSimulator,
       this.dateProvider,
       this.telemetryClient,
-      undefined,
+      createLogger('simulator:public-processor', bindings),
       this.config,
     );
 
@@ -165,6 +173,7 @@ export class CheckpointBuilder implements ICheckpointBlockBuilder {
       this.contractDataSource,
       globalVariables,
       txPublicSetupAllowList,
+      this.log.getBindings(),
     );
 
     return {
@@ -176,13 +185,17 @@ export class CheckpointBuilder implements ICheckpointBlockBuilder {
 
 /** Factory for creating checkpoint builders. */
 export class FullNodeCheckpointsBuilder implements ICheckpointsBuilder {
+  private log: Logger;
+
   constructor(
     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;
@@ -201,11 +214,12 @@ export class FullNodeCheckpointsBuilder implements ICheckpointsBuilder {
     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(),
@@ -219,6 +233,7 @@ export class FullNodeCheckpointsBuilder implements ICheckpointsBuilder {
       l1ToL2Messages,
       previousCheckpointOutHashes,
       fork,
+      bindings,
     );
 
     return new CheckpointBuilder(
@@ -228,6 +243,7 @@ export class FullNodeCheckpointsBuilder implements ICheckpointsBuilder {
       this.contractDataSource,
       this.dateProvider,
       this.telemetryClient,
+      bindings,
     );
   }
 
@@ -240,16 +256,24 @@ export class FullNodeCheckpointsBuilder implements ICheckpointsBuilder {
     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, previousCheckpointOutHashes, 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,
@@ -265,6 +289,7 @@ export class FullNodeCheckpointsBuilder implements ICheckpointsBuilder {
       previousCheckpointOutHashes,
       fork,
       existingBlocks,
+      bindings,
     );
 
     return new CheckpointBuilder(
@@ -274,6 +299,7 @@ export class FullNodeCheckpointsBuilder implements ICheckpointsBuilder {
       this.contractDataSource,
       this.dateProvider,
       this.telemetryClient,
+      bindings,
     );
   }
 

package/src/config.ts

@@ -65,15 +65,13 @@ 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/metrics.ts

@@ -6,8 +6,11 @@ import {
   Metrics,
   type TelemetryClient,
   type UpDownCounter,
+  createUpDownCounterWithDefault,
 } from '@aztec/telemetry-client';
 
+import type { BlockProposalValidationFailureReason } from './block_proposal_handler.js';
+
 export class ValidatorMetrics {
   private failedReexecutionCounter: UpDownCounter;
   private successfulAttestationsCount: UpDownCounter;
@@ -21,16 +24,44 @@ export class ValidatorMetrics {
   constructor(telemetryClient: TelemetryClient) {
     const meter = telemetryClient.getMeter('Validator');
 
-    this.failedReexecutionCounter = meter.createUpDownCounter(Metrics.VALIDATOR_FAILED_REEXECUTION_COUNT);
+    this.failedReexecutionCounter = createUpDownCounterWithDefault(meter, Metrics.VALIDATOR_FAILED_REEXECUTION_COUNT, {
+      [Attributes.STATUS]: ['failed'],
+    });
 
-    this.successfulAttestationsCount = meter.createUpDownCounter(Metrics.VALIDATOR_ATTESTATION_SUCCESS_COUNT);
+    this.successfulAttestationsCount = createUpDownCounterWithDefault(
+      meter,
+      Metrics.VALIDATOR_ATTESTATION_SUCCESS_COUNT,
+    );
 
-    this.failedAttestationsBadProposalCount = meter.createUpDownCounter(
+    this.failedAttestationsBadProposalCount = createUpDownCounterWithDefault(
+      meter,
       Metrics.VALIDATOR_ATTESTATION_FAILED_BAD_PROPOSAL_COUNT,
+      {
+        [Attributes.ERROR_TYPE]: [
+          'invalid_proposal',
+          'state_mismatch',
+          'failed_txs',
+          'in_hash_mismatch',
+          'parent_block_wrong_slot',
+        ],
+        [Attributes.IS_COMMITTEE_MEMBER]: [true, false],
+      },
     );
 
-    this.failedAttestationsNodeIssueCount = meter.createUpDownCounter(
+    this.failedAttestationsNodeIssueCount = createUpDownCounterWithDefault(
+      meter,
       Metrics.VALIDATOR_ATTESTATION_FAILED_NODE_ISSUE_COUNT,
+      {
+        [Attributes.ERROR_TYPE]: [
+          'parent_block_not_found',
+          'global_variables_mismatch',
+          'block_number_already_exists',
+          'txs_not_available',
+          'timeout',
+          'unknown_error',
+        ],
+        [Attributes.IS_COMMITTEE_MEMBER]: [true, false],
+      },
     );
 
     this.reexMana = meter.createHistogram(Metrics.VALIDATOR_RE_EXECUTION_MANA);
@@ -58,14 +89,22 @@ export class ValidatorMetrics {
     this.successfulAttestationsCount.add(num);
   }
 
-  public incFailedAttestationsBadProposal(num: number, reason: string, inCommittee: boolean) {
+  public incFailedAttestationsBadProposal(
+    num: number,
+    reason: BlockProposalValidationFailureReason,
+    inCommittee: boolean,
+  ) {
     this.failedAttestationsBadProposalCount.add(num, {
       [Attributes.ERROR_TYPE]: reason,
       [Attributes.IS_COMMITTEE_MEMBER]: inCommittee,
     });
   }
 
-  public incFailedAttestationsNodeIssue(num: number, reason: string, inCommittee: boolean) {
+  public incFailedAttestationsNodeIssue(
+    num: number,
+    reason: BlockProposalValidationFailureReason,
+    inCommittee: boolean,
+  ) {
     this.failedAttestationsNodeIssueCount.add(num, {
       [Attributes.ERROR_TYPE]: reason,
       [Attributes.IS_COMMITTEE_MEMBER]: inCommittee,

package/src/tx_validator/tx_validator_factory.ts

@@ -1,5 +1,6 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
+import type { LoggerBindings } from '@aztec/foundation/log';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import {
   AggregateTxValidator,
@@ -53,32 +54,41 @@ export function createValidatorForAcceptingTxs(
     blockNumber: BlockNumber;
     txsPermitted: boolean;
   },
+  bindings?: LoggerBindings,
 ): TxValidator<Tx> {
   const validators: TxValidator<Tx>[] = [
-    new TxPermittedValidator(txsPermitted),
-    new SizeTxValidator(),
-    new DataTxValidator(),
-    new MetadataTxValidator({
-      l1ChainId: new Fr(l1ChainId),
-      rollupVersion: new Fr(rollupVersion),
-      protocolContractsHash,
-      vkTreeRoot: getVKTreeRoot(),
-    }),
-    new TimestampTxValidator({
-      timestamp,
-      blockNumber,
-    }),
-    new DoubleSpendTxValidator(new NullifierCache(db)),
-    new PhasesTxValidator(contractDataSource, setupAllowList, timestamp),
-    new BlockHeaderTxValidator(new ArchiveCache(db)),
+    new TxPermittedValidator(txsPermitted, bindings),
+    new SizeTxValidator(bindings),
+    new DataTxValidator(bindings),
+    new MetadataTxValidator(
+      {
+        l1ChainId: new Fr(l1ChainId),
+        rollupVersion: new Fr(rollupVersion),
+        protocolContractsHash,
+        vkTreeRoot: getVKTreeRoot(),
+      },
+      bindings,
+    ),
+    new TimestampTxValidator(
+      {
+        timestamp,
+        blockNumber,
+      },
+      bindings,
+    ),
+    new DoubleSpendTxValidator(new NullifierCache(db), bindings),
+    new PhasesTxValidator(contractDataSource, setupAllowList, timestamp, bindings),
+    new BlockHeaderTxValidator(new ArchiveCache(db), bindings),
   ];
 
   if (!skipFeeEnforcement) {
-    validators.push(new GasTxValidator(new DatabasePublicStateSource(db), ProtocolContractAddress.FeeJuice, gasFees));
+    validators.push(
+      new GasTxValidator(new DatabasePublicStateSource(db), ProtocolContractAddress.FeeJuice, gasFees, bindings),
+    );
   }
 
   if (verifier) {
-    validators.push(new TxProofValidator(verifier));
+    validators.push(new TxProofValidator(verifier, bindings));
   }
 
   return new AggregateTxValidator(...validators);
@@ -89,6 +99,7 @@ export function createValidatorForBlockBuilding(
   contractDataSource: ContractDataSource,
   globalVariables: GlobalVariables,
   setupAllowList: AllowedElement[],
+  bindings?: LoggerBindings,
 ): PublicProcessorValidator {
   const nullifierCache = new NullifierCache(db);
   const archiveCache = new ArchiveCache(db);
@@ -102,6 +113,7 @@ export function createValidatorForBlockBuilding(
       contractDataSource,
       globalVariables,
       setupAllowList,
+      bindings,
     ),
     nullifierCache,
   };
@@ -114,22 +126,29 @@ function preprocessValidator(
   contractDataSource: ContractDataSource,
   globalVariables: GlobalVariables,
   setupAllowList: AllowedElement[],
+  bindings?: LoggerBindings,
 ): TxValidator<Tx> {
   // We don't include the TxProofValidator nor the DataTxValidator here because they are already checked by the time we get to block building.
   return new AggregateTxValidator(
-    new MetadataTxValidator({
-      l1ChainId: globalVariables.chainId,
-      rollupVersion: globalVariables.version,
-      protocolContractsHash,
-      vkTreeRoot: getVKTreeRoot(),
-    }),
-    new TimestampTxValidator({
-      timestamp: globalVariables.timestamp,
-      blockNumber: globalVariables.blockNumber,
-    }),
-    new DoubleSpendTxValidator(nullifierCache),
-    new PhasesTxValidator(contractDataSource, setupAllowList, globalVariables.timestamp),
-    new GasTxValidator(publicStateSource, ProtocolContractAddress.FeeJuice, globalVariables.gasFees),
-    new BlockHeaderTxValidator(archiveCache),
+    new MetadataTxValidator(
+      {
+        l1ChainId: globalVariables.chainId,
+        rollupVersion: globalVariables.version,
+        protocolContractsHash,
+        vkTreeRoot: getVKTreeRoot(),
+      },
+      bindings,
+    ),
+    new TimestampTxValidator(
+      {
+        timestamp: globalVariables.timestamp,
+        blockNumber: globalVariables.blockNumber,
+      },
+      bindings,
+    ),
+    new DoubleSpendTxValidator(nullifierCache, bindings),
+    new PhasesTxValidator(contractDataSource, setupAllowList, globalVariables.timestamp, bindings),
+    new GasTxValidator(publicStateSource, ProtocolContractAddress.FeeJuice, globalVariables.gasFees, bindings),
+    new BlockHeaderTxValidator(archiveCache, bindings),
   );
 }

package/src/validator.ts

@@ -18,19 +18,20 @@ import { RunningPromise } from '@aztec/foundation/running-promise';
 import { sleep } from '@aztec/foundation/sleep';
 import { DateProvider } from '@aztec/foundation/timer';
 import type { KeystoreManager } from '@aztec/node-keystore';
-import type { P2P, PeerId, TxProvider } from '@aztec/p2p';
+import type { P2P, PeerId } from '@aztec/p2p';
 import { AuthRequest, AuthResponse, BlockProposalValidator, ReqRespSubProtocol } from '@aztec/p2p';
 import { OffenseType, WANT_TO_SLASH_EVENT, type Watcher, type WatcherEmitter } from '@aztec/slasher';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { CommitteeAttestationsAndSigners, L2BlockNew, L2BlockSink, L2BlockSource } from '@aztec/stdlib/block';
+import type { CommitteeAttestationsAndSigners, L2Block, L2BlockSink, L2BlockSource } from '@aztec/stdlib/block';
 import { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
 import type {
   CreateCheckpointProposalLastBlockData,
+  ITxProvider,
   Validator,
   ValidatorClientFullConfig,
   WorldStateSynchronizer,
 } from '@aztec/stdlib/interfaces/server';
-import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import { type L1ToL2MessageSource, accumulateCheckpointOutHashes } from '@aztec/stdlib/messaging';
 import type {
   BlockProposal,
   BlockProposalOptions,
@@ -87,11 +88,6 @@ export class ValidatorClient extends (EventEmitter as new () => WatcherEmitter)
 
   private proposersOfInvalidBlocks: Set<string> = new Set();
 
-  // TODO(palla/mbps): Remove this once checkpoint validation is stable and we can validate all blocks properly.
-  // Tracks slots for which we have successfully validated a block proposal, so we can attest to checkpoint proposals for those slots.
-  // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
-  private validatedBlockSlots: Set<SlotNumber> = new Set();
-
   protected constructor(
     private keyStore: ExtendedValidatorKeyStore,
     private epochCache: EpochCache,
@@ -184,7 +180,7 @@ export class ValidatorClient extends (EventEmitter as new () => WatcherEmitter)
     p2pClient: P2P,
     blockSource: L2BlockSource & L2BlockSink,
     l1ToL2MessageSource: L1ToL2MessageSource,
-    txProvider: TxProvider,
+    txProvider: ITxProvider,
     keyStoreManager: KeystoreManager,
     blobClient: BlobClientInterface,
     dateProvider: DateProvider = new DateProvider(),
@@ -413,10 +409,6 @@ export class ValidatorClient extends (EventEmitter as new () => WatcherEmitter)
       return false;
     }
 
-    // TODO(palla/mbps): Remove this once checkpoint validation is stable.
-    // Track that we successfully validated a block for this slot, so we can attest to checkpoint proposals for it.
-    this.validatedBlockSlots.add(slotNumber);
-
     return true;
   }
 
@@ -461,17 +453,9 @@ export class ValidatorClient extends (EventEmitter as new () => WatcherEmitter)
       fishermanMode: this.config.fishermanMode || false,
     });
 
-    // TODO(palla/mbps): Remove this once checkpoint validation is stable.
-    // Check that we have successfully validated a block for this slot before attesting to the checkpoint.
-    if (!this.validatedBlockSlots.has(slotNumber)) {
-      this.log.warn(`No validated block found for slot ${slotNumber}, refusing to attest to checkpoint`, proposalInfo);
-      return undefined;
-    }
-
     // Validate the checkpoint proposal before attesting (unless skipCheckpointProposalValidation is set)
-    // TODO(palla/mbps): Change default to false once checkpoint validation is stable.
-    if (this.config.skipCheckpointProposalValidation !== false) {
-      this.log.verbose(`Skipping checkpoint proposal validation for slot ${slotNumber}`, proposalInfo);
+    if (this.config.skipCheckpointProposalValidation) {
+      this.log.warn(`Skipping checkpoint proposal validation for slot ${slotNumber}`, proposalInfo);
     } else {
       const validationResult = await this.validateCheckpointProposal(proposal, proposalInfo);
       if (!validationResult.isValid) {
@@ -547,7 +531,7 @@ export class ValidatorClient extends (EventEmitter as new () => WatcherEmitter)
     proposalInfo: LogData,
   ): Promise<{ isValid: true } | { isValid: false; reason: string }> {
     const slot = proposal.slotNumber;
-    const timeoutSeconds = 10;
+    const timeoutSeconds = 10; // TODO(palla/mbps): This should map to the timetable settings
 
     // Wait for last block to sync by archive
     let lastBlockHeader: BlockHeader | undefined;
@@ -617,6 +601,7 @@ export class ValidatorClient extends (EventEmitter as new () => WatcherEmitter)
         previousCheckpointOutHashes,
         fork,
         blocks,
+        this.log.getBindings(),
       );
 
       // Complete the checkpoint to get computed values
@@ -642,13 +627,17 @@ export class ValidatorClient extends (EventEmitter as new () => WatcherEmitter)
         return { isValid: false, reason: 'archive_mismatch' };
       }
 
-      // Check that the accumulated out hash matches the value in the proposal.
-      const computedOutHash = computedCheckpoint.getCheckpointOutHash();
-      const proposalOutHash = proposal.checkpointHeader.epochOutHash;
-      if (!computedOutHash.equals(proposalOutHash)) {
+      // Check that the accumulated epoch out hash matches the value in the proposal.
+      // The epoch out hash is the accumulated hash of all checkpoint out hashes in the epoch.
+      const checkpointOutHash = computedCheckpoint.getCheckpointOutHash();
+      const computedEpochOutHash = accumulateCheckpointOutHashes([...previousCheckpointOutHashes, checkpointOutHash]);
+      const proposalEpochOutHash = proposal.checkpointHeader.epochOutHash;
+      if (!computedEpochOutHash.equals(proposalEpochOutHash)) {
         this.log.warn(`Epoch out hash mismatch`, {
-          proposalOutHash: proposalOutHash.toString(),
-          computedOutHash: computedOutHash.toString(),
+          proposalEpochOutHash: proposalEpochOutHash.toString(),
+          computedEpochOutHash: computedEpochOutHash.toString(),
+          checkpointOutHash: checkpointOutHash.toString(),
+          previousCheckpointOutHashes: previousCheckpointOutHashes.map(h => h.toString()),
           ...proposalInfo,
         });
         return { isValid: false, reason: 'out_hash_mismatch' };
@@ -664,7 +653,7 @@ export class ValidatorClient extends (EventEmitter as new () => WatcherEmitter)
   /**
    * Extract checkpoint global variables from a block.
    */
-  private extractCheckpointConstants(block: L2BlockNew): CheckpointGlobalVariables {
+  private extractCheckpointConstants(block: L2Block): CheckpointGlobalVariables {
     const gv = block.header.globalVariables;
     return {
       chainId: gv.chainId,
@@ -739,7 +728,7 @@ export class ValidatorClient extends (EventEmitter as new () => WatcherEmitter)
     archive: Fr,
     txs: Tx[],
     proposerAddress: EthAddress | undefined,
-    options: BlockProposalOptions,
+    options: BlockProposalOptions = {},
   ): Promise<BlockProposal> {
     // TODO(palla/mbps): Prevent double proposals properly
     // if (this.previousProposal?.slotNumber === blockHeader.globalVariables.slotNumber) {
@@ -771,7 +760,7 @@ export class ValidatorClient extends (EventEmitter as new () => WatcherEmitter)
     archive: Fr,
     lastBlockInfo: CreateCheckpointProposalLastBlockData | undefined,
     proposerAddress: EthAddress | undefined,
-    options: CheckpointProposalOptions,
+    options: CheckpointProposalOptions = {},
   ): Promise<CheckpointProposal> {
     this.log.info(`Assembling checkpoint proposal for slot ${checkpointHeader.slotNumber}`);
     return await this.validationService.createCheckpointProposal(