libp2p 0.37.2 → 0.37.3-2836acc

package/src/connection-manager/dialer/dial-request.ts

@@ -5,7 +5,7 @@ import { setMaxListeners } from 'events'
 import { codes } from '../../errors.js'
 import { logger } from '@libp2p/logger'
 import type { Multiaddr } from '@multiformats/multiaddr'
-import type { Connection } from '@libp2p/interfaces/connection'
+import type { Connection } from '@libp2p/interface-connection'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { Dialer } from './index.js'
 

package/src/connection-manager/dialer/index.ts

@@ -18,16 +18,16 @@ import {
   MAX_PER_PEER_DIALS,
   MAX_ADDRS_TO_DIAL
 } from '../../constants.js'
-import type { Connection } from '@libp2p/interfaces/connection'
+import type { Connection } from '@libp2p/interface-connection'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { Startable } from '@libp2p/interfaces/startable'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import { getPeer } from '../../get-peer.js'
 import sort from 'it-sort'
-import { Components, Initializable } from '@libp2p/interfaces/components'
+import { Components, Initializable } from '@libp2p/components'
 import map from 'it-map'
-import type { AddressSorter } from '@libp2p/interfaces/peer-store'
-import type { ComponentMetricsTracker } from '@libp2p/interfaces/metrics'
+import type { AddressSorter } from '@libp2p/interface-peer-store'
+import type { ComponentMetricsTracker } from '@libp2p/interface-metrics'
 
 const log = logger('libp2p:dialer')
 

package/src/connection-manager/index.ts

@@ -9,15 +9,18 @@ import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
 import type { Startable } from '@libp2p/interfaces/startable'
 import { trackedMap } from '@libp2p/tracked-map'
 import { codes } from '../errors.js'
-import { isPeerId, PeerId } from '@libp2p/interfaces/peer-id'
+import { isPeerId, PeerId } from '@libp2p/interface-peer-id'
 import { setMaxListeners } from 'events'
-import type { Connection } from '@libp2p/interfaces/connection'
-import type { ConnectionManager } from '@libp2p/interfaces/connection-manager'
-import { Components, Initializable } from '@libp2p/interfaces/components'
-import * as STATUS from '@libp2p/interfaces/connection/status'
+import type { Connection } from '@libp2p/interface-connection'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
+import { Components, Initializable } from '@libp2p/components'
+import * as STATUS from '@libp2p/interface-connection/status'
 import { Dialer } from './dialer/index.js'
-import type { AddressSorter } from '@libp2p/interfaces/peer-store'
+import type { AddressSorter } from '@libp2p/interface-peer-store'
 import type { Resolver } from '@multiformats/multiaddr'
+import { PeerMap } from '@libp2p/peer-collections'
+import { TimeoutController } from 'timeout-abort-controller'
+import { KEEP_ALIVE } from '@libp2p/interface-peer-store/tags'
 
 const log = logger('libp2p:connection-manager')
 
@@ -30,13 +33,12 @@ const defaultOptions: Partial<ConnectionManagerInit> = {
   maxEventLoopDelay: Infinity,
   pollInterval: 2000,
   autoDialInterval: 10000,
-  movingAverageInterval: 60000,
-  defaultPeerValue: 1
+  movingAverageInterval: 60000
 }
 
 const METRICS_COMPONENT = 'connection-manager'
 const METRICS_PEER_CONNECTIONS = 'peer-connections'
-const METRICS_PEER_VALUES = 'peer-values'
+const STARTUP_RECONNECT_TIMEOUT = 60000
 
 export interface ConnectionManagerInit {
   /**
@@ -79,11 +81,6 @@ export interface ConnectionManagerInit {
    */
   movingAverageInterval?: number
 
-  /**
-   * The value of the peer
-   */
-  defaultPeerValue?: number
-
   /**
    * If true, try to connect to all discovered peers up to the connection manager limit
    */
@@ -124,6 +121,12 @@ export interface ConnectionManagerInit {
    * Multiaddr resolvers to use when dialing
    */
   resolvers?: Record<string, Resolver>
+
+  /**
+   * On startup we try to dial any peer that has previously been
+   * tagged with KEEP_ALIVE up to this timeout in ms. (default: 60000)
+   */
+  startupReconnectTimeout?: number
 }
 
 export interface ConnectionManagerEvents {
@@ -138,11 +141,12 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
   public readonly dialer: Dialer
   private components = new Components()
   private readonly opts: Required<ConnectionManagerInit>
-  private readonly peerValues: Map<string, number>
   private readonly connections: Map<string, Connection[]>
   private started: boolean
   private timer?: ReturnType<retimer>
   private readonly latencyMonitor: LatencyMonitor
+  private readonly startupReconnectTimeout: number
+  private connectOnStartupController?: TimeoutController
 
   constructor (init: ConnectionManagerInit) {
     super()
@@ -155,17 +159,6 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
 
     log('options: %o', this.opts)
 
-    /**
-     * Map of peer identifiers to their peer value for pruning connections.
-     *
-     * @type {Map<string, number>}
-     */
-    this.peerValues = trackedMap({
-      component: METRICS_COMPONENT,
-      metric: METRICS_PEER_VALUES,
-      metrics: this.components.getMetrics()
-    })
-
     /**
      * Map of connections per peer
      */
@@ -192,6 +185,8 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
 
     this.onConnect = this.onConnect.bind(this)
     this.onDisconnect = this.onDisconnect.bind(this)
+
+    this.startupReconnectTimeout = init.startupReconnectTimeout ?? STARTUP_RECONNECT_TIMEOUT
   }
 
   init (components: Components): void {
@@ -226,9 +221,43 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
   async afterStart () {
     this.components.getUpgrader().addEventListener('connection', this.onConnect)
     this.components.getUpgrader().addEventListener('connectionEnd', this.onDisconnect)
+
+    // re-connect to any peers with the KEEP_ALIVE tag
+    void Promise.resolve()
+      .then(async () => {
+        const keepAlivePeers: PeerId[] = []
+
+        for (const peer of await this.components.getPeerStore().all()) {
+          const tags = await this.components.getPeerStore().getTags(peer.id)
+          const hasKeepAlive = tags.filter(tag => tag.name === KEEP_ALIVE).length > 0
+
+          if (hasKeepAlive) {
+            keepAlivePeers.push(peer.id)
+          }
+        }
+
+        this.connectOnStartupController?.clear()
+        this.connectOnStartupController = new TimeoutController(this.startupReconnectTimeout)
+
+        await Promise.all(
+          keepAlivePeers.map(async peer => {
+            await this.openConnection(peer, {
+              signal: this.connectOnStartupController?.signal
+            })
+              .catch(err => {
+                log.error(err)
+              })
+          })
+        )
+      })
+      .finally(() => {
+        this.connectOnStartupController?.clear()
+      })
   }
 
   async beforeStop () {
+    // if we are still dialing KEEP_ALIVE peers, abort those dials
+    this.connectOnStartupController?.abort()
     this.components.getUpgrader().removeEventListener('connection', this.onConnect)
     this.components.getUpgrader().removeEventListener('connectionEnd', this.onDisconnect)
   }
@@ -271,18 +300,6 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     this.connections.clear()
   }
 
-  /**
-   * Sets the value of the given peer. Peers with lower values
-   * will be disconnected first.
-   */
-  setPeerValue (peerId: PeerId, value: number) {
-    if (value < 0 || value > 1) {
-      throw new Error('value should be a number between 0 and 1')
-    }
-
-    this.peerValues.set(peerId.toString(), value)
-  }
-
   /**
    * Checks the libp2p metrics to determine if any values have exceeded
    * the configured maximums.
@@ -340,11 +357,10 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
       await this.components.getPeerStore().keyBook.set(peerId, peerId.publicKey)
     }
 
-    if (!this.peerValues.has(peerIdStr)) {
-      this.peerValues.set(peerIdStr, this.opts.defaultPeerValue)
-    }
+    const numConnections = this.getConnections().length
+    const toPrune = numConnections - this.opts.maxConnections
 
-    await this._checkMaxLimit('maxConnections', this.getConnections().length)
+    await this._checkMaxLimit('maxConnections', numConnections, toPrune)
     this.dispatchEvent(new CustomEvent<Connection>('peer:connect', { detail: connection }))
   }
 
@@ -367,7 +383,6 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
       this.connections.set(peerId, storedConn)
     } else if (storedConn != null) {
       this.connections.delete(peerId)
-      this.peerValues.delete(connection.remotePeer.toString())
       this.dispatchEvent(new CustomEvent<Connection>('peer:disconnect', { detail: connection }))
 
       this.components.getMetrics()?.onPeerDisconnected(connection.remotePeer)
@@ -459,7 +474,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
   _onLatencyMeasure (evt: CustomEvent<SummaryObject>) {
     const { detail: summary } = evt
 
-    this._checkMaxLimit('maxEventLoopDelay', summary.avgMs)
+    this._checkMaxLimit('maxEventLoopDelay', summary.avgMs, 1)
       .catch(err => {
         log.error(err)
       })
@@ -468,46 +483,86 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
   /**
    * If the `value` of `name` has exceeded its limit, maybe close a connection
    */
-  async _checkMaxLimit (name: keyof ConnectionManagerInit, value: number) {
+  async _checkMaxLimit (name: keyof ConnectionManagerInit, value: number, toPrune: number = 1) {
     const limit = this.opts[name]
     log.trace('checking limit of %s. current value: %d of %d', name, value, limit)
     if (value > limit) {
-      log('%s: limit exceeded: %p, %d', this.components.getPeerId(), name, value)
-      await this._maybeDisconnectOne()
+      log('%s: limit exceeded: %p, %d/%d, pruning %d connection(s)', this.components.getPeerId(), name, value, limit, toPrune)
+      await this._maybePruneConnections(toPrune)
     }
   }
 
   /**
-   * If we have more connections than our maximum, close a connection
-   * to the lowest valued peer.
+   * If we have more connections than our maximum, select some excess connections
+   * to prune based on peer value
    */
-  async _maybeDisconnectOne () {
-    if (this.opts.minConnections < this.connections.size) {
-      const peerValues = Array.from(new Map([...this.peerValues.entries()].sort((a, b) => a[1] - b[1])))
+  async _maybePruneConnections (toPrune: number) {
+    const connections = this.getConnections()
 
-      log('%p: sorted peer values: %j', this.components.getPeerId(), peerValues)
-      const disconnectPeer = peerValues[0]
+    if (connections.length <= this.opts.minConnections || toPrune < 1) {
+      return
+    }
 
-      if (disconnectPeer != null) {
-        const peerId = disconnectPeer[0]
-        log('%p: lowest value peer is %s', this.components.getPeerId(), peerId)
-        log('%p: closing a connection to %j', this.components.getPeerId(), peerId)
+    const peerValues = new PeerMap<number>()
 
-        for (const connections of this.connections.values()) {
-          if (connections[0].remotePeer.toString() === peerId) {
-            void connections[0].close()
-              .catch(err => {
-                log.error(err)
-              })
+    // work out peer values
+    for (const connection of connections) {
+      const remotePeer = connection.remotePeer
 
-            // TODO: should not need to invoke this manually
-            this.onDisconnect(new CustomEvent<Connection>('connectionEnd', {
-              detail: connections[0]
-            }))
-            break
-          }
-        }
+      if (peerValues.has(remotePeer)) {
+        continue
       }
+
+      const tags = await this.components.getPeerStore().getTags(remotePeer)
+
+      // sum all tag values
+      peerValues.set(remotePeer, tags.reduce((acc, curr) => {
+        return acc + curr.value
+      }, 0))
     }
+
+    // sort by value, lowest to highest
+    const sortedConnections = connections.sort((a, b) => {
+      const peerAValue = peerValues.get(a.remotePeer) ?? 0
+      const peerBValue = peerValues.get(b.remotePeer) ?? 0
+
+      if (peerAValue > peerBValue) {
+        return 1
+      }
+
+      if (peerAValue < peerBValue) {
+        return -1
+      }
+
+      return 0
+    })
+
+    // close some connections
+    const toClose = []
+
+    for (const connection of sortedConnections) {
+      log('too many connections open - closing a connection to %p', connection.remotePeer)
+      toClose.push(connection)
+
+      if (toClose.length === toPrune) {
+        break
+      }
+    }
+
+    // close connections
+    await Promise.all(
+      toClose.map(async connection => {
+        try {
+          await connection.close()
+        } catch (err) {
+          log.error(err)
+        }
+
+        // TODO: should not need to invoke this manually
+        this.onDisconnect(new CustomEvent<Connection>('connectionEnd', {
+          detail: connection
+        }))
+      })
+    )
   }
 }

package/src/content-routing/index.ts

@@ -8,11 +8,11 @@ import {
 import drain from 'it-drain'
 import merge from 'it-merge'
 import { pipe } from 'it-pipe'
-import type { ContentRouting } from '@libp2p/interfaces/content-routing'
+import type { ContentRouting } from '@libp2p/interface-content-routing'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { Startable } from '@libp2p/interfaces/startable'
 import type { CID } from 'multiformats/cid'
-import type { Components } from '@libp2p/interfaces/components'
+import type { Components } from '@libp2p/components'
 
 export interface CompoundContentRoutingInit {
   routers: ContentRouting[]

package/src/content-routing/utils.ts

@@ -2,8 +2,8 @@ import errCode from 'err-code'
 import filter from 'it-filter'
 import map from 'it-map'
 import type { Source } from 'it-stream-types'
-import type { PeerInfo } from '@libp2p/interfaces/peer-info'
-import type { PeerStore } from '@libp2p/interfaces/peer-store'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
+import type { PeerStore } from '@libp2p/interface-peer-store'
 
 /**
  * Store the multiaddrs from every peer in the passed peer store

package/src/dht/dht-content-routing.ts

@@ -1,7 +1,7 @@
 import drain from 'it-drain'
 import errCode from 'err-code'
-import type { DHT } from '@libp2p/interfaces/dht'
-import type { ContentRouting } from '@libp2p/interfaces/content-routing'
+import type { DHT } from '@libp2p/interface-dht'
+import type { ContentRouting } from '@libp2p/interface-content-routing'
 import type { CID } from 'multiformats/cid'
 import type { AbortOptions } from '@libp2p/interfaces'
 

package/src/dht/dht-peer-routing.ts

@@ -1,8 +1,8 @@
 import errCode from 'err-code'
 import { messages, codes } from '../errors.js'
-import type { PeerRouting } from '@libp2p/interfaces/peer-routing'
-import type { DHT } from '@libp2p/interfaces/dht'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerRouting } from '@libp2p/interface-peer-routing'
+import type { DHT } from '@libp2p/interface-dht'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import type { AbortOptions } from '@libp2p/interfaces'
 
 /**

package/src/dht/dummy-dht.ts

@@ -1,9 +1,9 @@
-import type { DualDHT, QueryEvent, SingleDHT } from '@libp2p/interfaces/dht'
-import type { PeerDiscoveryEvents } from '@libp2p/interfaces/peer-discovery'
+import type { DualDHT, QueryEvent, SingleDHT } from '@libp2p/interface-dht'
+import type { PeerDiscoveryEvents } from '@libp2p/interface-peer-discovery'
 import errCode from 'err-code'
 import { messages, codes } from '../errors.js'
 import { EventEmitter } from '@libp2p/interfaces/events'
-import { symbol } from '@libp2p/interfaces/peer-discovery'
+import { symbol } from '@libp2p/interface-peer-discovery'
 
 export class DummyDHT extends EventEmitter<PeerDiscoveryEvents> implements DualDHT {
   get [symbol] (): true {

package/src/errors.ts

@@ -70,5 +70,8 @@ export enum codes {
   ERR_NOT_IMPLEMENTED = 'ERR_NOT_IMPLEMENTED',
   ERR_WRONG_PING_ACK = 'ERR_WRONG_PING_ACK',
   ERR_INVALID_RECORD = 'ERR_INVALID_RECORD',
-  ERR_ALREADY_SUCCEEDED = 'ERR_ALREADY_SUCCEEDED'
+  ERR_ALREADY_SUCCEEDED = 'ERR_ALREADY_SUCCEEDED',
+  ERR_NO_HANDLER_FOR_PROTOCOL = 'ERR_NO_HANDLER_FOR_PROTOCOL',
+  ERR_TOO_MANY_OUTBOUND_PROTOCOL_STREAMS = 'ERR_TOO_MANY_OUTBOUND_PROTOCOL_STREAMS',
+  ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS = 'ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS'
 }

package/src/fetch/index.ts

@@ -3,21 +3,24 @@ import errCode from 'err-code'
 import { codes } from '../errors.js'
 import * as lp from 'it-length-prefixed'
 import { FetchRequest, FetchResponse } from './pb/proto.js'
-import { handshake } from 'it-handshake'
 import { PROTOCOL_NAME, PROTOCOL_VERSION } from './constants.js'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Startable } from '@libp2p/interfaces/startable'
-import type { Stream } from '@libp2p/interfaces/connection'
-import type { IncomingStreamData } from '@libp2p/interfaces/registrar'
-import type { Components } from '@libp2p/interfaces/components'
+import type { Stream } from '@libp2p/interface-connection'
+import type { IncomingStreamData } from '@libp2p/interface-registrar'
+import type { Components } from '@libp2p/components'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { Duplex } from 'it-stream-types'
 import { abortableDuplex } from 'abortable-iterator'
+import { pipe } from 'it-pipe'
+import first from 'it-first'
 
 const log = logger('libp2p:fetch')
 
 export interface FetchServiceInit {
   protocolPrefix: string
+  maxInboundStreams: number
+  maxOutboundStreams: number
 }
 
 export interface HandleMessageOptions {
@@ -40,6 +43,7 @@ export class FetchService implements Startable {
   private readonly components: Components
   private readonly lookupFunctions: Map<string, LookupFunction>
   private started: boolean
+  private readonly init: FetchServiceInit
 
   constructor (components: Components, init: FetchServiceInit) {
     this.started = false
@@ -47,13 +51,21 @@ export class FetchService implements Startable {
     this.protocol = `/${init.protocolPrefix ?? 'libp2p'}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`
     this.lookupFunctions = new Map() // Maps key prefix to value lookup function
     this.handleMessage = this.handleMessage.bind(this)
+    this.init = init
   }
 
   async start () {
     await this.components.getRegistrar().handle(this.protocol, (data) => {
-      void this.handleMessage(data).catch(err => {
-        log.error(err)
-      })
+      void this.handleMessage(data)
+        .catch(err => {
+          log.error(err)
+        })
+        .finally(() => {
+          data.stream.close()
+        })
+    }, {
+      maxInboundStreams: this.init.maxInboundStreams,
+      maxOutboundStreams: this.init.maxOutboundStreams
     })
     this.started = true
   }
@@ -74,7 +86,7 @@ export class FetchService implements Startable {
     log('dialing %s to %p', this.protocol, peer)
 
     const connection = await this.components.getConnectionManager().openConnection(peer, options)
-    const { stream } = await connection.newStream([this.protocol], options)
+    const stream = await connection.newStream([this.protocol], options)
     let source: Duplex<Uint8Array> = stream
 
     // make stream abortable if AbortSignal passed
@@ -82,28 +94,42 @@ export class FetchService implements Startable {
       source = abortableDuplex(stream, options.signal)
     }
 
-    const shake = handshake(source)
-
-    // send message
-    shake.write(lp.encode.single(FetchRequest.encode({ identifier: key })).slice())
-
-    // read response
-    // @ts-expect-error fromReader returns a Source which has no .next method
-    const response = FetchResponse.decode((await lp.decode.fromReader(shake.reader).next()).value.slice())
-    switch (response.status) {
-      case (FetchResponse.StatusCode.OK): {
-        return response.data
-      }
-      case (FetchResponse.StatusCode.NOT_FOUND): {
-        return null
-      }
-      case (FetchResponse.StatusCode.ERROR): {
-        const errmsg = (new TextDecoder()).decode(response.data)
-        throw errCode(new Error('Error in fetch protocol response: ' + errmsg), codes.ERR_INVALID_PARAMETERS)
-      }
-      default: {
-        throw errCode(new Error('Unknown response status'), codes.ERR_INVALID_MESSAGE)
-      }
+    try {
+      const result = await pipe(
+        [FetchRequest.encode({ identifier: key })],
+        lp.encode(),
+        source,
+        lp.decode(),
+        async function (source) {
+          const buf = await first(source)
+
+          if (buf == null) {
+            throw errCode(new Error('No data received'), codes.ERR_INVALID_MESSAGE)
+          }
+
+          const response = FetchResponse.decode(buf)
+
+          switch (response.status) {
+            case (FetchResponse.StatusCode.OK): {
+              return response.data
+            }
+            case (FetchResponse.StatusCode.NOT_FOUND): {
+              return null
+            }
+            case (FetchResponse.StatusCode.ERROR): {
+              const errmsg = (new TextDecoder()).decode(response.data)
+              throw errCode(new Error('Error in fetch protocol response: ' + errmsg), codes.ERR_INVALID_PARAMETERS)
+            }
+            default: {
+              throw errCode(new Error('Unknown response status'), codes.ERR_INVALID_MESSAGE)
+            }
+          }
+        }
+      )
+
+      return result ?? null
+    } finally {
+      stream.close()
     }
   }
 
@@ -114,25 +140,40 @@ export class FetchService implements Startable {
    */
   async handleMessage (data: IncomingStreamData) {
     const { stream } = data
-    const shake = handshake(stream)
-    // @ts-expect-error fromReader returns a Source which has no .next method
-    const request = FetchRequest.decode((await lp.decode.fromReader(shake.reader).next()).value.slice())
-
-    let response: FetchResponse
-    const lookup = this._getLookupFunction(request.identifier)
-    if (lookup != null) {
-      const data = await lookup(request.identifier)
-      if (data != null) {
-        response = { status: FetchResponse.StatusCode.OK, data }
-      } else {
-        response = { status: FetchResponse.StatusCode.NOT_FOUND, data: new Uint8Array(0) }
-      }
-    } else {
-      const errmsg = (new TextEncoder()).encode('No lookup function registered for key: ' + request.identifier)
-      response = { status: FetchResponse.StatusCode.ERROR, data: errmsg }
-    }
-
-    shake.write(lp.encode.single(FetchResponse.encode(response)).slice())
+    const self = this
+
+    await pipe(
+      stream,
+      lp.decode(),
+      async function * (source) {
+        const buf = await first(source)
+
+        if (buf == null) {
+          throw errCode(new Error('No data received'), codes.ERR_INVALID_MESSAGE)
+        }
+
+        // for await (const buf of source) {
+        const request = FetchRequest.decode(buf)
+
+        let response: FetchResponse
+        const lookup = self._getLookupFunction(request.identifier)
+        if (lookup != null) {
+          const data = await lookup(request.identifier)
+          if (data != null) {
+            response = { status: FetchResponse.StatusCode.OK, data }
+          } else {
+            response = { status: FetchResponse.StatusCode.NOT_FOUND, data: new Uint8Array(0) }
+          }
+        } else {
+          const errmsg = (new TextEncoder()).encode('No lookup function registered for key: ' + request.identifier)
+          response = { status: FetchResponse.StatusCode.ERROR, data: errmsg }
+        }
+
+        yield FetchResponse.encode(response)
+      },
+      lp.encode(),
+      stream
+    )
   }
 
   /**

package/src/get-peer.ts

@@ -2,9 +2,9 @@ import { peerIdFromString } from '@libp2p/peer-id'
 import { Multiaddr } from '@multiformats/multiaddr'
 import errCode from 'err-code'
 import { codes } from './errors.js'
-import { isPeerId } from '@libp2p/interfaces/peer-id'
-import type { PeerId } from '@libp2p/interfaces/peer-id'
-import type { PeerInfo } from '@libp2p/interfaces/peer-info'
+import { isPeerId } from '@libp2p/interface-peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { PeerInfo } from '@libp2p/interface-peer-info'
 
 function peerIdFromMultiaddr (ma: Multiaddr) {
   const idStr = ma.getPeerId()