@aztec/validator-client 0.0.1-commit.179ed20 → 0.0.1-commit.181e2d196

package/dest/validator.js

@@ -1,5 +1,6 @@
 import { getBlobsPerL1Block } from '@aztec/blob-lib';
-import { BlockNumber } from '@aztec/foundation/branded-types';
+import { validateFeeAssetPriceModifier } from '@aztec/ethereum/contracts';
+import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { TimeoutError } from '@aztec/foundation/error';
 import { createLogger } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
@@ -8,7 +9,7 @@ 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 { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers';
+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';
@@ -41,6 +42,7 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
     l1ToL2MessageSource;
     config;
     blobClient;
+    haSigner;
     dateProvider;
     tracer;
     validationService;
@@ -48,13 +50,15 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
     log;
     // Whether it has already registered handlers on the p2p client
     hasRegisteredHandlers;
-    // Used to check if we are sending the same proposal twice
-    previousProposal;
+    /** Tracks the last block proposal we created, to detect duplicate proposal attempts. */ lastProposedBlock;
+    /** 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;
-    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();
+    /** Tracks the last checkpoint proposal we attested to, to prevent equivocation. */ lastAttestedProposal;
+    constructor(keyStore, epochCache, p2pClient, blockProposalHandler, blockSource, checkpointsBuilder, worldState, l1ToL2MessageSource, config, blobClient, haSigner, 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.haSigner = haSigner, 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');
@@ -93,6 +97,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()));
@@ -111,20 +116,27 @@ 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.maxTxsPerBlock
         });
         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 validatorKeyStore = nodeKeystoreAdapter;
+        let haSigner;
         if (config.haSigningEnabled) {
             // 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 { signer } = await createHASigner(haConfig, {
+                telemetryClient: telemetry,
+                dateProvider
+            });
+            haSigner = signer;
+            validatorKeyStore = new HAKeyStore(nodeKeystoreAdapter, signer);
         }
-        const validator = new ValidatorClient(validatorKeyStore, epochCache, p2pClient, blockProposalHandler, blockSource, checkpointsBuilder, worldState, l1ToL2MessageSource, config, blobClient, dateProvider, telemetry);
+        const validator = new ValidatorClient(validatorKeyStore, epochCache, p2pClient, blockProposalHandler, blockSource, checkpointsBuilder, worldState, l1ToL2MessageSource, config, blobClient, haSigner, dateProvider, telemetry);
         return validator;
     }
     getValidatorAddresses() {
@@ -151,6 +163,20 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             ...config
         };
     }
+    reloadKeystore(newManager) {
+        if (this.config.haSigningEnabled && !this.haSigner) {
+            this.log.warn('HA signing is enabled in config but was not initialized at startup. ' + 'Restart the node to enable HA signing.');
+        } else if (!this.config.haSigningEnabled && this.haSigner) {
+            this.log.warn('HA signing was disabled via config update but the HA signer is still active. ' + 'Restart the node to fully disable HA signing.');
+        }
+        const newAdapter = NodeKeystoreAdapter.fromKeyStoreManager(newManager);
+        if (this.haSigner) {
+            this.keyStore = new HAKeyStore(newAdapter, this.haSigner);
+        } else {
+            this.keyStore = newAdapter;
+        }
+        this.validationService = new ValidationService(this.keyStore, this.log.createChild('validation-service'));
+    }
     async start() {
         if (this.epochCacheUpdateLoop.isRunning()) {
             this.log.warn(`Validator client already started`);
@@ -183,6 +209,14 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             // and processed separately via the block handler above.
             const checkpointHandler = (checkpoint, proposalSender)=>this.attestToCheckpointProposal(checkpoint, proposalSender);
             this.p2pClient.registerCheckpointProposalHandler(checkpointHandler);
+            // Duplicate proposal handler - triggers slashing for equivocation
+            this.p2pClient.registerDuplicateProposalCallback((info)=>{
+                this.handleDuplicateProposal(info);
+            });
+            // Duplicate attestation handler - triggers slashing for attestation equivocation
+            this.p2pClient.registerDuplicateAttestationCallback((info)=>{
+                this.handleDuplicateAttestation(info);
+            });
             const myAddresses = this.getValidatorAddresses();
             this.p2pClient.registerThisValidatorAddresses(myAddresses);
             await this.p2pClient.addReqRespSubProtocol(ReqRespSubProtocol.AUTH, this.handleAuthRequest.bind(this));
@@ -203,6 +237,14 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             this.log.warn(`Received block proposal with invalid signature for slot ${slotNumber}`);
             return false;
         }
+        // Ignore proposals from ourselves (may happen in HA setups)
+        if (this.getValidatorAddresses().some((addr)=>addr.equals(proposer))) {
+            this.log.warn(`Ignoring block proposal from self for slot ${slotNumber}`, {
+                proposer: proposer.toString(),
+                slotNumber
+            });
+            return false;
+        }
         // Check if we're in the committee (for metrics purposes)
         const inCommittee = await this.epochCache.filterInCommittee(slotNumber, this.getValidatorAddresses());
         const partOfCommittee = inCommittee.length > 0;
@@ -274,6 +316,19 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             this.log.warn(`Received checkpoint proposal with invalid signature for slot ${slotNumber}`);
             return undefined;
         }
+        // Ignore proposals from ourselves (may happen in HA setups)
+        if (this.getValidatorAddresses().some((addr)=>addr.equals(proposer))) {
+            this.log.warn(`Ignoring block proposal from self for slot ${slotNumber}`, {
+                proposer: proposer.toString(),
+                slotNumber
+            });
+            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 ${slotNumber}`);
+            return undefined;
+        }
         // Check that I have any address in current committee before attesting
         const inCommittee = await this.epochCache.filterInCommittee(slotNumber, this.getValidatorAddresses());
         const partOfCommittee = inCommittee.length > 0;
@@ -315,6 +370,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) {
@@ -337,11 +402,32 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             });
             return undefined;
         }
-        return this.createCheckpointAttestationsFromProposal(proposal, attestors);
+        return await this.createCheckpointAttestationsFromProposal(proposal, attestors);
+    }
+    /**
+   * Checks if we should attest to a slot based on equivocation prevention rules.
+   * @returns true if we should attest, false if we should skip
+   */ shouldAttestToSlot(slotNumber) {
+        // If attestToEquivocatedProposals is true, always allow
+        if (this.config.attestToEquivocatedProposals) {
+            return true;
+        }
+        // Check if incoming slot is strictly greater than last attested
+        if (this.lastAttestedProposal && slotNumber <= this.lastAttestedProposal.slotNumber) {
+            this.log.warn(`Refusing to process a proposal for slot ${slotNumber} given we already attested to a proposal for slot ${this.lastAttestedProposal.slotNumber}`);
+            return false;
+        }
+        return true;
     }
     async createCheckpointAttestationsFromProposal(proposal, attestors = []) {
+        // 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);
-        await this.p2pClient.addCheckpointAttestations(attestations);
+        // Track the proposal we attested to (to prevent equivocation)
+        this.lastAttestedProposal = proposal;
+        await this.p2pClient.addOwnCheckpointAttestations(attestations);
         return attestations;
     }
     /**
@@ -349,7 +435,10 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
    * @returns Validation result with isValid flag and reason if invalid.
    */ async validateCheckpointProposal(proposal, proposalInfo) {
         const slot = proposal.slotNumber;
-        const timeoutSeconds = 10; // TODO(palla/mbps): This should map to the timetable settings
+        // 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 {
@@ -387,6 +476,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)
@@ -397,18 +494,15 @@ 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);
         try {
             // Create checkpoint builder with all existing blocks
-            const checkpointBuilder = await this.checkpointsBuilder.openCheckpoint(checkpointNumber, constants, l1ToL2Messages, previousCheckpointOutHashes, fork, blocks, this.log.getBindings());
+            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
@@ -472,6 +566,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
@@ -492,7 +587,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,
@@ -524,23 +619,75 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             }
         ]);
     }
+    /**
+   * 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}`, {
+            proposer: proposer.toString(),
+            slot,
+            type
+        });
+        // Emit slash event
+        this.emit(WANT_TO_SLASH_EVENT, [
+            {
+                validator: proposer,
+                amount: this.config.slashDuplicateProposalPenalty,
+                offenseType: OffenseType.DUPLICATE_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}`, {
+            attester: attester.toString(),
+            slot
+        });
+        this.emit(WANT_TO_SLASH_EVENT, [
+            {
+                validator: attester,
+                amount: this.config.slashDuplicateAttestationPenalty,
+                offenseType: OffenseType.DUPLICATE_ATTESTATION,
+                epochOrSlot: BigInt(slot)
+            }
+        ]);
+    }
     async createBlockProposal(blockHeader, indexWithinCheckpoint, inHash, archive, txs, proposerAddress, options = {}) {
-        // TODO(palla/mbps): Prevent double proposals properly
-        // if (this.previousProposal?.slotNumber === blockHeader.globalVariables.slotNumber) {
-        //   this.log.verbose(`Already made a proposal for the same slot, skipping proposal`);
-        //   return Promise.resolve(undefined);
-        // }
+        // Validate that we're not creating a proposal for an older or equal position
+        if (this.lastProposedBlock) {
+            const lastSlot = this.lastProposedBlock.slotNumber;
+            const lastIndex = this.lastProposedBlock.indexWithinCheckpoint;
+            const newSlot = blockHeader.globalVariables.slotNumber;
+            if (newSlot < lastSlot || newSlot === lastSlot && indexWithinCheckpoint <= lastIndex) {
+                throw new Error(`Cannot create block proposal for slot ${newSlot} index ${indexWithinCheckpoint}: ` + `already proposed block for slot ${lastSlot} index ${lastIndex}`);
+            }
+        }
         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, {
             ...options,
             broadcastInvalidBlockProposal: this.config.broadcastInvalidBlockProposal
         });
-        this.previousProposal = newProposal;
+        this.lastProposedBlock = newProposal;
         return newProposal;
     }
-    async createCheckpointProposal(checkpointHeader, archive, lastBlockInfo, proposerAddress, options = {}) {
+    async createCheckpointProposal(checkpointHeader, archive, feeAssetPriceModifier, lastBlockInfo, proposerAddress, options = {}) {
+        // Validate that we're not creating a proposal for an older or equal slot
+        if (this.lastProposedCheckpoint) {
+            const lastSlot = this.lastProposedCheckpoint.slotNumber;
+            const newSlot = checkpointHeader.slotNumber;
+            if (newSlot <= lastSlot) {
+                throw new Error(`Cannot create checkpoint proposal for slot ${newSlot}: ` + `already proposed checkpoint for slot ${lastSlot}`);
+            }
+        }
         this.log.info(`Assembling checkpoint proposal for slot ${checkpointHeader.slotNumber}`);
-        return await this.validationService.createCheckpointProposal(checkpointHeader, archive, lastBlockInfo, proposerAddress, options);
+        const newProposal = await this.validationService.createCheckpointProposal(checkpointHeader, archive, feeAssetPriceModifier, lastBlockInfo, proposerAddress, options);
+        this.lastProposedCheckpoint = newProposal;
+        return newProposal;
     }
     async broadcastBlockProposal(proposal) {
         await this.p2pClient.broadcastProposal(proposal);
@@ -555,6 +702,9 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             inCommittee
         });
         const attestations = await this.createCheckpointAttestationsFromProposal(proposal, inCommittee);
+        if (!attestations) {
+            return [];
+        }
         // We broadcast our own attestations to our peers so, in case our block does not get mined on L1,
         // other nodes can see that our validators did attest to this block proposal, and do not slash us
         // due to inactivity for missed attestations.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/validator-client",
-  "version": "0.0.1-commit.179ed20",
+  "version": "0.0.1-commit.181e2d196",
   "main": "dest/index.js",
   "type": "module",
   "exports": {
@@ -64,30 +64,30 @@
     ]
   },
   "dependencies": {
-    "@aztec/blob-client": "0.0.1-commit.179ed20",
-    "@aztec/blob-lib": "0.0.1-commit.179ed20",
-    "@aztec/constants": "0.0.1-commit.179ed20",
-    "@aztec/epoch-cache": "0.0.1-commit.179ed20",
-    "@aztec/ethereum": "0.0.1-commit.179ed20",
-    "@aztec/foundation": "0.0.1-commit.179ed20",
-    "@aztec/node-keystore": "0.0.1-commit.179ed20",
-    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.179ed20",
-    "@aztec/p2p": "0.0.1-commit.179ed20",
-    "@aztec/protocol-contracts": "0.0.1-commit.179ed20",
-    "@aztec/prover-client": "0.0.1-commit.179ed20",
-    "@aztec/simulator": "0.0.1-commit.179ed20",
-    "@aztec/slasher": "0.0.1-commit.179ed20",
-    "@aztec/stdlib": "0.0.1-commit.179ed20",
-    "@aztec/telemetry-client": "0.0.1-commit.179ed20",
-    "@aztec/validator-ha-signer": "0.0.1-commit.179ed20",
+    "@aztec/blob-client": "0.0.1-commit.181e2d196",
+    "@aztec/blob-lib": "0.0.1-commit.181e2d196",
+    "@aztec/constants": "0.0.1-commit.181e2d196",
+    "@aztec/epoch-cache": "0.0.1-commit.181e2d196",
+    "@aztec/ethereum": "0.0.1-commit.181e2d196",
+    "@aztec/foundation": "0.0.1-commit.181e2d196",
+    "@aztec/node-keystore": "0.0.1-commit.181e2d196",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.181e2d196",
+    "@aztec/p2p": "0.0.1-commit.181e2d196",
+    "@aztec/protocol-contracts": "0.0.1-commit.181e2d196",
+    "@aztec/prover-client": "0.0.1-commit.181e2d196",
+    "@aztec/simulator": "0.0.1-commit.181e2d196",
+    "@aztec/slasher": "0.0.1-commit.181e2d196",
+    "@aztec/stdlib": "0.0.1-commit.181e2d196",
+    "@aztec/telemetry-client": "0.0.1-commit.181e2d196",
+    "@aztec/validator-ha-signer": "0.0.1-commit.181e2d196",
     "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.179ed20",
-    "@aztec/world-state": "0.0.1-commit.179ed20",
+    "@aztec/archiver": "0.0.1-commit.181e2d196",
+    "@aztec/world-state": "0.0.1-commit.181e2d196",
     "@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,6 @@
 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 { Fr } from '@aztec/foundation/curves/bn254';
 import { TimeoutError } from '@aztec/foundation/error';
 import { createLogger } from '@aztec/foundation/log';
@@ -9,16 +8,12 @@ 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 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,
@@ -153,16 +148,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 +166,9 @@ export class BlockProposalHandler {
 
     // Compute the block number based on the parent block
     const blockNumber =
-      parentBlockHeader === 'genesis'
+      parentBlock === 'genesis'
         ? BlockNumber(INITIAL_L2_BLOCK_NUM)
-        : BlockNumber(parentBlockHeader.getBlockNumber() + 1);
+        : BlockNumber(parentBlock.header.getBlockNumber() + 1);
 
     // Check that this block number does not exist already
     const existingBlock = await this.blockSource.getBlockHeader(blockNumber);
@@ -190,7 +185,7 @@ export class BlockProposalHandler {
     });
 
     // Compute the checkpoint number for this block and validate checkpoint consistency
-    const checkpointResult = await this.computeCheckpointNumber(proposal, parentBlockHeader, proposalInfo);
+    const checkpointResult = this.computeCheckpointNumber(proposal, parentBlock, proposalInfo);
     if (checkpointResult.reason) {
       return { isValid: false, blockNumber, reason: checkpointResult.reason };
     }
@@ -218,17 +213,11 @@ export class BlockProposalHandler {
     // 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.
+      // Collect the out hashes of all the checkpoints before this one in the same epoch
       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))),
-      );
+      const previousCheckpointOutHashes = (await this.blockSource.getCheckpointsDataForEpoch(epoch))
+        .filter(c => c.checkpointNumber < checkpointNumber)
+        .map(c => c.checkpointOutHash);
 
       try {
         this.log.verbose(`Re-executing transactions in the proposal`, proposalInfo);
@@ -260,7 +249,7 @@ export class BlockProposalHandler {
     return { isValid: true, blockNumber, reexecutionResult };
   }
 
-  private async getParentBlock(proposal: BlockProposal): Promise<'genesis' | BlockHeader | undefined> {
+  private async getParentBlock(proposal: BlockProposal): Promise<'genesis' | BlockData | undefined> {
     const parentArchive = proposal.blockHeader.lastArchive.root;
     const slot = proposal.slotNumber;
     const config = this.checkpointsBuilder.getConfig();
@@ -276,12 +265,11 @@ export class BlockProposalHandler {
 
     try {
       return (
-        (await this.blockSource.getBlockHeaderByArchive(parentArchive)) ??
+        (await this.blockSource.getBlockDataByArchive(parentArchive)) ??
         (timeoutDurationMs <= 0
           ? undefined
           : await retryUntil(
-              () =>
-                this.blockSource.syncImmediate().then(() => this.blockSource.getBlockHeaderByArchive(parentArchive)),
+              () => this.blockSource.syncImmediate().then(() => this.blockSource.getBlockDataByArchive(parentArchive)),
               'force archiver sync',
               timeoutDurationMs / 1000,
               0.5,
@@ -297,12 +285,12 @@ export class BlockProposalHandler {
     }
   }
 
-  private async computeCheckpointNumber(
+  private computeCheckpointNumber(
     proposal: BlockProposal,
-    parentBlockHeader: 'genesis' | BlockHeader,
+    parentBlock: 'genesis' | BlockData,
     proposalInfo: object,
-  ): Promise<CheckpointComputationResult> {
-    if (parentBlockHeader === 'genesis') {
+  ): CheckpointComputationResult {
+    if (parentBlock === 'genesis') {
       // First block is in checkpoint 1
       if (proposal.indexWithinCheckpoint !== 0) {
         this.log.warn(`First block proposal has non-zero indexWithinCheckpoint`, proposalInfo);
@@ -311,19 +299,9 @@ export class BlockProposalHandler {
       return { checkpointNumber: CheckpointNumber.INITIAL };
     }
 
-    // Get the parent block to find its checkpoint number
-    // TODO(palla/mbps): The block header should include the checkpoint number to avoid this lookup,
-    // or at least the L2BlockSource should return a different struct that includes it.
-    const parentBlockNumber = parentBlockHeader.getBlockNumber();
-    const parentBlock = await this.blockSource.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 +313,7 @@ export class BlockProposalHandler {
       this.log.warn(`Non-sequential indexWithinCheckpoint`, proposalInfo);
       return { reason: 'invalid_proposal' };
     }
-    if (proposal.blockHeader.getSlot() !== parentBlockHeader.getSlot()) {
+    if (proposal.blockHeader.getSlot() !== parentBlock.header.getSlot()) {
       this.log.warn(`Slot should be equal to parent block slot for non-first block in checkpoint`, proposalInfo);
       return { reason: 'invalid_proposal' };
     }
@@ -356,7 +334,7 @@ export class BlockProposalHandler {
    */
   private validateNonFirstBlockInCheckpoint(
     proposal: BlockProposal,
-    parentBlock: L2Block,
+    parentBlock: BlockData,
     proposalInfo: object,
   ): CheckpointComputationResult | undefined {
     const proposalGlobals = proposal.blockHeader.globalVariables;
@@ -475,13 +453,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,
@@ -491,6 +470,7 @@ export class BlockProposalHandler {
     const checkpointBuilder = await this.checkpointsBuilder.openCheckpoint(
       checkpointNumber,
       constants,
+      0n, // only takes effect in the following checkpoint.
       l1ToL2Messages,
       previousCheckpointOutHashes,
       fork,