@aztec/p2p 0.0.0-test.0

package/dest/services/peer-manager/metrics.d.ts

@@ -0,0 +1,12 @@
+import { type TelemetryClient, type Tracer } from '@aztec/telemetry-client';
+import { type GoodByeReason } from '../reqresp/protocols/index.js';
+export declare class PeerManagerMetrics {
+    readonly telemetryClient: TelemetryClient;
+    private sentGoodbyes;
+    private receivedGoodbyes;
+    readonly tracer: Tracer;
+    constructor(telemetryClient: TelemetryClient, name?: string);
+    recordGoodbyeSent(reason: GoodByeReason): void;
+    recordGoodbyeReceived(reason: GoodByeReason): void;
+}
+//# sourceMappingURL=metrics.d.ts.map

package/dest/services/peer-manager/metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["../../../src/services/peer-manager/metrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,MAAM,EAGZ,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,KAAK,aAAa,EAAuB,MAAM,+BAA+B,CAAC;AAExF,qBAAa,kBAAkB;aAMD,eAAe,EAAE,eAAe;IAL5D,OAAO,CAAC,YAAY,CAAgB;IACpC,OAAO,CAAC,gBAAgB,CAAgB;IAExC,SAAgB,MAAM,EAAE,MAAM,CAAC;gBAEH,eAAe,EAAE,eAAe,EAAE,IAAI,SAAgB;IAgB3E,iBAAiB,CAAC,MAAM,EAAE,aAAa;IAIvC,qBAAqB,CAAC,MAAM,EAAE,aAAa;CAGnD"}

package/dest/services/peer-manager/metrics.js

@@ -0,0 +1,33 @@
+import { Attributes, Metrics, ValueType } from '@aztec/telemetry-client';
+import { prettyGoodbyeReason } from '../reqresp/protocols/index.js';
+export class PeerManagerMetrics {
+    telemetryClient;
+    sentGoodbyes;
+    receivedGoodbyes;
+    tracer;
+    constructor(telemetryClient, name = 'PeerManager'){
+        this.telemetryClient = telemetryClient;
+        this.tracer = telemetryClient.getTracer(name);
+        const meter = telemetryClient.getMeter(name);
+        this.sentGoodbyes = meter.createUpDownCounter(Metrics.PEER_MANAGER_GOODBYES_SENT, {
+            description: 'Number of goodbyes sent to peers',
+            unit: 'peers',
+            valueType: ValueType.INT
+        });
+        this.receivedGoodbyes = meter.createUpDownCounter(Metrics.PEER_MANAGER_GOODBYES_RECEIVED, {
+            description: 'Number of goodbyes received from peers',
+            unit: 'peers',
+            valueType: ValueType.INT
+        });
+    }
+    recordGoodbyeSent(reason) {
+        this.sentGoodbyes.add(1, {
+            [Attributes.P2P_GOODBYE_REASON]: prettyGoodbyeReason(reason)
+        });
+    }
+    recordGoodbyeReceived(reason) {
+        this.receivedGoodbyes.add(1, {
+            [Attributes.P2P_GOODBYE_REASON]: prettyGoodbyeReason(reason)
+        });
+    }
+}

package/dest/services/peer-manager/peer_manager.d.ts

@@ -0,0 +1,94 @@
+import type { PeerInfo } from '@aztec/stdlib/interfaces/server';
+import type { PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+import type { PeerId } from '@libp2p/interface';
+import type { P2PConfig } from '../../config.js';
+import type { PubSubLibp2p } from '../../util.js';
+import { GoodByeReason } from '../reqresp/protocols/goodbye.js';
+import type { ReqResp } from '../reqresp/reqresp.js';
+import type { PeerDiscoveryService } from '../service.js';
+import { type PeerScoring } from './peer_scoring.js';
+export declare class PeerManager {
+    private libP2PNode;
+    private peerDiscoveryService;
+    private config;
+    private logger;
+    private peerScoring;
+    private reqresp;
+    private cachedPeers;
+    private heartbeatCounter;
+    private displayPeerCountsPeerHeartbeat;
+    private timedOutPeers;
+    private metrics;
+    private discoveredPeerHandler;
+    constructor(libP2PNode: PubSubLibp2p, peerDiscoveryService: PeerDiscoveryService, config: P2PConfig, telemetryClient: TelemetryClient, logger: import("@aztec/foundation/log").Logger, peerScoring: PeerScoring, reqresp: ReqResp);
+    get tracer(): import("@aztec/telemetry-client").Tracer;
+    heartbeat(): void;
+    /**
+     * 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.
+     */
+    private cleanupExpiredTimeouts;
+    /**
+     * Simply logs the type of connected peer.
+     * @param e - The connected peer event.
+     */
+    private handleConnectedPeerEvent;
+    /**
+     * Simply logs the type of disconnected peer.
+     * @param e - The disconnected peer event.
+     */
+    private handleDisconnectedPeerEvent;
+    /**
+     * Handles a goodbye received from a peer.
+     *
+     * Used as the reqresp handler when a peer sends us goodbye message.
+     * @param peerId - The peer ID.
+     * @param reason - The reason for the goodbye.
+     */
+    goodbyeReceived(peerId: PeerId, reason: GoodByeReason): void;
+    penalizePeer(peerId: PeerId, penalty: PeerErrorSeverity): void;
+    getPeerScore(peerId: string): number;
+    getPeers(includePending?: boolean): PeerInfo[];
+    /**
+     * Discovers peers.
+     */
+    private discover;
+    private pruneUnhealthyPeers;
+    /**
+     * If the max peer count is reached, the lowest scoring peers will be pruned to satisfy the max peer count.
+     *
+     * @param connections - The list of connections to prune low scoring peers above the max peer count from.
+     * @returns The pruned list of connections.
+     */
+    private prioritizePeers;
+    /**
+     * If multiple connections to the same peer are found, the oldest connection is kept and the duplicates are pruned.
+     *
+     * This is necessary to resolve a race condition where multiple connections to the same peer are established if
+     * they are discovered at the same time.
+     *
+     * @param connections - The list of connections to prune duplicate peers from.
+     * @returns The pruned list of connections.
+     */
+    private pruneDuplicatePeers;
+    private goodbyeAndDisconnectPeer;
+    private disconnectPeer;
+    /**
+     *  Handles a discovered peer.
+     * @param enr - The discovered peer's ENR.
+     */
+    private handleDiscoveredPeer;
+    private dialPeer;
+    private shouldDialPeer;
+    private pruneCachedPeers;
+    /**
+     * Stops the peer manager.
+     * Removing all event listeners.
+     */
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=peer_manager.d.ts.map

package/dest/services/peer-manager/peer_manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"peer_manager.d.ts","sourceRoot":"","sources":["../../../src/services/peer-manager/peer_manager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAChE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,KAAK,eAAe,EAAa,MAAM,yBAAyB,CAAC;AAG1E,OAAO,KAAK,EAAc,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAI5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD,OAAO,EAAE,aAAa,EAAuB,MAAM,iCAAiC,CAAC;AACrF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAE1D,OAAO,EAAkB,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAoBrE,qBAAa,WAAW;IAUpB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,oBAAoB;IAC5B,OAAO,CAAC,MAAM;IAEd,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,OAAO;IAfjB,OAAO,CAAC,WAAW,CAAsC;IACzD,OAAO,CAAC,gBAAgB,CAAa;IACrC,OAAO,CAAC,8BAA8B,CAAa;IACnD,OAAO,CAAC,aAAa,CAAwC;IAE7D,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,qBAAqB,CAAC;gBAGpB,UAAU,EAAE,YAAY,EACxB,oBAAoB,EAAE,oBAAoB,EAC1C,MAAM,EAAE,SAAS,EACzB,eAAe,EAAE,eAAe,EACxB,MAAM,wCAAmC,EACzC,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,OAAO;IAmB1B,IAAI,MAAM,6CAET;IAGM,SAAS;IAShB;;;;;;OAMG;IACH,OAAO,CAAC,sBAAsB;IAU9B;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IAShC;;;OAGG;IACH,OAAO,CAAC,2BAA2B;IASnC;;;;;;OAMG;IACI,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa;IAQrD,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB;IAIvD,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAIpC,QAAQ,CAAC,cAAc,UAAQ,GAAG,QAAQ,EAAE;IAiCnD;;OAEG;IACH,OAAO,CAAC,QAAQ;IA6DhB,OAAO,CAAC,mBAAmB;IAoB3B;;;;;OAKG;IACH,OAAO,CAAC,eAAe;IAmBvB;;;;;;;;OAQG;IACH,OAAO,CAAC,mBAAmB;YAuBb,wBAAwB;YAcxB,cAAc;IAQ5B;;;OAGG;YACW,oBAAoB;YA8DpB,QAAQ;IA2BtB,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,gBAAgB;IAiBxB;;;OAGG;IACU,IAAI;CAYlB"}

package/dest/services/peer-manager/peer_manager.js

@@ -0,0 +1,445 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { createLogger } from '@aztec/foundation/log';
+import { trackSpan } from '@aztec/telemetry-client';
+import { inspect } from 'util';
+import { PeerEvent } from '../../types/index.js';
+import { ReqRespSubProtocol } from '../reqresp/interface.js';
+import { GoodByeReason, prettyGoodbyeReason } from '../reqresp/protocols/goodbye.js';
+import { PeerManagerMetrics } from './metrics.js';
+import { PeerScoreState } 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 FAILED_PEER_BAN_TIME_MS = 5 * 60 * 1000; // 5 minutes timeout after failing MAX_DIAL_ATTEMPTS
+export class PeerManager {
+    libP2PNode;
+    peerDiscoveryService;
+    config;
+    logger;
+    peerScoring;
+    reqresp;
+    cachedPeers;
+    heartbeatCounter;
+    displayPeerCountsPeerHeartbeat;
+    timedOutPeers;
+    metrics;
+    discoveredPeerHandler;
+    constructor(libP2PNode, peerDiscoveryService, config, telemetryClient, logger = createLogger('p2p:peer-manager'), peerScoring, reqresp){
+        this.libP2PNode = libP2PNode;
+        this.peerDiscoveryService = peerDiscoveryService;
+        this.config = config;
+        this.logger = logger;
+        this.peerScoring = peerScoring;
+        this.reqresp = reqresp;
+        this.cachedPeers = new Map();
+        this.heartbeatCounter = 0;
+        this.displayPeerCountsPeerHeartbeat = 0;
+        this.timedOutPeers = new Map();
+        this.metrics = new PeerManagerMetrics(telemetryClient, 'PeerManager');
+        // Handle new established connections
+        this.libP2PNode.addEventListener(PeerEvent.CONNECTED, this.handleConnectedPeerEvent.bind(this));
+        // Handle lost connections
+        this.libP2PNode.addEventListener(PeerEvent.DISCONNECTED, this.handleDisconnectedPeerEvent.bind(this));
+        // Handle Discovered peers
+        this.discoveredPeerHandler = (enr)=>this.handleDiscoveredPeer(enr).catch((e)=>this.logger.error('Error handling discovered peer', e));
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        this.peerDiscoveryService.on(PeerEvent.DISCOVERED, this.discoveredPeerHandler);
+        // Display peer counts every 60 seconds
+        this.displayPeerCountsPeerHeartbeat = Math.floor(60_000 / this.config.peerCheckIntervalMS);
+    }
+    get tracer() {
+        return this.metrics.tracer;
+    }
+    heartbeat() {
+        this.heartbeatCounter++;
+        this.peerScoring.decayAllScores();
+        this.cleanupExpiredTimeouts();
+        this.discover();
+    }
+    /**
+   * 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.
+   */ cleanupExpiredTimeouts() {
+        // Clean up expired timeouts
+        const now = Date.now();
+        for (const [peerId, timedOutPeer] of this.timedOutPeers.entries()){
+            if (now >= timedOutPeer.timeoutUntilMs) {
+                this.timedOutPeers.delete(peerId);
+            }
+        }
+    }
+    /**
+   * Simply logs the type of connected peer.
+   * @param e - The connected peer event.
+   */ handleConnectedPeerEvent(e) {
+        const peerId = e.detail;
+        if (this.peerDiscoveryService.isBootstrapPeer(peerId)) {
+            this.logger.verbose(`Connected to bootstrap peer ${peerId.toString()}`);
+        } else {
+            this.logger.verbose(`Connected to transaction peer ${peerId.toString()}`);
+        }
+    }
+    /**
+   * Simply logs the type of disconnected peer.
+   * @param e - The disconnected peer event.
+   */ handleDisconnectedPeerEvent(e) {
+        const peerId = e.detail;
+        if (this.peerDiscoveryService.isBootstrapPeer(peerId)) {
+            this.logger.verbose(`Disconnected from bootstrap peer ${peerId.toString()}`);
+        } else {
+            this.logger.verbose(`Disconnected from transaction peer ${peerId.toString()}`);
+        }
+    }
+    /**
+   * Handles a goodbye received from a peer.
+   *
+   * Used as the reqresp handler when a peer sends us goodbye message.
+   * @param peerId - The peer ID.
+   * @param reason - The reason for the goodbye.
+   */ goodbyeReceived(peerId, reason) {
+        this.logger.debug(`Goodbye received from peer ${peerId.toString()} with reason ${prettyGoodbyeReason(reason)}`);
+        this.metrics.recordGoodbyeReceived(reason);
+        void this.disconnectPeer(peerId);
+    }
+    penalizePeer(peerId, penalty) {
+        this.peerScoring.penalizePeer(peerId, penalty);
+    }
+    getPeerScore(peerId) {
+        return this.peerScoring.getScore(peerId);
+    }
+    getPeers(includePending = false) {
+        const connected = this.libP2PNode.getPeers().map((peer)=>({
+                id: peer.toString(),
+                score: this.getPeerScore(peer.toString()),
+                status: 'connected'
+            }));
+        if (!includePending) {
+            return connected;
+        }
+        const dialQueue = this.libP2PNode.getDialQueue().filter((peer)=>!!peer.peerId).map((peer)=>({
+                id: peer.peerId.toString(),
+                status: 'dialing',
+                dialStatus: peer.status,
+                addresses: peer.multiaddrs.map((m)=>m.toString())
+            }));
+        const cachedPeers = Array.from(this.cachedPeers.values()).filter((peer)=>!dialQueue.some((dialPeer)=>dialPeer.id && peer.peerId.toString() === dialPeer.id.toString())).filter((peer)=>!connected.some((connPeer)=>connPeer.id.toString() === peer.peerId.toString())).map((peer)=>({
+                status: 'cached',
+                id: peer.peerId.toString(),
+                addresses: [
+                    peer.multiaddrTcp.toString()
+                ],
+                dialAttempts: peer.dialAttempts,
+                enr: peer.enr.encodeTxt()
+            }));
+        return [
+            ...connected,
+            ...dialQueue,
+            ...cachedPeers
+        ];
+    }
+    /**
+   * Discovers peers.
+   */ discover() {
+        const connections = this.libP2PNode.getConnections();
+        const healthyConnections = this.prioritizePeers(this.pruneUnhealthyPeers(this.pruneDuplicatePeers(connections)));
+        // Calculate how many connections we're looking to make
+        const peersToConnect = this.config.maxPeerCount - healthyConnections.length;
+        const logLevel = this.heartbeatCounter % this.displayPeerCountsPeerHeartbeat === 0 ? 'info' : 'debug';
+        this.logger[logLevel](`Connected to ${healthyConnections.length} peers`, {
+            connections: healthyConnections.length,
+            maxPeerCount: this.config.maxPeerCount,
+            cachedPeers: this.cachedPeers.size,
+            ...this.peerScoring.getStats()
+        });
+        // Exit if no peers to connect
+        if (peersToConnect <= 0) {
+            return;
+        }
+        const cachedPeersToDial = [];
+        const pendingDials = new Set(this.libP2PNode.getDialQueue().map((pendingDial)=>pendingDial.peerId?.toString()).filter(Boolean));
+        for (const [id, peerData] of this.cachedPeers.entries()){
+            // if already dialling or connected to, remove from cache
+            if (pendingDials.has(id) || healthyConnections.some((conn)=>conn.remotePeer.equals(peerData.peerId)) || // if peer has been in cache for the max cache age, remove from cache
+            Date.now() - peerData.addedUnixMs > MAX_CACHED_PEER_AGE_MS) {
+                this.cachedPeers.delete(id);
+            } else {
+                // cachedPeersToDial.set(id, enr);
+                cachedPeersToDial.push(peerData);
+            }
+        }
+        // reverse to dial older entries first
+        cachedPeersToDial.reverse();
+        for (const peer of cachedPeersToDial){
+            // We remove from the cache before, as dialling will add it back if it fails
+            this.cachedPeers.delete(peer.peerId.toString());
+            void this.dialPeer(peer);
+        }
+        // if we need more peers, start randomNodesQuery
+        if (peersToConnect > 0) {
+            this.logger.trace(`Running random nodes query to connect to ${peersToConnect} peers`);
+            void this.peerDiscoveryService.runRandomNodesQuery();
+        }
+    }
+    pruneUnhealthyPeers(connections) {
+        const connectedHealthyPeers = [];
+        for (const peer of connections){
+            const score = this.peerScoring.getScoreState(peer.remotePeer.toString());
+            switch(score){
+                case PeerScoreState.Banned:
+                    void this.goodbyeAndDisconnectPeer(peer.remotePeer, GoodByeReason.BANNED);
+                    break;
+                case PeerScoreState.Disconnect:
+                    void this.goodbyeAndDisconnectPeer(peer.remotePeer, GoodByeReason.LOW_SCORE);
+                    break;
+                case PeerScoreState.Healthy:
+                    connectedHealthyPeers.push(peer);
+            }
+        }
+        return connectedHealthyPeers;
+    }
+    /**
+   * If the max peer count is reached, the lowest scoring peers will be pruned to satisfy the max peer count.
+   *
+   * @param connections - The list of connections to prune low scoring peers above the max peer count from.
+   * @returns The pruned list of connections.
+   */ prioritizePeers(connections) {
+        if (connections.length > this.config.maxPeerCount) {
+            // Sort the peer scores from lowest to highest
+            const prioritizedConnections = connections.sort((connectionA, connectionB)=>{
+                const connectionScoreA = this.peerScoring.getScore(connectionA.remotePeer.toString());
+                const connectionScoreB = this.peerScoring.getScore(connectionB.remotePeer.toString());
+                return connectionScoreB - connectionScoreA;
+            });
+            // Disconnect from the lowest scoring connections.
+            for (const conn of prioritizedConnections.slice(this.config.maxPeerCount)){
+                void this.goodbyeAndDisconnectPeer(conn.remotePeer, GoodByeReason.MAX_PEERS);
+            }
+            return prioritizedConnections.slice(0, this.config.maxPeerCount);
+        } else {
+            return connections;
+        }
+    }
+    /**
+   * If multiple connections to the same peer are found, the oldest connection is kept and the duplicates are pruned.
+   *
+   * This is necessary to resolve a race condition where multiple connections to the same peer are established if
+   * they are discovered at the same time.
+   *
+   * @param connections - The list of connections to prune duplicate peers from.
+   * @returns The pruned list of connections.
+   */ pruneDuplicatePeers(connections) {
+        const peerConnections = new Map();
+        for (const conn of connections){
+            const peerId = conn.remotePeer.toString();
+            const existingConnection = peerConnections.get(peerId);
+            if (!existingConnection) {
+                peerConnections.set(peerId, conn);
+            } else {
+                // Keep the oldest connection for each peer
+                this.logger.debug(`Found duplicate connection to peer ${peerId}, keeping oldest connection`);
+                if (conn.timeline.open < existingConnection.timeline.open) {
+                    peerConnections.set(peerId, conn);
+                    void existingConnection.close();
+                } else {
+                    void conn.close();
+                }
+            }
+        }
+        return [
+            ...peerConnections.values()
+        ];
+    }
+    async goodbyeAndDisconnectPeer(peer, reason) {
+        this.logger.debug(`Disconnecting peer ${peer.toString()} with reason ${prettyGoodbyeReason(reason)}`);
+        this.metrics.recordGoodbyeSent(reason);
+        try {
+            await this.reqresp.sendRequestToPeer(peer, ReqRespSubProtocol.GOODBYE, Buffer.from([
+                reason
+            ]));
+        } catch (error) {
+            this.logger.debug(`Failed to send goodbye to peer ${peer.toString()}: ${error}`);
+        } finally{
+            await this.disconnectPeer(peer);
+        }
+    }
+    async disconnectPeer(peer) {
+        try {
+            await this.libP2PNode.hangUp(peer);
+        } catch (error) {
+            this.logger.debug(`Failed to disconnect peer ${peer.toString()}`, {
+                error: inspect(error)
+            });
+        }
+    }
+    /**
+   *  Handles a discovered peer.
+   * @param enr - The discovered peer's ENR.
+   */ async handleDiscoveredPeer(enr) {
+        // Check that the peer has not already been banned
+        const peerId = await enr.peerId();
+        const peerIdString = peerId.toString();
+        // Check if peer is temporarily timed out
+        const timedOutPeer = this.timedOutPeers.get(peerIdString);
+        if (timedOutPeer) {
+            if (Date.now() < timedOutPeer.timeoutUntilMs) {
+                this.logger.trace(`Skipping timed out peer ${peerId}`);
+                return;
+            }
+            // Timeout period expired, remove from timed out peers
+            this.timedOutPeers.delete(peerIdString);
+        }
+        if (this.peerScoring.getScoreState(peerIdString) != PeerScoreState.Healthy) {
+            return;
+        }
+        const [multiaddrTcp] = await Promise.all([
+            enr.getFullMultiaddr('tcp')
+        ]);
+        this.logger.trace(`Handling discovered peer ${peerId} at ${multiaddrTcp?.toString() ?? 'undefined address'}`);
+        // stop if no tcp addr in multiaddr
+        if (!multiaddrTcp) {
+            this.logger.debug(`No TCP address in discovered node's multiaddr ${enr.encodeTxt()}`);
+            return;
+        }
+        // check if peer is already connected
+        const connections = this.libP2PNode.getConnections();
+        if (connections.some((conn)=>conn.remotePeer.equals(peerId))) {
+            this.logger.trace(`Already connected to peer ${peerId}`);
+            return;
+        }
+        // check if peer is already in cache
+        if (this.cachedPeers.has(peerIdString)) {
+            this.logger.trace(`Peer already in cache ${peerIdString}`);
+            return;
+        }
+        // create cached peer object
+        const cachedPeer = {
+            peerId,
+            enr,
+            multiaddrTcp,
+            dialAttempts: 0,
+            addedUnixMs: Date.now()
+        };
+        // Determine if we should dial immediately or not
+        if (this.shouldDialPeer()) {
+            void this.dialPeer(cachedPeer);
+        } else {
+            this.logger.trace(`Caching peer ${peerIdString}`);
+            this.cachedPeers.set(peerIdString, cachedPeer);
+            // Prune set of cached peers
+            this.pruneCachedPeers();
+        }
+    }
+    async dialPeer(peer) {
+        const id = peer.peerId.toString();
+        // Add to the address book before dialing
+        await this.libP2PNode.peerStore.merge(peer.peerId, {
+            multiaddrs: [
+                peer.multiaddrTcp
+            ]
+        });
+        this.logger.trace(`Dialing peer ${id}`);
+        try {
+            await this.libP2PNode.dial(peer.multiaddrTcp);
+        } catch (error) {
+            peer.dialAttempts++;
+            if (peer.dialAttempts < MAX_DIAL_ATTEMPTS) {
+                this.logger.trace(`Failed to dial peer ${id} (attempt ${peer.dialAttempts})`, {
+                    error: inspect(error)
+                });
+                this.cachedPeers.set(id, peer);
+            } else {
+                formatLibp2pDialError(error);
+                this.logger.debug(`Failed to dial peer ${id} (dropping)`, {
+                    error: inspect(error)
+                });
+                this.cachedPeers.delete(id);
+                // Add to timed out peers
+                this.timedOutPeers.set(id, {
+                    peerId: id,
+                    timeoutUntilMs: Date.now() + FAILED_PEER_BAN_TIME_MS
+                });
+            }
+        }
+    }
+    shouldDialPeer() {
+        const connections = this.libP2PNode.getConnections().length;
+        if (connections >= this.config.maxPeerCount) {
+            this.logger.trace(`Not dialing peer due to max peer count of ${this.config.maxPeerCount} reached (${connections} current connections)`);
+            return false;
+        }
+        return true;
+    }
+    pruneCachedPeers() {
+        let peersToDelete = this.cachedPeers.size - MAX_CACHED_PEERS;
+        if (peersToDelete <= 0) {
+            return;
+        }
+        // Remove the oldest peers
+        for (const key of this.cachedPeers.keys()){
+            this.cachedPeers.delete(key);
+            this.logger.trace(`Pruning peer ${key} from cache`);
+            peersToDelete--;
+            if (peersToDelete <= 0) {
+                break;
+            }
+        }
+    }
+    /**
+   * Stops the peer manager.
+   * Removing all event listeners.
+   */ async stop() {
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        this.peerDiscoveryService.off(PeerEvent.DISCOVERED, this.discoveredPeerHandler);
+        // Send goodbyes to all peers
+        await Promise.all(this.libP2PNode.getPeers().map((peer)=>this.goodbyeAndDisconnectPeer(peer, GoodByeReason.SHUTDOWN)));
+        this.libP2PNode.removeEventListener(PeerEvent.CONNECTED, this.handleConnectedPeerEvent);
+        this.libP2PNode.removeEventListener(PeerEvent.DISCONNECTED, this.handleDisconnectedPeerEvent);
+    }
+}
+_ts_decorate([
+    trackSpan('PeerManager.heartbeat')
+], PeerManager.prototype, "heartbeat", null);
+/**
+ * copied from github.com/ChainSafe/lodestar
+ * libp2p errors with extremely noisy errors here, which are deeply nested taking 30-50 lines.
+ * Some known errors:
+ * ```
+ * Error: The operation was aborted
+ * Error: stream ended before 1 bytes became available
+ * Error: Error occurred during XX handshake: Error occurred while verifying signed payload: Peer ID doesn't match libp2p public key
+ * ```
+ *
+ * Also the error's message is not properly formatted, where the error message is indented and includes the full stack
+ * ```
+ * {
+ *  emessage: '\n' +
+ *    '    Error: stream ended before 1 bytes became available\n' +
+ *    '        at /home/lion/Code/eth2.0/lodestar/node_modules/it-reader/index.js:37:9\n' +
+ *    '        at runMicrotasks (<anonymous>)\n' +
+ *    '        at decoder (/home/lion/Code/eth2.0/lodestar/node_modules/it-length-prefixed/src/decode.js:113:22)\n' +
+ *    '        at first (/home/lion/Code/eth2.0/lodestar/node_modules/it-first/index.js:11:20)\n' +
+ *    '        at Object.exports.read (/home/lion/Code/eth2.0/lodestar/node_modules/multistream-select/src/multistream.js:31:15)\n' +
+ *    '        at module.exports (/home/lion/Code/eth2.0/lodestar/node_modules/multistream-select/src/select.js:21:19)\n' +
+ *    '        at Upgrader._encryptOutbound (/home/lion/Code/eth2.0/lodestar/node_modules/libp2p/src/upgrader.js:397:36)\n' +
+ *    '        at Upgrader.upgradeOutbound (/home/lion/Code/eth2.0/lodestar/node_modules/libp2p/src/upgrader.js:176:11)\n' +
+ *    '        at ClassIsWrapper.dial (/home/lion/Code/eth2.0/lodestar/node_modules/libp2p-tcp/src/index.js:49:18)'
+ * }
+ * ```
+ *
+ * Tracking issue https://github.com/libp2p/js-libp2p/issues/996
+ */ function formatLibp2pDialError(e) {
+    const errorMessage = e.message.trim();
+    const newlineIndex = errorMessage.indexOf('\n');
+    e.message = newlineIndex !== -1 ? errorMessage.slice(0, newlineIndex) : errorMessage;
+    if (e.message.includes('The operation was aborted') || e.message.includes('stream ended before 1 bytes became available') || e.message.includes('The operation was aborted')) {
+        e.stack = undefined;
+    }
+}

package/dest/services/peer-manager/peer_scoring.d.ts

@@ -0,0 +1,28 @@
+import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import type { PeerId } from '@libp2p/interface';
+import type { P2PConfig } from '../../config.js';
+export declare enum PeerScoreState {
+    Banned = 0,
+    Disconnect = 1,
+    Healthy = 2
+}
+export declare class PeerScoring {
+    private logger;
+    private scores;
+    private lastUpdateTime;
+    private decayInterval;
+    private decayFactor;
+    peerPenalties: {
+        [key in PeerErrorSeverity]: number;
+    };
+    constructor(config: P2PConfig);
+    penalizePeer(peerId: PeerId, penalty: PeerErrorSeverity): number;
+    updateScore(peerId: string, scoreDelta: number): number;
+    decayAllScores(): void;
+    getScore(peerId: string): number;
+    getScoreState(peerId: string): PeerScoreState;
+    getStats(): {
+        medianScore: number;
+    };
+}
+//# sourceMappingURL=peer_scoring.d.ts.map

package/dest/services/peer-manager/peer_scoring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"peer_scoring.d.ts","sourceRoot":"","sources":["../../../src/services/peer-manager/peer_scoring.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAQjD,oBAAY,cAAc;IACxB,MAAM,IAAA;IACN,UAAU,IAAA;IACV,OAAO,IAAA;CACR;AAMD,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAAoC;IAClD,OAAO,CAAC,MAAM,CAAkC;IAChD,OAAO,CAAC,cAAc,CAAkC;IACxD,OAAO,CAAC,aAAa,CAAa;IAClC,OAAO,CAAC,WAAW,CAAO;IAC1B,aAAa,EAAE;SAAG,GAAG,IAAI,iBAAiB,GAAG,MAAM;KAAE,CAAC;gBAE1C,MAAM,EAAE,SAAS;IAYtB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB;IAQ9D,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM;IAmBvD,cAAc,IAAI,IAAI;IActB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAIzB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc;IAYpD,QAAQ,IAAI;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE;CAGpC"}