@aztec/p2p 0.0.1-commit.3469e52 → 0.0.1-commit.59e663cd

package/src/msg_validators/attestation_validator/fisherman_attestation_validator.ts

@@ -1,5 +1,5 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import { type CheckpointAttestation, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import { type CheckpointAttestation, PeerErrorSeverity, type ValidationResult } from '@aztec/stdlib/p2p';
 import { Attributes, Metrics, type TelemetryClient } from '@aztec/telemetry-client';
 
 import type { AttestationPool } from '../../mem_pools/attestation_pool/attestation_pool.js';
@@ -28,10 +28,10 @@ export class FishermanAttestationValidator extends CheckpointAttestationValidato
     this.invalidAttestationCounter = meter.createUpDownCounter(Metrics.VALIDATOR_INVALID_ATTESTATION_RECEIVED_COUNT);
   }
 
-  override async validate(message: CheckpointAttestation): Promise<PeerErrorSeverity | undefined> {
+  override async validate(message: CheckpointAttestation): Promise<ValidationResult> {
     // First run the standard validation
     const baseValidationResult = await super.validate(message);
-    if (baseValidationResult !== undefined) {
+    if (baseValidationResult.result !== 'accept') {
       // Track base validation failures (invalid signature, wrong committee, etc.)
       this.invalidAttestationCounter.add(1, {
         [Attributes.ERROR_TYPE]: 'base_validation_failed',
@@ -45,7 +45,7 @@ export class FishermanAttestationValidator extends CheckpointAttestationValidato
     const proposer = message.getProposer();
 
     if (!attester || !proposer) {
-      return undefined;
+      return { result: 'accept' };
     }
 
     const proposalId = message.archive.toString();
@@ -74,7 +74,7 @@ export class FishermanAttestationValidator extends CheckpointAttestationValidato
         });
 
         // Return error to reject the message, but LibP2PService won't penalize in fisherman mode
-        return PeerErrorSeverity.LowToleranceError;
+        return { result: 'reject', severity: PeerErrorSeverity.LowToleranceError };
       }
     } else {
       // We might receive attestations before proposals in some cases
@@ -83,6 +83,6 @@ export class FishermanAttestationValidator extends CheckpointAttestationValidato
       );
     }
 
-    return undefined;
+    return { result: 'accept' };
   }
 }

package/src/msg_validators/clock_tolerance.ts

@@ -0,0 +1,51 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+
+/**
+ * Maximum clock disparity tolerance for P2P message validation (in milliseconds).
+ * Messages for the previous slot are accepted if we're within this many milliseconds
+ * of the current slot start. This prevents penalizing peers for messages that
+ * were valid when sent but arrived slightly late due to network latency.
+ *
+ * This follows Ethereum's MAXIMUM_GOSSIP_CLOCK_DISPARITY approach.
+ */
+export const MAXIMUM_GOSSIP_CLOCK_DISPARITY_MS = 500;
+
+/**
+ * Checks if a message for the previous slot should be accepted due to clock tolerance.
+ *
+ * @param messageSlot - The slot number from the received message
+ * @param currentSlot - The current slot number
+ * @param epochCache - EpochCache to get timing information
+ * @returns true if the message is for the previous slot AND we're within the clock tolerance window
+ */
+export function isWithinClockTolerance(
+  messageSlot: SlotNumber,
+  currentSlot: SlotNumber,
+  epochCache: EpochCacheInterface,
+): boolean {
+  // Guard against slot 0 edge case (genesis)
+  if (currentSlot === SlotNumber.ZERO) {
+    return false;
+  }
+
+  // Only apply tolerance to messages for the previous slot
+  const previousSlot = SlotNumber(currentSlot - 1);
+  if (messageSlot !== previousSlot) {
+    return false;
+  }
+
+  // Check how far we are into the current slot (in milliseconds)
+  const { ts: slotStartTs, nowMs, slot } = epochCache.getEpochAndSlotNow();
+
+  // Sanity check: ensure the epoch cache's current slot matches the expected current slot
+  if (slot !== currentSlot) {
+    return false;
+  }
+
+  // ts is in seconds, convert to ms; nowMs is already in milliseconds
+  const slotStartMs = slotStartTs * 1000n;
+  const elapsedMs = Number(nowMs - slotStartMs);
+
+  return elapsedMs < MAXIMUM_GOSSIP_CLOCK_DISPARITY_MS;
+}

package/src/msg_validators/proposal_validator/proposal_validator.ts

@@ -1,7 +1,9 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
 import { NoCommitteeError } from '@aztec/ethereum/contracts';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { BlockProposal, CheckpointProposal, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import { BlockProposal, CheckpointProposal, PeerErrorSeverity, type ValidationResult } from '@aztec/stdlib/p2p';
+
+import { isWithinClockTolerance } from '../clock_tolerance.js';
 
 export abstract class ProposalValidator<TProposal extends BlockProposal | CheckpointProposal> {
   protected epochCache: EpochCacheInterface;
@@ -14,30 +16,35 @@ export abstract class ProposalValidator<TProposal extends BlockProposal | Checkp
     this.logger = createLogger(loggerName);
   }
 
-  public async validate(proposal: TProposal): Promise<PeerErrorSeverity | undefined> {
+  public async validate(proposal: TProposal): Promise<ValidationResult> {
     try {
       // Slot check
       const { currentSlot, nextSlot } = this.epochCache.getCurrentAndNextSlot();
       const slotNumber = proposal.slotNumber;
       if (slotNumber !== currentSlot && slotNumber !== nextSlot) {
-        this.logger.debug(`Penalizing peer for invalid slot number ${slotNumber}`, { currentSlot, nextSlot });
-        return PeerErrorSeverity.HighToleranceError;
+        // Check if message is for previous slot and within clock tolerance
+        if (!isWithinClockTolerance(slotNumber, currentSlot, this.epochCache)) {
+          this.logger.warn(`Penalizing peer for invalid slot number ${slotNumber}`, { currentSlot, nextSlot });
+          return { result: 'reject', severity: PeerErrorSeverity.HighToleranceError };
+        }
+        this.logger.verbose(`Ignoring proposal for previous slot ${slotNumber} within clock tolerance`);
+        return { result: 'ignore' };
       }
 
       // Signature validity
       const proposer = proposal.getSender();
       if (!proposer) {
-        this.logger.debug(`Penalizing peer for proposal with invalid signature`);
-        return PeerErrorSeverity.MidToleranceError;
+        this.logger.warn(`Penalizing peer for proposal with invalid signature`);
+        return { result: 'reject', severity: PeerErrorSeverity.MidToleranceError };
       }
 
       // Transactions permitted check
       const embeddedTxCount = proposal.txs?.length ?? 0;
       if (!this.txsPermitted && (proposal.txHashes.length > 0 || embeddedTxCount > 0)) {
-        this.logger.debug(
+        this.logger.warn(
           `Penalizing peer for proposal with ${proposal.txHashes.length} transaction(s) when transactions are not permitted`,
         );
-        return PeerErrorSeverity.MidToleranceError;
+        return { result: 'reject', severity: PeerErrorSeverity.MidToleranceError };
       }
 
       // Embedded txs must be listed in txHashes
@@ -52,17 +59,17 @@ export abstract class ProposalValidator<TProposal extends BlockProposal | Checkp
           txHashesLength: proposal.txHashes.length,
           missingTxHashes,
         });
-        return PeerErrorSeverity.MidToleranceError;
+        return { result: 'reject', severity: PeerErrorSeverity.MidToleranceError };
       }
 
       // Proposer check
       const expectedProposer = await this.epochCache.getProposerAttesterAddressInSlot(slotNumber);
       if (expectedProposer !== undefined && !proposer.equals(expectedProposer)) {
-        this.logger.debug(`Penalizing peer for invalid proposer for current slot ${slotNumber}`, {
+        this.logger.warn(`Penalizing peer for invalid proposer for current slot ${slotNumber}`, {
           expectedProposer,
           proposer: proposer.toString(),
         });
-        return PeerErrorSeverity.MidToleranceError;
+        return { result: 'reject', severity: PeerErrorSeverity.MidToleranceError };
       }
 
       // Validate tx hashes for all txs embedded in the proposal
@@ -71,13 +78,13 @@ export abstract class ProposalValidator<TProposal extends BlockProposal | Checkp
           proposer,
           slotNumber,
         });
-        return PeerErrorSeverity.LowToleranceError;
+        return { result: 'reject', severity: PeerErrorSeverity.LowToleranceError };
       }
 
-      return undefined;
+      return { result: 'accept' };
     } catch (e) {
       if (e instanceof NoCommitteeError) {
-        return PeerErrorSeverity.LowToleranceError;
+        return { result: 'reject', severity: PeerErrorSeverity.LowToleranceError };
       }
       throw e;
     }

package/src/msg_validators/proposal_validator/proposal_validator_test_suite.ts

@@ -1,7 +1,12 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
 import type { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import { type BlockProposal, type CheckpointProposal, PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import {
+  type BlockProposal,
+  type CheckpointProposal,
+  PeerErrorSeverity,
+  type ValidationResult,
+} from '@aztec/stdlib/p2p';
 import type { TxHash } from '@aztec/stdlib/tx';
 
 import type { MockProxy } from 'jest-mock-extended';
@@ -10,7 +15,7 @@ export interface ProposalValidatorTestParams<TProposal extends BlockProposal | C
   validatorFactory: (
     epochCache: EpochCacheInterface,
     opts: { txsPermitted: boolean },
-  ) => { validate: (proposal: TProposal) => Promise<PeerErrorSeverity | undefined> };
+  ) => { validate: (proposal: TProposal) => Promise<ValidationResult> };
   makeProposal: (options?: any) => Promise<TProposal>;
   makeHeader: (epochNumber: number | bigint, slotNumber: number | bigint, blockNumber: number | bigint) => any;
   getSigner: () => Secp256k1Signer;
@@ -29,11 +34,12 @@ export function sharedProposalValidatorTests<TProposal extends BlockProposal | C
 
   describe('shared proposal validation logic', () => {
     let epochCache: MockProxy<EpochCacheInterface>;
-    let validator: { validate: (proposal: TProposal) => Promise<PeerErrorSeverity | undefined> };
+    let validator: { validate: (proposal: TProposal) => Promise<ValidationResult> };
+    const previousSlot = getSlot(99);
     const currentSlot = getSlot(100);
     const nextSlot = getSlot(101);
 
-    function mockGetProposer(currentProposer: EthAddress, nextProposer: EthAddress) {
+    function mockGetProposer(currentProposer: EthAddress, nextProposer: EthAddress, previousProposer?: EthAddress) {
       epochCache.getProposerAttesterAddressInSlot.mockImplementation(slot => {
         if (slot === currentSlot) {
           return Promise.resolve(currentProposer);
@@ -41,6 +47,9 @@ export function sharedProposalValidatorTests<TProposal extends BlockProposal | C
         if (slot === nextSlot) {
           return Promise.resolve(nextProposer);
         }
+        if (slot === previousSlot && previousProposer) {
+          return Promise.resolve(previousProposer);
+        }
         throw new Error('Unexpected argument');
       });
     }
@@ -54,18 +63,48 @@ export function sharedProposalValidatorTests<TProposal extends BlockProposal | C
       });
     });
 
-    it('returns high tolerance error if slot number is not current or next slot', async () => {
+    it('returns high tolerance error if slot number is not current or next slot (outside clock tolerance)', async () => {
       const header = makeHeader(1, 99, 99);
       const mockProposal = await makeProposal({ blockHeader: header, lastBlockHeader: header });
 
+      // Mock getEpochAndSlotNow to return time OUTSIDE clock tolerance (1000ms elapsed)
+      epochCache.getEpochAndSlotNow.mockReturnValue({
+        epoch: 1 as any,
+        slot: currentSlot,
+        ts: 1000n, // slot started at 1000 seconds
+        nowMs: 1001000n, // 1000ms elapsed, outside 500ms tolerance
+      });
+
       epochCache.getProposerAttesterAddressInSlot.mockResolvedValue(getAddress());
       const result = await validator.validate(mockProposal);
-      expect(result).toBe(PeerErrorSeverity.HighToleranceError);
+      expect(result).toEqual({ result: 'reject', severity: PeerErrorSeverity.HighToleranceError });
 
       // Should not try to resolve proposers if base validation fails
       expect(epochCache.getProposerAttesterAddressInSlot).not.toHaveBeenCalled();
     });
 
+    it('returns ignore if previous slot proposal is within clock tolerance', async () => {
+      const previousProposer = getSigner();
+      const header = makeHeader(1, 99, 99);
+      const mockProposal = await makeProposal({
+        blockHeader: header,
+        lastBlockHeader: header,
+        signer: previousProposer,
+      });
+
+      // Mock getEpochAndSlotNow to return time WITHIN clock tolerance (100ms elapsed)
+      epochCache.getEpochAndSlotNow.mockReturnValue({
+        epoch: 1 as any,
+        slot: currentSlot,
+        ts: 1000n, // slot started at 1000 seconds
+        nowMs: 1000100n, // 100ms elapsed, within 500ms tolerance
+      });
+
+      mockGetProposer(getAddress(), getAddress(), getAddress(previousProposer));
+      const result = await validator.validate(mockProposal);
+      expect(result).toEqual({ result: 'ignore' });
+    });
+
     it('returns mid tolerance error if proposer is not current proposer for current slot', async () => {
       const currentProposer = getSigner();
       const nextProposer = getSigner();
@@ -79,7 +118,7 @@ export function sharedProposalValidatorTests<TProposal extends BlockProposal | C
 
       mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
       const result = await validator.validate(mockProposal);
-      expect(result).toBe(PeerErrorSeverity.MidToleranceError);
+      expect(result).toEqual({ result: 'reject', severity: PeerErrorSeverity.MidToleranceError });
     });
 
     it('returns mid tolerance error if proposer is not next proposer for next slot', async () => {
@@ -95,7 +134,7 @@ export function sharedProposalValidatorTests<TProposal extends BlockProposal | C
 
       mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
       const result = await validator.validate(mockProposal);
-      expect(result).toBe(PeerErrorSeverity.MidToleranceError);
+      expect(result).toEqual({ result: 'reject', severity: PeerErrorSeverity.MidToleranceError });
     });
 
     it('returns mid tolerance error if proposer is current proposer but proposal is for next slot', async () => {
@@ -110,7 +149,7 @@ export function sharedProposalValidatorTests<TProposal extends BlockProposal | C
 
       mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
       const result = await validator.validate(mockProposal);
-      expect(result).toBe(PeerErrorSeverity.MidToleranceError);
+      expect(result).toEqual({ result: 'reject', severity: PeerErrorSeverity.MidToleranceError });
     });
 
     it('returns undefined if proposal is valid for current slot and proposer', async () => {
@@ -125,7 +164,7 @@ export function sharedProposalValidatorTests<TProposal extends BlockProposal | C
 
       mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
       const result = await validator.validate(mockProposal);
-      expect(result).toBeUndefined();
+      expect(result).toEqual({ result: 'accept' });
     });
 
     it('returns undefined if proposal is valid for next slot and proposer', async () => {
@@ -136,7 +175,7 @@ export function sharedProposalValidatorTests<TProposal extends BlockProposal | C
 
       mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
       const result = await validator.validate(mockProposal);
-      expect(result).toBeUndefined();
+      expect(result).toEqual({ result: 'accept' });
     });
 
     describe('transaction permission validation', () => {
@@ -153,7 +192,7 @@ export function sharedProposalValidatorTests<TProposal extends BlockProposal | C
 
         mockGetProposer(getAddress(currentProposer), getAddress());
         const result = await validatorWithTxsDisabled.validate(mockProposal);
-        expect(result).toBe(PeerErrorSeverity.MidToleranceError);
+        expect(result).toEqual({ result: 'reject', severity: PeerErrorSeverity.MidToleranceError });
       });
 
       it('returns undefined if txs not permitted but proposal has no txHashes', async () => {
@@ -169,7 +208,7 @@ export function sharedProposalValidatorTests<TProposal extends BlockProposal | C
 
         mockGetProposer(getAddress(currentProposer), getAddress());
         const result = await validatorWithTxsDisabled.validate(mockProposal);
-        expect(result).toBeUndefined();
+        expect(result).toEqual({ result: 'accept' });
       });
 
       it('returns undefined if txs permitted and proposal contains txHashes', async () => {
@@ -184,7 +223,7 @@ export function sharedProposalValidatorTests<TProposal extends BlockProposal | C
 
         mockGetProposer(getAddress(currentProposer), getAddress());
         const result = await validator.validate(mockProposal);
-        expect(result).toBeUndefined();
+        expect(result).toEqual({ result: 'accept' });
       });
     });
   });

package/src/msg_validators/tx_validator/block_header_validator.ts

@@ -15,7 +15,9 @@ export class BlockHeaderTxValidator<T extends AnyTx> implements TxValidator<T> {
   }
 
   async validateTx(tx: T): Promise<TxValidationResult> {
-    const [index] = await this.#archiveSource.getArchiveIndices([await tx.data.constants.anchorBlockHeader.hash()]);
+    const [index] = await this.#archiveSource.getArchiveIndices([
+      (await tx.data.constants.anchorBlockHeader.hash()).toField(),
+    ]);
     if (index === undefined) {
       this.#log.verbose(`Rejecting tx ${'txHash' in tx ? tx.txHash : tx.hash} for referencing an unknown block header`);
       return { result: 'invalid', reason: [TX_ERROR_BLOCK_HEADER] };

package/src/services/libp2p/libp2p_service.ts

@@ -8,7 +8,7 @@ import { Timer } from '@aztec/foundation/timer';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractsHash } from '@aztec/protocol-contracts';
-import type { EthAddress, L2BlockNew, L2BlockSource } from '@aztec/stdlib/block';
+import type { EthAddress, L2Block, L2BlockSource } from '@aztec/stdlib/block';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import { GasFees } from '@aztec/stdlib/gas';
 import type { ClientProtocolCircuitVerifier, PeerInfo, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
@@ -20,6 +20,7 @@ import {
   type Gossipable,
   P2PClientType,
   P2PMessage,
+  type ValidationResult as P2PValidationResult,
   PeerErrorSeverity,
   TopicType,
   createTopicString,
@@ -924,7 +925,8 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     const validationFunc: () => Promise<ReceivedMessageValidationResult<CheckpointAttestation>> = async () => {
       const attestation = CheckpointAttestation.fromBuffer(payloadData);
       const pool = this.mempools.attestationPool;
-      const isValid = await this.validateCheckpointAttestation(source, attestation);
+      const validationResult = await this.validateCheckpointAttestation(source, attestation);
+      const isValid = validationResult.result === 'accept';
       const exists = isValid && (await pool.hasCheckpointAttestation(attestation));
 
       let canAdd = true;
@@ -943,9 +945,9 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
         [Attributes.P2P_ID]: source.toString(),
       });
 
-      if (!isValid) {
+      if (validationResult.result === 'reject') {
         return { result: TopicValidatorResult.Reject };
-      } else if (exists) {
+      } else if (validationResult.result === 'ignore' || exists) {
         return { result: TopicValidatorResult.Ignore, obj: attestation };
       } else if (!canAdd) {
         this.logger.warn(`Dropping checkpoint attestation due to per-(slot, proposalId) attestation cap`, {
@@ -986,7 +988,8 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   private async processBlockFromPeer(payloadData: Buffer, msgId: string, source: PeerId): Promise<void> {
     const validationFunc: () => Promise<ReceivedMessageValidationResult<BlockProposal>> = async () => {
       const block = BlockProposal.fromBuffer(payloadData);
-      const isValid = await this.validateBlockProposal(source, block);
+      const validationResult = await this.validateBlockProposal(source, block);
+      const isValid = validationResult.result === 'accept';
       const pool = this.mempools.attestationPool;
 
       const exists = isValid && (await pool.hasBlockProposal(block));
@@ -1000,9 +1003,9 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
         [Attributes.P2P_ID]: source.toString(),
       });
 
-      if (!isValid) {
+      if (validationResult.result === 'reject') {
         return { result: TopicValidatorResult.Reject };
-      } else if (exists) {
+      } else if (validationResult.result === 'ignore' || exists) {
         return { result: TopicValidatorResult.Ignore, obj: block };
       } else if (!canAdd) {
         this.peerManager.penalizePeer(source, PeerErrorSeverity.MidToleranceError);
@@ -1082,7 +1085,8 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     // TODO(palla/mbps): This pattern is repeated across multiple message handlers, consider abstracting it.
     const validationFunc: () => Promise<ReceivedMessageValidationResult<CheckpointProposal>> = async () => {
       const checkpoint = CheckpointProposal.fromBuffer(payloadData);
-      const isValid = await this.validateCheckpointProposal(source, checkpoint);
+      const validationResult = await this.validateCheckpointProposal(source, checkpoint);
+      const isValid = validationResult.result === 'accept';
       const pool = this.mempools.attestationPool;
 
       const exists = isValid && (await pool.hasCheckpointProposal(checkpoint));
@@ -1096,9 +1100,9 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
         [Attributes.P2P_ID]: source.toString(),
       });
 
-      if (!isValid) {
+      if (validationResult.result === 'reject') {
         return { result: TopicValidatorResult.Reject };
-      } else if (exists) {
+      } else if (validationResult.result === 'ignore' || exists) {
         return { result: TopicValidatorResult.Ignore, obj: checkpoint };
       } else if (!canAdd) {
         this.peerManager.penalizePeer(source, PeerErrorSeverity.MidToleranceError);
@@ -1337,7 +1341,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   }))
   private async validateRequestedBlock(
     requestedBlockNumber: Fr,
-    responseBlock: L2BlockNew,
+    responseBlock: L2Block,
     peerId: PeerId,
   ): Promise<boolean> {
     try {
@@ -1576,15 +1580,18 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     [Attributes.BLOCK_ARCHIVE]: attestation.archive.toString(),
     [Attributes.P2P_ID]: await attestation.p2pMessageLoggingIdentifier().then(i => i.toString()),
   }))
-  public async validateCheckpointAttestation(peerId: PeerId, attestation: CheckpointAttestation): Promise<boolean> {
-    const severity = await this.checkpointAttestationValidator.validate(attestation);
-    if (severity) {
+  public async validateCheckpointAttestation(
+    peerId: PeerId,
+    attestation: CheckpointAttestation,
+  ): Promise<P2PValidationResult> {
+    const result = await this.checkpointAttestationValidator.validate(attestation);
+
+    if (result.result === 'reject') {
       this.logger.debug(`Penalizing peer ${peerId} for checkpoint attestation validation failure`);
-      this.peerManager.penalizePeer(peerId, severity);
-      return false;
+      this.peerManager.penalizePeer(peerId, result.severity);
     }
 
-    return true;
+    return result;
   }
 
   /**
@@ -1596,15 +1603,15 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   @trackSpan('Libp2pService.validateBlockProposal', (_peerId, block) => ({
     [Attributes.SLOT_NUMBER]: block.slotNumber.toString(),
   }))
-  public async validateBlockProposal(peerId: PeerId, block: BlockProposal): Promise<boolean> {
-    const severity = await this.blockProposalValidator.validate(block);
-    if (severity) {
+  public async validateBlockProposal(peerId: PeerId, block: BlockProposal): Promise<P2PValidationResult> {
+    const result = await this.blockProposalValidator.validate(block);
+
+    if (result.result === 'reject') {
       this.logger.debug(`Penalizing peer ${peerId} for block proposal validation failure`);
-      this.peerManager.penalizePeer(peerId, severity);
-      return false;
+      this.peerManager.penalizePeer(peerId, result.severity);
     }
 
-    return true;
+    return result;
   }
 
   /**
@@ -1616,15 +1623,18 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   @trackSpan('Libp2pService.validateCheckpointProposal', (_peerId, checkpoint) => ({
     [Attributes.SLOT_NUMBER]: checkpoint.slotNumber.toString(),
   }))
-  public async validateCheckpointProposal(peerId: PeerId, checkpoint: CheckpointProposal): Promise<boolean> {
-    const severity = await this.checkpointProposalValidator.validate(checkpoint);
-    if (severity) {
+  public async validateCheckpointProposal(
+    peerId: PeerId,
+    checkpoint: CheckpointProposal,
+  ): Promise<P2PValidationResult> {
+    const result = await this.checkpointProposalValidator.validate(checkpoint);
+
+    if (result.result === 'reject') {
       this.logger.debug(`Penalizing peer ${peerId} for checkpoint proposal validation failure`);
-      this.peerManager.penalizePeer(peerId, severity);
-      return false;
+      this.peerManager.penalizePeer(peerId, result.severity);
     }
 
-    return true;
+    return result;
   }
 
   public getPeerScore(peerId: PeerId): number {

package/src/services/reqresp/interface.ts

@@ -1,5 +1,5 @@
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { L2BlockNew } from '@aztec/stdlib/block';
+import { L2Block } from '@aztec/stdlib/block';
 import { TxArray, TxHashArray } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
@@ -198,7 +198,7 @@ export const subProtocolMap = {
   },
   [ReqRespSubProtocol.BLOCK]: {
     request: Fr, // block number
-    response: L2BlockNew,
+    response: L2Block,
   },
   [ReqRespSubProtocol.AUTH]: {
     request: AuthRequest,

package/src/services/tx_collection/slow_tx_collection.ts

@@ -4,7 +4,7 @@ import { type Logger, createLogger } from '@aztec/foundation/log';
 import { boundInclusive } from '@aztec/foundation/number';
 import { RunningPromise } from '@aztec/foundation/promise';
 import { DateProvider } from '@aztec/foundation/timer';
-import type { L2BlockNew } from '@aztec/stdlib/block';
+import type { L2Block } from '@aztec/stdlib/block';
 import { type L1RollupConstants, getEpochAtSlot, getTimestampRangeForEpoch } from '@aztec/stdlib/epoch-helpers';
 import { type Tx, TxHash } from '@aztec/stdlib/tx';
 
@@ -76,7 +76,7 @@ export class SlowTxCollection {
   }
 
   /** Starts collecting the given tx hashes for the given L2Block in the slow loop */
-  public startCollecting(block: L2BlockNew, txHashes: TxHash[]) {
+  public startCollecting(block: L2Block, txHashes: TxHash[]) {
     const slot = block.header.getSlot();
     const deadline = this.getDeadlineForSlot(slot);
     if (+deadline < this.dateProvider.now()) {

package/src/services/tx_collection/tx_collection.ts

@@ -3,7 +3,7 @@ import { compactArray } from '@aztec/foundation/collection';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { type PromiseWithResolvers, RunningPromise } from '@aztec/foundation/promise';
 import { DateProvider } from '@aztec/foundation/timer';
-import type { L2BlockInfo, L2BlockNew } from '@aztec/stdlib/block';
+import type { L2Block, L2BlockInfo } from '@aztec/stdlib/block';
 import type { L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import type { BlockProposal } from '@aztec/stdlib/p2p';
 import { Tx, TxHash } from '@aztec/stdlib/tx';
@@ -25,7 +25,7 @@ export type CollectionMethod = 'fast-req-resp' | 'fast-node-rpc' | 'slow-req-res
 export type MissingTxInfo = { blockNumber: BlockNumber; deadline: Date; readyForReqResp: boolean };
 
 export type FastCollectionRequestInput =
-  | { type: 'block'; block: L2BlockNew }
+  | { type: 'block'; block: L2Block }
   | { type: 'proposal'; blockProposal: BlockProposal; blockNumber: BlockNumber };
 
 export type FastCollectionRequest = FastCollectionRequestInput & {
@@ -146,7 +146,7 @@ export class TxCollection {
   }
 
   /** Starts collecting the given tx hashes for the given L2Block in the slow loop */
-  public startCollecting(block: L2BlockNew, txHashes: TxHash[]) {
+  public startCollecting(block: L2Block, txHashes: TxHash[]) {
     return this.slowCollection.startCollecting(block, txHashes);
   }
 
@@ -162,7 +162,7 @@ export class TxCollection {
 
   /** Collects the set of txs for the given mined block as fast as possible */
   public collectFastForBlock(
-    block: L2BlockNew,
+    block: L2Block,
     txHashes: TxHash[] | string[],
     opts: { deadline: Date; pinnedPeer?: PeerId },
   ) {

package/src/services/tx_provider.ts

@@ -2,7 +2,7 @@ import { BlockNumber } from '@aztec/foundation/branded-types';
 import { compactArray } from '@aztec/foundation/collection';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { elapsed } from '@aztec/foundation/timer';
-import type { L2BlockInfo, L2BlockNew } from '@aztec/stdlib/block';
+import type { L2Block, L2BlockInfo } from '@aztec/stdlib/block';
 import type { ITxProvider } from '@aztec/stdlib/interfaces/server';
 import type { BlockProposal } from '@aztec/stdlib/p2p';
 import { Tx, TxHash } from '@aztec/stdlib/tx';
@@ -68,7 +68,7 @@ export class TxProvider implements ITxProvider {
   }
 
   /** Gathers txs from the tx pool, remote rpc nodes, and reqresp. */
-  public getTxsForBlock(block: L2BlockNew, opts: { deadline: Date }): Promise<{ txs: Tx[]; missingTxs: TxHash[] }> {
+  public getTxsForBlock(block: L2Block, opts: { deadline: Date }): Promise<{ txs: Tx[]; missingTxs: TxHash[] }> {
     return this.getOrderedTxsFromAllSources(
       { type: 'block', block },
       block.toBlockInfo(),

package/src/test-helpers/index.ts

@@ -4,3 +4,4 @@ export * from './make-enrs.js';
 export * from './make-test-p2p-clients.js';
 export * from './reqresp-nodes.js';
 export * from './mock-pubsub.js';
+export * from './test_tx_provider.js';