@aztec/validator-client 0.0.1-commit.7035c9bd6 → 0.0.1-commit.71324e566

package/dest/validator.js

@@ -1,27 +1,22 @@
 import { getBlobsPerL1Block } from '@aztec/blob-lib';
-import { validateFeeAssetPriceModifier } from '@aztec/ethereum/contracts';
-import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
-import { TimeoutError } from '@aztec/foundation/error';
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
 import { createLogger } from '@aztec/foundation/log';
-import { retryUntil } from '@aztec/foundation/retry';
 import { RunningPromise } from '@aztec/foundation/running-promise';
 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 { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
 import { AttestationTimeoutError } from '@aztec/stdlib/validators';
 import { getTelemetryClient } from '@aztec/telemetry-client';
 import { createHASigner, createLocalSignerWithProtection, createSignerFromSharedDb } 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';
 import { ValidationService } from './duties/validation_service.js';
 import { HAKeyStore } from './key_store/ha_key_store.js';
 import { NodeKeystoreAdapter } from './key_store/node_keystore_adapter.js';
 import { ValidatorMetrics } from './metrics.js';
+import { ProposalHandler } from './proposal_handler.js';
 // We maintain a set of proposers who have proposed invalid blocks.
 // Just cap the set to avoid unbounded growth.
 const MAX_PROPOSERS_OF_INVALID_BLOCKS = 1000;
@@ -36,7 +31,7 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
     keyStore;
     epochCache;
     p2pClient;
-    blockProposalHandler;
+    proposalHandler;
     blockSource;
     checkpointsBuilder;
     worldState;
@@ -58,8 +53,8 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
     /** 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, 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();
+    constructor(keyStore, epochCache, p2pClient, proposalHandler, 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.proposalHandler = proposalHandler, 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');
@@ -120,7 +115,7 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             txsPermitted: !config.disableTransactions,
             maxTxsPerBlock: config.validateMaxTxsPerBlock
         });
-        const blockProposalHandler = new BlockProposalHandler(checkpointsBuilder, worldState, blockSource, l1ToL2MessageSource, txProvider, blockProposalValidator, epochCache, config, metrics, dateProvider, telemetry);
+        const proposalHandler = new ProposalHandler(checkpointsBuilder, worldState, blockSource, l1ToL2MessageSource, txProvider, blockProposalValidator, epochCache, config, blobClient, metrics, dateProvider, telemetry, undefined);
         const nodeKeystoreAdapter = NodeKeystoreAdapter.fromKeyStoreManager(keyStoreManager);
         let slashingProtectionSigner;
         if (slashingProtectionDb) {
@@ -149,14 +144,14 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             }));
         }
         const validatorKeyStore = new HAKeyStore(nodeKeystoreAdapter, slashingProtectionSigner);
-        const validator = new ValidatorClient(validatorKeyStore, epochCache, p2pClient, blockProposalHandler, blockSource, checkpointsBuilder, worldState, l1ToL2MessageSource, config, blobClient, slashingProtectionSigner, dateProvider, telemetry);
+        const validator = new ValidatorClient(validatorKeyStore, epochCache, p2pClient, proposalHandler, blockSource, checkpointsBuilder, worldState, l1ToL2MessageSource, config, blobClient, slashingProtectionSigner, dateProvider, telemetry);
         return validator;
     }
     getValidatorAddresses() {
         return this.keyStore.getAddresses().filter((addr)=>!this.config.disabledValidators.some((disabled)=>disabled.equals(addr)));
     }
-    getBlockProposalHandler() {
-        return this.blockProposalHandler;
+    getProposalHandler() {
+        return this.proposalHandler;
     }
     signWithAddress(addr, msg, context) {
         return this.keyStore.signTypedDataWithAddress(addr, msg, context);
@@ -212,7 +207,7 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             // The checkpoint is received as CheckpointProposalCore since the lastBlock is extracted
             // and processed separately via the block handler above.
             const checkpointHandler = (checkpoint, proposalSender)=>this.attestToCheckpointProposal(checkpoint, proposalSender);
-            this.p2pClient.registerCheckpointProposalHandler(checkpointHandler);
+            this.p2pClient.registerValidatorCheckpointProposalHandler(checkpointHandler);
             // Duplicate proposal handler - triggers slashing for equivocation
             this.p2pClient.registerDuplicateProposalCallback((info)=>{
                 this.handleDuplicateProposal(info);
@@ -262,9 +257,9 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
         });
         // Reexecute txs if we are part of the committee, or if slashing is enabled, or if we are configured to always reexecute.
         // In fisherman mode, we always reexecute to validate proposals.
-        const { validatorReexecute, slashBroadcastedInvalidBlockPenalty, alwaysReexecuteBlockProposals, fishermanMode } = this.config;
-        const shouldReexecute = fishermanMode || slashBroadcastedInvalidBlockPenalty > 0n && validatorReexecute || partOfCommittee && validatorReexecute || alwaysReexecuteBlockProposals || this.blobClient.canUpload();
-        const validationResult = await this.blockProposalHandler.handleBlockProposal(proposal, proposalSender, !!shouldReexecute && !escapeHatchOpen);
+        const { slashBroadcastedInvalidBlockPenalty, alwaysReexecuteBlockProposals, fishermanMode } = this.config;
+        const shouldReexecute = fishermanMode || slashBroadcastedInvalidBlockPenalty > 0n || partOfCommittee || alwaysReexecuteBlockProposals || this.blobClient.canUpload();
+        const validationResult = await this.proposalHandler.handleBlockProposal(proposal, proposalSender, !!shouldReexecute && !escapeHatchOpen);
         if (!validationResult.isValid) {
             const reason = validationResult.reason || 'unknown';
             this.log.warn(`Block proposal validation failed: ${reason}`, proposalInfo);
@@ -314,49 +309,39 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             this.log.warn(`Escape hatch open for slot ${proposalSlotNumber}, skipping checkpoint attestation handling`);
             return undefined;
         }
-        // Reject proposals with invalid signatures
-        if (!proposer) {
-            this.log.warn(`Received checkpoint proposal with invalid signature for proposal slot ${proposalSlotNumber}`);
-            return undefined;
-        }
         // Ignore proposals from ourselves (may happen in HA setups)
-        if (this.getValidatorAddresses().some((addr)=>addr.equals(proposer))) {
+        if (proposer && this.getValidatorAddresses().some((addr)=>addr.equals(proposer))) {
             this.log.debug(`Ignoring block proposal from self for slot ${proposalSlotNumber}`, {
                 proposer: proposer.toString(),
                 proposalSlotNumber
             });
             return undefined;
         }
-        // Validate fee asset price modifier is within allowed range
-        if (!validateFeeAssetPriceModifier(proposal.feeAssetPriceModifier)) {
-            this.log.warn(`Received checkpoint proposal with invalid feeAssetPriceModifier ${proposal.feeAssetPriceModifier} for slot ${proposalSlotNumber}`);
-            return undefined;
-        }
         // Check that I have any address in the committee where this checkpoint will land before attesting
         const inCommittee = await this.epochCache.filterInCommittee(proposalSlotNumber, this.getValidatorAddresses());
         const partOfCommittee = inCommittee.length > 0;
         const proposalInfo = {
             proposalSlotNumber,
             archive: proposal.archive.toString(),
-            proposer: proposer.toString()
+            proposer: proposer?.toString()
         };
         this.log.info(`Received checkpoint proposal for slot ${proposalSlotNumber}`, {
             ...proposalInfo,
             fishermanMode: this.config.fishermanMode || false
         });
-        // Validate the checkpoint proposal before attesting (unless skipCheckpointProposalValidation is set)
+        // Validate the checkpoint proposal before attesting (unless skipCheckpointProposalValidation is set).
+        // Uses the cached result from the all-nodes callback if available (avoids double validation).
+        let checkpointNumber;
         if (this.config.skipCheckpointProposalValidation) {
             this.log.warn(`Skipping checkpoint proposal validation for slot ${proposalSlotNumber}`, proposalInfo);
+            checkpointNumber = CheckpointNumber(0);
         } else {
-            const validationResult = await this.validateCheckpointProposal(proposal, proposalInfo);
+            const validationResult = await this.proposalHandler.handleCheckpointProposal(proposal, proposalInfo);
             if (!validationResult.isValid) {
                 this.log.warn(`Checkpoint proposal validation failed: ${validationResult.reason}`, proposalInfo);
                 return undefined;
             }
-        }
-        // Upload blobs to filestore if we can (fire and forget)
-        if (this.blobClient.canUpload()) {
-            void this.uploadBlobsForCheckpoint(proposal, proposalInfo);
+            checkpointNumber = validationResult.checkpointNumber;
         }
         // Check that I have any address in current committee before attesting
         // In fisherman mode, we still create attestations for validation even if not in committee
@@ -403,7 +388,7 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             });
             return undefined;
         }
-        return await this.createCheckpointAttestationsFromProposal(proposal, attestors);
+        return await this.createCheckpointAttestationsFromProposal(proposal, attestors, checkpointNumber);
     }
     /**
    * Checks if we should attest to a slot based on equivocation prevention rules.
@@ -420,176 +405,18 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
         }
         return true;
     }
-    async createCheckpointAttestationsFromProposal(proposal, attestors = []) {
+    async createCheckpointAttestationsFromProposal(proposal, attestors = [], checkpointNumber) {
         // Equivocation check: must happen right before signing to minimize the race window
         if (!this.shouldAttestToSlot(proposal.slotNumber)) {
             return undefined;
         }
-        const attestations = await this.validationService.attestToCheckpointProposal(proposal, attestors);
+        const attestations = await this.validationService.attestToCheckpointProposal(proposal, attestors, checkpointNumber);
         // Track the proposal we attested to (to prevent equivocation)
         this.lastAttestedProposal = proposal;
         await this.p2pClient.addOwnCheckpointAttestations(attestations);
         return attestations;
     }
     /**
-   * Validates a checkpoint proposal by building the full checkpoint and comparing it with the proposal.
-   * @returns Validation result with isValid flag and reason if invalid.
-   */ async validateCheckpointProposal(proposal, proposalInfo) {
-        const slot = proposal.slotNumber;
-        // Timeout block syncing at the start of the next slot
-        const config = this.checkpointsBuilder.getConfig();
-        const nextSlotTimestampSeconds = Number(getTimestampForSlot(SlotNumber(slot + 1), config));
-        const timeoutSeconds = Math.max(1, nextSlotTimestampSeconds - Math.floor(this.dateProvider.now() / 1000));
-        // Wait for last block to sync by archive
-        let lastBlockHeader;
-        try {
-            lastBlockHeader = await retryUntil(async ()=>{
-                await this.blockSource.syncImmediate();
-                return this.blockSource.getBlockHeaderByArchive(proposal.archive);
-            }, `waiting for block with archive ${proposal.archive.toString()} for slot ${slot}`, timeoutSeconds, 0.5);
-        } catch (err) {
-            if (err instanceof TimeoutError) {
-                this.log.warn(`Timed out waiting for block with archive matching checkpoint proposal`, proposalInfo);
-                return {
-                    isValid: false,
-                    reason: 'last_block_not_found'
-                };
-            }
-            this.log.error(`Error fetching last block for checkpoint proposal`, err, proposalInfo);
-            return {
-                isValid: false,
-                reason: 'block_fetch_error'
-            };
-        }
-        if (!lastBlockHeader) {
-            this.log.warn(`Last block not found for checkpoint proposal`, proposalInfo);
-            return {
-                isValid: false,
-                reason: 'last_block_not_found'
-            };
-        }
-        // Get all full blocks for the slot and checkpoint
-        const blocks = await this.blockSource.getBlocksForSlot(slot);
-        if (blocks.length === 0) {
-            this.log.warn(`No blocks found for slot ${slot}`, proposalInfo);
-            return {
-                isValid: false,
-                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)
-        });
-        // Get checkpoint constants from first block
-        const firstBlock = blocks[0];
-        const constants = this.extractCheckpointConstants(firstBlock);
-        const checkpointNumber = firstBlock.checkpointNumber;
-        // Get L1-to-L2 messages for this checkpoint
-        const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(checkpointNumber);
-        // Collect the out hashes of all the checkpoints before this one in the same epoch
-        const epoch = getEpochAtSlot(slot, this.epochCache.getL1Constants());
-        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);
-        try {
-            // Create checkpoint builder with all existing blocks
-            const checkpointBuilder = await this.checkpointsBuilder.openCheckpoint(checkpointNumber, constants, proposal.feeAssetPriceModifier, l1ToL2Messages, previousCheckpointOutHashes, fork, blocks, this.log.getBindings());
-            // Complete the checkpoint to get computed values
-            const computedCheckpoint = await checkpointBuilder.completeCheckpoint();
-            // Compare checkpoint header with proposal
-            if (!computedCheckpoint.header.equals(proposal.checkpointHeader)) {
-                this.log.warn(`Checkpoint header mismatch`, {
-                    ...proposalInfo,
-                    computed: computedCheckpoint.header.toInspect(),
-                    proposal: proposal.checkpointHeader.toInspect()
-                });
-                return {
-                    isValid: false,
-                    reason: 'checkpoint_header_mismatch'
-                };
-            }
-            // Compare archive root with proposal
-            if (!computedCheckpoint.archive.root.equals(proposal.archive)) {
-                this.log.warn(`Archive root mismatch`, {
-                    ...proposalInfo,
-                    computed: computedCheckpoint.archive.root.toString(),
-                    proposal: proposal.archive.toString()
-                });
-                return {
-                    isValid: false,
-                    reason: 'archive_mismatch'
-                };
-            }
-            // 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`, {
-                    proposalEpochOutHash: proposalEpochOutHash.toString(),
-                    computedEpochOutHash: computedEpochOutHash.toString(),
-                    checkpointOutHash: checkpointOutHash.toString(),
-                    previousCheckpointOutHashes: previousCheckpointOutHashes.map((h)=>h.toString()),
-                    ...proposalInfo
-                });
-                return {
-                    isValid: false,
-                    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
-            };
-        } finally{
-            await fork.close();
-        }
-    }
-    /**
-   * Extract checkpoint global variables from a block.
-   */ extractCheckpointConstants(block) {
-        const gv = block.header.globalVariables;
-        return {
-            chainId: gv.chainId,
-            version: gv.version,
-            slotNumber: gv.slotNumber,
-            timestamp: gv.timestamp,
-            coinbase: gv.coinbase,
-            feeRecipient: gv.feeRecipient,
-            gasFees: gv.gasFees
-        };
-    }
-    /**
    * Uploads blobs for a checkpoint to the filestore (fire and forget).
    */ async uploadBlobsForCheckpoint(proposal, proposalInfo) {
         try {
@@ -674,7 +501,7 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             }
         ]);
     }
-    async createBlockProposal(blockHeader, indexWithinCheckpoint, inHash, archive, txs, proposerAddress, options = {}) {
+    async createBlockProposal(blockHeader, checkpointNumber, indexWithinCheckpoint, inHash, archive, txs, proposerAddress, options = {}) {
         // Validate that we're not creating a proposal for an older or equal position
         if (this.lastProposedBlock) {
             const lastSlot = this.lastProposedBlock.slotNumber;
@@ -685,14 +512,14 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             }
         }
         this.log.info(`Assembling block proposal for block ${blockHeader.globalVariables.blockNumber} slot ${blockHeader.globalVariables.slotNumber}`);
-        const newProposal = await this.validationService.createBlockProposal(blockHeader, indexWithinCheckpoint, inHash, archive, txs, proposerAddress, {
+        const newProposal = await this.validationService.createBlockProposal(blockHeader, checkpointNumber, indexWithinCheckpoint, inHash, archive, txs, proposerAddress, {
             ...options,
             broadcastInvalidBlockProposal: this.config.broadcastInvalidBlockProposal
         });
         this.lastProposedBlock = newProposal;
         return newProposal;
     }
-    async createCheckpointProposal(checkpointHeader, archive, feeAssetPriceModifier, lastBlockInfo, proposerAddress, options = {}) {
+    async createCheckpointProposal(checkpointHeader, archive, checkpointNumber, feeAssetPriceModifier, lastBlockProposal, proposerAddress, options = {}) {
         // Validate that we're not creating a proposal for an older or equal slot
         if (this.lastProposedCheckpoint) {
             const lastSlot = this.lastProposedCheckpoint.slotNumber;
@@ -702,23 +529,23 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             }
         }
         this.log.info(`Assembling checkpoint proposal for slot ${checkpointHeader.slotNumber}`);
-        const newProposal = await this.validationService.createCheckpointProposal(checkpointHeader, archive, feeAssetPriceModifier, lastBlockInfo, proposerAddress, options);
+        const newProposal = await this.validationService.createCheckpointProposal(checkpointHeader, archive, checkpointNumber, feeAssetPriceModifier, lastBlockProposal, proposerAddress, options);
         this.lastProposedCheckpoint = newProposal;
         return newProposal;
     }
     async broadcastBlockProposal(proposal) {
         await this.p2pClient.broadcastProposal(proposal);
     }
-    async signAttestationsAndSigners(attestationsAndSigners, proposer, slot, blockNumber) {
-        return await this.validationService.signAttestationsAndSigners(attestationsAndSigners, proposer, slot, blockNumber);
+    async signAttestationsAndSigners(attestationsAndSigners, proposer, slot, checkpointNumber) {
+        return await this.validationService.signAttestationsAndSigners(attestationsAndSigners, proposer, slot, checkpointNumber);
     }
-    async collectOwnAttestations(proposal) {
+    async collectOwnAttestations(proposal, checkpointNumber) {
         const slot = proposal.slotNumber;
         const inCommittee = await this.epochCache.filterInCommittee(slot, this.getValidatorAddresses());
         this.log.debug(`Collecting ${inCommittee.length} self-attestations for slot ${slot}`, {
             inCommittee
         });
-        const attestations = await this.createCheckpointAttestationsFromProposal(proposal, inCommittee);
+        const attestations = await this.createCheckpointAttestationsFromProposal(proposal, inCommittee, checkpointNumber);
         if (!attestations) {
             return [];
         }
@@ -730,7 +557,7 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
         });
         return attestations;
     }
-    async collectAttestations(proposal, required, deadline) {
+    async collectAttestations(proposal, required, deadline, checkpointNumber) {
         // Wait and poll the p2pClient's attestation pool for this checkpoint until we have enough attestations
         const slot = proposal.slotNumber;
         this.log.debug(`Collecting ${required} attestations for slot ${slot} with deadline ${deadline.toISOString()}`);
@@ -738,7 +565,7 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             this.log.error(`Deadline ${deadline.toISOString()} for collecting ${required} attestations for slot ${slot} is in the past`);
             throw new AttestationTimeoutError(0, required, slot);
         }
-        await this.collectOwnAttestations(proposal);
+        await this.collectOwnAttestations(proposal, checkpointNumber);
         const proposalId = proposal.archive.toString();
         const myAddresses = this.getValidatorAddresses();
         let attestations = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/validator-client",
-  "version": "0.0.1-commit.7035c9bd6",
+  "version": "0.0.1-commit.71324e566",
   "main": "dest/index.js",
   "type": "module",
   "exports": {
@@ -64,30 +64,30 @@
     ]
   },
   "dependencies": {
-    "@aztec/blob-client": "0.0.1-commit.7035c9bd6",
-    "@aztec/blob-lib": "0.0.1-commit.7035c9bd6",
-    "@aztec/constants": "0.0.1-commit.7035c9bd6",
-    "@aztec/epoch-cache": "0.0.1-commit.7035c9bd6",
-    "@aztec/ethereum": "0.0.1-commit.7035c9bd6",
-    "@aztec/foundation": "0.0.1-commit.7035c9bd6",
-    "@aztec/node-keystore": "0.0.1-commit.7035c9bd6",
-    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.7035c9bd6",
-    "@aztec/p2p": "0.0.1-commit.7035c9bd6",
-    "@aztec/protocol-contracts": "0.0.1-commit.7035c9bd6",
-    "@aztec/prover-client": "0.0.1-commit.7035c9bd6",
-    "@aztec/simulator": "0.0.1-commit.7035c9bd6",
-    "@aztec/slasher": "0.0.1-commit.7035c9bd6",
-    "@aztec/stdlib": "0.0.1-commit.7035c9bd6",
-    "@aztec/telemetry-client": "0.0.1-commit.7035c9bd6",
-    "@aztec/validator-ha-signer": "0.0.1-commit.7035c9bd6",
+    "@aztec/blob-client": "0.0.1-commit.71324e566",
+    "@aztec/blob-lib": "0.0.1-commit.71324e566",
+    "@aztec/constants": "0.0.1-commit.71324e566",
+    "@aztec/epoch-cache": "0.0.1-commit.71324e566",
+    "@aztec/ethereum": "0.0.1-commit.71324e566",
+    "@aztec/foundation": "0.0.1-commit.71324e566",
+    "@aztec/node-keystore": "0.0.1-commit.71324e566",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.71324e566",
+    "@aztec/p2p": "0.0.1-commit.71324e566",
+    "@aztec/protocol-contracts": "0.0.1-commit.71324e566",
+    "@aztec/prover-client": "0.0.1-commit.71324e566",
+    "@aztec/simulator": "0.0.1-commit.71324e566",
+    "@aztec/slasher": "0.0.1-commit.71324e566",
+    "@aztec/stdlib": "0.0.1-commit.71324e566",
+    "@aztec/telemetry-client": "0.0.1-commit.71324e566",
+    "@aztec/validator-ha-signer": "0.0.1-commit.71324e566",
     "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.7035c9bd6",
-    "@aztec/world-state": "0.0.1-commit.7035c9bd6",
+    "@aztec/archiver": "0.0.1-commit.71324e566",
+    "@aztec/world-state": "0.0.1-commit.71324e566",
     "@electric-sql/pglite": "^0.3.14",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",

package/src/config.ts

@@ -49,11 +49,6 @@ export const validatorClientConfigMappings: ConfigMappingsType<ValidatorClientCo
     description: 'Interval between polling for new attestations',
     ...numberConfigHelper(200),
   },
-  validatorReexecute: {
-    env: 'VALIDATOR_REEXECUTE',
-    description: 'Re-execute transactions before attesting',
-    ...booleanConfigHelper(true),
-  },
   alwaysReexecuteBlockProposals: {
     description:
       'Whether to always reexecute block proposals, even for non-validator nodes (useful for monitoring network status).',
@@ -80,22 +75,22 @@ export const validatorClientConfigMappings: ConfigMappingsType<ValidatorClientCo
   validateMaxL2BlockGas: {
     env: 'VALIDATOR_MAX_L2_BLOCK_GAS',
     description: 'Maximum L2 block gas for validation. Proposals exceeding this limit are rejected.',
-    parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
+    parseEnv: (val: string) => parseInt(val, 10),
   },
   validateMaxDABlockGas: {
     env: 'VALIDATOR_MAX_DA_BLOCK_GAS',
     description: 'Maximum DA block gas for validation. Proposals exceeding this limit are rejected.',
-    parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
+    parseEnv: (val: string) => parseInt(val, 10),
   },
   validateMaxTxsPerBlock: {
     env: 'VALIDATOR_MAX_TX_PER_BLOCK',
     description: 'Maximum transactions per block for validation. Proposals exceeding this limit are rejected.',
-    parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
+    parseEnv: (val: string) => parseInt(val, 10),
   },
   validateMaxTxsPerCheckpoint: {
     env: 'VALIDATOR_MAX_TX_PER_CHECKPOINT',
     description: 'Maximum transactions per checkpoint for validation. Proposals exceeding this limit are rejected.',
-    parseEnv: (val: string) => (val ? parseInt(val, 10) : undefined),
+    parseEnv: (val: string) => parseInt(val, 10),
   },
   ...localSignerConfigMappings,
   ...validatorHASignerConfigMappings,

package/src/duties/validation_service.ts

@@ -1,9 +1,4 @@
-import {
-  BlockNumber,
-  type CheckpointNumber,
-  IndexWithinCheckpoint,
-  type SlotNumber,
-} from '@aztec/foundation/branded-types';
+import { 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';
@@ -11,7 +6,6 @@ import type { EthAddress } from '@aztec/foundation/eth-address';
 import type { Signature } from '@aztec/foundation/eth-signature';
 import { createLogger } from '@aztec/foundation/log';
 import type { CommitteeAttestationsAndSigners } from '@aztec/stdlib/block';
-import type { CreateCheckpointProposalLastBlockData } from '@aztec/stdlib/interfaces/server';
 import {
   BlockProposal,
   type BlockProposalOptions,
@@ -52,6 +46,7 @@ export class ValidationService {
    */
   public createBlockProposal(
     blockHeader: BlockHeader,
+    checkpointNumber: CheckpointNumber,
     blockIndexWithinCheckpoint: IndexWithinCheckpoint,
     inHash: Fr,
     archive: Fr,
@@ -72,6 +67,7 @@ export class ValidationService {
 
     return BlockProposal.createProposalFromSigner(
       blockHeader,
+      checkpointNumber,
       blockIndexWithinCheckpoint,
       inHash,
       archive,
@@ -86,7 +82,7 @@ export class ValidationService {
    *
    * @param checkpointHeader - The checkpoint header containing aggregated data
    * @param archive - The archive of the checkpoint
-   * @param lastBlockInfo - Info about the last block (header, index, txs) or undefined
+   * @param lastBlockProposal - Signed block proposal for the last block in the checkpoint, or undefined
    * @param proposerAttesterAddress - The address of the proposer
    * @param options - Checkpoint proposal options
    *
@@ -95,14 +91,17 @@ export class ValidationService {
   public createCheckpointProposal(
     checkpointHeader: CheckpointHeader,
     archive: Fr,
+    checkpointNumber: CheckpointNumber,
     feeAssetPriceModifier: bigint,
-    lastBlockInfo: CreateCheckpointProposalLastBlockData | undefined,
+    lastBlockProposal: BlockProposal | undefined,
     proposerAttesterAddress: EthAddress | undefined,
     options: CheckpointProposalOptions,
   ): Promise<CheckpointProposal> {
-    // For testing: change the archive to trigger state_mismatch validation failure
+    // For testing: change the archive to trigger state_mismatch validation failure.
+    // If there's a last block proposal, use its (already invalid) archive to keep signatures consistent
+    // so P2P validation passes and the slasher can detect the offense.
     if (options.broadcastInvalidCheckpointProposal) {
-      archive = Fr.random();
+      archive = lastBlockProposal?.archiveRoot ?? Fr.random();
       this.log.warn(`Creating INVALID checkpoint proposal for slot ${checkpointHeader.slotNumber}`);
     }
 
@@ -112,19 +111,12 @@ export class ValidationService {
       return this.keyStore.signMessageWithAddress(address, payload, context);
     };
 
-    // Last block to include in the proposal
-    const lastBlock = lastBlockInfo && {
-      blockHeader: lastBlockInfo.blockHeader,
-      indexWithinCheckpoint: lastBlockInfo.indexWithinCheckpoint,
-      txHashes: lastBlockInfo.txs.map(tx => tx.getTxHash()),
-      txs: options.publishFullTxs ? lastBlockInfo.txs : undefined,
-    };
-
     return CheckpointProposal.createProposalFromSigner(
       checkpointHeader,
       archive,
+      checkpointNumber,
       feeAssetPriceModifier,
-      lastBlock,
+      lastBlockProposal,
       payloadSigner,
     );
   }
@@ -142,6 +134,7 @@ export class ValidationService {
   async attestToCheckpointProposal(
     proposal: CheckpointProposalCore,
     attestors: EthAddress[],
+    checkpointNumber: CheckpointNumber,
   ): Promise<CheckpointAttestation[]> {
     // Create the attestation payload from the checkpoint proposal
     const payload = new ConsensusPayload(proposal.checkpointHeader, proposal.archive, proposal.feeAssetPriceModifier);
@@ -149,14 +142,9 @@ export class ValidationService {
       keccak256(payload.getPayloadToSign(SignatureDomainSeparator.checkpointAttestation)),
     );
 
-    // TODO(spy/ha): Use checkpointNumber instead of blockNumber once CheckpointHeader includes it.
-    // CheckpointProposalCore doesn't have lastBlock info, so use 0 as a proxy.
-    // blockNumber is NOT used for the primary key so it's safe to use here.
-    // See CheckpointHeader TODO and SigningContext types documentation.
-    const blockNumber = BlockNumber(0);
     const context: SigningContext = {
       slot: proposal.slotNumber,
-      blockNumber,
+      checkpointNumber,
       dutyType: DutyType.ATTESTATION,
     };
 
@@ -195,7 +183,6 @@ export class ValidationService {
    * @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
@@ -204,11 +191,11 @@ export class ValidationService {
     attestationsAndSigners: CommitteeAttestationsAndSigners,
     proposer: EthAddress,
     slot: SlotNumber,
-    blockNumber: BlockNumber | CheckpointNumber,
+    checkpointNumber: CheckpointNumber,
   ): Promise<Signature> {
     const context: SigningContext = {
       slot,
-      blockNumber,
+      checkpointNumber,
       dutyType: DutyType.ATTESTATIONS_AND_SIGNERS,
     };