@aztec/validator-client 0.0.1-commit.7d4e6cd → 0.0.1-commit.8227e42

package/src/block_proposal_handler.ts

@@ -1,4 +1,5 @@
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import type { EpochCache } from '@aztec/epoch-cache';
 import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { TimeoutError } from '@aztec/foundation/error';
@@ -6,14 +7,13 @@ import { createLogger } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
 import { DateProvider, Timer } from '@aztec/foundation/timer';
 import type { P2P, PeerId } from '@aztec/p2p';
-import { TxProvider } from '@aztec/p2p';
 import { BlockProposalValidator } from '@aztec/p2p/msg_validators';
-import type { L2BlockNew, L2BlockSink, L2BlockSource } from '@aztec/stdlib/block';
-import { getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
-import type { ValidatorClientFullConfig, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import type { BlockData, L2Block, L2BlockSink, L2BlockSource } from '@aztec/stdlib/block';
+import { getEpochAtSlot, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import type { ITxProvider, ValidatorClientFullConfig, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import { type L1ToL2MessageSource, computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
 import type { BlockProposal } from '@aztec/stdlib/p2p';
-import { BlockHeader, type CheckpointGlobalVariables, type FailedTx, type Tx } from '@aztec/stdlib/tx';
+import type { CheckpointGlobalVariables, FailedTx, Tx } from '@aztec/stdlib/tx';
 import {
   ReExFailedTxsError,
   ReExStateMismatchError,
@@ -39,7 +39,7 @@ export type BlockProposalValidationFailureReason =
   | 'unknown_error';
 
 type ReexecuteTransactionsResult = {
-  block: L2BlockNew;
+  block: L2Block;
   failedTxs: FailedTx[];
   reexecutionTimeMs: number;
   totalManaUsed: number;
@@ -72,8 +72,9 @@ export class BlockProposalHandler {
     private worldState: WorldStateSynchronizer,
     private blockSource: L2BlockSource & L2BlockSink,
     private l1ToL2MessageSource: L1ToL2MessageSource,
-    private txProvider: TxProvider,
+    private txProvider: ITxProvider,
     private blockProposalValidator: BlockProposalValidator,
+    private epochCache: EpochCache,
     private config: ValidatorClientFullConfig,
     private metrics?: ValidatorMetrics,
     private dateProvider: DateProvider = new DateProvider(),
@@ -140,23 +141,23 @@ export class BlockProposalHandler {
 
     // Check that the proposal is from the current proposer, or the next proposer
     // This should have been handled by the p2p layer, but we double check here out of caution
-    const invalidProposal = await this.blockProposalValidator.validate(proposal);
-    if (invalidProposal) {
+    const validationResult = await this.blockProposalValidator.validate(proposal);
+    if (validationResult.result !== 'accept') {
       this.log.warn(`Proposal is not valid, skipping processing`, proposalInfo);
       return { isValid: false, reason: 'invalid_proposal' };
     }
 
     // Check that the parent proposal is a block we know, otherwise reexecution would fail
-    const parentBlockHeader = await this.getParentBlock(proposal);
-    if (parentBlockHeader === undefined) {
+    const parentBlock = await this.getParentBlock(proposal);
+    if (parentBlock === undefined) {
       this.log.warn(`Parent block for proposal not found, skipping processing`, proposalInfo);
       return { isValid: false, reason: 'parent_block_not_found' };
     }
 
-    // Check that the parent block's slot is less than the proposal's slot (should not happen, but we check anyway)
-    if (parentBlockHeader !== 'genesis' && parentBlockHeader.getSlot() >= slotNumber) {
-      this.log.warn(`Parent block slot is greater than or equal to proposal slot, skipping processing`, {
-        parentBlockSlot: parentBlockHeader.getSlot().toString(),
+    // Check that the parent block's slot is not greater than the proposal's slot.
+    if (parentBlock !== 'genesis' && parentBlock.header.getSlot() > slotNumber) {
+      this.log.warn(`Parent block slot is greater than proposal slot, skipping processing`, {
+        parentBlockSlot: parentBlock.header.getSlot().toString(),
         proposalSlot: slotNumber.toString(),
         ...proposalInfo,
       });
@@ -165,9 +166,9 @@ export class BlockProposalHandler {
 
     // Compute the block number based on the parent block
     const blockNumber =
-      parentBlockHeader === 'genesis'
+      parentBlock === 'genesis'
         ? BlockNumber(INITIAL_L2_BLOCK_NUM)
-        : BlockNumber(parentBlockHeader.getBlockNumber() + 1);
+        : BlockNumber(parentBlock.header.getBlockNumber() + 1);
 
     // Check that this block number does not exist already
     const existingBlock = await this.blockSource.getBlockHeader(blockNumber);
@@ -184,7 +185,7 @@ export class BlockProposalHandler {
     });
 
     // Compute the checkpoint number for this block and validate checkpoint consistency
-    const checkpointResult = await this.computeCheckpointNumber(proposal, parentBlockHeader, proposalInfo);
+    const checkpointResult = this.computeCheckpointNumber(proposal, parentBlock, proposalInfo);
     if (checkpointResult.reason) {
       return { isValid: false, blockNumber, reason: checkpointResult.reason };
     }
@@ -212,6 +213,12 @@ export class BlockProposalHandler {
     // Try re-executing the transactions in the proposal if needed
     let reexecutionResult;
     if (shouldReexecute) {
+      // Collect the out hashes of all the checkpoints before this one in the same epoch
+      const epoch = getEpochAtSlot(slotNumber, this.epochCache.getL1Constants());
+      const previousCheckpointOutHashes = (await this.blockSource.getCheckpointsDataForEpoch(epoch))
+        .filter(c => c.checkpointNumber < checkpointNumber)
+        .map(c => c.checkpointOutHash);
+
       try {
         this.log.verbose(`Re-executing transactions in the proposal`, proposalInfo);
         reexecutionResult = await this.reexecuteTransactions(
@@ -220,6 +227,7 @@ export class BlockProposalHandler {
           checkpointNumber,
           txs,
           l1ToL2Messages,
+          previousCheckpointOutHashes,
         );
       } catch (error) {
         this.log.error(`Error reexecuting txs while processing block proposal`, error, proposalInfo);
@@ -229,7 +237,6 @@ export class BlockProposalHandler {
     }
 
     // If we succeeded, push this block into the archiver (unless disabled)
-    // TODO(palla/mbps): Change default to false once block sync is stable.
     if (reexecutionResult?.block && this.config.skipPushProposedBlocksToArchiver === false) {
       await this.blockSource.addBlock(reexecutionResult?.block);
     }
@@ -242,7 +249,7 @@ export class BlockProposalHandler {
     return { isValid: true, blockNumber, reexecutionResult };
   }
 
-  private async getParentBlock(proposal: BlockProposal): Promise<'genesis' | BlockHeader | undefined> {
+  private async getParentBlock(proposal: BlockProposal): Promise<'genesis' | BlockData | undefined> {
     const parentArchive = proposal.blockHeader.lastArchive.root;
     const slot = proposal.slotNumber;
     const config = this.checkpointsBuilder.getConfig();
@@ -258,12 +265,11 @@ export class BlockProposalHandler {
 
     try {
       return (
-        (await this.blockSource.getBlockHeaderByArchive(parentArchive)) ??
+        (await this.blockSource.getBlockDataByArchive(parentArchive)) ??
         (timeoutDurationMs <= 0
           ? undefined
           : await retryUntil(
-              () =>
-                this.blockSource.syncImmediate().then(() => this.blockSource.getBlockHeaderByArchive(parentArchive)),
+              () => this.blockSource.syncImmediate().then(() => this.blockSource.getBlockDataByArchive(parentArchive)),
               'force archiver sync',
               timeoutDurationMs / 1000,
               0.5,
@@ -279,12 +285,12 @@ export class BlockProposalHandler {
     }
   }
 
-  private async computeCheckpointNumber(
+  private computeCheckpointNumber(
     proposal: BlockProposal,
-    parentBlockHeader: 'genesis' | BlockHeader,
+    parentBlock: 'genesis' | BlockData,
     proposalInfo: object,
-  ): Promise<CheckpointComputationResult> {
-    if (parentBlockHeader === 'genesis') {
+  ): CheckpointComputationResult {
+    if (parentBlock === 'genesis') {
       // First block is in checkpoint 1
       if (proposal.indexWithinCheckpoint !== 0) {
         this.log.warn(`First block proposal has non-zero indexWithinCheckpoint`, proposalInfo);
@@ -293,19 +299,9 @@ export class BlockProposalHandler {
       return { checkpointNumber: CheckpointNumber.INITIAL };
     }
 
-    // Get the parent block to find its checkpoint number
-    // TODO(palla/mbps): The block header should include the checkpoint number to avoid this lookup,
-    // or at least the L2BlockSource should return a different struct that includes it.
-    const parentBlockNumber = parentBlockHeader.getBlockNumber();
-    const parentBlock = await this.blockSource.getL2BlockNew(parentBlockNumber);
-    if (!parentBlock) {
-      this.log.warn(`Parent block ${parentBlockNumber} not found in archiver`, proposalInfo);
-      return { reason: 'invalid_proposal' };
-    }
-
     if (proposal.indexWithinCheckpoint === 0) {
       // If this is the first block in a new checkpoint, increment the checkpoint number
-      if (!(proposal.blockHeader.getSlot() > parentBlockHeader.getSlot())) {
+      if (!(proposal.blockHeader.getSlot() > parentBlock.header.getSlot())) {
         this.log.warn(`Slot should be greater than parent block slot for first block in checkpoint`, proposalInfo);
         return { reason: 'invalid_proposal' };
       }
@@ -317,7 +313,7 @@ export class BlockProposalHandler {
       this.log.warn(`Non-sequential indexWithinCheckpoint`, proposalInfo);
       return { reason: 'invalid_proposal' };
     }
-    if (proposal.blockHeader.getSlot() !== parentBlockHeader.getSlot()) {
+    if (proposal.blockHeader.getSlot() !== parentBlock.header.getSlot()) {
       this.log.warn(`Slot should be equal to parent block slot for non-first block in checkpoint`, proposalInfo);
       return { reason: 'invalid_proposal' };
     }
@@ -338,7 +334,7 @@ export class BlockProposalHandler {
    */
   private validateNonFirstBlockInCheckpoint(
     proposal: BlockProposal,
-    parentBlock: L2BlockNew,
+    parentBlock: BlockData,
     proposalInfo: object,
   ): CheckpointComputationResult | undefined {
     const proposalGlobals = proposal.blockHeader.globalVariables;
@@ -414,31 +410,7 @@ export class BlockProposalHandler {
 
   private getReexecutionDeadline(slot: SlotNumber, config: { l1GenesisTime: bigint; slotDuration: number }): Date {
     const nextSlotTimestampSeconds = Number(getTimestampForSlot(SlotNumber(slot + 1), config));
-    const msNeededForPropagationAndPublishing = this.config.validatorReexecuteDeadlineMs;
-    return new Date(nextSlotTimestampSeconds * 1000 - msNeededForPropagationAndPublishing);
-  }
-
-  /**
-   * Gets all prior blocks in the same checkpoint (same slot and checkpoint number) up to but not including upToBlockNumber.
-   */
-  private async getBlocksInCheckpoint(
-    slot: SlotNumber,
-    upToBlockNumber: BlockNumber,
-    checkpointNumber: CheckpointNumber,
-  ): Promise<L2BlockNew[]> {
-    const blocks: L2BlockNew[] = [];
-    let currentBlockNumber = BlockNumber(upToBlockNumber - 1);
-
-    while (currentBlockNumber >= INITIAL_L2_BLOCK_NUM) {
-      const block = await this.blockSource.getL2BlockNew(currentBlockNumber);
-      if (!block || block.header.getSlot() !== slot || block.checkpointNumber !== checkpointNumber) {
-        break;
-      }
-      blocks.unshift(block);
-      currentBlockNumber = BlockNumber(currentBlockNumber - 1);
-    }
-
-    return blocks;
+    return new Date(nextSlotTimestampSeconds * 1000);
   }
 
   private getReexecuteFailureReason(err: any) {
@@ -459,6 +431,7 @@ export class BlockProposalHandler {
     checkpointNumber: CheckpointNumber,
     txs: Tx[],
     l1ToL2Messages: Fr[],
+    previousCheckpointOutHashes: Fr[],
   ): Promise<ReexecuteTransactionsResult> {
     const { blockHeader, txHashes } = proposal;
 
@@ -473,18 +446,21 @@ export class BlockProposalHandler {
     const slot = proposal.slotNumber;
     const config = this.checkpointsBuilder.getConfig();
 
-    // Get prior blocks in this checkpoint (same slot and checkpoint number)
-    const priorBlocks = await this.getBlocksInCheckpoint(slot, blockNumber, checkpointNumber);
+    // Get prior blocks in this checkpoint (same slot before current block)
+    const allBlocksInSlot = await this.blockSource.getBlocksForSlot(slot);
+    const priorBlocks = allBlocksInSlot.filter(b => b.number < blockNumber && b.header.getSlot() === slot);
 
     // Fork before the block to be built
     const parentBlockNumber = BlockNumber(blockNumber - 1);
-    using fork = await this.worldState.fork(parentBlockNumber);
+    await this.worldState.syncImmediate(parentBlockNumber);
+    await using fork = await this.worldState.fork(parentBlockNumber);
 
-    // Build checkpoint constants from proposal (excludes blockNumber and timestamp which are per-block)
+    // Build checkpoint constants from proposal (excludes blockNumber which is per-block)
     const constants: CheckpointGlobalVariables = {
       chainId: new Fr(config.l1ChainId),
       version: new Fr(config.rollupVersion),
       slotNumber: slot,
+      timestamp: blockHeader.globalVariables.timestamp,
       coinbase: blockHeader.globalVariables.coinbase,
       feeRecipient: blockHeader.globalVariables.feeRecipient,
       gasFees: blockHeader.globalVariables.gasFees,
@@ -494,9 +470,12 @@ export class BlockProposalHandler {
     const checkpointBuilder = await this.checkpointsBuilder.openCheckpoint(
       checkpointNumber,
       constants,
+      0n, // only takes effect in the following checkpoint.
       l1ToL2Messages,
+      previousCheckpointOutHashes,
       fork,
       priorBlocks,
+      this.log.getBindings(),
     );
 
     // Build the new block

package/src/checkpoint_builder.ts

@@ -1,10 +1,10 @@
 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';
+import { DateProvider, elapsed } from '@aztec/foundation/timer';
+import { createTxValidatorForBlockBuilding, getDefaultAllowedSetupFunctions } from '@aztec/p2p/msg_validators';
 import { LightweightCheckpointBuilder } from '@aztec/prover-client/light';
 import {
   GuardedMerkleTreeOperations,
@@ -12,39 +12,37 @@ 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,
+  NoValidTxsError,
   type PublicProcessorLimits,
+  type WorldStateSynchronizer,
 } from '@aztec/stdlib/interfaces/server';
+import { type DebugLogStore, NullDebugLogStore } from '@aztec/stdlib/logs';
 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');
-
-export interface BuildBlockInCheckpointResult {
-  block: L2BlockNew;
-  publicGas: Gas;
-  publicProcessorDuration: number;
-  numTxs: number;
-  failedTxs: FailedTx[];
-  blockBuildingTimer: Timer;
-  usedTxs: Tx[];
-}
+// Re-export for backward compatibility
+export type { BuildBlockInCheckpointResult } from '@aztec/stdlib/interfaces/server';
 
 /**
  * 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 +50,14 @@ export class CheckpointBuilder {
     private contractDataSource: ContractDataSource,
     private dateProvider: DateProvider,
     private telemetryClient: TelemetryClient,
-  ) {}
+    bindings?: LoggerBindings,
+    private debugLogStore: DebugLogStore = new NullDebugLogStore(),
+  ) {
+    this.log = createLogger('checkpoint-builder', {
+      ...bindings,
+      instanceId: `checkpoint-${checkpointBuilder.checkpointNumber}`,
+    });
+  }
 
   getConstantData(): CheckpointGlobalVariables {
     return this.checkpointBuilder.constants;
@@ -65,12 +70,16 @@ export class CheckpointBuilder {
     pendingTxs: Iterable<Tx> | AsyncIterable<Tx>,
     blockNumber: BlockNumber,
     timestamp: bigint,
-    opts: PublicProcessorLimits & { expectedEndState?: StateReference },
+    opts: PublicProcessorLimits & { expectedEndState?: StateReference } = {},
   ): Promise<BuildBlockInCheckpointResult> {
-    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,36 +94,46 @@ 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),
     );
 
+    // Throw if we didn't collect a single valid tx and we're not allowed to build empty blocks
+    // (only the first block in a checkpoint can be empty)
+    if (processedTxs.length === 0 && this.checkpointBuilder.getBlockCount() > 0) {
+      throw new NoValidTxsError(failedTxs);
+    }
+
     // Add block to checkpoint
-    const block = await this.checkpointBuilder.addBlock(globalVariables, processedTxs, {
+    const { block } = await this.checkpointBuilder.addBlock(globalVariables, processedTxs, {
       expectedEndState: opts.expectedEndState,
     });
 
     // How much public gas was processed
     const publicGas = processedTxs.reduce((acc, tx) => acc.add(tx.gasUsed.publicGas), Gas.empty());
 
-    const res = {
+    this.log.debug('Built block within checkpoint', {
+      header: block.header.toInspect(),
+      processedTxs: processedTxs.map(tx => tx.hash.toString()),
+      failedTxs: failedTxs.map(tx => tx.tx.txHash.toString()),
+    });
+
+    return {
       block,
       publicGas,
       publicProcessorDuration,
       numTxs: processedTxs.length,
       failedTxs,
-      blockBuildingTimer,
       usedTxs,
+      usedTxBlobFields,
     };
-    log.debug('Built block within checkpoint', res.block.header);
-    return res;
   }
 
   /** Completes the checkpoint and returns it. */
   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 +149,19 @@ 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 collectDebugLogs = this.debugLogStore.isEnabled;
+
+    const bindings = this.log.getBindings();
     const publicTxSimulator = createPublicTxSimulatorForBlockBuilding(
       guardedFork,
       contractsDB,
       globalVariables,
       this.telemetryClient,
+      bindings,
+      collectDebugLogs,
     );
 
     const processor = new PublicProcessor(
@@ -147,15 +171,17 @@ export class CheckpointBuilder {
       publicTxSimulator,
       this.dateProvider,
       this.telemetryClient,
-      undefined,
+      createLogger('simulator:public-processor', bindings),
       this.config,
+      this.debugLogStore,
     );
 
-    const validator = createValidatorForBlockBuilding(
+    const validator = createTxValidatorForBlockBuilding(
       fork,
       this.contractDataSource,
       globalVariables,
       txPublicSetupAllowList,
+      this.log.getBindings(),
     );
 
     return {
@@ -165,16 +191,20 @@ 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(),
-  ) {}
+    private debugLogStore: DebugLogStore = new NullDebugLogStore(),
+  ) {
+    this.log = createLogger('checkpoint-builder');
+  }
 
   public getConfig(): FullNodeBlockBuilderConfig {
     return this.config;
@@ -190,25 +220,32 @@ export class FullNodeCheckpointsBuilder {
   async startCheckpoint(
     checkpointNumber: CheckpointNumber,
     constants: CheckpointGlobalVariables,
+    feeAssetPriceModifier: bigint,
     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(),
       initialArchiveRoot: bufferToHex(archiveTree.root),
       constants,
+      feeAssetPriceModifier,
     });
 
     const lightweightBuilder = await LightweightCheckpointBuilder.startNewCheckpoint(
       checkpointNumber,
       constants,
       l1ToL2Messages,
+      previousCheckpointOutHashes,
       fork,
+      bindings,
+      feeAssetPriceModifier,
     );
 
     return new CheckpointBuilder(
@@ -218,6 +255,8 @@ export class FullNodeCheckpointsBuilder {
       this.contractDataSource,
       this.dateProvider,
       this.telemetryClient,
+      bindings,
+      this.debugLogStore,
     );
   }
 
@@ -227,32 +266,47 @@ export class FullNodeCheckpointsBuilder {
   async openCheckpoint(
     checkpointNumber: CheckpointNumber,
     constants: CheckpointGlobalVariables,
+    feeAssetPriceModifier: bigint,
     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,
+        feeAssetPriceModifier,
+        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,
       initialStateReference: stateReference.toInspect(),
       initialArchiveRoot: bufferToHex(archiveTree.root),
       constants,
+      feeAssetPriceModifier,
     });
 
     const lightweightBuilder = await LightweightCheckpointBuilder.resumeCheckpoint(
       checkpointNumber,
       constants,
+      feeAssetPriceModifier,
       l1ToL2Messages,
+      previousCheckpointOutHashes,
       fork,
       existingBlocks,
+      bindings,
     );
 
     return new CheckpointBuilder(
@@ -262,6 +316,13 @@ export class FullNodeCheckpointsBuilder {
       this.contractDataSource,
       this.dateProvider,
       this.telemetryClient,
+      bindings,
+      this.debugLogStore,
     );
   }
+
+  /** 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

@@ -6,6 +6,7 @@ import {
   secretValueConfigHelper,
 } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
+import { validatorHASignerConfigMappings } from '@aztec/stdlib/ha-signing';
 import type { ValidatorClientConfig } from '@aztec/stdlib/interfaces/server';
 
 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,19 @@ 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,
+  },
+  attestToEquivocatedProposals: {
+    description: 'Agree to attest to equivocated checkpoint proposals (for testing purposes only)',
+    ...booleanConfigHelper(false),
   },
+  ...validatorHASignerConfigMappings,
 };
 
 /**