use PeerData to hold the ping instead of a new variable

Author: danisharora099

packages/core/src/lib/base_protocol.ts

@@ -6,7 +6,6 @@ import type { IBaseProtocol, Libp2pComponents } from "@waku/interfaces";
 import { getPeersForProtocol, selectPeerForProtocol } from "@waku/utils/libp2p";
 
 import { filterPeers } from "./filterPeers.js";
-import { KeepAliveManager } from "./keep_alive_manager.js";
 import { StreamManager } from "./stream_manager.js";
 
 /**
@@ -55,10 +54,8 @@ export class BaseProtocol implements IBaseProtocol {
   }
 
   protected async getPeer(peerId?: PeerId): Promise<Peer> {
-    const { peerPings } = KeepAliveManager.getInstance();
     const { peer } = await selectPeerForProtocol(
       this.peerStore,
-      peerPings,
       [this.multicodec],
       peerId
     );

packages/core/src/lib/connection_manager.ts

@@ -118,6 +118,7 @@ export class ConnectionManager
 
     this.keepAliveManager = KeepAliveManager.createInstance(
       this.libp2p.services.ping,
+      this.libp2p.peerStore,
       keepAliveOptions,
       relay
     );

packages/core/src/lib/keep_alive_manager.ts

@@ -1,6 +1,8 @@
 import type { PeerId } from "@libp2p/interface/peer-id";
+import type { PeerStore } from "@libp2p/interface/peer-store";
 import type { IRelay } from "@waku/interfaces";
 import type { KeepAliveOptions } from "@waku/interfaces";
+import { utf8ToBytes } from "@waku/utils/bytes";
 import debug from "debug";
 import type { PingService } from "libp2p/ping";
 
@@ -17,29 +19,32 @@ export class KeepAliveManager {
   private options: KeepAliveOptions;
   private relay?: IRelay;
   private libp2pPing: PingService;
-  public peerPings: Map<string, number>;
+  private peerStore: PeerStore;
 
   private constructor(
     libp2pPing: PingService,
+    peerStore: PeerStore,
     options: KeepAliveOptions,
     relay?: IRelay
   ) {
     this.pingKeepAliveTimers = new Map();
     this.relayKeepAliveTimers = new Map();
     this.options = options;
     this.relay = relay;
-    this.peerPings = new Map();
     this.libp2pPing = libp2pPing;
+    this.peerStore = peerStore;
   }
 
   public static createInstance(
     libp2pPing: PingService,
+    peerStore: PeerStore,
     options: KeepAliveOptions,
     relay?: IRelay
   ): KeepAliveManager {
     if (!KeepAliveManager.instance) {
       KeepAliveManager.instance = new KeepAliveManager(
         libp2pPing,
+        peerStore,
         options,
         relay
       );
@@ -71,7 +76,13 @@ export class KeepAliveManager {
           .ping(peerId)
           .then((ping) => {
             log(`Ping succeeded (${peerIdStr})`, ping);
-            this.peerPings.set(peerIdStr, ping);
+            this.peerStore
+              .patch(peerId, {
+                metadata: {
+                  ping: utf8ToBytes(ping.toString())
+                }
+              })
+              .catch((e) => log("Failed to update ping", e));
           })
           .catch((e) => {
             log(`Ping failed (${peerIdStr})`, e);

packages/utils/src/libp2p/index.ts

@@ -3,6 +3,8 @@ import type { PeerId } from "@libp2p/interface/peer-id";
 import type { Peer, PeerStore } from "@libp2p/interface/peer-store";
 import debug from "debug";
 
+import { bytesToUtf8 } from "../bytes/index.js";
+
 const log = debug("waku:libp2p-utils");
 
 /**
@@ -23,14 +25,17 @@ export function selectRandomPeer(peers: Peer[]): Peer | undefined {
  * @returns The peer with the lowest latency, or undefined if no peer could be reached
  */
 export async function selectLowestLatencyPeer(
-  peerPings: Map<string, number>,
+  peerStore: PeerStore,
   peers: Peer[]
 ): Promise<Peer | undefined> {
   if (peers.length === 0) return;
 
   const results = await Promise.all(
-    peers.map((peer) => {
-      const ping = peerPings.get(peer.id.toString()) ?? Infinity;
+    peers.map(async (peer) => {
+      const pingBytes = (await peerStore.get(peer.id)).metadata.get("ping");
+      if (!pingBytes) return { peer, ping: Infinity };
+
+      const ping = Number(bytesToUtf8(pingBytes)) ?? Infinity;
       return { peer, ping };
     })
   );
@@ -69,7 +74,6 @@ export async function getPeersForProtocol(
  */
 export async function selectPeerForProtocol(
   peerStore: PeerStore,
-  peerPings: Map<string, number>,
   protocols: string[],
   peerId?: PeerId
 ): Promise<{ peer: Peer; protocol: string }> {
@@ -83,7 +87,7 @@ export async function selectPeerForProtocol(
     }
   } else {
     const peers = await getPeersForProtocol(peerStore, protocols);
-    peer = await selectLowestLatencyPeer(peerPings, peers);
+    peer = await selectLowestLatencyPeer(peerStore, peers);
     if (!peer) {
       peer = selectRandomPeer(peers);
       if (!peer)