@aztec/validator-client 0.0.1-commit.9593d84 → 0.0.1-commit.96bb3f7

package/dest/validator.js

@@ -1,4 +1,8 @@
+import { getBlobsPerL1Block } from '@aztec/blob-lib';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { TimeoutError } from '@aztec/foundation/error';
 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';
@@ -26,7 +30,12 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
     epochCache;
     p2pClient;
     blockProposalHandler;
+    blockSource;
+    checkpointsBuilder;
+    worldState;
+    l1ToL2MessageSource;
     config;
+    blobClient;
     dateProvider;
     tracer;
     validationService;
@@ -39,8 +48,12 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
     lastEpochForCommitteeUpdateLoop;
     epochCacheUpdateLoop;
     proposersOfInvalidBlocks;
-    constructor(keyStore, epochCache, p2pClient, blockProposalHandler, config, dateProvider = new DateProvider(), telemetry = getTelemetryClient(), log = createLogger('validator')){
-        super(), this.keyStore = keyStore, this.epochCache = epochCache, this.p2pClient = p2pClient, this.blockProposalHandler = blockProposalHandler, this.config = config, this.dateProvider = dateProvider, this.hasRegisteredHandlers = false, this.proposersOfInvalidBlocks = new Set();
+    // TODO(palla/mbps): Remove this once checkpoint validation is stable and we can validate all blocks properly.
+    // Tracks slots for which we have successfully validated a block proposal, so we can attest to checkpoint proposals for those slots.
+    // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+    validatedBlockSlots;
+    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(), this.validatedBlockSlots = 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');
@@ -94,13 +107,13 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             this.log.error(`Error updating epoch committee`, err);
         }
     }
-    static new(config, blockBuilder, epochCache, p2pClient, blockSource, l1ToL2MessageSource, txProvider, keyStoreManager, dateProvider = new DateProvider(), telemetry = getTelemetryClient()) {
+    static 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
         });
-        const blockProposalHandler = new BlockProposalHandler(blockBuilder, blockSource, l1ToL2MessageSource, txProvider, blockProposalValidator, config, metrics, dateProvider, telemetry);
-        const validator = new ValidatorClient(NodeKeystoreAdapter.fromKeyStoreManager(keyStoreManager), epochCache, p2pClient, blockProposalHandler, config, dateProvider, telemetry);
+        const blockProposalHandler = new BlockProposalHandler(checkpointsBuilder, worldState, blockSource, l1ToL2MessageSource, txProvider, blockProposalValidator, config, metrics, dateProvider, telemetry);
+        const validator = new ValidatorClient(NodeKeystoreAdapter.fromKeyStoreManager(keyStoreManager), epochCache, p2pClient, blockProposalHandler, blockSource, checkpointsBuilder, worldState, l1ToL2MessageSource, config, blobClient, dateProvider, telemetry);
         return validator;
     }
     getValidatorAddresses() {
@@ -109,10 +122,6 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
     getBlockProposalHandler() {
         return this.blockProposalHandler;
     }
-    // Proxy method for backwards compatibility with tests
-    reExecuteTransactions(proposal, blockNumber, txs, l1ToL2Messages) {
-        return this.blockProposalHandler.reexecuteTransactions(proposal, blockNumber, txs, l1ToL2Messages);
-    }
     signWithAddress(addr, msg) {
         return this.keyStore.signTypedDataWithAddress(addr, msg);
     }
@@ -153,41 +162,50 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
         if (!this.hasRegisteredHandlers) {
             this.hasRegisteredHandlers = true;
             this.log.debug(`Registering validator handlers for p2p client`);
-            const handler = (block, proposalSender)=>this.attestToProposal(block, proposalSender);
-            this.p2pClient.registerBlockProposalHandler(handler);
+            // Block proposal handler - validates but does NOT attest (validators only attest to checkpoints)
+            const blockHandler = (block, proposalSender)=>this.validateBlockProposal(block, proposalSender);
+            this.p2pClient.registerBlockProposalHandler(blockHandler);
+            // Checkpoint proposal handler - validates and creates attestations
+            // 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);
             const myAddresses = this.getValidatorAddresses();
             this.p2pClient.registerThisValidatorAddresses(myAddresses);
             await this.p2pClient.addReqRespSubProtocol(ReqRespSubProtocol.AUTH, this.handleAuthRequest.bind(this));
         }
     }
-    async attestToProposal(proposal, proposalSender) {
+    /**
+   * Validate a block proposal from a peer.
+   * Note: Validators do NOT attest to individual blocks - attestations are only for checkpoint proposals.
+   * @returns true if the proposal is valid, false otherwise
+   */ async validateBlockProposal(proposal, proposalSender) {
         const slotNumber = proposal.slotNumber;
         const proposer = proposal.getSender();
         // Reject proposals with invalid signatures
         if (!proposer) {
-            this.log.warn(`Received proposal with invalid signature for slot ${slotNumber}`);
-            return undefined;
+            this.log.warn(`Received block proposal with invalid signature for slot ${slotNumber}`);
+            return false;
         }
-        // Check that I have any address in current committee before attesting
+        // Check if we're in the committee (for metrics purposes)
         const inCommittee = await this.epochCache.filterInCommittee(slotNumber, this.getValidatorAddresses());
         const partOfCommittee = inCommittee.length > 0;
         const proposalInfo = {
             ...proposal.toBlockInfo(),
             proposer: proposer.toString()
         };
-        this.log.info(`Received proposal for slot ${slotNumber}`, {
+        this.log.info(`Received block proposal for slot ${slotNumber}`, {
             ...proposalInfo,
             txHashes: proposal.txHashes.map((t)=>t.toString()),
             fishermanMode: this.config.fishermanMode || false
         });
-        // Reexecute txs if we are part of the committee so we can attest, or if slashing is enabled so we can slash
-        // invalid proposals even when not in the committee, or if we are configured to always reexecute for monitoring purposes.
+        // 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;
+        const shouldReexecute = fishermanMode || slashBroadcastedInvalidBlockPenalty > 0n && validatorReexecute || partOfCommittee && validatorReexecute || alwaysReexecuteBlockProposals || this.blobClient.canUpload();
         const validationResult = await this.blockProposalHandler.handleBlockProposal(proposal, proposalSender, !!shouldReexecute);
         if (!validationResult.isValid) {
-            this.log.warn(`Proposal validation failed: ${validationResult.reason}`, proposalInfo);
+            this.log.warn(`Block proposal validation failed: ${validationResult.reason}`, proposalInfo);
             const reason = validationResult.reason || 'unknown';
             // Classify failure reason: bad proposal vs node issue
             const badProposalReasons = [
@@ -200,7 +218,7 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             if (badProposalReasons.includes(reason)) {
                 this.metrics.incFailedAttestationsBadProposal(1, reason, partOfCommittee);
             } else {
-                // Node issues so we can't attest
+                // Node issues so we can't validate
                 this.metrics.incFailedAttestationsNodeIssue(1, reason, partOfCommittee);
             }
             // Slash invalid block proposals (can happen even when not in committee)
@@ -208,8 +226,66 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
                 this.log.warn(`Slashing proposer for invalid block proposal`, proposalInfo);
                 this.slashInvalidBlock(proposal);
             }
+            return false;
+        }
+        this.log.info(`Validated block proposal for slot ${slotNumber}`, {
+            ...proposalInfo,
+            inCommittee: partOfCommittee,
+            fishermanMode: this.config.fishermanMode || false
+        });
+        // TODO(palla/mbps): Remove this once checkpoint validation is stable.
+        // Track that we successfully validated a block for this slot, so we can attest to checkpoint proposals for it.
+        this.validatedBlockSlots.add(slotNumber);
+        return true;
+    }
+    /**
+   * Validate and attest to a checkpoint proposal from a peer.
+   * The proposal is received as CheckpointProposalCore (without lastBlock) since
+   * the lastBlock is extracted and processed separately via the block handler.
+   * @returns Checkpoint attestations if valid, undefined otherwise
+   */ async attestToCheckpointProposal(proposal, _proposalSender) {
+        const slotNumber = proposal.slotNumber;
+        const proposer = proposal.getSender();
+        // Reject proposals with invalid signatures
+        if (!proposer) {
+            this.log.warn(`Received checkpoint proposal with invalid signature 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;
+        const proposalInfo = {
+            slotNumber,
+            archive: proposal.archive.toString(),
+            proposer: proposer.toString(),
+            txCount: proposal.txHashes.length
+        };
+        this.log.info(`Received checkpoint proposal for slot ${slotNumber}`, {
+            ...proposalInfo,
+            txHashes: proposal.txHashes.map((t)=>t.toString()),
+            fishermanMode: this.config.fishermanMode || false
+        });
+        // TODO(palla/mbps): Remove this once checkpoint validation is stable.
+        // Check that we have successfully validated a block for this slot before attesting to the checkpoint.
+        if (!this.validatedBlockSlots.has(slotNumber)) {
+            this.log.warn(`No validated block found for slot ${slotNumber}, refusing to attest to checkpoint`, proposalInfo);
             return undefined;
         }
+        // Validate the checkpoint proposal before attesting (unless skipCheckpointProposalValidation is set)
+        // TODO(palla/mbps): Change default to false once checkpoint validation is stable.
+        if (this.config.skipCheckpointProposalValidation !== false) {
+            this.log.verbose(`Skipping checkpoint proposal validation for slot ${slotNumber}`, proposalInfo);
+        } else {
+            const validationResult = await this.validateCheckpointProposal(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);
+        }
         // 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
         if (!partOfCommittee && !this.config.fishermanMode) {
@@ -217,13 +293,12 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             return undefined;
         }
         // Provided all of the above checks pass, we can attest to the proposal
-        this.log.info(`${partOfCommittee ? 'Attesting to' : 'Validated'} proposal for slot ${slotNumber}`, {
+        this.log.info(`${partOfCommittee ? 'Attesting to' : 'Validated'} checkpoint proposal for slot ${slotNumber}`, {
             ...proposalInfo,
             inCommittee: partOfCommittee,
             fishermanMode: this.config.fishermanMode || false
         });
         this.metrics.incSuccessfulAttestations(inCommittee.length);
-        // If the above function does not throw an error, then we can attest to the proposal
         // Determine which validators should attest
         let attestors;
         if (partOfCommittee) {
@@ -240,13 +315,194 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
         }
         if (this.config.fishermanMode) {
             // bail out early and don't save attestations to the pool in fisherman mode
-            this.log.info(`Creating attestations for proposal for slot ${slotNumber}`, {
+            this.log.info(`Creating checkpoint attestations for slot ${slotNumber}`, {
                 ...proposalInfo,
                 attestors: attestors.map((a)=>a.toString())
             });
             return undefined;
         }
-        return this.createBlockAttestationsFromProposal(proposal, attestors);
+        return this.createCheckpointAttestationsFromProposal(proposal, attestors);
+    }
+    async createCheckpointAttestationsFromProposal(proposal, attestors = []) {
+        const attestations = await this.validationService.attestToCheckpointProposal(proposal, attestors);
+        await this.p2pClient.addCheckpointAttestations(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;
+        const timeoutSeconds = 10;
+        // 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 the last full block to determine checkpoint number
+        const lastBlock = await this.blockSource.getL2BlockNew(lastBlockHeader.getBlockNumber());
+        if (!lastBlock) {
+            this.log.warn(`Last block ${lastBlockHeader.getBlockNumber()} not found`, proposalInfo);
+            return {
+                isValid: false,
+                reason: 'last_block_not_found'
+            };
+        }
+        const checkpointNumber = lastBlock.checkpointNumber;
+        // Get all full blocks for the slot and checkpoint
+        const blocks = await this.getBlocksForSlot(slot, lastBlockHeader, checkpointNumber);
+        if (blocks.length === 0) {
+            this.log.warn(`No blocks found for slot ${slot}`, proposalInfo);
+            return {
+                isValid: false,
+                reason: 'no_blocks_for_slot'
+            };
+        }
+        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);
+        // Get L1-to-L2 messages for this checkpoint
+        const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(checkpointNumber);
+        // 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, fork, blocks);
+            // 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'
+                };
+            }
+            this.log.verbose(`Checkpoint proposal validation successful for slot ${slot}`, proposalInfo);
+            return {
+                isValid: true
+            };
+        } finally{
+            await fork.close();
+        }
+    }
+    /**
+   * Get all full blocks for a given slot and checkpoint by walking backwards from the last block.
+   * Returns blocks in ascending order (earliest to latest).
+   * TODO(palla/mbps): Add getL2BlocksForSlot() to L2BlockSource interface for efficiency.
+   */ async getBlocksForSlot(slot, lastBlockHeader, checkpointNumber) {
+        const blocks = [];
+        let currentHeader = lastBlockHeader;
+        const { genesisArchiveRoot } = await this.blockSource.getGenesisValues();
+        while(currentHeader.getSlot() === slot){
+            const block = await this.blockSource.getL2BlockNew(currentHeader.getBlockNumber());
+            if (!block) {
+                this.log.warn(`Block ${currentHeader.getBlockNumber()} not found while getting blocks for slot ${slot}`);
+                break;
+            }
+            if (block.checkpointNumber !== checkpointNumber) {
+                break;
+            }
+            blocks.unshift(block);
+            const prevArchive = currentHeader.lastArchive.root;
+            if (prevArchive.equals(genesisArchiveRoot)) {
+                break;
+            }
+            const prevHeader = await this.blockSource.getBlockHeaderByArchive(prevArchive);
+            if (!prevHeader || prevHeader.getSlot() !== slot) {
+                break;
+            }
+            currentHeader = prevHeader;
+        }
+        return blocks;
+    }
+    /**
+   * Extract checkpoint global variables from a block.
+   */ extractCheckpointConstants(block) {
+        const gv = block.header.globalVariables;
+        return {
+            chainId: gv.chainId,
+            version: gv.version,
+            slotNumber: gv.slotNumber,
+            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);
+            if (!lastBlockHeader) {
+                this.log.warn(`Failed to get last block header for blob upload`, proposalInfo);
+                return;
+            }
+            // Get the last full block to determine checkpoint number
+            const lastBlock = await this.blockSource.getL2BlockNew(lastBlockHeader.getBlockNumber());
+            if (!lastBlock) {
+                this.log.warn(`Failed to get last block for blob upload`, proposalInfo);
+                return;
+            }
+            const blocks = await this.getBlocksForSlot(proposal.slotNumber, lastBlockHeader, lastBlock.checkpointNumber);
+            if (blocks.length === 0) {
+                this.log.warn(`No blocks found for blob upload`, proposalInfo);
+                return;
+            }
+            const blobFields = blocks.flatMap((b)=>b.toBlobFields());
+            const blobs = getBlobsPerL1Block(blobFields);
+            await this.blobClient.sendBlobsToFilestore(blobs);
+            this.log.debug(`Uploaded ${blobs.length} blobs to filestore for checkpoint at slot ${proposal.slotNumber}`, {
+                ...proposalInfo,
+                numBlobs: blobs.length
+            });
+        } catch (err) {
+            this.log.warn(`Failed to upload blobs for checkpoint: ${err}`, proposalInfo);
+        }
     }
     slashInvalidBlock(proposal) {
         const proposer = proposal.getSender();
@@ -270,18 +526,24 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             }
         ]);
     }
-    async createBlockProposal(blockNumber, header, archive, txs, proposerAddress, options) {
-        if (this.previousProposal?.slotNumber === header.slotNumber) {
-            this.log.verbose(`Already made a proposal for the same slot, skipping proposal`);
-            return Promise.resolve(undefined);
-        }
-        const newProposal = await this.validationService.createBlockProposal(header, archive, txs, proposerAddress, {
+    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);
+        // }
+        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;
         return newProposal;
     }
+    async createCheckpointProposal(checkpointHeader, archive, lastBlockInfo, proposerAddress, options) {
+        this.log.info(`Assembling checkpoint proposal for slot ${checkpointHeader.slotNumber}`);
+        return await this.validationService.createCheckpointProposal(checkpointHeader, archive, lastBlockInfo, proposerAddress, options);
+    }
     async broadcastBlockProposal(proposal) {
         await this.p2pClient.broadcastProposal(proposal);
     }
@@ -289,23 +551,23 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
         return await this.validationService.signAttestationsAndSigners(attestationsAndSigners, proposer);
     }
     async collectOwnAttestations(proposal) {
-        const slot = proposal.payload.header.slotNumber;
+        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.createBlockAttestationsFromProposal(proposal, inCommittee);
+        const attestations = await this.createCheckpointAttestationsFromProposal(proposal, inCommittee);
         // 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.
-        void this.p2pClient.broadcastAttestations(attestations).catch((err)=>{
+        void this.p2pClient.broadcastCheckpointAttestations(attestations).catch((err)=>{
             this.log.error(`Failed to broadcast self-attestations for slot ${slot}`, err);
         });
         return attestations;
     }
     async collectAttestations(proposal, required, deadline) {
-        // Wait and poll the p2pClient's attestation pool for this block until we have enough attestations
-        const slot = proposal.payload.header.slotNumber;
+        // 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()}`);
         if (+deadline < this.dateProvider.now()) {
             this.log.error(`Deadline ${deadline.toISOString()} for collecting ${required} attestations for slot ${slot} is in the past`);
@@ -316,13 +578,13 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
         const myAddresses = this.getValidatorAddresses();
         let attestations = [];
         while(true){
-            // Filter out attestations with a mismatching payload. This should NOT happen since we have verified
+            // 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.getAttestationsForSlot(slot, proposalId)).filter((attestation)=>{
-                if (!attestation.payload.equals(proposal.payload)) {
-                    this.log.warn(`Received attestation for slot ${slot} with mismatched payload from ${attestation.getSender()?.toString()}`, {
-                        attestationPayload: attestation.payload,
-                        proposalPayload: proposal.payload
+            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;
                 }
@@ -354,11 +616,6 @@ const SLASHABLE_BLOCK_PROPOSAL_VALIDATION_RESULT = [
             await sleep(this.config.attestationPollingIntervalMs);
         }
     }
-    async createBlockAttestationsFromProposal(proposal, attestors = []) {
-        const attestations = await this.validationService.attestToProposal(proposal, attestors);
-        await this.p2pClient.addAttestations(attestations);
-        return attestations;
-    }
     async handleAuthRequest(peer, msg) {
         const authRequest = AuthRequest.fromBuffer(msg);
         const statusMessage = await this.p2pClient.handleAuthRequestFromPeer(authRequest, peer).catch((_)=>undefined);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/validator-client",
-  "version": "0.0.1-commit.9593d84",
+  "version": "0.0.1-commit.96bb3f7",
   "main": "dest/index.js",
   "type": "module",
   "exports": {
@@ -18,8 +18,8 @@
   },
   "scripts": {
     "start": "node --no-warnings ./dest/bin",
-    "build": "yarn clean && tsgo -b",
-    "build:dev": "tsgo -b --watch",
+    "build": "yarn clean && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --watch",
     "clean": "rm -rf ./dest .tsbuildinfo",
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
   },
@@ -64,15 +64,21 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "0.0.1-commit.9593d84",
-    "@aztec/epoch-cache": "0.0.1-commit.9593d84",
-    "@aztec/ethereum": "0.0.1-commit.9593d84",
-    "@aztec/foundation": "0.0.1-commit.9593d84",
-    "@aztec/node-keystore": "0.0.1-commit.9593d84",
-    "@aztec/p2p": "0.0.1-commit.9593d84",
-    "@aztec/slasher": "0.0.1-commit.9593d84",
-    "@aztec/stdlib": "0.0.1-commit.9593d84",
-    "@aztec/telemetry-client": "0.0.1-commit.9593d84",
+    "@aztec/blob-client": "0.0.1-commit.96bb3f7",
+    "@aztec/blob-lib": "0.0.1-commit.96bb3f7",
+    "@aztec/constants": "0.0.1-commit.96bb3f7",
+    "@aztec/epoch-cache": "0.0.1-commit.96bb3f7",
+    "@aztec/ethereum": "0.0.1-commit.96bb3f7",
+    "@aztec/foundation": "0.0.1-commit.96bb3f7",
+    "@aztec/node-keystore": "0.0.1-commit.96bb3f7",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.96bb3f7",
+    "@aztec/p2p": "0.0.1-commit.96bb3f7",
+    "@aztec/protocol-contracts": "0.0.1-commit.96bb3f7",
+    "@aztec/prover-client": "0.0.1-commit.96bb3f7",
+    "@aztec/simulator": "0.0.1-commit.96bb3f7",
+    "@aztec/slasher": "0.0.1-commit.96bb3f7",
+    "@aztec/stdlib": "0.0.1-commit.96bb3f7",
+    "@aztec/telemetry-client": "0.0.1-commit.96bb3f7",
     "koa": "^2.16.1",
     "koa-router": "^13.1.1",
     "tslib": "^2.4.0",