replace findPeer and findProvider

For findProvider, return seq[PeerRecord] instead of SignedPeerRecord as PeerRecords are not stored in the Kad DHT. Possibly leaves open the ability to poison the provider records in the DHT

codex/blockexchange/engine/discovery.nim

@@ -112,7 +112,7 @@ proc discoveryTaskLoop(b: DiscoveryEngine) {.async: (raises: []).} =
         continue
 
       if haves.len < b.minPeersPerBlock:
-        let request = b.discovery.find(cid)
+        let request = b.discovery.find(cid) # seq[PeerRecord]
         b.inFlightDiscReqs[cid] = request
         codex_inflight_discovery.set(b.inFlightDiscReqs.len.int64)
 
@@ -121,12 +121,16 @@ proc discoveryTaskLoop(b: DiscoveryEngine) {.async: (raises: []).} =
           codex_inflight_discovery.set(b.inFlightDiscReqs.len.int64)
 
         if (await request.withTimeout(DefaultDiscoveryTimeout)) and
-            peers =? (await request).catch:
-          let dialed = await allFinished(peers.mapIt(b.network.dialPeer(it.data)))
+            providers =? (await request).catch:
+          let dialed = await allFinished(
+            providers.mapIt(
+              b.network.dialPeer(it)
+            )
+          )
 
           for i, f in dialed:
             if f.failed:
-              await b.discovery.removeProvider(peers[i].data.peerId)
+              await b.discovery.removeProvider(providers[i].peerId)
   except CancelledError:
     trace "Discovery task cancelled"
     return

codex/discovery.nim

@@ -62,42 +62,40 @@ proc toNodeId*(host: ca.Address): NodeId =
 proc findPeer*(
     d: Discovery, peerId: PeerId
 ): Future[?PeerRecord] {.async: (raises: [CancelledError]).} =
-  trace "protocol.resolve..."
+  trace "protocol.findPeer..."
   ## Find peer using the given Discovery object
   ##
 
   try:
-    let node = await d.protocol.resolve(toNodeId(peerId))
+    without peerInfo = await d.protocol.findPeer(peerId), error:
+      debug "Could not find peer", peerId = peerId, error = error.msg
+      return PeerRecord.none
+
+    return some peerInfo.toPeerRecord
 
-    return
-      if node.isSome():
-        node.get().record.data.some
-      else:
-        PeerRecord.none
   except CancelledError as exc:
     warn "Error finding peer", peerId = peerId, exc = exc.msg
     raise exc
-  except CatchableError as exc:
-    warn "Error finding peer", peerId = peerId, exc = exc.msg
-
-  return PeerRecord.none
 
 method find*(
     d: Discovery, cid: Cid
-): Future[seq[SignedPeerRecord]] {.async: (raises: [CancelledError]), base.} =
+): Future[seq[PeerRecord]] {.async: (raises: [CancelledError]), base.} =
   ## Find block providers
   ##
 
   try:
-    without providers =? (await d.protocol.getProviders(cid.toNodeId())).mapFailure,
+    without var providers =? (await d.protocol.getProviders(cid.toKey())).mapFailure,
       error:
       warn "Error finding providers for block", cid, error = error.msg
 
-    return providers.filterIt(not (it.data.peerId == d.peerId))
+    providers.excl(d.peerId)
+
+    return providers.mapIt(it.toPeerRecord)
+  
   except CancelledError as exc:
     warn "Error finding providers for block", cid, exc = exc.msg
     raise exc
-  except CatchableError as exc:
+  except LPStreamError, DialFailedError as exc:
     warn "Error finding providers for block", cid, exc = exc.msg
 
 method provide*(d: Discovery, cid: Cid) {.async: (raises: [CancelledError]), base.} =

codex/utils/addrutils.nim

@@ -102,3 +102,15 @@ proc toBootstrapAddrs*(sprs: openArray[SignedPeerRecord]): seq[(PeerId, seq[Mult
     res.add spr.toBootstrapAddr
 
   return res
+
+proc toPeerRecord*(peerInfo: PeerInfo): PeerRecord =
+  ## Convert PeerInfo to PeerRecord
+  ##
+  PeerRecord.init(peerInfo.peerId, peerInfo.addrs)
+
+proc toPeerRecord*(provider: Provider): PeerRecord =
+  ## Convert Provider to PeerRecord
+  ##
+  PeerRecord.init(provider.peerId, provider.addrs)
+
+{.pop.}