@aztec/p2p 0.71.0 → 0.73.0

package/src/services/reqresp/reqresp.ts

@@ -2,6 +2,7 @@
 import { PeerErrorSeverity } from '@aztec/circuit-types';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { executeTimeout } from '@aztec/foundation/timer';
+import { Attributes, type TelemetryClient, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
 import { type IncomingStreamData, type PeerId, type Stream } from '@libp2p/interface';
 import { pipe } from 'it-pipe';
@@ -14,8 +15,10 @@ import {
   InvalidResponseError,
 } from '../../errors/reqresp.error.js';
 import { SnappyTransform } from '../encoding.js';
-import { type PeerManager } from '../peer_manager.js';
+import { type PeerScoring } from '../peer-manager/peer_scoring.js';
 import { type P2PReqRespConfig } from './config.js';
+import { BatchConnectionSampler } from './connection-sampler/batch_connection_sampler.js';
+import { ConnectionSampler } from './connection-sampler/connection_sampler.js';
 import {
   DEFAULT_SUB_PROTOCOL_HANDLERS,
   DEFAULT_SUB_PROTOCOL_VALIDATORS,
@@ -25,7 +28,8 @@ import {
   type SubProtocolMap,
   subProtocolMap,
 } from './interface.js';
-import { RequestResponseRateLimiter } from './rate_limiter/rate_limiter.js';
+import { ReqRespMetrics } from './metrics.js';
+import { RequestResponseRateLimiter } from './rate-limiter/rate_limiter.js';
 
 /**
  * The Request Response Service
@@ -51,18 +55,35 @@ export class ReqResp {
   private subProtocolHandlers: ReqRespSubProtocolHandlers = DEFAULT_SUB_PROTOCOL_HANDLERS;
   private subProtocolValidators: ReqRespSubProtocolValidators = DEFAULT_SUB_PROTOCOL_VALIDATORS;
 
+  private connectionSampler: ConnectionSampler;
   private rateLimiter: RequestResponseRateLimiter;
 
   private snappyTransform: SnappyTransform;
 
-  constructor(config: P2PReqRespConfig, protected readonly libp2p: Libp2p, private peerManager: PeerManager) {
+  private metrics: ReqRespMetrics;
+
+  constructor(
+    config: P2PReqRespConfig,
+    private libp2p: Libp2p,
+    private peerScoring: PeerScoring,
+    telemetryClient: TelemetryClient = getTelemetryClient(),
+  ) {
     this.logger = createLogger('p2p:reqresp');
 
     this.overallRequestTimeoutMs = config.overallRequestTimeoutMs;
     this.individualRequestTimeoutMs = config.individualRequestTimeoutMs;
 
-    this.rateLimiter = new RequestResponseRateLimiter(peerManager);
+    this.rateLimiter = new RequestResponseRateLimiter(peerScoring);
+
+    // Connection sampler is used to sample our connected peers
+    this.connectionSampler = new ConnectionSampler(libp2p);
+
     this.snappyTransform = new SnappyTransform();
+    this.metrics = new ReqRespMetrics(telemetryClient);
+  }
+
+  get tracer() {
+    return this.metrics.tracer;
   }
 
   /**
@@ -74,7 +95,13 @@ export class ReqResp {
 
     // Register all protocol handlers
     for (const subProtocol of Object.keys(this.subProtocolHandlers)) {
-      await this.libp2p.handle(subProtocol, this.streamHandler.bind(this, subProtocol as ReqRespSubProtocol));
+      await this.libp2p.handle(
+        subProtocol,
+        (data: IncomingStreamData) =>
+          void this.streamHandler(subProtocol as ReqRespSubProtocol, data).catch(err =>
+            this.logger.error(`Error on libp2p subprotocol ${subProtocol} handler`, err),
+          ),
+      );
     }
     this.rateLimiter.start();
   }
@@ -83,12 +110,15 @@ export class ReqResp {
    * Stop the reqresp service
    */
   async stop() {
-    // Unregister all handlers
-    for (const protocol of Object.keys(this.subProtocolHandlers)) {
-      await this.libp2p.unhandle(protocol);
-    }
+    // Unregister handlers in parallel
+    const unregisterPromises = Object.keys(this.subProtocolHandlers).map(protocol => this.libp2p.unhandle(protocol));
+    await Promise.all(unregisterPromises);
 
-    // Close all active connections
+    // Close connection sampler
+    await this.connectionSampler.stop();
+    this.logger.debug('ReqResp: Connection sampler stopped');
+
+    // Close streams in parallel
     const closeStreamPromises = this.libp2p.getConnections().map(connection => connection.close());
     await Promise.all(closeStreamPromises);
     this.logger.debug('ReqResp: All active streams closed');
@@ -113,8 +143,8 @@ export class ReqResp {
    * If no response is received from any peer, it returns undefined.
    *
    * The method performs the following steps:
-   * - Iterates over all active peers.
-   * - Opens a stream with each peer using the specified sub-protocol.
+   * - Sample a peer to send the request to.
+   * - Opens a stream with the peer using the specified sub-protocol.
    *
    * When a response is received, it is validated using the given sub protocols response validator.
    * To see the interface for the response validator - see `interface.ts`
@@ -132,15 +162,32 @@ export class ReqResp {
     subProtocol: SubProtocol,
     request: InstanceType<SubProtocolMap[SubProtocol]['request']>,
   ): Promise<InstanceType<SubProtocolMap[SubProtocol]['response']> | undefined> {
+    const responseValidator = this.subProtocolValidators[subProtocol];
+    const requestBuffer = request.toBuffer();
+
     const requestFunction = async () => {
-      const responseValidator = this.subProtocolValidators[subProtocol];
-      const requestBuffer = request.toBuffer();
+      // Attempt to ask all of our peers, but sampled in a random order
+      // This function is wrapped in a timeout, so we will exit the loop if we have not received a response
+      const numberOfPeers = this.libp2p.getPeers().length;
+
+      if (numberOfPeers === 0) {
+        this.logger.debug('No active peers to send requests to');
+        return undefined;
+      }
+
+      const attemptedPeers: Map<string, boolean> = new Map();
+      for (let i = 0; i < numberOfPeers; i++) {
+        // Sample a peer to make a request to
+        const peer = this.connectionSampler.getPeer(attemptedPeers);
+        this.logger.trace(`Attempting to send request to peer: ${peer?.toString()}`);
+        if (!peer) {
+          this.logger.debug('No peers available to send requests to');
+          return undefined;
+        }
 
-      // Get active peers
-      const peers = this.libp2p.getPeers();
+        attemptedPeers.set(peer.toString(), true);
 
-      // Attempt to ask all of our peers
-      for (const peer of peers) {
+        this.logger.trace(`Sending request to peer: ${peer.toString()}`);
         const response = await this.sendRequestToPeer(peer, subProtocol, requestBuffer);
 
         // If we get a response, return it, otherwise we iterate onto the next peer
@@ -155,7 +202,6 @@ export class ReqResp {
           return object;
         }
       }
-      return undefined;
     };
 
     try {
@@ -170,6 +216,152 @@ export class ReqResp {
     }
   }
 
+  /**
+   * Request multiple messages over the same sub protocol, balancing the requests across peers.
+   *
+   * @devnote
+   * - The function prioritizes sending requests to free peers using a batch sampling strategy.
+   * - If a peer fails to respond or returns an invalid response, it is removed from the sampling pool and replaced.
+   * - The function stops retrying once all requests are processed, no active peers remain, or the maximum retry attempts are reached.
+   * - Responses are validated using a custom validator for the sub-protocol.*
+   *
+   * Requests are sent in parallel to each peer, but multiple requests are sent to the same peer in series
+   * - If a peer fails to respond or returns an invalid response, it is removed from the sampling pool and replaced.
+   * - The function stops retrying once all requests are processed, no active peers remain, or the maximum retry attempts are reached.
+   * - Responses are validated using a custom validator for the sub-protocol.*
+   *
+   * @param subProtocol
+   * @param requests
+   * @param timeoutMs
+   * @param maxPeers
+   * @returns
+   *
+   * @throws {CollectiveReqRespTimeoutError} - If the request batch exceeds the specified timeout (`timeoutMs`).
+   */
+  @trackSpan(
+    'ReqResp.sendBatchRequest',
+    (subProtocol: ReqRespSubProtocol, requests: InstanceType<SubProtocolMap[ReqRespSubProtocol]['request']>[]) => ({
+      [Attributes.P2P_REQ_RESP_PROTOCOL]: subProtocol,
+      [Attributes.P2P_REQ_RESP_BATCH_REQUESTS_COUNT]: requests.length,
+    }),
+  )
+  async sendBatchRequest<SubProtocol extends ReqRespSubProtocol>(
+    subProtocol: SubProtocol,
+    requests: InstanceType<SubProtocolMap[SubProtocol]['request']>[],
+    timeoutMs = 10000,
+    maxPeers = Math.min(10, requests.length),
+    maxRetryAttempts = 3,
+  ): Promise<InstanceType<SubProtocolMap[SubProtocol]['response']>[]> {
+    const responseValidator = this.subProtocolValidators[subProtocol];
+    const responses: InstanceType<SubProtocolMap[SubProtocol]['response']>[] = new Array(requests.length);
+    const requestBuffers = requests.map(req => req.toBuffer());
+
+    const requestFunction = async () => {
+      // Track which requests still need to be processed
+      const pendingRequestIndices = new Set(requestBuffers.map((_, i) => i));
+
+      // Create batch sampler with the total number of requests and max peers
+      const batchSampler = new BatchConnectionSampler(this.connectionSampler, requests.length, maxPeers);
+
+      if (batchSampler.activePeerCount === 0) {
+        this.logger.debug('No active peers to send requests to');
+        return [];
+      }
+
+      // This is where it gets fun
+      // The outer loop is the retry loop, we will continue to retry until we process all indices we have
+      // not received a response for, or we have reached the max retry attempts
+
+      // The inner loop is the batch loop, we will process all requests for each peer in parallel
+      // We will then process the results of the requests, and resample any peers that failed to respond
+      // We will continue to retry until we have processed all indices, or we have reached the max retry attempts
+
+      let retryAttempts = 0;
+      while (pendingRequestIndices.size > 0 && batchSampler.activePeerCount > 0 && retryAttempts < maxRetryAttempts) {
+        // Process requests in parallel for each available peer
+        const requestBatches = new Map<PeerId, number[]>();
+
+        // Group requests by peer
+        for (const requestIndex of pendingRequestIndices) {
+          const peer = batchSampler.getPeerForRequest(requestIndex);
+          if (!peer) {
+            break;
+          }
+
+          if (!requestBatches.has(peer)) {
+            requestBatches.set(peer, []);
+          }
+          requestBatches.get(peer)!.push(requestIndex);
+        }
+
+        // Make parallel requests for each peer's batch
+        // A batch entry will look something like this:
+        // PeerId0: [0, 1, 2, 3]
+        // PeerId1: [4, 5, 6, 7]
+
+        // Peer Id 0 will send requests 0, 1, 2, 3 in serial
+        // while simultaneously Peer Id 1 will send requests 4, 5, 6, 7 in serial
+
+        const batchResults = await Promise.all(
+          Array.from(requestBatches.entries()).map(async ([peer, indices]) => {
+            try {
+              // Requests all going to the same peer are sent synchronously
+              const peerResults: { index: number; response: InstanceType<SubProtocolMap[SubProtocol]['response']> }[] =
+                [];
+              for (const index of indices) {
+                const response = await this.sendRequestToPeer(peer, subProtocol, requestBuffers[index]);
+
+                if (response && response.length > 0) {
+                  const object = subProtocolMap[subProtocol].response.fromBuffer(response);
+                  const isValid = await responseValidator(requests[index], object, peer);
+
+                  if (isValid) {
+                    peerResults.push({ index, response: object });
+                  }
+                }
+              }
+
+              return { peer, results: peerResults };
+            } catch (error) {
+              this.logger.debug(`Failed batch request to peer ${peer.toString()}:`, error);
+              batchSampler.removePeerAndReplace(peer);
+              return { peer, results: [] };
+            }
+          }),
+        );
+
+        // Process results
+        for (const { results } of batchResults) {
+          for (const { index, response } of results) {
+            if (response) {
+              responses[index] = response;
+              pendingRequestIndices.delete(index);
+            }
+          }
+        }
+
+        retryAttempts++;
+      }
+
+      if (retryAttempts >= maxRetryAttempts) {
+        this.logger.debug(`Max retry attempts ${maxRetryAttempts} reached for batch request`);
+      }
+
+      return responses;
+    };
+
+    try {
+      return await executeTimeout<InstanceType<SubProtocolMap[SubProtocol]['response']>[]>(
+        requestFunction,
+        timeoutMs,
+        () => new CollectiveReqRespTimeoutError(),
+      );
+    } catch (e: any) {
+      this.logger.debug(`${e.message} | subProtocol: ${subProtocol}`);
+      return [];
+    }
+  }
+
   /**
    * Sends a request to a specific peer
    *
@@ -194,15 +386,20 @@ export class ReqResp {
    * If the stream is not closed by the dialled peer, and a timeout occurs, then
    * the stream is closed on the requester's end and sender (us) updates its peer score
    */
-  async sendRequestToPeer(
+  @trackSpan('ReqResp.sendRequestToPeer', (peerId: PeerId, subProtocol: ReqRespSubProtocol, _: Buffer) => ({
+    [Attributes.P2P_ID]: peerId.toString(),
+    [Attributes.P2P_REQ_RESP_PROTOCOL]: subProtocol,
+  }))
+  public async sendRequestToPeer(
     peerId: PeerId,
     subProtocol: ReqRespSubProtocol,
     payload: Buffer,
   ): Promise<Buffer | undefined> {
     let stream: Stream | undefined;
     try {
-      stream = await this.libp2p.dialProtocol(peerId, subProtocol);
-      this.logger.trace(`Stream opened with ${peerId.toString()} for ${subProtocol}`);
+      this.metrics.recordRequestSent(subProtocol);
+
+      stream = await this.connectionSampler.dialProtocol(peerId, subProtocol);
 
       // Open the stream with a timeout
       const result = await executeTimeout<Buffer>(
@@ -213,12 +410,13 @@ export class ReqResp {
 
       return result;
     } catch (e: any) {
+      this.metrics.recordRequestError(subProtocol);
       this.handleResponseError(e, peerId, subProtocol);
     } finally {
+      // Only close the stream if we created it
       if (stream) {
         try {
-          await stream.close();
-          this.logger.trace(`Stream closed with ${peerId.toString()} for ${subProtocol}`);
+          await this.connectionSampler.close(stream.id);
         } catch (closeError) {
           this.logger.error(
             `Error closing stream: ${closeError instanceof Error ? closeError.message : 'Unknown error'}`,
@@ -241,7 +439,7 @@ export class ReqResp {
   private handleResponseError(e: any, peerId: PeerId, subProtocol: ReqRespSubProtocol): void {
     const severity = this.categorizeError(e, peerId, subProtocol);
     if (severity) {
-      this.peerManager.penalizePeer(peerId, severity);
+      this.peerScoring.penalizePeer(peerId, severity);
     }
   }
 
@@ -320,7 +518,13 @@ export class ReqResp {
    * We check rate limits for each peer, note the peer will be penalised within the rate limiter implementation
    * if they exceed their peer specific limits.
    */
+  @trackSpan('ReqResp.streamHandler', (protocol: ReqRespSubProtocol, { connection }: IncomingStreamData) => ({
+    [Attributes.P2P_REQ_RESP_PROTOCOL]: protocol,
+    [Attributes.P2P_ID]: connection.remotePeer.toString(),
+  }))
   private async streamHandler(protocol: ReqRespSubProtocol, { stream, connection }: IncomingStreamData) {
+    this.metrics.recordRequestReceived(protocol);
+
     // Store a reference to from this for the async generator
     if (!this.rateLimiter.allow(protocol, connection.remotePeer)) {
       this.logger.warn(`Rate limit exceeded for ${protocol} from ${connection.remotePeer}`);
@@ -339,7 +543,7 @@ export class ReqResp {
         async function* (source: any) {
           for await (const chunkList of source) {
             const msg = Buffer.from(chunkList.subarray());
-            const response = await handler(msg);
+            const response = await handler(connection.remotePeer, msg);
             yield new Uint8Array(transform.outboundTransformNoTopic(response));
           }
         },
@@ -347,6 +551,7 @@ export class ReqResp {
       );
     } catch (e: any) {
       this.logger.warn(e);
+      this.metrics.recordResponseError(protocol);
     } finally {
       await stream.close();
     }

package/src/services/service.ts

@@ -45,6 +45,18 @@ export interface P2PService {
     request: InstanceType<SubProtocolMap[Protocol]['request']>,
   ): Promise<InstanceType<SubProtocolMap[Protocol]['response']> | undefined>;
 
+  /**
+   * Send a batch of requests to peers, and return the responses
+   *
+   * @param protocol - The request response protocol to use
+   * @param requests - The requests to send to the peers
+   * @returns The responses to the requests
+   */
+  sendBatchRequest<Protocol extends ReqRespSubProtocol>(
+    protocol: Protocol,
+    requests: InstanceType<SubProtocolMap[Protocol]['request']>[],
+  ): Promise<InstanceType<SubProtocolMap[Protocol]['response']>[] | undefined>;
+
   // Leaky abstraction: fix https://github.com/AztecProtocol/aztec-packages/issues/7963
   registerBlockReceivedCallback(callback: (block: BlockProposal) => Promise<BlockAttestation | undefined>): void;
 

package/src/util.ts

@@ -1,9 +1,10 @@
-import { type AztecKVStore, type AztecSingleton } from '@aztec/kv-store';
+import { type AztecAsyncKVStore } from '@aztec/kv-store';
 import { type DataStoreConfig } from '@aztec/kv-store/config';
 
 import type { GossipSub } from '@chainsafe/libp2p-gossipsub';
 import { generateKeyPair, marshalPrivateKey, unmarshalPrivateKey } from '@libp2p/crypto/keys';
 import { type PeerId, type PrivateKey } from '@libp2p/interface';
+import { type ConnectionManager } from '@libp2p/interface-internal';
 import { createFromPrivKey } from '@libp2p/peer-id-factory';
 import { resolve } from 'dns/promises';
 import type { Libp2p } from 'libp2p';
@@ -13,6 +14,9 @@ import { type P2PConfig } from './config.js';
 export interface PubSubLibp2p extends Libp2p {
   services: {
     pubsub: GossipSub;
+    components: {
+      connectionManager: ConnectionManager;
+    };
   };
 }
 
@@ -153,14 +157,17 @@ export async function configureP2PClientAddresses(
  * 3. If not, create a new one, then persist it in the node
  *
  */
-export async function getPeerIdPrivateKey(config: { peerIdPrivateKey?: string }, store: AztecKVStore): Promise<string> {
-  const peerIdPrivateKeySingleton: AztecSingleton<string> = store.openSingleton('peerIdPrivateKey');
+export async function getPeerIdPrivateKey(
+  config: { peerIdPrivateKey?: string },
+  store: AztecAsyncKVStore,
+): Promise<string> {
+  const peerIdPrivateKeySingleton = store.openSingleton<string>('peerIdPrivateKey');
   if (config.peerIdPrivateKey) {
     await peerIdPrivateKeySingleton.set(config.peerIdPrivateKey);
     return config.peerIdPrivateKey;
   }
 
-  const storedPeerIdPrivateKey = peerIdPrivateKeySingleton.get();
+  const storedPeerIdPrivateKey = await peerIdPrivateKeySingleton.getAsync();
   if (storedPeerIdPrivateKey) {
     return storedPeerIdPrivateKey;
   }

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

@@ -1 +0,0 @@
-{"version":3,"file":"peer_scoring.d.ts","sourceRoot":"","sources":["../../../src/services/peer-scoring/peer_scoring.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAGzD,OAAO,EAAE,KAAK,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,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;IAY7B,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM;IAmBvD,cAAc,IAAI,IAAI;IActB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAIhC,aAAa,CAAC,MAAM,EAAE,MAAM;IAW5B,QAAQ,IAAI;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE;CAGpC"}

package/dest/services/peer-scoring/peer_scoring.js

@@ -1,75 +0,0 @@
-import { PeerErrorSeverity } from '@aztec/circuit-types';
-import { median } from '@aztec/foundation/collection';
-const DefaultPeerPenalties = {
-    [PeerErrorSeverity.LowToleranceError]: 50,
-    [PeerErrorSeverity.MidToleranceError]: 10,
-    [PeerErrorSeverity.HighToleranceError]: 2,
-};
-export var PeerScoreState;
-(function (PeerScoreState) {
-    PeerScoreState[PeerScoreState["Banned"] = 0] = "Banned";
-    PeerScoreState[PeerScoreState["Disconnect"] = 1] = "Disconnect";
-    PeerScoreState[PeerScoreState["Healthy"] = 2] = "Healthy";
-})(PeerScoreState || (PeerScoreState = {}));
-// TODO: move into config / constants
-const MIN_SCORE_BEFORE_BAN = -100;
-const MIN_SCORE_BEFORE_DISCONNECT = -50;
-export class PeerScoring {
-    constructor(config) {
-        this.scores = new Map();
-        this.lastUpdateTime = new Map();
-        this.decayInterval = 1000 * 60; // 1 minute
-        this.decayFactor = 0.9;
-        const orderedValues = config.peerPenaltyValues?.sort((a, b) => a - b);
-        this.peerPenalties = {
-            [PeerErrorSeverity.HighToleranceError]: orderedValues?.[0] ?? DefaultPeerPenalties[PeerErrorSeverity.HighToleranceError],
-            [PeerErrorSeverity.MidToleranceError]: orderedValues?.[1] ?? DefaultPeerPenalties[PeerErrorSeverity.MidToleranceError],
-            [PeerErrorSeverity.LowToleranceError]: orderedValues?.[2] ?? DefaultPeerPenalties[PeerErrorSeverity.LowToleranceError],
-        };
-    }
-    updateScore(peerId, scoreDelta) {
-        const currentTime = Date.now();
-        const lastUpdate = this.lastUpdateTime.get(peerId) || currentTime;
-        const timePassed = currentTime - lastUpdate;
-        const decayPeriods = Math.floor(timePassed / this.decayInterval);
-        let currentScore = this.scores.get(peerId) || 0;
-        // Apply decay
-        currentScore *= Math.pow(this.decayFactor, decayPeriods);
-        // Apply new score delta
-        currentScore += scoreDelta;
-        this.scores.set(peerId, currentScore);
-        this.lastUpdateTime.set(peerId, currentTime);
-        return currentScore;
-    }
-    decayAllScores() {
-        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);
-                this.scores.set(peerId, score);
-                this.lastUpdateTime.set(peerId, currentTime);
-            }
-        }
-    }
-    getScore(peerId) {
-        return this.scores.get(peerId) || 0;
-    }
-    getScoreState(peerId) {
-        // TODO: permanently store banned peers???
-        const score = this.getScore(peerId);
-        if (score < MIN_SCORE_BEFORE_BAN) {
-            return PeerScoreState.Banned;
-        }
-        else if (score < MIN_SCORE_BEFORE_DISCONNECT) {
-            return PeerScoreState.Disconnect;
-        }
-        return PeerScoreState.Healthy;
-    }
-    getStats() {
-        return { medianScore: median(Array.from(this.scores.values())) ?? 0 };
-    }
-}
-//# sourceMappingURL=data:application/json;base64,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

package/dest/services/peer_manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"peer_manager.d.ts","sourceRoot":"","sources":["../../src/services/peer_manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAAE,KAAK,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAE7E,OAAO,EAAE,KAAK,eAAe,EAAE,UAAU,EAAa,MAAM,yBAAyB,CAAC;AAGtF,OAAO,EAAmB,KAAK,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAIjE,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAqBzD,qBAAa,WAAY,SAAQ,UAAU;IAQvC,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,oBAAoB;IAC5B,OAAO,CAAC,MAAM;IAEd,OAAO,CAAC,MAAM;IAXhB,OAAO,CAAC,WAAW,CAAsC;IACzD,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,gBAAgB,CAAa;IACrC,OAAO,CAAC,8BAA8B,CAAa;IACnD,OAAO,CAAC,aAAa,CAAwC;gBAGnD,UAAU,EAAE,YAAY,EACxB,oBAAoB,EAAE,oBAAoB,EAC1C,MAAM,EAAE,SAAS,EACzB,eAAe,EAAE,eAAe,EACxB,MAAM,yCAAmC;IAkB5C,SAAS;IAShB;;;;;;OAMG;IACH,OAAO,CAAC,sBAAsB;IAU9B;;;OAGG;IACH,OAAO,CAAC,wBAAwB;IAShC;;;OAGG;IACH,OAAO,CAAC,2BAA2B;IAS5B,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB;IAOvD,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;YAoBb,cAAc;IAK5B;;;OAGG;YACW,oBAAoB;YA8DpB,QAAQ;IA2BtB,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,gBAAgB;IAiBxB;;;OAGG;IACI,IAAI;CAKZ"}