@aztec/p2p 0.0.1-commit.9ef841308 → 0.0.1-commit.a89ec08

package/src/services/libp2p/libp2p_service.ts

@@ -18,6 +18,7 @@ import {
   type CheckpointProposalCore,
   type Gossipable,
   P2PMessage,
+  type ValidationResult as P2PValidationResult,
   PeerErrorSeverity,
   PeerErrorSeverityByHarshness,
   TopicType,
@@ -51,10 +52,9 @@ import { yamux } from '@chainsafe/libp2p-yamux';
 import { bootstrap } from '@libp2p/bootstrap';
 import { identify } from '@libp2p/identify';
 import { type Message, type MultiaddrConnection, type PeerId, TopicValidatorResult } from '@libp2p/interface';
-import type { AddressManager, ConnectionManager } from '@libp2p/interface-internal';
+import type { ConnectionManager } from '@libp2p/interface-internal';
 import { mplex } from '@libp2p/mplex';
 import { tcp } from '@libp2p/tcp';
-import { multiaddr } from '@multiformats/multiaddr';
 import { ENR } from '@nethermindeth/enr';
 import { createLibp2p } from 'libp2p';
 
@@ -131,7 +131,7 @@ type ValidationOutcome = { allPassed: true } | { allPassed: false; failure: Vali
 // REFACTOR: Unify with the type above
 type ReceivedMessageValidationResult<T, M = undefined> =
   | { obj: T; result: Exclude<TopicValidatorResult, TopicValidatorResult.Reject>; metadata?: M }
-  | { obj?: T; result: TopicValidatorResult.Reject; metadata?: M; severity: PeerErrorSeverity };
+  | { obj?: T; result: TopicValidatorResult.Reject; metadata?: M };
 
 /**
  * Lib P2P implementation of the P2PService interface.
@@ -175,10 +175,6 @@ export class LibP2PService extends WithTracer implements P2PService {
   private checkpointReceivedCallback: P2PCheckpointReceivedCallback;
 
   private gossipSubEventHandler: (e: CustomEvent<GossipsubMessage>) => void;
-  private ipChangedHandler?: (ip: string) => void;
-
-  /** Discovered public IP address (set when queryForIp is enabled and no static IP was configured). */
-  private discoveredP2pIp?: string;
 
   private instrumentation: P2PInstrumentation;
 
@@ -447,9 +443,8 @@ export class LibP2PService extends WithTracer implements P2PService {
             topics: topicScoreParams,
           }),
         }) as (components: GossipSubComponents) => GossipSub,
-        components: (components: { connectionManager: ConnectionManager; addressManager: AddressManager }) => ({
+        components: (components: { connectionManager: ConnectionManager }) => ({
           connectionManager: components.connectionManager,
-          addressManager: components.addressManager,
         }),
       },
       logger: createLibp2pComponentLogger(logger.module, logger.getBindings()),
@@ -508,10 +503,10 @@ export class LibP2PService extends WithTracer implements P2PService {
 
     // Get listen & announce addresses for logging
     const { p2pIp, p2pPort } = this.config;
-    if (!p2pIp && !this.config.queryForIp) {
+    if (!p2pIp) {
       throw new Error('Announce address not provided.');
     }
-    const announceTcpMultiaddr = p2pIp ? convertToMultiaddr(p2pIp, p2pPort, 'tcp') : undefined;
+    const announceTcpMultiaddr = convertToMultiaddr(p2pIp, p2pPort, 'tcp');
 
     // Create request response protocol handlers
     const txHandler = reqRespTxHandler(this.mempools);
@@ -565,31 +560,6 @@ export class LibP2PService extends WithTracer implements P2PService {
     if (!this.config.p2pDiscoveryDisabled) {
       await this.peerDiscoveryService.start();
     }
-
-    // When queryForIp is enabled and no static IP was configured, bridge discv5 IP discovery to libp2p.
-    // Discv5 discovers our public IP via peer WHOAREYOU exchanges (enrUpdate=true) and emits 'ip:changed'.
-    // We confirm the discovered address in the libp2p AddressManager so it appears in getMultiaddrs()
-    // and is pushed to all connected peers via the identify protocol.
-    if (this.config.queryForIp && !p2pIp) {
-      this.ipChangedHandler = (ip: string) => {
-        const addressManager = this.node.services.components.addressManager;
-        const newAddr = multiaddr(convertToMultiaddr(ip, this.config.p2pPort, 'tcp'));
-
-        // Remove old discovered IP if one exists
-        if (this.discoveredP2pIp) {
-          const oldAddr = multiaddr(convertToMultiaddr(this.discoveredP2pIp, this.config.p2pPort, 'tcp'));
-          addressManager.removeObservedAddr(oldAddr);
-        }
-
-        addressManager.addObservedAddr(newAddr);
-        addressManager.confirmObservedAddr(newAddr);
-        // Store discovered IP
-        this.discoveredP2pIp = ip;
-        this.logger.info('Public IP discovered via discv5', { ip });
-      };
-      this.peerDiscoveryService.on('ip:changed', this.ipChangedHandler);
-    }
-
     this.discoveryRunningPromise = new RunningPromise(
       async () => {
         await this.peerManager.heartbeat();
@@ -602,7 +572,7 @@ export class LibP2PService extends WithTracer implements P2PService {
     this.logger.info(`Started P2P service`, {
       listen: this.config.listenAddress,
       port: this.config.p2pPort,
-      announce: announceTcpMultiaddr ?? 'pending (queryForIp=true)',
+      announce: announceTcpMultiaddr,
       peerId: this.node.peerId.toString(),
     });
   }
@@ -615,12 +585,6 @@ export class LibP2PService extends WithTracer implements P2PService {
     // Remove gossip sub listener
     this.node.services.pubsub.removeEventListener(GossipSubEvent.MESSAGE, this.gossipSubEventHandler);
 
-    // Remove ip:changed listener if registered
-    if (this.ipChangedHandler) {
-      this.peerDiscoveryService.off('ip:changed', this.ipChangedHandler);
-      this.ipChangedHandler = undefined;
-    }
-
     // Stop peer manager
     this.logger.debug('Stopping peer manager...');
     await this.peerManager.stop();
@@ -790,9 +754,6 @@ export class LibP2PService extends WithTracer implements P2PService {
     if (!validator || !validator.addMessage(msgId)) {
       this.instrumentation.incMessagePrevalidationStatus(false, topicType);
       this.node.services.pubsub.reportMessageValidationResult(msgId, source.toString(), TopicValidatorResult.Ignore);
-      if (topicType === TopicType.tx) {
-        this.logger.verbose(`Ignoring already-seen tx gossip message`, { msgId, source: source.toString() });
-      }
       return { result: false, topicType };
     }
 
@@ -919,56 +880,30 @@ export class LibP2PService extends WithTracer implements P2PService {
     source: PeerId,
     topicType: TopicType,
   ): Promise<ReceivedMessageValidationResult<T, M>> {
-    // Default to reject result with a penalty if validation function throws an error
-    let resultAndObj: ReceivedMessageValidationResult<T, M> = {
-      result: TopicValidatorResult.Reject,
-      severity: PeerErrorSeverity.MidToleranceError,
-    };
+    let resultAndObj: ReceivedMessageValidationResult<T, M> = { result: TopicValidatorResult.Reject };
     const timer = new Timer();
     try {
       resultAndObj = await validationFunc();
     } catch (err) {
-      this.logger.error(`Error validating gossipsub message`, err, { msgId, source: source.toString(), topicType });
-    }
-
-    if (resultAndObj.result === TopicValidatorResult.Accept) {
-      this.logger.debug(`Message ${topicType} accepted by validator`, { msgId, source: source.toString(), topicType });
-      this.instrumentation.recordMessageValidation(topicType, timer);
-    } else if (resultAndObj.result === TopicValidatorResult.Reject) {
-      this.logger.warn(`Message ${topicType} rejected by validator with severity ${resultAndObj.severity}`, {
+      this.peerManager.penalizePeer(source, PeerErrorSeverity.LowToleranceError);
+      this.logger.error(`Error deserializing and validating gossipsub message`, err, {
         msgId,
         source: source.toString(),
         topicType,
-        severity: resultAndObj.severity,
       });
-      this.peerManager.penalizePeer(source, resultAndObj.severity);
-    } else {
-      this.logger.trace(`Message ${topicType} ignored by validator`, { msgId, source: source.toString(), topicType });
+    }
+
+    if (resultAndObj.result === TopicValidatorResult.Accept) {
+      this.instrumentation.recordMessageValidation(topicType, timer);
     }
 
     this.node.services.pubsub.reportMessageValidationResult(msgId, source.toString(), resultAndObj.result);
     return resultAndObj;
   }
 
-  private tryDeserialize<T>(deserializeFunc: () => T, msgId: string, source: PeerId): T | undefined {
-    try {
-      return deserializeFunc();
-    } catch (err) {
-      this.logger.warn(`Failed to deserialize gossipsub message from buffer`, {
-        err,
-        msgId,
-        source: source.toString(),
-      });
-      return undefined;
-    }
-  }
-
   protected async handleGossipedTx(payloadData: Buffer, msgId: string, source: PeerId) {
     const validationFunc: () => Promise<ReceivedMessageValidationResult<Tx>> = async () => {
-      const tx = this.tryDeserialize(() => Tx.fromBuffer(payloadData), msgId, source);
-      if (!tx) {
-        return { result: TopicValidatorResult.Reject, severity: PeerErrorSeverity.LowToleranceError };
-      }
+      const tx = Tx.fromBuffer(payloadData);
 
       const currentBlockNumber = await this.archiver.getBlockNumber();
       const { ts: nextSlotTimestamp } = this.epochCache.getEpochAndSlotInNextL1Slot();
@@ -988,20 +923,13 @@ export class LibP2PService extends WithTracer implements P2PService {
           severity = await this.handleDoubleSpendFailure(tx, txBlockNumber);
         }
 
-        this.logger.verbose(`Rejecting gossiped tx ${tx.getTxHash().toString()}: stage 1 validation failed`, {
-          validator: name,
-          severity,
-          source: source.toString(),
-        });
-        return { result: TopicValidatorResult.Reject, severity };
+        this.peerManager.penalizePeer(source, severity);
+        return { result: TopicValidatorResult.Reject };
       }
 
       // Pool pre-check: see if the pool would accept this tx before doing expensive proof verification
       const canAdd = await this.mempools.txPool.canAddPendingTx(tx);
       if (canAdd === 'ignored') {
-        this.logger.verbose(`Ignoring gossiped tx ${tx.getTxHash().toString()}: pool pre-check returned ignored`, {
-          source: source.toString(),
-        });
         return { result: TopicValidatorResult.Ignore, obj: tx };
       }
 
@@ -1009,13 +937,9 @@ export class LibP2PService extends WithTracer implements P2PService {
       const secondStageValidators = this.createSecondStageMessageValidators();
       const secondStageOutcome = await this.runValidations(tx, secondStageValidators);
       if (!secondStageOutcome.allPassed) {
-        const { severity, name } = secondStageOutcome.failure;
-        this.logger.verbose(`Rejecting gossiped tx ${tx.getTxHash().toString()}: stage 2 validation failed`, {
-          validator: name,
-          severity,
-          source: source.toString(),
-        });
-        return { result: TopicValidatorResult.Reject, severity };
+        const { severity } = secondStageOutcome.failure;
+        this.peerManager.penalizePeer(source, severity);
+        return { result: TopicValidatorResult.Reject };
       }
 
       // Pool add: persist the tx
@@ -1025,7 +949,7 @@ export class LibP2PService extends WithTracer implements P2PService {
       const wasAccepted = addResult.accepted.some(h => h.equals(txHash));
       const wasIgnored = addResult.ignored.some(h => h.equals(txHash));
 
-      this.logger.verbose(`Validate propagated tx ${txHash.toString()}`, {
+      this.logger.trace(`Validate propagated tx`, {
         wasAccepted,
         wasIgnored,
         [Attributes.P2P_ID]: source.toString(),
@@ -1040,7 +964,8 @@ export class LibP2PService extends WithTracer implements P2PService {
           source: source.toString(),
           txHash: txHash.toString(),
         });
-        return { result: TopicValidatorResult.Reject, severity: PeerErrorSeverity.HighToleranceError };
+        this.peerManager.penalizePeer(source, PeerErrorSeverity.HighToleranceError);
+        return { result: TopicValidatorResult.Reject };
       }
     };
 
@@ -1070,16 +995,7 @@ export class LibP2PService extends WithTracer implements P2PService {
     source: PeerId,
   ): Promise<void> {
     const { result, obj: attestation } = await this.validateReceivedMessage<CheckpointAttestation>(
-      () => {
-        const attestation = this.tryDeserialize(() => CheckpointAttestation.fromBuffer(payloadData), msgId, source);
-        if (!attestation) {
-          return Promise.resolve({
-            result: TopicValidatorResult.Reject,
-            severity: PeerErrorSeverity.LowToleranceError,
-          });
-        }
-        return this.validateAndStoreCheckpointAttestation(source, attestation);
-      },
+      () => this.validateAndStoreCheckpointAttestation(source, CheckpointAttestation.fromBuffer(payloadData)),
       msgId,
       source,
       TopicType.checkpoint_attestation,
@@ -1112,7 +1028,8 @@ export class LibP2PService extends WithTracer implements P2PService {
 
     if (validationResult.result === 'reject') {
       this.logger.warn(`Penalizing peer ${peerId} for checkpoint attestation validation failure`);
-      return { result: TopicValidatorResult.Reject, severity: validationResult.severity };
+      this.peerManager.penalizePeer(peerId, validationResult.severity);
+      return { result: TopicValidatorResult.Reject };
     }
 
     if (validationResult.result === 'ignore') {
@@ -1138,16 +1055,16 @@ export class LibP2PService extends WithTracer implements P2PService {
       return { result: TopicValidatorResult.Ignore, obj: attestation };
     }
 
-    // Could not add (cap reached for signer), penalize and do not re-broadcast
+    // Could not add (cap reached for signer), no need to re-broadcast
     if (!added) {
-      this.logger.warn(`Rejecting checkpoint attestation due to cap`, {
+      this.logger.warn(`Dropping checkpoint attestation due to cap`, {
         slot: slot.toString(),
         archive: attestation.archive.toString(),
         source: peerId.toString(),
         attester: attestation.getSender()?.toString(),
         count,
       });
-      return { result: TopicValidatorResult.Reject, severity: PeerErrorSeverity.HighToleranceError };
+      return { result: TopicValidatorResult.Ignore, obj: attestation };
     }
 
     // Check if this is a duplicate attestation (signer attested to a different proposal at the same slot)
@@ -1202,7 +1119,8 @@ export class LibP2PService extends WithTracer implements P2PService {
 
     if (validationResult.result === 'reject') {
       this.logger.warn(`Penalizing peer ${peerId} for block proposal validation failure`);
-      return { result: TopicValidatorResult.Reject, severity: validationResult.severity };
+      this.peerManager.penalizePeer(peerId, validationResult.severity);
+      return { result: TopicValidatorResult.Reject };
     }
 
     if (validationResult.result === 'ignore') {
@@ -1226,6 +1144,7 @@ export class LibP2PService extends WithTracer implements P2PService {
 
     // Too many blocks received for this slot and index, penalize peer and do not re-broadcast
     if (!added) {
+      this.peerManager.penalizePeer(peerId, PeerErrorSeverity.HighToleranceError);
       this.logger.warn(`Penalizing peer for block proposal exceeding per-position cap`, {
         ...block.toBlockInfo(),
         indexWithinCheckpoint: block.indexWithinCheckpoint,
@@ -1233,11 +1152,7 @@ export class LibP2PService extends WithTracer implements P2PService {
         proposer: block.getSender()?.toString(),
         source: peerId.toString(),
       });
-      return {
-        result: TopicValidatorResult.Reject,
-        metadata: { isEquivocated },
-        severity: PeerErrorSeverity.HighToleranceError,
-      };
+      return { result: TopicValidatorResult.Reject, metadata: { isEquivocated } };
     }
 
     // If this was a duplicate proposal, do not process it, but do invoke the duplicate callback,
@@ -1330,7 +1245,8 @@ export class LibP2PService extends WithTracer implements P2PService {
 
     if (validationResult.result === 'reject') {
       this.logger.warn(`Penalizing peer ${peerId} for checkpoint proposal validation failure`);
-      return { result: TopicValidatorResult.Reject, severity: validationResult.severity };
+      this.peerManager.penalizePeer(peerId, validationResult.severity);
+      return { result: TopicValidatorResult.Reject };
     }
 
     if (validationResult.result === 'ignore') {
@@ -1345,21 +1261,20 @@ export class LibP2PService extends WithTracer implements P2PService {
         [Attributes.SLOT_NUMBER]: checkpoint.slotNumber.toString(),
         [Attributes.P2P_ID]: peerId.toString(),
       });
-      const blockProposalResult = await this.validateAndStoreBlockProposal(peerId, blockProposal);
-      const { obj, metadata: { isEquivocated } = {} } = blockProposalResult;
-      if (blockProposalResult.result === TopicValidatorResult.Reject || !obj || isEquivocated) {
+      const {
+        result,
+        obj,
+        metadata: { isEquivocated } = {},
+      } = await this.validateAndStoreBlockProposal(peerId, blockProposal);
+      if (result === TopicValidatorResult.Reject || !obj || isEquivocated) {
         this.logger.debug(`Rejecting checkpoint due to invalid last block proposal`, {
           [Attributes.SLOT_NUMBER]: checkpoint.slotNumber.toString(),
           [Attributes.P2P_ID]: peerId.toString(),
           isEquivocated,
-          result: blockProposalResult.result,
+          result,
         });
-        return {
-          result: TopicValidatorResult.Reject,
-          severity:
-            'severity' in blockProposalResult ? blockProposalResult.severity : PeerErrorSeverity.MidToleranceError,
-        };
-      } else if (blockProposalResult.result === TopicValidatorResult.Accept && obj && !isEquivocated) {
+        return { result: TopicValidatorResult.Reject };
+      } else if (result === TopicValidatorResult.Accept && obj && !isEquivocated) {
         processBlock = true;
       }
     }
@@ -1386,17 +1301,13 @@ export class LibP2PService extends WithTracer implements P2PService {
     // Too many checkpoint proposals received for this slot, penalize peer and do not re-broadcast
     // Note: We still return the checkpoint obj so the lastBlock can be processed if valid
     if (!added) {
+      this.peerManager.penalizePeer(peerId, PeerErrorSeverity.HighToleranceError);
       this.logger.warn(`Penalizing peer for checkpoint proposal exceeding per-slot cap`, {
         ...checkpoint.toCheckpointInfo(),
         count,
         source: peerId.toString(),
       });
-      return {
-        result: TopicValidatorResult.Reject,
-        obj: checkpoint,
-        metadata: { isEquivocated, processBlock },
-        severity: PeerErrorSeverity.HighToleranceError,
-      };
+      return { result: TopicValidatorResult.Reject, obj: checkpoint, metadata: { isEquivocated, processBlock } };
     }
 
     // If this was a duplicate proposal, do not process it, but do invoke the duplicate callback,
@@ -1820,6 +1731,31 @@ export class LibP2PService extends WithTracer implements P2PService {
     return PeerErrorSeverity.HighToleranceError;
   }
 
+  /**
+   * Validate a checkpoint attestation.
+   *
+   * @param attestation - The checkpoint attestation to validate.
+   * @returns True if the checkpoint attestation is valid, false otherwise.
+   */
+  @trackSpan('Libp2pService.validateCheckpointAttestation', async (_, attestation) => ({
+    [Attributes.SLOT_NUMBER]: attestation.payload.header.slotNumber,
+    [Attributes.BLOCK_ARCHIVE]: attestation.archive.toString(),
+    [Attributes.P2P_ID]: await attestation.p2pMessageLoggingIdentifier().then(i => i.toString()),
+  }))
+  public async validateCheckpointAttestation(
+    peerId: PeerId,
+    attestation: CheckpointAttestation,
+  ): Promise<P2PValidationResult> {
+    const result = await this.checkpointAttestationValidator.validate(attestation);
+
+    if (result.result === 'reject') {
+      this.logger.warn(`Penalizing peer ${peerId} for checkpoint attestation validation failure`);
+      this.peerManager.penalizePeer(peerId, result.severity);
+    }
+
+    return result;
+  }
+
   public getPeerScore(peerId: PeerId): number {
     return this.node.services.pubsub.score.score(peerId.toString());
   }

package/src/services/peer-manager/metrics.ts

@@ -18,7 +18,6 @@ export class PeerManagerMetrics {
   private sentGoodbyes: UpDownCounter;
   private receivedGoodbyes: UpDownCounter;
   private peerCount: Gauge;
-  private healthyPeerCount: Gauge;
   private lowScoreDisconnects: UpDownCounter;
   private peerConnectionDuration: Histogram;
 
@@ -50,7 +49,6 @@ export class PeerManagerMetrics {
       goodbyeReasonAttrs,
     );
     this.peerCount = meter.createGauge(Metrics.PEER_MANAGER_PEER_COUNT);
-    this.healthyPeerCount = meter.createGauge(Metrics.PEER_MANAGER_HEALTHY_PEER_COUNT);
     this.lowScoreDisconnects = createUpDownCounterWithDefault(meter, Metrics.PEER_MANAGER_LOW_SCORE_DISCONNECTS, {
       [Attributes.P2P_PEER_SCORE_STATE]: ['Banned', 'Disconnect'],
     });
@@ -69,10 +67,6 @@ export class PeerManagerMetrics {
     this.peerCount.record(count);
   }
 
-  public recordHealthyPeerCount(count: number) {
-    this.healthyPeerCount.record(count);
-  }
-
   public recordLowScoreDisconnect(scoreState: 'Banned' | 'Disconnect') {
     this.lowScoreDisconnects.add(1, { [Attributes.P2P_PEER_SCORE_STATE]: scoreState });
   }
@@ -85,7 +79,6 @@ export class PeerManagerMetrics {
     const connectedAt = this.peerConnectedAt.get(id.toString());
     if (connectedAt) {
       this.peerConnectionDuration.record(Date.now() - connectedAt);
-      this.peerConnectedAt.delete(id.toString());
     }
   }
 }

package/src/services/peer-manager/peer_manager.ts

@@ -32,7 +32,7 @@ import { PeerScoreState, type PeerScoring } from './peer_scoring.js';
 const MAX_DIAL_ATTEMPTS = 3;
 const MAX_CACHED_PEERS = 100;
 const MAX_CACHED_PEER_AGE_MS = 5 * 60 * 1000; // 5 minutes
-const DEFAULT_FAILED_PEER_BAN_TIME_MS = 5 * 60 * 1000; // 5 minutes timeout after failing MAX_DIAL_ATTEMPTS
+const FAILED_PEER_BAN_TIME_MS = 5 * 60 * 1000; // 5 minutes timeout after failing MAX_DIAL_ATTEMPTS
 const GOODBYE_DIAL_TIMEOUT_MS = 1000;
 const FAILED_AUTH_HANDSHAKE_EXPIRY_MS = 60 * 60 * 1000; // 1 hour
 
@@ -226,30 +226,20 @@ export class PeerManager implements PeerManagerInterface {
   }
 
   /**
-   * Cleans up expired timeouts and stale failed-auth-handshake entries.
+   * Cleans up expired timeouts.
    *
    * When peers fail to dial after a number of retries, they are temporarily timed out.
    * This function removes any peers that have been in the timed out state for too long.
    * To give them a chance to reconnect.
-   *
-   * Also evicts entries from the failed-auth-handshake map whose expiry window has passed.
-   * Without this, peers that probe once and never reconnect would leave their entries in the
-   * map forever, causing an unbounded memory leak.
    */
   private cleanupExpiredTimeouts() {
+    // Clean up expired timeouts
     const now = this.dateProvider.now();
-
     for (const [peerId, timedOutPeer] of this.timedOutPeers.entries()) {
       if (now >= timedOutPeer.timeoutUntilMs) {
         this.timedOutPeers.delete(peerId);
       }
     }
-
-    for (const [id, entry] of this.failedAuthHandshakes.entries()) {
-      if (now - entry.lastFailureTimestamp > FAILED_AUTH_HANDSHAKE_EXPIRY_MS) {
-        this.failedAuthHandshakes.delete(id);
-      }
-    }
   }
 
   /**
@@ -313,20 +303,15 @@ export class PeerManager implements PeerManagerInterface {
    */
   private handleDisconnectedPeerEvent(e: CustomEvent<PeerId>) {
     const peerId = e.detail;
-    const peerIdStr = peerId.toString();
     this.metrics.peerDisconnected(peerId);
-    this.logger.verbose(`Disconnected from peer ${peerIdStr}`);
-    const validatorAddress = this.authenticatedPeerIdToValidatorAddress.get(peerIdStr);
+    this.logger.verbose(`Disconnected from peer ${peerId.toString()}`);
+    const validatorAddress = this.authenticatedPeerIdToValidatorAddress.get(peerId.toString());
     if (validatorAddress !== undefined) {
       this.logger.info(
-        `Removing authentication for validator ${validatorAddress} at peer id ${peerIdStr} due to disconnection`,
+        `Removing authentication for validator ${validatorAddress} at peer id ${peerId.toString()} due to disconnection`,
       );
       this.authenticatedValidatorAddressToPeerId.delete(validatorAddress.toString());
-      this.authenticatedPeerIdToValidatorAddress.delete(peerIdStr);
-    }
-
-    if (this.peerScoring.getScoreState(peerIdStr) === PeerScoreState.Healthy) {
-      this.peerScoring.removePeer(peerIdStr);
+      this.authenticatedPeerIdToValidatorAddress.delete(peerId.toString());
     }
   }
 
@@ -530,8 +515,7 @@ export class PeerManager implements PeerManagerInterface {
       ...this.peerScoring.getStats(),
     });
 
-    this.metrics.recordPeerCount(connections.length);
-    this.metrics.recordHealthyPeerCount(healthyConnections.length);
+    this.metrics.recordPeerCount(healthyConnections.length);
 
     // Exit if no peers to connect
     if (peersToConnect <= 0) {
@@ -791,8 +775,7 @@ export class PeerManager implements PeerManagerInterface {
         // Add to timed out peers
         this.timedOutPeers.set(id, {
           peerId: id,
-          timeoutUntilMs:
-            this.dateProvider.now() + (this.config.peerFailedBanTimeMs ?? DEFAULT_FAILED_PEER_BAN_TIME_MS),
+          timeoutUntilMs: this.dateProvider.now() + FAILED_PEER_BAN_TIME_MS,
         });
       }
     }
@@ -954,8 +937,6 @@ export class PeerManager implements PeerManagerInterface {
           `Received auth for validator ${sender.toString()} from peer ${peerIdString}, but this validator is already authenticated to peer ${peerForAddress.toString()}`,
           { ...logData, address: sender.toString() },
         );
-        this.markAuthHandshakeFailed(peerId);
-        this.markPeerForDisconnect(peerId);
         return;
       }
 

package/src/services/peer-manager/peer_scoring.ts

@@ -1,6 +1,5 @@
 import { median } from '@aztec/foundation/collection';
 import { createLogger } from '@aztec/foundation/log';
-import { DateProvider } from '@aztec/foundation/timer';
 import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
 import {
   Attributes,
@@ -55,7 +54,6 @@ export enum PeerScoreState {
 // TODO: move into config / constants
 const MIN_SCORE_BEFORE_BAN = -100;
 const MIN_SCORE_BEFORE_DISCONNECT = -50;
-const SCORE_CLEANUP_THRESHOLD = 0.1;
 
 export class PeerScoring {
   private logger = createLogger('p2p:peer-scoring');
@@ -67,11 +65,7 @@ export class PeerScoring {
 
   private peerStateCounter: UpDownCounter;
 
-  constructor(
-    config: P2PConfig,
-    telemetry: TelemetryClient = getTelemetryClient(),
-    private readonly dateProvider: DateProvider = new DateProvider(),
-  ) {
+  constructor(config: P2PConfig, telemetry: TelemetryClient = getTelemetryClient()) {
     const orderedValues = config.peerPenaltyValues?.sort((a, b) => a - b);
     this.peerPenalties = {
       [PeerErrorSeverity.HighToleranceError]:
@@ -98,7 +92,7 @@ export class PeerScoring {
   }
 
   updateScore(peerId: string, scoreDelta: number): number {
-    const currentTime = this.dateProvider.now();
+    const currentTime = Date.now();
     const lastUpdate = this.lastUpdateTime.get(peerId) || currentTime;
     const timePassed = currentTime - lastUpdate;
     const decayPeriods = Math.floor(timePassed / this.decayInterval);
@@ -117,29 +111,19 @@ export class PeerScoring {
   }
 
   decayAllScores(): void {
-    const currentTime = this.dateProvider.now();
+    const currentTime = Date.now();
     for (const [peerId, lastUpdate] of this.lastUpdateTime.entries()) {
       const timePassed = currentTime - lastUpdate;
       const decayPeriods = Math.floor(timePassed / this.decayInterval);
       if (decayPeriods > 0) {
         let score = this.scores.get(peerId) || 0;
         score *= Math.pow(this.decayFactor, decayPeriods);
-        if (Math.abs(score) < SCORE_CLEANUP_THRESHOLD) {
-          this.scores.delete(peerId);
-          this.lastUpdateTime.delete(peerId);
-        } else {
-          this.scores.set(peerId, score);
-          this.lastUpdateTime.set(peerId, currentTime);
-        }
+        this.scores.set(peerId, score);
+        this.lastUpdateTime.set(peerId, currentTime);
       }
     }
   }
 
-  removePeer(peerId: string): void {
-    this.scores.delete(peerId);
-    this.lastUpdateTime.delete(peerId);
-  }
-
   getScore(peerId: string): number {
     return this.scores.get(peerId) || 0;
   }