libp2p 0.42.2-593deefe → 0.42.2-5e63ee2d

package/src/circuit/client.ts

@@ -1,381 +0,0 @@
-import { logger } from '@libp2p/logger'
-import { RELAY_V2_HOP_CODEC } from './multicodec.js'
-import { getExpiration, namespaceToCid } from './utils.js'
-import {
-  CIRCUIT_PROTO_CODE,
-  DEFAULT_MAX_RESERVATIONS,
-  RELAY_RENDEZVOUS_NS
-} from './constants.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { AddressSorter } from '@libp2p/interface-peer-store'
-import type { Connection } from '@libp2p/interface-connection'
-import sort from 'it-sort'
-import all from 'it-all'
-import { pipe } from 'it-pipe'
-import { publicAddressesFirst } from '@libp2p/utils/address-sort'
-import { reserve } from './hop.js'
-import { EventEmitter, CustomEvent } from '@libp2p/interfaces/events'
-import type { Startable } from '@libp2p/interfaces/startable'
-import type { Components } from '../components.js'
-import type { RelayReservationManagerConfig } from './index.js'
-import { PeerSet, PeerMap, PeerList } from '@libp2p/peer-collections'
-
-const log = logger('libp2p:circuit:client')
-
-const noop = () => {}
-
-/**
- * CircuitServiceInit initializes the circuit service using values
- * from the provided config and an @type{AddressSorter}.
- */
-export interface CircuitServiceInit extends RelayReservationManagerConfig {
-  /**
-   * Allows prioritizing addresses from the peerstore for dialing. The
-   * default behavior is to prioritise public addresses.
-   */
-  addressSorter?: AddressSorter
-  /**
-   * A callback to invoke when an error occurs in the circuit service.
-   */
-  onError?: (error: Error) => void
-}
-
-export interface RelayReservationManagerEvents {
-  'relay:reservation': CustomEvent
-}
-
-/**
- * ReservationManager automatically makes a circuit v2 reservation on any connected
- * peers that support the circuit v2 HOP protocol.
- */
-export class RelayReservationManager extends EventEmitter<RelayReservationManagerEvents> implements Startable {
-  private readonly components: Components
-  private readonly addressSorter: AddressSorter
-  private readonly maxReservations: number
-  private readonly relays: PeerSet
-  private readonly reservationMap: PeerMap<ReturnType<typeof setTimeout>>
-  private readonly onError: (error: Error) => void
-  private started: boolean
-
-  constructor (components: Components, init: CircuitServiceInit) {
-    super()
-    this.started = false
-    this.components = components
-    this.addressSorter = init.addressSorter ?? publicAddressesFirst
-    this.maxReservations = init.maxReservations ?? DEFAULT_MAX_RESERVATIONS
-    this.relays = new PeerSet()
-    this.reservationMap = new PeerMap()
-    this.onError = init.onError ?? noop
-
-    this._onProtocolChange = this._onProtocolChange.bind(this)
-    this._onPeerDisconnected = this._onPeerDisconnected.bind(this)
-    this._onPeerConnect = this._onPeerConnect.bind(this)
-
-    this.components.peerStore.addEventListener('change:protocols', (evt) => {
-      void this._onProtocolChange(evt.detail).catch(err => {
-        log.error('handling protocol change failed', err)
-      })
-    })
-
-    this.components.connectionManager.addEventListener('peer:disconnect', this._onPeerDisconnected)
-    this.components.connectionManager.addEventListener('peer:connect', this._onPeerConnect)
-  }
-
-  isStarted () {
-    return this.started
-  }
-
-  start () {
-    void this._listenOnAvailableHopRelays().catch(err => { log.error('error listening on relays', err) })
-    this.started = true
-  }
-
-  async stop () {
-    this.reservationMap.forEach((timer) => clearTimeout(timer))
-    this.reservationMap.clear()
-    this.relays.clear()
-  }
-
-  /**
-   * Check if a peer supports the relay protocol.
-   * If the protocol is not supported, check if it was supported before and remove it as a listen relay.
-   * If the protocol is supported, check if the peer supports **HOP** and add it as a listener if
-   * inside the threshold.
-   */
-  async _onProtocolChange ({ peerId, protocols }: {peerId: PeerId, protocols: string[]}) {
-    if (peerId.equals(this.components.peerId)) {
-      return
-    }
-
-    // Check if it has the protocol
-    const hasProtocol = protocols.includes(RELAY_V2_HOP_CODEC)
-    log.trace('Peer %p protocol change %p', peerId, this.components.peerId)
-
-    // If no protocol, check if we were keeping the peer before as a listenRelay
-    if (!hasProtocol) {
-      if (this.relays.has(peerId)) {
-        await this._removeListenRelay(peerId)
-      }
-      return
-    }
-
-    if (this.relays.has(peerId)) {
-      return
-    }
-
-    // If protocol, check if can hop, store info in the metadataBook and listen on it
-    try {
-      const connections = this.components.connectionManager.getConnections(peerId)
-
-      // if no connections, try to listen on relay
-      if (connections.length === 0) {
-        void this._tryToListenOnRelay(peerId)
-        return
-      }
-      const connection = connections[0]
-
-      // Do not hop on a relayed connection
-      if (connection.remoteAddr.protoCodes().includes(CIRCUIT_PROTO_CODE)) {
-        log('relayed connection to %p will not be used to hop on', peerId)
-        return
-      }
-
-      await this._addListenRelay(connection, peerId)
-    } catch (err: any) {
-      log.error('could not add %p as relay', peerId)
-      this.onError(err)
-    }
-  }
-
-  /**
-   * Handle case when peer connects. If we already have the peer in the protobook,
-   * we treat this event as an `onProtocolChange`.
-   */
-  _onPeerConnect ({ detail: connection }: CustomEvent<Connection>) {
-    void this.components.peerStore.protoBook.get(connection.remotePeer)
-      .then((protocols) => {
-        void this._onProtocolChange({ peerId: connection.remotePeer, protocols })
-          .catch((err) => log.error('handling reconnect failed', err))
-      },
-      (err) => {
-        // this is not necessarily an error as we will only have the protocols stored
-        // in case of a reconnect
-        log.trace('could not fetch protocols for peer: %p', connection.remotePeer, err)
-      })
-  }
-
-  /**
-   * Peer disconnects
-   */
-  _onPeerDisconnected (evt: CustomEvent<Connection>) {
-    const connection = evt.detail
-    const peerId = connection.remotePeer
-    clearTimeout(this.reservationMap.get(peerId))
-    this.reservationMap.delete(peerId)
-
-    // Not listening on this relay
-    if (!this.relays.has(peerId)) {
-      return
-    }
-
-    this._removeListenRelay(peerId).catch(err => {
-      log.error(err)
-    })
-  }
-
-  /**
-   * Attempt to listen on the given relay connection
-   */
-  async _addListenRelay (connection: Connection, peerId: PeerId): Promise<void> {
-    log.trace('peerId %p is being added as relay', peerId)
-    try {
-      // Check if already enough relay reservations
-      if (this.relays.size >= this.maxReservations) {
-        return
-      }
-
-      await this.createOrRefreshReservation(peerId)
-
-      // Get peer known addresses and sort them with public addresses first
-      const remoteAddrs = await pipe(
-        await this.components.peerStore.addressBook.get(connection.remotePeer),
-        (source) => sort(source, this.addressSorter),
-        async (source) => await all(source)
-      )
-
-      // Attempt to listen on relay
-      const result = await Promise.all(
-        remoteAddrs.map(async addr => {
-          let multiaddr = addr.multiaddr
-
-          if (multiaddr.getPeerId() == null) {
-            multiaddr = multiaddr.encapsulate(`/p2p/${connection.remotePeer.toString()}`)
-          }
-          multiaddr = multiaddr.encapsulate('/p2p-circuit')
-          try {
-            // Announce multiaddrs will update on listen success by TransportManager event being triggered
-            await this.components.transportManager.listen([multiaddr])
-            return true
-          } catch (err: any) {
-            log.error('error listening on circuit address', multiaddr, err)
-            this.onError(err)
-          }
-
-          return false
-        })
-      )
-
-      if (result.includes(true)) {
-        this.relays.add(peerId)
-      }
-    } catch (err: any) {
-      this.relays.delete(peerId)
-      log.error('error adding relay for %p %s', peerId, err)
-      this.onError(err)
-    }
-  }
-
-  /**
-   * Remove listen relay
-   */
-  async _removeListenRelay (PeerId: PeerId) {
-    const recheck = this.relays.has(PeerId)
-    this.relays.delete(PeerId)
-    if (recheck) {
-      // TODO: this should be responsibility of the connMgr
-      await this._listenOnAvailableHopRelays(new PeerList([PeerId]))
-    }
-  }
-
-  /**
-   * Try to listen on available hop relay connections.
-   * The following order will happen while we do not have enough relays.
-   * 1. Check the metadata store for known relays, try to listen on the ones we are already connected.
-   * 2. Dial and try to listen on the peers we know that support hop but are not connected.
-   * 3. Search the network.
-   */
-  async _listenOnAvailableHopRelays (peersToIgnore: PeerList = new PeerList([])) {
-    // Check if already listening on enough relays
-    if (this.relays.size >= this.maxReservations) {
-      return
-    }
-
-    const knownHopsToDial: PeerId[] = []
-    const peers = (await this.components.peerStore.all())
-      // filter by a list of peers supporting RELAY_V2_HOP and ones we are not listening on
-      .filter(({ id, protocols }) =>
-        protocols.includes(RELAY_V2_HOP_CODEC) && !this.relays.has(id) && !peersToIgnore.includes(id)
-      )
-      .map(({ id }) => {
-        const connections = this.components.connectionManager.getConnections(id)
-        if (connections.length === 0) {
-          knownHopsToDial.push(id)
-          return [id, null]
-        }
-        return [id, connections[0]]
-      })
-      .sort(() => Math.random() - 0.5)
-
-    // Check if we have known hop peers to use and attempt to listen on the already connected
-    for (const [id, conn] of peers) {
-      await this._addListenRelay(conn as Connection, id as PeerId)
-
-      // Check if already listening on enough relays
-      if (this.relays.size >= this.maxReservations) {
-        return
-      }
-    }
-
-    // Try to listen on known peers that are not connected
-    for (const peerId of knownHopsToDial) {
-      // Check if already listening on enough relays
-      if (this.relays.size >= this.maxReservations) {
-        return
-      }
-
-      await this._tryToListenOnRelay(peerId)
-    }
-
-    // Try to find relays to hop on the network
-    try {
-      const cid = await namespaceToCid(RELAY_RENDEZVOUS_NS)
-      for await (const provider of this.components.contentRouting.findProviders(cid)) {
-        if (
-          provider.multiaddrs.length > 0 &&
-          !provider.id.equals(this.components.peerId)
-        ) {
-          const peerId = provider.id
-
-          await this.components.peerStore.addressBook.add(peerId, provider.multiaddrs)
-          await this._tryToListenOnRelay(peerId)
-
-          // Check if already listening on enough relays
-          if (this.relays.size >= this.maxReservations) {
-            return
-          }
-        }
-      }
-    } catch (err: any) {
-      log.error('failed when finding relays on the network', err)
-      this.onError(err)
-    }
-  }
-
-  async _tryToListenOnRelay (peerId: PeerId) {
-    try {
-      if (peerId.equals(this.components.peerId)) {
-        log.trace('Skipping dialling self %p', peerId.toString())
-        return
-      }
-      const connection = await this.components.connectionManager.openConnection(peerId)
-      await this._addListenRelay(connection, peerId)
-    } catch (err: any) {
-      log.error('Could not connect and listen on relay %p', peerId, err)
-      this.onError(err)
-    }
-  }
-
-  private readonly createOrRefreshReservation = async (peerId: PeerId) => {
-    try {
-      const connections = this.components.connectionManager.getConnections(peerId)
-
-      if (connections.length === 0) {
-        throw new Error('No connections to peer')
-      }
-
-      const connection = connections[0]
-
-      const reservation = await reserve(connection)
-
-      const refreshReservation = this.createOrRefreshReservation
-
-      if (reservation != null) {
-        log('new reservation on %p', peerId)
-
-        // clear any previous timeouts
-        const previous = this.reservationMap.get(peerId)
-        if (previous != null) {
-          clearTimeout(previous)
-        }
-
-        const timeout = setTimeout(
-          (peerId: PeerId) => {
-            void refreshReservation(peerId).catch(err => {
-              log.error('error refreshing reservation for %p', peerId, err)
-            })
-          },
-          Math.max(getExpiration(reservation.expire) - 100, 0),
-          peerId
-        )
-        this.reservationMap.set(
-          peerId,
-          timeout
-        )
-        this.dispatchEvent(new CustomEvent<unknown>('relay:reservation'))
-      }
-    } catch (err: any) {
-      log.error(err)
-      await this._removeListenRelay(peerId)
-    }
-  }
-}

package/src/circuit/hop.ts

@@ -1,210 +0,0 @@
-import type { PeerId } from '@libp2p/interface-peer-id'
-import { RecordEnvelope } from '@libp2p/peer-record'
-import { logger } from '@libp2p/logger'
-import type { Connection, Stream } from '@libp2p/interface-connection'
-import { HopMessage, Limit, Reservation, Status, StopMessage } from './pb/index.js'
-import type { Multiaddr } from '@multiformats/multiaddr'
-import { multiaddr } from '@multiformats/multiaddr'
-import type { Acl, ReservationStore } from './interfaces.js'
-import { RELAY_V2_HOP_CODEC } from './multicodec.js'
-import { stop } from './stop.js'
-import { ReservationVoucherRecord } from './reservation-voucher.js'
-import { peerIdFromBytes } from '@libp2p/peer-id'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { ProtobufStream } from 'it-pb-stream'
-import { pbStream } from 'it-pb-stream'
-import { CIRCUIT_PROTO_CODE, RELAY_DESTINATION_TAG } from './constants.js'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import { createLimitedRelay } from './utils.js'
-
-const log = logger('libp2p:circuit:v2:hop')
-
-export interface HopProtocolOptions {
-  connection: Connection
-  request: HopMessage
-  stream: ProtobufStream<Stream>
-  relayPeer: PeerId
-  relayAddrs: Multiaddr[]
-  limit?: Limit
-  acl?: Acl
-  reservationStore: ReservationStore
-  connectionManager: ConnectionManager
-  peerStore: PeerStore
-}
-
-export async function handleHopProtocol (options: HopProtocolOptions): Promise<void> {
-  const { stream, request } = options
-  log('received hop message')
-  switch (request.type) {
-    case HopMessage.Type.RESERVE: await handleReserve(options); break
-    case HopMessage.Type.CONNECT: await handleConnect(options); break
-    default: {
-      log.error('invalid hop request type %s via peer %s', options.request.type, options.connection.remotePeer)
-      stream.pb(HopMessage).write({ type: HopMessage.Type.STATUS, status: Status.UNEXPECTED_MESSAGE })
-    }
-  }
-}
-
-export async function reserve (connection: Connection): Promise<Reservation> {
-  log('requesting reservation from %s', connection.remotePeer)
-  const stream = await connection.newStream([RELAY_V2_HOP_CODEC])
-  const pbstr = pbStream(stream)
-  const hopstr = pbstr.pb(HopMessage)
-  hopstr.write({ type: HopMessage.Type.RESERVE })
-
-  let response: HopMessage
-  try {
-    response = await hopstr.read()
-  } catch (err: any) {
-    log.error('error passing reserve message response from %s because', connection.remotePeer, err.message)
-    stream.close()
-    throw err
-  }
-
-  if (response.status === Status.OK && (response.reservation != null)) {
-    return response.reservation
-  }
-  const errMsg = `reservation failed with status ${response.status ?? 'undefined'}`
-  log.error(errMsg)
-  throw new Error(errMsg)
-}
-
-const isRelayAddr = (ma: Multiaddr): boolean => ma.protoCodes().includes(CIRCUIT_PROTO_CODE)
-
-async function handleReserve ({ connection, stream: pbstr, relayPeer, relayAddrs, acl, reservationStore, peerStore }: HopProtocolOptions): Promise<void> {
-  const hopstr = pbstr.pb(HopMessage)
-  log('hop reserve request from %s', connection.remotePeer)
-
-  if (isRelayAddr(connection.remoteAddr)) {
-    log.error('relay reservation over circuit connection denied for peer: %p', connection.remotePeer)
-    hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED })
-    return
-  }
-
-  if ((await acl?.allowReserve?.(connection.remotePeer, connection.remoteAddr)) === false) {
-    log.error('acl denied reservation to %s', connection.remotePeer)
-    hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED })
-    return
-  }
-
-  const result = await reservationStore.reserve(connection.remotePeer, connection.remoteAddr)
-
-  if (result.status !== Status.OK) {
-    hopstr.write({ type: HopMessage.Type.STATUS, status: result.status })
-    return
-  }
-
-  try {
-    // tag relayed peer
-    // result.expire is non-null if `ReservationStore.reserve` returns with status == OK
-    if (result.expire != null) {
-      const ttl = new Date().getTime() - result.expire
-      await peerStore.tagPeer(relayPeer, RELAY_DESTINATION_TAG, { value: 1, ttl })
-    }
-    hopstr.write({
-      type: HopMessage.Type.STATUS,
-      status: Status.OK,
-      reservation: await makeReservation(relayAddrs, relayPeer, connection.remotePeer, BigInt(result.expire ?? 0)),
-      limit: (await reservationStore.get(relayPeer))?.limit
-    })
-    log('sent confirmation response to %s', connection.remotePeer)
-  } catch (err) {
-    log.error('failed to send confirmation response to %s', connection.remotePeer)
-    await reservationStore.removeReservation(connection.remotePeer)
-  }
-}
-
-async function handleConnect (options: HopProtocolOptions): Promise<void> {
-  const { connection, stream, request, reservationStore, connectionManager, acl } = options
-  const hopstr = stream.pb(HopMessage)
-
-  log('hop connect request from %s', connection.remotePeer)
-
-  let dstPeer: PeerId
-  try {
-    if (request.peer == null) {
-      log.error('no peer info in hop connect request')
-      throw new Error('no peer info in request')
-    }
-    request.peer.addrs.forEach(multiaddr)
-    dstPeer = peerIdFromBytes(request.peer.id)
-  } catch (err) {
-    log.error('invalid hop connect request via peer %p %s', connection.remotePeer, err)
-    hopstr.write({ type: HopMessage.Type.STATUS, status: Status.MALFORMED_MESSAGE })
-    return
-  }
-
-  if (acl?.allowConnect !== undefined) {
-    const status = await acl.allowConnect(connection.remotePeer, connection.remoteAddr, dstPeer)
-    if (status !== Status.OK) {
-      log.error('hop connect denied for %s with status %s', connection.remotePeer, status)
-      hopstr.write({ type: HopMessage.Type.STATUS, status: status })
-      return
-    }
-  }
-
-  if (!await reservationStore.hasReservation(dstPeer)) {
-    log.error('hop connect denied for %s with status %s', connection.remotePeer, Status.NO_RESERVATION)
-    hopstr.write({ type: HopMessage.Type.STATUS, status: Status.NO_RESERVATION })
-    return
-  }
-
-  const connections = connectionManager.getConnections(dstPeer)
-  if (connections.length === 0) {
-    log('hop connect denied for %s as there is no destination connection', connection.remotePeer)
-    hopstr.write({ type: HopMessage.Type.STATUS, status: Status.NO_RESERVATION })
-    return
-  }
-  const destinationConnection = connections[0]
-  log('hop connect request from %s to %s is valid', connection.remotePeer, dstPeer)
-
-  const destinationStream = await stop({
-    connection: destinationConnection,
-    request: {
-      type: StopMessage.Type.CONNECT,
-      peer: {
-        id: connection.remotePeer.toBytes(),
-        addrs: [multiaddr('/p2p/' + connection.remotePeer.toString()).bytes]
-      }
-    }
-  })
-
-  if (destinationStream == null) {
-    log.error('failed to open stream to destination peer %s', destinationConnection?.remotePeer)
-    hopstr.write({ type: HopMessage.Type.STATUS, status: Status.CONNECTION_FAILED })
-    return
-  }
-
-  hopstr.write({ type: HopMessage.Type.STATUS, status: Status.OK })
-  const sourceStream = stream.unwrap()
-
-  log('connection to destination established, short circuiting streams...')
-  const limit = (await reservationStore.get(dstPeer))?.limit
-  // Short circuit the two streams to create the relayed connection
-  return createLimitedRelay(sourceStream, destinationStream, limit)
-}
-
-async function makeReservation (
-  relayAddrs: Multiaddr[],
-  relayPeerId: PeerId,
-  remotePeer: PeerId,
-  expire: bigint
-): Promise<Reservation> {
-  const addrs = []
-
-  for (const relayAddr of relayAddrs) {
-    addrs.push(relayAddr.bytes)
-  }
-
-  const voucher = await RecordEnvelope.seal(new ReservationVoucherRecord({
-    peer: remotePeer,
-    relay: relayPeerId,
-    expiration: Number(expire)
-  }), relayPeerId)
-
-  return {
-    addrs,
-    expire,
-    voucher: voucher.marshal()
-  }
-}

package/src/circuit/interfaces.ts

@@ -1,28 +0,0 @@
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Multiaddr } from '@multiformats/multiaddr'
-import type { Limit, Status } from './pb/index.js'
-
-export type ReservationStatus = Status.OK | Status.PERMISSION_DENIED | Status.RESERVATION_REFUSED
-
-export interface Reservation {
-  addr: Multiaddr
-  expire: Date
-  limit?: Limit
-}
-
-export interface ReservationStore {
-  reserve: (peer: PeerId, addr: Multiaddr, limit?: Limit) => {status: ReservationStatus, expire?: number}
-  removeReservation: (peer: PeerId) => void
-  hasReservation: (dst: PeerId) => boolean
-  get: (peer: PeerId) => Reservation | undefined
-}
-
-export type AclStatus = Status.OK | Status.RESOURCE_LIMIT_EXCEEDED | Status.PERMISSION_DENIED
-
-export interface Acl {
-  allowReserve: (peer: PeerId, addr: Multiaddr) => Promise<boolean>
-  /**
-   * Checks if connection should be allowed
-   */
-  allowConnect: (src: PeerId, addr: Multiaddr, dst: PeerId) => Promise<AclStatus>
-}

package/src/circuit/listener.ts

@@ -1,83 +0,0 @@
-import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { Listener } from '@libp2p/interface-transport'
-import { peerIdFromString } from '@libp2p/peer-id'
-import type { Multiaddr } from '@multiformats/multiaddr'
-import { multiaddr } from '@multiformats/multiaddr'
-
-export interface ListenerOptions {
-  peerStore: PeerStore
-  connectionManager: ConnectionManager
-}
-
-export function createListener (options: ListenerOptions): Listener {
-  const listeningAddrs = new Map()
-
-  /**
-   * Add swarm handler and listen for incoming connections
-   */
-  async function listen (addr: Multiaddr): Promise<void> {
-    const addrString = addr.toString().split('/p2p-circuit').find(a => a !== '')
-    const ma = multiaddr(addrString)
-
-    const relayPeerStr = ma.getPeerId()
-
-    if (relayPeerStr == null) {
-      throw new Error('Could not determine relay peer from multiaddr')
-    }
-
-    const relayPeerId = peerIdFromString(relayPeerStr)
-
-    await options.peerStore.addressBook.add(relayPeerId, [ma])
-
-    const relayConn = await options.connectionManager.openConnection(relayPeerId)
-    const relayedAddr = relayConn.remoteAddr.encapsulate('/p2p-circuit')
-
-    listeningAddrs.set(relayConn.remotePeer.toString(), relayedAddr)
-    listener.dispatchEvent(new CustomEvent('listening'))
-  }
-
-  /**
-   * Get fixed up multiaddrs
-   *
-   * NOTE: This method will grab the peers multiaddrs and expand them such that:
-   *
-   * a) If it's an existing /p2p-circuit address for a specific relay i.e.
-   * `/ip4/0.0.0.0/tcp/0/ipfs/QmRelay/p2p-circuit` this method will expand the
-   * address to `/ip4/0.0.0.0/tcp/0/ipfs/QmRelay/p2p-circuit/ipfs/QmPeer` where
-   * `QmPeer` is this peers id
-   * b) If it's not a /p2p-circuit address, it will encapsulate the address as a /p2p-circuit
-   * addr, such when dialing over a relay with this address, it will create the circuit using
-   * the encapsulated transport address. This is useful when for example, a peer should only
-   * be dialed over TCP rather than any other transport
-   *
-   * @returns {Multiaddr[]}
-   */
-  function getAddrs () {
-    const addrs = []
-    for (const addr of listeningAddrs.values()) {
-      addrs.push(addr)
-    }
-    return addrs
-  }
-
-  const listener: Listener = Object.assign(new EventEmitter(), {
-    close: async () => await Promise.resolve(),
-    listen,
-    getAddrs
-  })
-
-  // Remove listeningAddrs when a peer disconnects
-  options.connectionManager.addEventListener('peer:disconnect', (evt) => {
-    const { detail: connection } = evt
-    const deleted = listeningAddrs.delete(connection.remotePeer.toString())
-
-    if (deleted) {
-      // Announce listen addresses change
-      listener.dispatchEvent(new CustomEvent('close'))
-    }
-  })
-
-  return listener
-}