@aztec/p2p 0.67.1 → 0.68.0

package/src/{service → services/libp2p}/libp2p_service.ts

@@ -6,16 +6,19 @@ import {
   type Gossipable,
   type L2BlockSource,
   MerkleTreeId,
+  PeerErrorSeverity,
   type PeerInfo,
   type RawGossipMessage,
-  TopicType,
   TopicTypeMap,
   Tx,
   TxHash,
   type WorldStateSynchronizer,
+  getTopicTypeForClientType,
   metricsTopicStrToLabels,
 } from '@aztec/circuit-types';
+import { P2PClientType } from '@aztec/circuit-types';
 import { Fr } from '@aztec/circuits.js';
+import { type EpochCache } from '@aztec/epoch-cache';
 import { createLogger } from '@aztec/foundation/log';
 import { SerialQueue } from '@aztec/foundation/queue';
 import { RunningPromise } from '@aztec/foundation/running-promise';
@@ -28,26 +31,27 @@ import { createPeerScoreParams, createTopicScoreParams } from '@chainsafe/libp2p
 import { noise } from '@chainsafe/libp2p-noise';
 import { yamux } from '@chainsafe/libp2p-yamux';
 import { identify } from '@libp2p/identify';
-import type { PeerId } from '@libp2p/interface';
+import { type Message, type PeerId, TopicValidatorResult } from '@libp2p/interface';
 import '@libp2p/kad-dht';
 import { mplex } from '@libp2p/mplex';
 import { tcp } from '@libp2p/tcp';
 import { createLibp2p } from 'libp2p';
 
-import { type P2PConfig } from '../config.js';
-import { type MemPools } from '../mem_pools/interface.js';
+import { type P2PConfig } from '../../config.js';
+import { type MemPools } from '../../mem_pools/interface.js';
+import { EpochProofQuoteValidator } from '../../msg_validators/epoch_proof_quote_validator/index.js';
+import { AttestationValidator, BlockProposalValidator } from '../../msg_validators/index.js';
 import {
   DataTxValidator,
   DoubleSpendTxValidator,
   MetadataTxValidator,
   TxProofValidator,
-} from '../tx_validator/index.js';
-import { type PubSubLibp2p, convertToMultiaddr } from '../util.js';
-import { AztecDatastore } from './data_store.js';
-import { SnappyTransform, fastMsgIdFn, getMsgIdFn, msgIdToStrFn } from './encoding.js';
-import { PeerManager } from './peer_manager.js';
-import { PeerErrorSeverity } from './peer_scoring.js';
-import { pingHandler, statusHandler } from './reqresp/handlers.js';
+} from '../../msg_validators/tx_validator/index.js';
+import { type PubSubLibp2p, convertToMultiaddr } from '../../util.js';
+import { AztecDatastore } from '../data_store.js';
+import { SnappyTransform, fastMsgIdFn, getMsgIdFn, msgIdToStrFn } from '../encoding.js';
+import { PeerManager } from '../peer_manager.js';
+import { pingHandler, statusHandler } from '../reqresp/handlers.js';
 import {
   DEFAULT_SUB_PROTOCOL_HANDLERS,
   DEFAULT_SUB_PROTOCOL_VALIDATORS,
@@ -57,18 +61,38 @@ import {
   STATUS_PROTOCOL,
   type SubProtocolMap,
   TX_REQ_PROTOCOL,
-} from './reqresp/interface.js';
-import { ReqResp } from './reqresp/reqresp.js';
-import type { P2PService, PeerDiscoveryService } from './service.js';
+} from '../reqresp/interface.js';
+import { ReqResp } from '../reqresp/reqresp.js';
+import type { P2PService, PeerDiscoveryService } from '../service.js';
+
+interface MessageValidator {
+  validator: {
+    validateTx(tx: Tx): Promise<boolean>;
+  };
+  severity: PeerErrorSeverity;
+}
+
+interface ValidationResult {
+  name: string;
+  isValid: boolean;
+  severity: PeerErrorSeverity;
+}
+
+type ValidationOutcome = { allPassed: true } | { allPassed: false; failure: ValidationResult };
 
 /**
  * Lib P2P implementation of the P2PService interface.
  */
-export class LibP2PService extends WithTracer implements P2PService {
+export class LibP2PService<T extends P2PClientType> extends WithTracer implements P2PService {
   private jobQueue: SerialQueue = new SerialQueue();
   private peerManager: PeerManager;
   private discoveryRunningPromise?: RunningPromise;
 
+  // Message validators
+  private attestationValidator: AttestationValidator;
+  private blockProposalValidator: BlockProposalValidator;
+  private epochProofQuoteValidator: EpochProofQuoteValidator;
+
   // Request and response sub service
   public reqresp: ReqResp;
 
@@ -80,11 +104,13 @@ export class LibP2PService extends WithTracer implements P2PService {
   private blockReceivedCallback: (block: BlockProposal) => Promise<BlockAttestation | undefined>;
 
   constructor(
+    private clientType: T,
     private config: P2PConfig,
     private node: PubSubLibp2p,
     private peerDiscoveryService: PeerDiscoveryService,
-    private mempools: MemPools,
+    private mempools: MemPools<T>,
     private l2BlockSource: L2BlockSource,
+    private epochCache: EpochCache,
     private proofVerifier: ClientProtocolCircuitVerifier,
     private worldStateSynchronizer: WorldStateSynchronizer,
     private telemetry: TelemetryClient,
@@ -93,13 +119,17 @@ export class LibP2PService extends WithTracer implements P2PService {
   ) {
     super(telemetry, 'LibP2PService');
 
-    this.peerManager = new PeerManager(node, peerDiscoveryService, config, logger);
+    this.peerManager = new PeerManager(node, peerDiscoveryService, config, this.tracer, logger);
     this.node.services.pubsub.score.params.appSpecificScore = (peerId: string) => {
       return this.peerManager.getPeerScore(peerId);
     };
     this.node.services.pubsub.score.params.appSpecificWeight = 10;
     this.reqresp = new ReqResp(config, node, this.peerManager);
 
+    this.attestationValidator = new AttestationValidator(epochCache);
+    this.blockProposalValidator = new BlockProposalValidator(epochCache);
+    this.epochProofQuoteValidator = new EpochProofQuoteValidator(epochCache);
+
     this.blockReceivedCallback = (block: BlockProposal): Promise<BlockAttestation | undefined> => {
       this.logger.verbose(
         `[WARNING] handler not yet registered: Block received callback not set. Received block ${block.p2pMessageIdentifier()} from peer.`,
@@ -131,22 +161,37 @@ export class LibP2PService extends WithTracer implements P2PService {
     await this.node.start();
 
     // Subscribe to standard GossipSub topics by default
-    for (const topic in TopicType) {
+    for (const topic of getTopicTypeForClientType(this.clientType)) {
       this.subscribeToTopic(TopicTypeMap[topic].p2pTopic);
     }
 
+    // Add p2p topic validators
+    // As they are stored within a kv pair, there is no need to register them conditionally
+    // based on the client type
+    const topicValidators = {
+      [Tx.p2pTopic]: this.validatePropagatedTxFromMessage.bind(this),
+      [BlockAttestation.p2pTopic]: this.validatePropagatedAttestationFromMessage.bind(this),
+      [BlockProposal.p2pTopic]: this.validatePropagatedBlockFromMessage.bind(this),
+      [EpochProofQuote.p2pTopic]: this.validatePropagatedEpochProofQuoteFromMessage.bind(this),
+    };
+    for (const [topic, validator] of Object.entries(topicValidators)) {
+      this.node.services.pubsub.topicValidators.set(topic, validator);
+    }
+
     // add GossipSub listener
     this.node.services.pubsub.addEventListener('gossipsub:message', async e => {
-      const { msg, propagationSource: peerId } = e.detail;
+      const { msg } = e.detail;
       this.logger.trace(`Received PUBSUB message.`);
 
-      await this.jobQueue.put(() => this.handleNewGossipMessage(msg, peerId));
+      await this.jobQueue.put(() => this.handleNewGossipMessage(msg));
     });
 
     // Start running promise for peer discovery
-    this.discoveryRunningPromise = new RunningPromise(() => {
-      this.peerManager.heartbeat();
-    }, this.config.peerCheckIntervalMS);
+    this.discoveryRunningPromise = new RunningPromise(
+      () => this.peerManager.heartbeat(),
+      this.logger,
+      this.config.peerCheckIntervalMS,
+    );
     this.discoveryRunningPromise.start();
 
     // Define the sub protocol validators - This is done within this start() method to gain a callback to the existing validateTx function
@@ -186,12 +231,14 @@ export class LibP2PService extends WithTracer implements P2PService {
    * @param txPool - The transaction pool to be accessed by the service.
    * @returns The new service.
    */
-  public static async new(
+  public static async new<T extends P2PClientType>(
+    clientType: T,
     config: P2PConfig,
     peerDiscoveryService: PeerDiscoveryService,
     peerId: PeerId,
-    mempools: MemPools,
+    mempools: MemPools<T>,
     l2BlockSource: L2BlockSource,
+    epochCache: EpochCache,
     proofVerifier: ClientProtocolCircuitVerifier,
     worldStateSynchronizer: WorldStateSynchronizer,
     store: AztecKVStore,
@@ -251,6 +298,7 @@ export class LibP2PService extends WithTracer implements P2PService {
           dataTransform: new SnappyTransform(),
           metricsRegister: otelMetricsAdapter,
           metricsTopicStrToLabel: metricsTopicStrToLabels(),
+          asyncValidation: true,
           scoreParams: createPeerScoreParams({
             topics: {
               [Tx.p2pTopic]: createTopicScoreParams({
@@ -299,11 +347,13 @@ export class LibP2PService extends WithTracer implements P2PService {
     };
 
     return new LibP2PService(
+      clientType,
       config,
       node,
       peerDiscoveryService,
       mempools,
       l2BlockSource,
+      epochCache,
       proofVerifier,
       worldStateSynchronizer,
       telemetry,
@@ -376,12 +426,12 @@ export class LibP2PService extends WithTracer implements P2PService {
    * @param topic - The message's topic.
    * @param data - The message data
    */
-  private async handleNewGossipMessage(message: RawGossipMessage, peerId: PeerId) {
+  private async handleNewGossipMessage(message: RawGossipMessage) {
     if (message.topic === Tx.p2pTopic) {
       const tx = Tx.fromBuffer(Buffer.from(message.data));
-      await this.processTxFromPeer(tx, peerId);
+      await this.processTxFromPeer(tx);
     }
-    if (message.topic === BlockAttestation.p2pTopic) {
+    if (message.topic === BlockAttestation.p2pTopic && this.clientType === P2PClientType.Full) {
       const attestation = BlockAttestation.fromBuffer(Buffer.from(message.data));
       await this.processAttestationFromPeer(attestation);
     }
@@ -410,7 +460,7 @@ export class LibP2PService extends WithTracer implements P2PService {
   }))
   private async processAttestationFromPeer(attestation: BlockAttestation): Promise<void> {
     this.logger.debug(`Received attestation ${attestation.p2pMessageIdentifier()} from external peer.`);
-    await this.mempools.attestationPool.addAttestations([attestation]);
+    await this.mempools.attestationPool!.addAttestations([attestation]);
   }
 
   /**Process block from peer
@@ -468,16 +518,11 @@ export class LibP2PService extends WithTracer implements P2PService {
     });
   }
 
-  private async processTxFromPeer(tx: Tx, peerId: PeerId): Promise<void> {
+  private async processTxFromPeer(tx: Tx): Promise<void> {
     const txHash = tx.getTxHash();
     const txHashString = txHash.toString();
     this.logger.verbose(`Received tx ${txHashString} from external peer.`);
-
-    const isValidTx = await this.validatePropagatedTx(tx, peerId);
-
-    if (isValidTx) {
-      await this.mempools.txPool.addTxs([tx]);
-    }
+    await this.mempools.txPool.addTxs([tx]);
   }
 
   /**
@@ -494,6 +539,9 @@ export class LibP2PService extends WithTracer implements P2PService {
    * @param peerId - The peer ID of the peer that sent the tx.
    * @returns True if the tx is valid, false otherwise.
    */
+  @trackSpan('Libp2pService.validateRequestedTx', (requestedTxHash, _responseTx) => ({
+    [Attributes.TX_HASH]: requestedTxHash.toString(),
+  }))
   private async validateRequestedTx(requestedTxHash: TxHash, responseTx: Tx, peerId: PeerId): Promise<boolean> {
     const proofValidator = new TxProofValidator(this.proofVerifier);
     const validProof = await proofValidator.validateTx(responseTx);
@@ -514,67 +562,264 @@ export class LibP2PService extends WithTracer implements P2PService {
     return true;
   }
 
+  /**
+   * Validate a tx from a peer.
+   * @param propagationSource - The peer ID of the peer that sent the tx.
+   * @param msg - The tx message.
+   * @returns True if the tx is valid, false otherwise.
+   */
+  private async validatePropagatedTxFromMessage(
+    propagationSource: PeerId,
+    msg: Message,
+  ): Promise<TopicValidatorResult> {
+    const tx = Tx.fromBuffer(Buffer.from(msg.data));
+    const isValid = await this.validatePropagatedTx(tx, propagationSource);
+    this.logger.trace(`validatePropagatedTx: ${isValid}`, {
+      [Attributes.TX_HASH]: tx.getTxHash().toString(),
+      [Attributes.P2P_ID]: propagationSource.toString(),
+    });
+    return isValid ? TopicValidatorResult.Accept : TopicValidatorResult.Reject;
+  }
+
+  /**
+   * Validate an attestation from a peer.
+   * @param propagationSource - The peer ID of the peer that sent the attestation.
+   * @param msg - The attestation message.
+   * @returns True if the attestation is valid, false otherwise.
+   */
+  private async validatePropagatedAttestationFromMessage(
+    propagationSource: PeerId,
+    msg: Message,
+  ): Promise<TopicValidatorResult> {
+    const attestation = BlockAttestation.fromBuffer(Buffer.from(msg.data));
+    const isValid = await this.validateAttestation(propagationSource, attestation);
+    this.logger.trace(`validatePropagatedAttestation: ${isValid}`, {
+      [Attributes.SLOT_NUMBER]: attestation.payload.header.globalVariables.slotNumber.toString(),
+      [Attributes.P2P_ID]: propagationSource.toString(),
+    });
+    return isValid ? TopicValidatorResult.Accept : TopicValidatorResult.Reject;
+  }
+
+  /**
+   * Validate a block proposal from a peer.
+   * @param propagationSource - The peer ID of the peer that sent the block.
+   * @param msg - The block proposal message.
+   * @returns True if the block proposal is valid, false otherwise.
+   */
+  private async validatePropagatedBlockFromMessage(
+    propagationSource: PeerId,
+    msg: Message,
+  ): Promise<TopicValidatorResult> {
+    const block = BlockProposal.fromBuffer(Buffer.from(msg.data));
+    const isValid = await this.validateBlockProposal(propagationSource, block);
+    this.logger.trace(`validatePropagatedBlock: ${isValid}`, {
+      [Attributes.SLOT_NUMBER]: block.payload.header.globalVariables.slotNumber.toString(),
+      [Attributes.P2P_ID]: propagationSource.toString(),
+    });
+    return isValid ? TopicValidatorResult.Accept : TopicValidatorResult.Reject;
+  }
+
+  /**
+   * Validate an epoch proof quote from a peer.
+   * @param propagationSource - The peer ID of the peer that sent the epoch proof quote.
+   * @param msg - The epoch proof quote message.
+   * @returns True if the epoch proof quote is valid, false otherwise.
+   */
+  private async validatePropagatedEpochProofQuoteFromMessage(
+    propagationSource: PeerId,
+    msg: Message,
+  ): Promise<TopicValidatorResult> {
+    const epochProofQuote = EpochProofQuote.fromBuffer(Buffer.from(msg.data));
+    const isValid = await this.validateEpochProofQuote(propagationSource, epochProofQuote);
+    this.logger.trace(`validatePropagatedEpochProofQuote: ${isValid}`, {
+      [Attributes.EPOCH_NUMBER]: epochProofQuote.payload.epochToProve.toString(),
+      [Attributes.P2P_ID]: propagationSource.toString(),
+    });
+    return isValid ? TopicValidatorResult.Accept : TopicValidatorResult.Reject;
+  }
+
+  @trackSpan('Libp2pService.validatePropagatedTx', tx => ({
+    [Attributes.TX_HASH]: tx.getTxHash().toString(),
+  }))
   private async validatePropagatedTx(tx: Tx, peerId: PeerId): Promise<boolean> {
     const blockNumber = (await this.l2BlockSource.getBlockNumber()) + 1;
-    // basic data validation
-    const dataValidator = new DataTxValidator();
-    const validData = await dataValidator.validateTx(tx);
-    if (!validData) {
-      // penalize
-      this.node.services.pubsub.score.markInvalidMessageDelivery(peerId.toString(), Tx.p2pTopic);
-      return false;
+    const messageValidators = this.createMessageValidators(blockNumber);
+    const outcome = await this.runValidations(tx, messageValidators);
+
+    if (outcome.allPassed) {
+      return true;
     }
 
-    // metadata validation
-    const metadataValidator = new MetadataTxValidator(new Fr(this.config.l1ChainId), new Fr(blockNumber));
-    const validMetadata = await metadataValidator.validateTx(tx);
-    if (!validMetadata) {
-      // penalize
-      this.node.services.pubsub.score.markInvalidMessageDelivery(peerId.toString(), Tx.p2pTopic);
+    const { name, severity } = outcome.failure;
+
+    // Double spend validator has a special case handler
+    if (name === 'doubleSpendValidator') {
+      const isValid = await this.handleDoubleSpendFailure(tx, blockNumber, peerId);
+      if (isValid) {
+        return true;
+      }
+    }
+
+    this.peerManager.penalizePeer(peerId, severity);
+    return false;
+  }
+
+  /**
+   * Create message validators for the given block number.
+   *
+   * Each validator is a pair of a validator and a severity.
+   * If a validator fails, the peer is penalized with the severity of the validator.
+   *
+   * @param blockNumber - The block number to create validators for.
+   * @returns The message validators.
+   */
+  private createMessageValidators(blockNumber: number): Record<string, MessageValidator> {
+    return {
+      dataValidator: {
+        validator: new DataTxValidator(),
+        severity: PeerErrorSeverity.HighToleranceError,
+      },
+      metadataValidator: {
+        validator: new MetadataTxValidator(new Fr(this.config.l1ChainId), new Fr(blockNumber)),
+        severity: PeerErrorSeverity.HighToleranceError,
+      },
+      proofValidator: {
+        validator: new TxProofValidator(this.proofVerifier),
+        severity: PeerErrorSeverity.MidToleranceError,
+      },
+      doubleSpendValidator: {
+        validator: new DoubleSpendTxValidator({
+          getNullifierIndices: (nullifiers: Buffer[]) => {
+            const merkleTree = this.worldStateSynchronizer.getCommitted();
+            return merkleTree.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers);
+          },
+        }),
+        severity: PeerErrorSeverity.HighToleranceError,
+      },
+    };
+  }
+
+  /**
+   * Run validations on a tx.
+   * @param tx - The tx to validate.
+   * @param messageValidators - The message validators to run.
+   * @returns The validation outcome.
+   */
+  private async runValidations(
+    tx: Tx,
+    messageValidators: Record<string, MessageValidator>,
+  ): Promise<ValidationOutcome> {
+    const validationPromises = Object.entries(messageValidators).map(async ([name, { validator, severity }]) => {
+      const isValid = await validator.validateTx(tx);
+      return { name, isValid, severity };
+    });
+
+    // A promise that resolves when all validations have been run
+    const allValidations = Promise.all(validationPromises);
+
+    // A promise that resolves when the first validation fails
+    const firstFailure = Promise.race(
+      validationPromises.map(async promise => {
+        const result = await promise;
+        return result.isValid ? new Promise(() => {}) : result;
+      }),
+    );
+
+    // Wait for the first validation to fail or all validations to pass
+    const result = await Promise.race([
+      allValidations.then(() => ({ allPassed: true as const })),
+      firstFailure.then(failure => ({ allPassed: false as const, failure: failure as ValidationResult })),
+    ]);
+
+    // If all validations pass, allPassed will be true, if failed, then the failure will be the first validation to fail
+    return result;
+  }
+
+  /**
+   * Handle a double spend failure.
+   *
+   * Double spend failures are managed on their own because they are a special case.
+   * We must check if the double spend is recent or old, if it is past a threshold, then we heavily penalize the peer.
+   *
+   * @param tx - The tx that failed the double spend validator.
+   * @param blockNumber - The block number of the tx.
+   * @param peerId - The peer ID of the peer that sent the tx.
+   * @returns True if the tx is valid, false otherwise.
+   */
+  private async handleDoubleSpendFailure(tx: Tx, blockNumber: number, peerId: PeerId): Promise<boolean> {
+    if (blockNumber <= this.config.severePeerPenaltyBlockLength) {
       return false;
     }
 
-    // double spend validation
-    const doubleSpendValidator = new DoubleSpendTxValidator({
-      getNullifierIndex: async (nullifier: Fr) => {
-        const merkleTree = this.worldStateSynchronizer.getCommitted();
-        const index = await merkleTree.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
-        return index;
+    const snapshotValidator = new DoubleSpendTxValidator({
+      getNullifierIndices: (nullifiers: Buffer[]) => {
+        const merkleTree = this.worldStateSynchronizer.getSnapshot(
+          blockNumber - this.config.severePeerPenaltyBlockLength,
+        );
+        return merkleTree.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers);
       },
     });
-    const validDoubleSpend = await doubleSpendValidator.validateTx(tx);
-    if (!validDoubleSpend) {
-      // check if nullifier is older than 20 blocks
-      if (blockNumber - this.config.severePeerPenaltyBlockLength > 0) {
-        const snapshotValidator = new DoubleSpendTxValidator({
-          getNullifierIndex: async (nullifier: Fr) => {
-            const merkleTree = this.worldStateSynchronizer.getSnapshot(
-              blockNumber - this.config.severePeerPenaltyBlockLength,
-            );
-            const index = await merkleTree.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
-            return index;
-          },
-        });
-
-        const validSnapshot = await snapshotValidator.validateTx(tx);
-        // High penalty if nullifier is older than 20 blocks
-        if (!validSnapshot) {
-          // penalize
-          this.peerManager.penalizePeer(peerId, PeerErrorSeverity.LowToleranceError);
-          return false;
-        }
-      }
-      // penalize
-      this.peerManager.penalizePeer(peerId, PeerErrorSeverity.HighToleranceError);
+
+    const validSnapshot = await snapshotValidator.validateTx(tx);
+    if (!validSnapshot) {
+      this.peerManager.penalizePeer(peerId, PeerErrorSeverity.LowToleranceError);
       return false;
     }
 
-    // proof validation
-    const proofValidator = new TxProofValidator(this.proofVerifier);
-    const validProof = await proofValidator.validateTx(tx);
-    if (!validProof) {
-      // penalize
-      this.peerManager.penalizePeer(peerId, PeerErrorSeverity.MidToleranceError);
+    return true;
+  }
+
+  /**
+   * Validate an attestation.
+   *
+   * @param attestation - The attestation to validate.
+   * @returns True if the attestation is valid, false otherwise.
+   */
+  @trackSpan('Libp2pService.validateAttestation', (_peerId, attestation) => ({
+    [Attributes.SLOT_NUMBER]: attestation.payload.header.globalVariables.slotNumber.toString(),
+  }))
+  public async validateAttestation(peerId: PeerId, attestation: BlockAttestation): Promise<boolean> {
+    const severity = await this.attestationValidator.validate(attestation);
+    if (severity) {
+      this.peerManager.penalizePeer(peerId, severity);
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Validate a block proposal.
+   *
+   * @param block - The block proposal to validate.
+   * @returns True if the block proposal is valid, false otherwise.
+   */
+  @trackSpan('Libp2pService.validateBlockProposal', (_peerId, block) => ({
+    [Attributes.SLOT_NUMBER]: block.payload.header.globalVariables.slotNumber.toString(),
+  }))
+  public async validateBlockProposal(peerId: PeerId, block: BlockProposal): Promise<boolean> {
+    const severity = await this.blockProposalValidator.validate(block);
+    if (severity) {
+      this.peerManager.penalizePeer(peerId, severity);
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Validate an epoch proof quote.
+   *
+   * @param epochProofQuote - The epoch proof quote to validate.
+   * @returns True if the epoch proof quote is valid, false otherwise.
+   */
+  @trackSpan('Libp2pService.validateEpochProofQuote', (_peerId, epochProofQuote) => ({
+    [Attributes.EPOCH_NUMBER]: epochProofQuote.payload.epochToProve.toString(),
+  }))
+  public async validateEpochProofQuote(peerId: PeerId, epochProofQuote: EpochProofQuote): Promise<boolean> {
+    const severity = await this.epochProofQuoteValidator.validate(epochProofQuote);
+    if (severity) {
+      this.peerManager.penalizePeer(peerId, severity);
       return false;
     }
 

package/src/{service → services/peer-scoring}/peer_scoring.ts

@@ -1,29 +1,12 @@
+import { PeerErrorSeverity } from '@aztec/circuit-types';
 import { median } from '@aztec/foundation/collection';
 
-import { type P2PConfig } from '../config.js';
-
-export enum PeerErrorSeverity {
-  /**
-   * Not malicious action, but it must not be tolerated
-   * ~2 occurrences will get the peer banned
-   */
-  LowToleranceError = 'LowToleranceError',
-  /**
-   * Negative action that can be tolerated only sometimes
-   * ~10 occurrences will get the peer banned
-   */
-  MidToleranceError = 'MidToleranceError',
-  /**
-   * Some error that can be tolerated multiple times
-   * ~50 occurrences will get the peer banned
-   */
-  HighToleranceError = 'HighToleranceError',
-}
+import { type P2PConfig } from '../../config.js';
 
 const DefaultPeerPenalties = {
-  [PeerErrorSeverity.LowToleranceError]: 2,
+  [PeerErrorSeverity.LowToleranceError]: 50,
   [PeerErrorSeverity.MidToleranceError]: 10,
-  [PeerErrorSeverity.HighToleranceError]: 50,
+  [PeerErrorSeverity.HighToleranceError]: 2,
 };
 
 export class PeerScoring {
@@ -37,11 +20,11 @@ export class PeerScoring {
     const orderedValues = config.peerPenaltyValues?.sort((a, b) => a - b);
     this.peerPenalties = {
       [PeerErrorSeverity.HighToleranceError]:
-        orderedValues?.[0] ?? DefaultPeerPenalties[PeerErrorSeverity.LowToleranceError],
+        orderedValues?.[0] ?? DefaultPeerPenalties[PeerErrorSeverity.HighToleranceError],
       [PeerErrorSeverity.MidToleranceError]:
         orderedValues?.[1] ?? DefaultPeerPenalties[PeerErrorSeverity.MidToleranceError],
       [PeerErrorSeverity.LowToleranceError]:
-        orderedValues?.[2] ?? DefaultPeerPenalties[PeerErrorSeverity.HighToleranceError],
+        orderedValues?.[2] ?? DefaultPeerPenalties[PeerErrorSeverity.LowToleranceError],
     };
   }