@aztec/validator-client 0.0.1-commit.1bb068fb5 → 0.0.1-commit.1de2a32

package/dest/validator.js

@@ -9,11 +9,12 @@ import { sleep } from '@aztec/foundation/sleep';
 import { DateProvider } from '@aztec/foundation/timer';
 import { AuthRequest, AuthResponse, BlockProposalValidator, ReqRespSubProtocol } from '@aztec/p2p';
 import { OffenseType, WANT_TO_SLASH_EVENT } from '@aztec/slasher';
+import { validateCheckpoint } from '@aztec/stdlib/checkpoint';
 import { getEpochAtSlot, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
 import { accumulateCheckpointOutHashes } from '@aztec/stdlib/messaging';
 import { AttestationTimeoutError } from '@aztec/stdlib/validators';
 import { getTelemetryClient } from '@aztec/telemetry-client';
-import { createHASigner } from '@aztec/validator-ha-signer/factory';
+import { createHASigner, createLocalSignerWithProtection } from '@aztec/validator-ha-signer/factory';
 import { DutyType } from '@aztec/validator-ha-signer/types';
 import { EventEmitter } from 'events';
 import { BlockProposalHandler } from './block_proposal_handler.js';
@@ -42,6 +43,7 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
     l1ToL2MessageSource;
     config;
     blobClient;
+    slashingProtectionSigner;
     dateProvider;
     tracer;
     validationService;
@@ -53,10 +55,11 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
     /** Tracks the last checkpoint proposal we created. */ lastProposedCheckpoint;
     lastEpochForCommitteeUpdateLoop;
     epochCacheUpdateLoop;
+    /** Tracks the last epoch in which each attester successfully submitted at least one attestation. */ lastAttestedEpochByAttester;
     proposersOfInvalidBlocks;
     /** Tracks the last checkpoint proposal we attested to, to prevent equivocation. */ lastAttestedProposal;
-    constructor(keyStore, epochCache, p2pClient, blockProposalHandler, blockSource, checkpointsBuilder, worldState, l1ToL2MessageSource, config, blobClient, dateProvider = new DateProvider(), telemetry = getTelemetryClient(), log = createLogger('validator')){
-        super(), this.keyStore = keyStore, this.epochCache = epochCache, this.p2pClient = p2pClient, this.blockProposalHandler = blockProposalHandler, this.blockSource = blockSource, this.checkpointsBuilder = checkpointsBuilder, this.worldState = worldState, this.l1ToL2MessageSource = l1ToL2MessageSource, this.config = config, this.blobClient = blobClient, this.dateProvider = dateProvider, this.hasRegisteredHandlers = false, this.proposersOfInvalidBlocks = new Set();
+    constructor(keyStore, epochCache, p2pClient, blockProposalHandler, blockSource, checkpointsBuilder, worldState, l1ToL2MessageSource, config, blobClient, slashingProtectionSigner, dateProvider = new DateProvider(), telemetry = getTelemetryClient(), log = createLogger('validator')){
+        super(), this.keyStore = keyStore, this.epochCache = epochCache, this.p2pClient = p2pClient, this.blockProposalHandler = blockProposalHandler, this.blockSource = blockSource, this.checkpointsBuilder = checkpointsBuilder, this.worldState = worldState, this.l1ToL2MessageSource = l1ToL2MessageSource, this.config = config, this.blobClient = blobClient, this.slashingProtectionSigner = slashingProtectionSigner, this.dateProvider = dateProvider, this.hasRegisteredHandlers = false, this.lastAttestedEpochByAttester = new Map(), this.proposersOfInvalidBlocks = new Set();
         // Create child logger with fisherman prefix if in fisherman mode
         this.log = config.fishermanMode ? log.createChild('[FISHERMAN]') : log;
         this.tracer = telemetry.getTracer('Validator');
@@ -95,6 +98,7 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
                 this.log.trace(`No committee found for slot`);
                 return;
             }
+            this.metrics.setCurrentEpoch(epoch);
             if (epoch !== this.lastEpochForCommitteeUpdateLoop) {
                 const me = this.getValidatorAddresses();
                 const committeeSet = new Set(committee.map((v)=>v.toString()));
@@ -113,20 +117,33 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
     static async new(config, checkpointsBuilder, worldState, epochCache, p2pClient, blockSource, l1ToL2MessageSource, txProvider, keyStoreManager, blobClient, dateProvider = new DateProvider(), telemetry = getTelemetryClient()) {
         const metrics = new ValidatorMetrics(telemetry);
         const blockProposalValidator = new BlockProposalValidator(epochCache, {
-            txsPermitted: !config.disableTransactions
+            txsPermitted: !config.disableTransactions,
+            maxTxsPerBlock: config.validateMaxTxsPerBlock
         });
         const blockProposalHandler = new BlockProposalHandler(checkpointsBuilder, worldState, blockSource, l1ToL2MessageSource, txProvider, blockProposalValidator, epochCache, config, metrics, dateProvider, telemetry);
-        let validatorKeyStore = NodeKeystoreAdapter.fromKeyStoreManager(keyStoreManager);
+        const nodeKeystoreAdapter = NodeKeystoreAdapter.fromKeyStoreManager(keyStoreManager);
+        let slashingProtectionSigner;
         if (config.haSigningEnabled) {
+            // Multi-node HA mode: use PostgreSQL-backed distributed locking.
             // If maxStuckDutiesAgeMs is not explicitly set, compute it from Aztec slot duration
             const haConfig = {
                 ...config,
                 maxStuckDutiesAgeMs: config.maxStuckDutiesAgeMs ?? epochCache.getL1Constants().slotDuration * 2 * 1000
             };
-            const { signer } = await createHASigner(haConfig);
-            validatorKeyStore = new HAKeyStore(validatorKeyStore, signer);
-        }
-        const validator = new ValidatorClient(validatorKeyStore, epochCache, p2pClient, blockProposalHandler, blockSource, checkpointsBuilder, worldState, l1ToL2MessageSource, config, blobClient, dateProvider, telemetry);
+            ({ signer: slashingProtectionSigner } = await createHASigner(haConfig, {
+                telemetryClient: telemetry,
+                dateProvider
+            }));
+        } else {
+            // Single-node mode: use LMDB-backed local signing protection.
+            // This prevents double-signing if the node crashes and restarts mid-proposal.
+            ({ signer: slashingProtectionSigner } = await createLocalSignerWithProtection(config, {
+                telemetryClient: telemetry,
+                dateProvider
+            }));
+        }
+        const validatorKeyStore = new HAKeyStore(nodeKeystoreAdapter, slashingProtectionSigner);
+        const validator = new ValidatorClient(validatorKeyStore, epochCache, p2pClient, blockProposalHandler, blockSource, checkpointsBuilder, worldState, l1ToL2MessageSource, config, blobClient, slashingProtectionSigner, dateProvider, telemetry);
         return validator;
     }
     getValidatorAddresses() {
@@ -153,6 +170,11 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             ...config
         };
     }
+    reloadKeystore(newManager) {
+        const newAdapter = NodeKeystoreAdapter.fromKeyStoreManager(newManager);
+        this.keyStore = new HAKeyStore(newAdapter, this.slashingProtectionSigner);
+        this.validationService = new ValidationService(this.keyStore, this.log.createChild('validation-service'));
+    }
     async start() {
         if (this.epochCacheUpdateLoop.isRunning()) {
             this.log.warn(`Validator client already started`);
@@ -311,12 +333,10 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
         const proposalInfo = {
             slotNumber,
             archive: proposal.archive.toString(),
-            proposer: proposer.toString(),
-            txCount: proposal.txHashes.length
+            proposer: proposer.toString()
         };
         this.log.info(`Received checkpoint proposal for slot ${slotNumber}`, {
             ...proposalInfo,
-            txHashes: proposal.txHashes.map((t)=>t.toString()),
             fishermanMode: this.config.fishermanMode || false
         });
         // Validate the checkpoint proposal before attesting (unless skipCheckpointProposalValidation is set)
@@ -346,6 +366,16 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             fishermanMode: this.config.fishermanMode || false
         });
         this.metrics.incSuccessfulAttestations(inCommittee.length);
+        // Track epoch participation per attester: count each (attester, epoch) pair at most once
+        const proposalEpoch = getEpochAtSlot(slotNumber, this.epochCache.getL1Constants());
+        for (const attester of inCommittee){
+            const key = attester.toString();
+            const lastEpoch = this.lastAttestedEpochByAttester.get(key);
+            if (lastEpoch === undefined || proposalEpoch > lastEpoch) {
+                this.lastAttestedEpochByAttester.set(key, proposalEpoch);
+                this.metrics.incAttestedEpochCount(attester);
+            }
+        }
         // Determine which validators should attest
         let attestors;
         if (partOfCommittee) {
@@ -442,6 +472,14 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
                 reason: 'no_blocks_for_slot'
             };
         }
+        // Ensure the last block for this slot matches the archive in the checkpoint proposal
+        if (!blocks.at(-1)?.archive.root.equals(proposal.archive)) {
+            this.log.warn(`Last block archive mismatch for checkpoint proposal`, proposalInfo);
+            return {
+                isValid: false,
+                reason: 'last_block_archive_mismatch'
+            };
+        }
         this.log.debug(`Found ${blocks.length} blocks for slot ${slot}`, {
             ...proposalInfo,
             blockNumbers: blocks.map((b)=>b.number)
@@ -452,12 +490,9 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
         const checkpointNumber = firstBlock.checkpointNumber;
         // Get L1-to-L2 messages for this checkpoint
         const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(checkpointNumber);
-        // Compute the previous checkpoint out hashes for the epoch.
-        // TODO: There can be a more efficient way to get the previous checkpoint out hashes without having to fetch the
-        // actual checkpoints and the blocks/txs in them.
+        // Collect the out hashes of all the checkpoints before this one in the same epoch
         const epoch = getEpochAtSlot(slot, this.epochCache.getL1Constants());
-        const previousCheckpoints = (await this.blockSource.getCheckpointsForEpoch(epoch)).filter((b)=>b.number < checkpointNumber).sort((a, b)=>a.number - b.number);
-        const previousCheckpointOutHashes = previousCheckpoints.map((c)=>c.getCheckpointOutHash());
+        const previousCheckpointOutHashes = (await this.blockSource.getCheckpointsDataForEpoch(epoch)).filter((c)=>c.checkpointNumber < checkpointNumber).map((c)=>c.checkpointOutHash);
         // Fork world state at the block before the first block
         const parentBlockNumber = BlockNumber(firstBlock.number - 1);
         const fork = await this.worldState.fork(parentBlockNumber);
@@ -511,6 +546,22 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
                     reason: 'out_hash_mismatch'
                 };
             }
+            // Final round of validations on the checkpoint, just in case.
+            try {
+                validateCheckpoint(computedCheckpoint, {
+                    rollupManaLimit: this.checkpointsBuilder.getConfig().rollupManaLimit,
+                    maxDABlockGas: this.config.validateMaxDABlockGas,
+                    maxL2BlockGas: this.config.validateMaxL2BlockGas,
+                    maxTxsPerBlock: this.config.validateMaxTxsPerBlock,
+                    maxTxsPerCheckpoint: this.config.validateMaxTxsPerCheckpoint
+                });
+            } catch (err) {
+                this.log.warn(`Checkpoint validation failed: ${err}`, proposalInfo);
+                return {
+                    isValid: false,
+                    reason: 'checkpoint_validation_failed'
+                };
+            }
             this.log.verbose(`Checkpoint proposal validation successful for slot ${slot}`, proposalInfo);
             return {
                 isValid: true
@@ -527,6 +578,7 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             chainId: gv.chainId,
             version: gv.version,
             slotNumber: gv.slotNumber,
+            timestamp: gv.timestamp,
             coinbase: gv.coinbase,
             feeRecipient: gv.feeRecipient,
             gasFees: gv.gasFees
@@ -547,7 +599,7 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
                 return;
             }
             const blobFields = blocks.flatMap((b)=>b.toBlobFields());
-            const blobs = getBlobsPerL1Block(blobFields);
+            const blobs = await getBlobsPerL1Block(blobFields);
             await this.blobClient.sendBlobsToFilestore(blobs);
             this.log.debug(`Uploaded ${blobs.length} blobs to filestore for checkpoint at slot ${proposal.slotNumber}`, {
                 ...proposalInfo,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/validator-client",
-  "version": "0.0.1-commit.1bb068fb5",
+  "version": "0.0.1-commit.1de2a32",
   "main": "dest/index.js",
   "type": "module",
   "exports": {
@@ -64,30 +64,30 @@
     ]
   },
   "dependencies": {
-    "@aztec/blob-client": "0.0.1-commit.1bb068fb5",
-    "@aztec/blob-lib": "0.0.1-commit.1bb068fb5",
-    "@aztec/constants": "0.0.1-commit.1bb068fb5",
-    "@aztec/epoch-cache": "0.0.1-commit.1bb068fb5",
-    "@aztec/ethereum": "0.0.1-commit.1bb068fb5",
-    "@aztec/foundation": "0.0.1-commit.1bb068fb5",
-    "@aztec/node-keystore": "0.0.1-commit.1bb068fb5",
-    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.1bb068fb5",
-    "@aztec/p2p": "0.0.1-commit.1bb068fb5",
-    "@aztec/protocol-contracts": "0.0.1-commit.1bb068fb5",
-    "@aztec/prover-client": "0.0.1-commit.1bb068fb5",
-    "@aztec/simulator": "0.0.1-commit.1bb068fb5",
-    "@aztec/slasher": "0.0.1-commit.1bb068fb5",
-    "@aztec/stdlib": "0.0.1-commit.1bb068fb5",
-    "@aztec/telemetry-client": "0.0.1-commit.1bb068fb5",
-    "@aztec/validator-ha-signer": "0.0.1-commit.1bb068fb5",
+    "@aztec/blob-client": "0.0.1-commit.1de2a32",
+    "@aztec/blob-lib": "0.0.1-commit.1de2a32",
+    "@aztec/constants": "0.0.1-commit.1de2a32",
+    "@aztec/epoch-cache": "0.0.1-commit.1de2a32",
+    "@aztec/ethereum": "0.0.1-commit.1de2a32",
+    "@aztec/foundation": "0.0.1-commit.1de2a32",
+    "@aztec/node-keystore": "0.0.1-commit.1de2a32",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.1de2a32",
+    "@aztec/p2p": "0.0.1-commit.1de2a32",
+    "@aztec/protocol-contracts": "0.0.1-commit.1de2a32",
+    "@aztec/prover-client": "0.0.1-commit.1de2a32",
+    "@aztec/simulator": "0.0.1-commit.1de2a32",
+    "@aztec/slasher": "0.0.1-commit.1de2a32",
+    "@aztec/stdlib": "0.0.1-commit.1de2a32",
+    "@aztec/telemetry-client": "0.0.1-commit.1de2a32",
+    "@aztec/validator-ha-signer": "0.0.1-commit.1de2a32",
     "koa": "^2.16.1",
     "koa-router": "^13.1.1",
     "tslib": "^2.4.0",
     "viem": "npm:@aztec/viem@2.38.2"
   },
   "devDependencies": {
-    "@aztec/archiver": "0.0.1-commit.1bb068fb5",
-    "@aztec/world-state": "0.0.1-commit.1bb068fb5",
+    "@aztec/archiver": "0.0.1-commit.1de2a32",
+    "@aztec/world-state": "0.0.1-commit.1de2a32",
     "@electric-sql/pglite": "^0.3.14",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",

package/src/block_proposal_handler.ts

@@ -1,7 +1,7 @@
 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 { chunkBy } from '@aztec/foundation/collection';
+import { pick } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { TimeoutError } from '@aztec/foundation/error';
 import { createLogger } from '@aztec/foundation/log';
@@ -9,16 +9,13 @@ import { retryUntil } from '@aztec/foundation/retry';
 import { DateProvider, Timer } from '@aztec/foundation/timer';
 import type { P2P, PeerId } from '@aztec/p2p';
 import { BlockProposalValidator } from '@aztec/p2p/msg_validators';
-import type { L2Block, L2BlockSink, L2BlockSource } from '@aztec/stdlib/block';
+import type { BlockData, L2Block, L2BlockSink, L2BlockSource } from '@aztec/stdlib/block';
 import { getEpochAtSlot, getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import { Gas } from '@aztec/stdlib/gas';
 import type { ITxProvider, ValidatorClientFullConfig, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
-import {
-  type L1ToL2MessageSource,
-  computeCheckpointOutHash,
-  computeInHashFromL1ToL2Messages,
-} from '@aztec/stdlib/messaging';
+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,
@@ -92,25 +89,28 @@ export class BlockProposalHandler {
     this.tracer = telemetry.getTracer('BlockProposalHandler');
   }
 
-  registerForReexecution(p2pClient: P2P): BlockProposalHandler {
-    // Non-validator handler that re-executes for monitoring but does not attest.
+  register(p2pClient: P2P, shouldReexecute: boolean): BlockProposalHandler {
+    // Non-validator handler that processes or re-executes for monitoring but does not attest.
     // Returns boolean indicating whether the proposal was valid.
     const handler = async (proposal: BlockProposal, proposalSender: PeerId): Promise<boolean> => {
       try {
-        const result = await this.handleBlockProposal(proposal, proposalSender, true);
+        const { slotNumber, blockNumber } = proposal;
+        const result = await this.handleBlockProposal(proposal, proposalSender, shouldReexecute);
         if (result.isValid) {
-          this.log.info(`Non-validator reexecution completed for slot ${proposal.slotNumber}`, {
+          this.log.info(`Non-validator block proposal ${blockNumber} at slot ${slotNumber} handled`, {
             blockNumber: result.blockNumber,
+            slotNumber,
             reexecutionTimeMs: result.reexecutionResult?.reexecutionTimeMs,
             totalManaUsed: result.reexecutionResult?.totalManaUsed,
             numTxs: result.reexecutionResult?.block?.body?.txEffects?.length ?? 0,
+            reexecuted: shouldReexecute,
           });
           return true;
         } else {
-          this.log.warn(`Non-validator reexecution failed for slot ${proposal.slotNumber}`, {
-            blockNumber: result.blockNumber,
-            reason: result.reason,
-          });
+          this.log.warn(
+            `Non-validator block proposal ${blockNumber} at slot ${slotNumber} failed processing with ${result.reason}`,
+            { blockNumber: result.blockNumber, slotNumber, reason: result.reason },
+          );
           return false;
         }
       } catch (error) {
@@ -153,16 +153,16 @@ export class BlockProposalHandler {
     }
 
     // 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 not greater than the proposal's slot.
-    if (parentBlockHeader !== 'genesis' && parentBlockHeader.getSlot() > slotNumber) {
+    if (parentBlock !== 'genesis' && parentBlock.header.getSlot() > slotNumber) {
       this.log.warn(`Parent block slot is greater than proposal slot, skipping processing`, {
-        parentBlockSlot: parentBlockHeader.getSlot().toString(),
+        parentBlockSlot: parentBlock.header.getSlot().toString(),
         proposalSlot: slotNumber.toString(),
         ...proposalInfo,
       });
@@ -171,9 +171,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);
@@ -189,8 +189,17 @@ export class BlockProposalHandler {
       deadline: this.getReexecutionDeadline(slotNumber, config),
     });
 
+    // If reexecution is disabled, bail. We are just interested in triggering tx collection.
+    if (!shouldReexecute) {
+      this.log.info(
+        `Received valid block ${blockNumber} proposal at index ${proposal.indexWithinCheckpoint} on slot ${slotNumber}`,
+        proposalInfo,
+      );
+      return { isValid: true, blockNumber };
+    }
+
     // 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 };
     }
@@ -215,36 +224,28 @@ export class BlockProposalHandler {
       return { isValid: false, blockNumber, reason: 'txs_not_available' };
     }
 
+    // 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 re-executing the transactions in the proposal if needed
     let reexecutionResult;
-    if (shouldReexecute) {
-      // Compute the previous checkpoint out hashes for the epoch.
-      // TODO(leila/mbps): There can be a more efficient way to get the previous checkpoint out
-      // hashes without having to fetch all the blocks.
-      const epoch = getEpochAtSlot(slotNumber, this.epochCache.getL1Constants());
-      const checkpointedBlocks = (await this.blockSource.getCheckpointedBlocksForEpoch(epoch))
-        .filter(b => b.block.number < blockNumber)
-        .sort((a, b) => a.block.number - b.block.number);
-      const blocksByCheckpoint = chunkBy(checkpointedBlocks, b => b.checkpointNumber);
-      const previousCheckpointOutHashes = blocksByCheckpoint.map(checkpointBlocks =>
-        computeCheckpointOutHash(checkpointBlocks.map(b => b.block.body.txEffects.map(tx => tx.l2ToL1Msgs))),
+    try {
+      this.log.verbose(`Re-executing transactions in the proposal`, proposalInfo);
+      reexecutionResult = await this.reexecuteTransactions(
+        proposal,
+        blockNumber,
+        checkpointNumber,
+        txs,
+        l1ToL2Messages,
+        previousCheckpointOutHashes,
       );
-
-      try {
-        this.log.verbose(`Re-executing transactions in the proposal`, proposalInfo);
-        reexecutionResult = await this.reexecuteTransactions(
-          proposal,
-          blockNumber,
-          checkpointNumber,
-          txs,
-          l1ToL2Messages,
-          previousCheckpointOutHashes,
-        );
-      } catch (error) {
-        this.log.error(`Error reexecuting txs while processing block proposal`, error, proposalInfo);
-        const reason = this.getReexecuteFailureReason(error);
-        return { isValid: false, blockNumber, reason, reexecutionResult };
-      }
+    } catch (error) {
+      this.log.error(`Error reexecuting txs while processing block proposal`, error, proposalInfo);
+      const reason = this.getReexecuteFailureReason(error);
+      return { isValid: false, blockNumber, reason, reexecutionResult };
     }
 
     // If we succeeded, push this block into the archiver (unless disabled)
@@ -253,14 +254,14 @@ export class BlockProposalHandler {
     }
 
     this.log.info(
-      `Successfully processed block ${blockNumber} proposal at index ${proposal.indexWithinCheckpoint} on slot ${slotNumber}`,
-      proposalInfo,
+      `Successfully re-executed block ${blockNumber} proposal at index ${proposal.indexWithinCheckpoint} on slot ${slotNumber}`,
+      { ...proposalInfo, ...pick(reexecutionResult, 'reexecutionTimeMs', 'totalManaUsed') },
     );
 
     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();
@@ -276,12 +277,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,
@@ -297,12 +297,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);
@@ -311,19 +311,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.getL2Block(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' };
       }
@@ -335,7 +325,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' };
     }
@@ -356,7 +346,7 @@ export class BlockProposalHandler {
    */
   private validateNonFirstBlockInCheckpoint(
     proposal: BlockProposal,
-    parentBlock: L2Block,
+    parentBlock: BlockData,
     proposalInfo: object,
   ): CheckpointComputationResult | undefined {
     const proposalGlobals = proposal.blockHeader.globalVariables;
@@ -475,13 +465,14 @@ export class BlockProposalHandler {
     // Fork before the block to be built
     const parentBlockNumber = BlockNumber(blockNumber - 1);
     await this.worldState.syncImmediate(parentBlockNumber);
-    using fork = await this.worldState.fork(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,
@@ -501,18 +492,25 @@ export class BlockProposalHandler {
 
     // Build the new block
     const deadline = this.getReexecutionDeadline(slot, config);
+    const maxBlockGas =
+      this.config.validateMaxL2BlockGas !== undefined || this.config.validateMaxDABlockGas !== undefined
+        ? new Gas(this.config.validateMaxDABlockGas ?? Infinity, this.config.validateMaxL2BlockGas ?? Infinity)
+        : undefined;
     const result = await checkpointBuilder.buildBlock(txs, blockNumber, blockHeader.globalVariables.timestamp, {
       deadline,
       expectedEndState: blockHeader.state,
+      maxTransactions: this.config.validateMaxTxsPerBlock,
+      maxBlockGas,
     });
 
     const { block, failedTxs } = result;
     const numFailedTxs = failedTxs.length;
 
-    this.log.verbose(`Transaction re-execution complete for slot ${slot}`, {
+    this.log.verbose(`Block proposal ${blockNumber} at slot ${slot} transaction re-execution complete`, {
       numFailedTxs,
       numProposalTxs: txHashes.length,
       numProcessedTxs: block.body.txEffects.length,
+      blockNumber,
       slot,
     });