@aztec/validator-client 0.0.1-commit.3fd054f6 → 0.0.1-commit.431c48d

package/dest/validator.js

@@ -1,42 +1,36 @@
 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 { FifoSet } from '@aztec/foundation/fifo-set';
 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 { AuthRequest, AuthResponse, ReqRespSubProtocol } from '@aztec/p2p';
+import { OffenseType, WANT_TO_CLEAR_SLASH_EVENT, WANT_TO_SLASH_EVENT, getOffenseTypeName } from '@aztec/slasher';
+import { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
+import { ConsensusTimetable } from '@aztec/stdlib/timetable';
 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, SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT, SLASHABLE_CHECKPOINT_PROPOSAL_VALIDATION_RESULT } 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;
-// What errors from the block proposal handler result in slashing
-const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
-    'state_mismatch',
-    'failed_txs'
-];
+const MAX_TRACKED_INVALID_CHECKPOINT_PROPOSALS = 1000;
+const MAX_TRACKED_BAD_ATTESTATIONS = 10_000;
 /**
  * Validator Client
  */ export class ValidatorClient extends EventEmitter {
     keyStore;
     epochCache;
     p2pClient;
-    blockProposalHandler;
+    proposalHandler;
     blockSource;
     checkpointsBuilder;
     worldState;
@@ -57,14 +51,18 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
     epochCacheUpdateLoop;
     /** Tracks the last epoch in which each attester successfully submitted at least one attestation. */ lastAttestedEpochByAttester;
     proposersOfInvalidBlocks;
+    invalidCheckpointProposalOffenseKeys;
+    oversizedProposalOffenseKeys;
+    badAttestationOffenseKeys;
     /** 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 = FifoSet.withLimit(MAX_PROPOSERS_OF_INVALID_BLOCKS), this.invalidCheckpointProposalOffenseKeys = FifoSet.withLimit(MAX_TRACKED_INVALID_CHECKPOINT_PROPOSALS), this.oversizedProposalOffenseKeys = FifoSet.withLimit(MAX_TRACKED_INVALID_CHECKPOINT_PROPOSALS), this.badAttestationOffenseKeys = FifoSet.withLimit(MAX_TRACKED_BAD_ATTESTATIONS);
         // Create child logger with fisherman prefix if in fisherman mode
         this.log = config.fishermanMode ? log.createChild('[FISHERMAN]') : log;
         this.tracer = telemetry.getTracer('Validator');
         this.metrics = new ValidatorMetrics(telemetry);
-        this.validationService = new ValidationService(keyStore, this.log.createChild('validation-service'));
+        this.validationService = new ValidationService(keyStore, this.getSignatureContext(), this.log.createChild('validation-service'));
+        this.proposalHandler.setCheckpointProposalValidationFailureCallback((proposal, result, proposalInfo)=>this.handleInvalidCheckpointProposal(proposal, result, proposalInfo));
         // Refresh epoch cache every second to trigger alert if participation in committee changes
         this.epochCacheUpdateLoop = new RunningPromise(this.handleEpochCommitteeUpdate.bind(this), this.log, 1000);
         const myAddresses = this.getValidatorAddresses();
@@ -114,13 +112,13 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             this.log.error(`Error updating epoch committee`, err);
         }
     }
-    static async new(config, checkpointsBuilder, worldState, epochCache, p2pClient, blockSource, l1ToL2MessageSource, txProvider, keyStoreManager, blobClient, dateProvider = new DateProvider(), telemetry = getTelemetryClient(), slashingProtectionDb) {
+    static async new(config, checkpointsBuilder, worldState, epochCache, p2pClient, blockSource, l1ToL2MessageSource, txProvider, keyStoreManager, blobClient, reexecutionTracker, dateProvider = new DateProvider(), telemetry = getTelemetryClient(), slashingProtectionDb) {
         const metrics = new ValidatorMetrics(telemetry);
-        const blockProposalValidator = new BlockProposalValidator(epochCache, {
-            txsPermitted: !config.disableTransactions,
-            maxTxsPerBlock: config.validateMaxTxsPerBlock
+        const consensusTimetable = new ConsensusTimetable({
+            l1Constants: epochCache.getL1Constants(),
+            blockDuration: config.blockDurationMs / 1000
         });
-        const blockProposalHandler = new BlockProposalHandler(checkpointsBuilder, worldState, blockSource, l1ToL2MessageSource, txProvider, blockProposalValidator, epochCache, config, metrics, dateProvider, telemetry);
+        const proposalHandler = new ProposalHandler(checkpointsBuilder, worldState, blockSource, l1ToL2MessageSource, txProvider, epochCache, consensusTimetable, config, blobClient, reexecutionTracker, metrics, dateProvider, telemetry, undefined);
         const nodeKeystoreAdapter = NodeKeystoreAdapter.fromKeyStoreManager(keyStoreManager);
         let slashingProtectionSigner;
         if (slashingProtectionDb) {
@@ -149,18 +147,24 @@ 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);
     }
+    getSignatureContext() {
+        return {
+            chainId: this.config.l1ChainId,
+            rollupAddress: this.config.rollupAddress
+        };
+    }
     getCoinbaseForAttestor(attestor) {
         return this.keyStore.getCoinbaseAddress(attestor);
     }
@@ -170,16 +174,23 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
     getConfig() {
         return this.config;
     }
+    hasProposalEquivocation(slotNumber) {
+        return this.proposalHandler.hasProposalEquivocation(slotNumber);
+    }
+    hasInvalidProposals(slotNumber) {
+        return this.proposalHandler.hasInvalidProposals(slotNumber);
+    }
     updateConfig(config) {
         this.config = {
             ...this.config,
             ...config
         };
+        this.proposalHandler.updateConfig(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'));
+        this.validationService = new ValidationService(this.keyStore, this.getSignatureContext(), this.log.createChild('validation-service'));
     }
     async start() {
         if (this.epochCacheUpdateLoop.isRunning()) {
@@ -212,15 +223,22 @@ 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);
             });
+            // Oversized proposal handler - triggers slashing for proposals beyond the per-checkpoint block limit
+            this.p2pClient.registerOversizedProposalCallback((info)=>{
+                this.handleOversizedProposal(info);
+            });
             // Duplicate attestation handler - triggers slashing for attestation equivocation
             this.p2pClient.registerDuplicateAttestationCallback((info)=>{
                 this.handleDuplicateAttestation(info);
             });
+            this.p2pClient.registerCheckpointAttestationCallback((attestation)=>{
+                this.handleCheckpointAttestation(attestation);
+            });
             const myAddresses = this.getValidatorAddresses();
             this.p2pClient.registerThisValidatorAddresses(myAddresses);
             await this.p2pClient.addReqRespSubProtocol(ReqRespSubProtocol.AUTH, this.handleAuthRequest.bind(this));
@@ -260,11 +278,8 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             txHashes: proposal.txHashes.map((t)=>t.toString()),
             fishermanMode: this.config.fishermanMode || false
         });
-        // 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);
+        // Reexecute outside the escape hatch so slashing observers can detect invalid proposals even when penalties are 0.
+        const validationResult = await this.proposalHandler.handleBlockProposal(proposal, proposalSender, !escapeHatchOpen);
         if (!validationResult.isValid) {
             const reason = validationResult.reason || 'unknown';
             this.log.warn(`Block proposal validation failed: ${reason}`, proposalInfo);
@@ -274,7 +289,9 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
                 'state_mismatch',
                 'failed_txs',
                 'in_hash_mismatch',
-                'parent_block_wrong_slot'
+                'parent_block_wrong_slot',
+                'duplicate_txs',
+                'invalid_embedded_txs'
             ];
             if (badProposalReasons.includes(reason)) {
                 this.metrics.incFailedAttestationsBadProposal(1, reason, partOfCommittee);
@@ -282,10 +299,14 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
                 // Node issues so we can't validate
                 this.metrics.incFailedAttestationsNodeIssue(1, reason, partOfCommittee);
             }
-            // Slash invalid block proposals (can happen even when not in committee)
-            if (!escapeHatchOpen && validationResult.reason && SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT.includes(validationResult.reason) && slashBroadcastedInvalidBlockPenalty > 0n) {
-                this.log.warn(`Slashing proposer for invalid block proposal`, proposalInfo);
+            if (!escapeHatchOpen && validationResult.reason && SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT.includes(validationResult.reason)) {
+                this.log.info(`Detected invalid block proposal offense`, {
+                    ...proposalInfo,
+                    amount: this.config.slashBroadcastedInvalidBlockPenalty,
+                    offenseType: getOffenseTypeName(OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL)
+                });
                 this.slashInvalidBlock(proposal);
+                this.markInvalidProposalSlot(proposal.slotNumber);
             }
             return false;
         }
@@ -314,49 +335,43 @@ 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}`);
+        // Early-out for equivocation: refuses if we've already attested to a higher slot.
+        if (!this.shouldAttestToSlot(proposalSlotNumber)) {
             return undefined;
         }
         // Ignore proposals from ourselves (may happen in HA setups)
-        if (this.getValidatorAddresses().some((addr)=>addr.equals(proposer))) {
-            this.log.debug(`Ignoring block proposal from self for slot ${proposalSlotNumber}`, {
+        if (proposer && this.getValidatorAddresses().some((addr)=>addr.equals(proposer))) {
+            this.log.debug(`Not attesting to 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 +418,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,180 +435,24 @@ 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 {
-            const lastBlockHeader = await this.blockSource.getBlockHeaderByArchive(proposal.archive);
+            const lastBlockHeader = (await this.blockSource.getBlockData({
+                archive: proposal.archive
+            }))?.header;
             if (!lastBlockHeader) {
                 this.log.warn(`Failed to get last block header for blob upload`, proposalInfo);
                 return;
@@ -621,11 +480,6 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             this.log.warn(`Cannot slash proposal with invalid signature`);
             return;
         }
-        // Trim the set if it's too big.
-        if (this.proposersOfInvalidBlocks.size > MAX_PROPOSERS_OF_INVALID_BLOCKS) {
-            // remove oldest proposer. `values` is guaranteed to be in insertion order.
-            this.proposersOfInvalidBlocks.delete(this.proposersOfInvalidBlocks.values().next().value);
-        }
         this.proposersOfInvalidBlocks.add(proposer.toString());
         this.emit(WANT_TO_SLASH_EVENT, [
             {
@@ -636,17 +490,122 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             }
         ]);
     }
+    handleInvalidCheckpointProposal(proposal, result, proposalInfo) {
+        if (!SLASHABLE_CHECKPOINT_PROPOSAL_VALIDATION_RESULT[result.reason]) {
+            return;
+        }
+        // The slot is already marked invalid by the all-nodes checkpoint handler that invokes this callback,
+        // so we only emit the proposer slash event here.
+        if (this.slashInvalidCheckpointProposal(proposal)) {
+            this.log.info(`Detected invalid checkpoint proposal offense`, {
+                ...proposalInfo,
+                reason: result.reason,
+                amount: this.config.slashBroadcastedInvalidCheckpointProposalPenalty,
+                offenseType: getOffenseTypeName(OffenseType.BROADCASTED_INVALID_CHECKPOINT_PROPOSAL)
+            });
+        }
+    }
+    slashInvalidCheckpointProposal(proposal) {
+        const proposer = proposal.getSender();
+        if (!proposer) {
+            this.log.warn(`Cannot slash checkpoint proposal with invalid signature`, {
+                slotNumber: proposal.slotNumber,
+                archive: proposal.archive.toString()
+            });
+            return false;
+        }
+        const offenseType = OffenseType.BROADCASTED_INVALID_CHECKPOINT_PROPOSAL;
+        const offenseKey = `${proposer.toString()}:${offenseType}:${proposal.slotNumber}`;
+        if (!this.invalidCheckpointProposalOffenseKeys.addIfAbsent(offenseKey)) {
+            return false;
+        }
+        this.emit(WANT_TO_SLASH_EVENT, [
+            {
+                validator: proposer,
+                amount: this.config.slashBroadcastedInvalidCheckpointProposalPenalty,
+                offenseType,
+                epochOrSlot: BigInt(proposal.slotNumber)
+            }
+        ]);
+        return true;
+    }
+    markInvalidProposalSlot(slotNumber) {
+        this.proposalHandler.markInvalidProposalSlot(slotNumber);
+    }
+    handleCheckpointAttestation(attestation) {
+        const slotNumber = attestation.slotNumber;
+        if (!this.proposalHandler.hasInvalidProposals(slotNumber) || this.proposalHandler.hasProposalEquivocation(slotNumber)) {
+            return;
+        }
+        const attester = attestation.getSender();
+        if (!attester) {
+            this.log.warn(`Cannot slash checkpoint attestation with invalid signature`, {
+                slotNumber,
+                archive: attestation.archive.toString()
+            });
+            return;
+        }
+        this.slashAttestedToInvalidCheckpointProposal(slotNumber, attester);
+    }
+    slashAttestedToInvalidCheckpointProposal(slotNumber, attester) {
+        const offenseKey = `${attester.toString()}:${OffenseType.ATTESTED_TO_INVALID_CHECKPOINT_PROPOSAL}:${slotNumber}`;
+        if (!this.badAttestationOffenseKeys.addIfAbsent(offenseKey)) {
+            return;
+        }
+        this.log.info(`Detected attestation to invalid checkpoint proposal offense`, {
+            attester: attester.toString(),
+            slotNumber,
+            amount: this.config.slashAttestInvalidCheckpointProposalPenalty,
+            offenseType: getOffenseTypeName(OffenseType.ATTESTED_TO_INVALID_CHECKPOINT_PROPOSAL)
+        });
+        this.emit(WANT_TO_SLASH_EVENT, [
+            {
+                validator: attester,
+                amount: this.config.slashAttestInvalidCheckpointProposalPenalty,
+                offenseType: OffenseType.ATTESTED_TO_INVALID_CHECKPOINT_PROPOSAL,
+                epochOrSlot: BigInt(slotNumber)
+            }
+        ]);
+    }
+    /**
+   * Handle detection of an oversized block proposal: one whose index within its checkpoint lands at or
+   * beyond the consensus per-checkpoint block limit. A single signed proposal at an illegal index is
+   * self-contained evidence, so emit an invalid-block-proposal slash event for the proposer, deduped per
+   * (proposer, slot) since the p2p layer reports every oversized proposal it stores.
+   */ handleOversizedProposal(info) {
+        const { slot, proposer } = info;
+        const offenseType = OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL;
+        if (!this.oversizedProposalOffenseKeys.addIfAbsent(`${proposer.toString()}:${offenseType}:${slot}`)) {
+            return;
+        }
+        this.log.info(`Detected oversized block proposal offense from ${proposer.toString()} at slot ${slot}`, {
+            proposer: proposer.toString(),
+            slot,
+            amount: this.config.slashBroadcastedInvalidBlockPenalty,
+            offenseType: getOffenseTypeName(offenseType)
+        });
+        this.emit(WANT_TO_SLASH_EVENT, [
+            {
+                validator: proposer,
+                amount: this.config.slashBroadcastedInvalidBlockPenalty,
+                offenseType,
+                epochOrSlot: BigInt(slot)
+            }
+        ]);
+    }
     /**
    * Handle detection of a duplicate proposal (equivocation).
    * Emits a slash event when a proposer sends multiple proposals for the same position.
    */ handleDuplicateProposal(info) {
         const { slot, proposer, type } = info;
-        this.log.warn(`Triggering slash event for duplicate ${type} proposal from ${proposer.toString()} at slot ${slot}`, {
+        this.proposalHandler.markProposalEquivocation(slot);
+        this.log.info(`Detected duplicate ${type} proposal offense from ${proposer.toString()} at slot ${slot}`, {
             proposer: proposer.toString(),
             slot,
-            type
+            type,
+            amount: this.config.slashDuplicateProposalPenalty,
+            offenseType: getOffenseTypeName(OffenseType.DUPLICATE_PROPOSAL)
         });
-        // Emit slash event
         this.emit(WANT_TO_SLASH_EVENT, [
             {
                 validator: proposer,
@@ -655,15 +614,23 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
                 epochOrSlot: BigInt(slot)
             }
         ]);
+        this.emit(WANT_TO_CLEAR_SLASH_EVENT, [
+            {
+                offenseType: OffenseType.ATTESTED_TO_INVALID_CHECKPOINT_PROPOSAL,
+                epochOrSlot: BigInt(slot)
+            }
+        ]);
     }
     /**
    * Handle detection of a duplicate attestation (equivocation).
    * Emits a slash event when an attester signs attestations for different proposals at the same slot.
    */ handleDuplicateAttestation(info) {
         const { slot, attester } = info;
-        this.log.warn(`Triggering slash event for duplicate attestation from ${attester.toString()} at slot ${slot}`, {
+        this.log.info(`Detected duplicate attestation offense from ${attester.toString()} at slot ${slot}`, {
             attester: attester.toString(),
-            slot
+            slot,
+            amount: this.config.slashDuplicateAttestationPenalty,
+            offenseType: getOffenseTypeName(OffenseType.DUPLICATE_ATTESTATION)
         });
         this.emit(WANT_TO_SLASH_EVENT, [
             {
@@ -674,7 +641,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 +652,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
+            broadcastInvalidBlockProposal: 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 +669,30 @@ 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;
+        // Self-record this slot's outcome on the re-execution tracker. Proposers don't run their
+        // own proposals through `handleCheckpointProposal`, so without this call the proposer's
+        // sentinel would see no outcome for slots it proposed and would mis-attribute itself as
+        // inactive. We pass the locally-computed `archive` (not `newProposal.archive`, which may
+        // be intentionally corrupted under test-only flags); from the proposer's local-view
+        // perspective the work it just completed is valid by definition.
+        this.proposalHandler.recordOwnCheckpointProposalAsValid(checkpointHeader.slotNumber, archive, checkpointNumber);
         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 +704,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,28 +712,20 @@ 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);
-        const proposalId = proposal.archive.toString();
+        await this.collectOwnAttestations(proposal, checkpointNumber);
+        const proposalPayloadHash = proposal.getPayloadHash();
         const myAddresses = this.getValidatorAddresses();
         let attestations = [];
         while(true){
-            // Filter out attestations with a mismatching archive. This should NOT happen since we have verified
-            // the proposer signature (ie our own) before accepting the attestation into the pool via the p2p client.
-            const collectedAttestations = (await this.p2pClient.getCheckpointAttestationsForSlot(slot, proposalId)).filter((attestation)=>{
-                if (!attestation.archive.equals(proposal.archive)) {
-                    this.log.warn(`Received attestation for slot ${slot} with mismatched archive from ${attestation.getSender()?.toString()}`, {
-                        attestationArchive: attestation.archive.toString(),
-                        proposalArchive: proposal.archive.toString()
-                    });
-                    return false;
-                }
-                return true;
-            });
+            // The pool already filters by proposal payload hash; if any attestation slips through with a
+            // mismatched payload hash, drop it defensively. Equivocations are emitted as separate slash
+            // events from libp2p_service.
+            const collectedAttestations = await this.p2pClient.getCheckpointAttestationsForSlot(slot, proposalPayloadHash);
             // Log new attestations we collected
             const oldSenders = attestations.map((attestation)=>attestation.getSender());
             for (const collected of collectedAttestations){
                 const collectedSender = collected.getSender();
-                // Skip attestations with invalid signatures
+                // Skip attestations with invalid signatures. Should not happen as we don't add invalid attestations to our pool.
                 if (!collectedSender) {
                     this.log.warn(`Skipping attestation with invalid signature for slot ${slot}`);
                     continue;