libp2p 0.43.4 → 0.44.0-0d46c78f

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2p",
-  "version": "0.43.4",
+  "version": "0.44.0-0d46c78f",
   "description": "JavaScript implementation of libp2p, a modular peer to peer network stack",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p#readme",
@@ -52,14 +52,34 @@
       "types": "./dist/src/index.d.ts",
       "import": "./dist/src/index.js"
     },
+    "./autonat": {
+      "types": "./dist/src/autonat/index.d.ts",
+      "import": "./dist/src/autonat/index.js"
+    },
     "./circuit-relay": {
       "types": "./dist/src/circuit-relay/index.d.ts",
       "import": "./dist/src/circuit-relay/index.js"
     },
+    "./fetch": {
+      "types": "./dist/src/fetch/index.d.ts",
+      "import": "./dist/src/fetch/index.js"
+    },
+    "./identify": {
+      "types": "./dist/src/identify/index.d.ts",
+      "import": "./dist/src/identify/index.js"
+    },
     "./insecure": {
       "types": "./dist/src/insecure/index.d.ts",
       "import": "./dist/src/insecure/index.js"
     },
+    "./upnp-nat": {
+      "types": "./dist/src/upnp-nat/index.d.ts",
+      "import": "./dist/src/upnp-nat/index.js"
+    },
+    "./ping": {
+      "types": "./dist/src/ping/index.d.ts",
+      "import": "./dist/src/ping/index.js"
+    },
     "./pnet": {
       "types": "./dist/src/pnet/index.d.ts",
       "import": "./dist/src/pnet/index.js"
@@ -101,94 +121,89 @@
   "dependencies": {
     "@achingbrain/nat-port-mapper": "^1.0.3",
     "@libp2p/crypto": "^1.0.4",
-    "@libp2p/interface-address-manager": "^2.0.0",
-    "@libp2p/interface-connection": "^3.0.2",
-    "@libp2p/interface-connection-encrypter": "^3.0.1",
-    "@libp2p/interface-connection-gater": "^1.0.0",
-    "@libp2p/interface-connection-manager": "^1.1.1",
-    "@libp2p/interface-content-routing": "^2.0.0",
-    "@libp2p/interface-dht": "^2.0.0",
+    "@libp2p/interface-address-manager": "^3.0.0",
+    "@libp2p/interface-connection": "^5.0.0",
+    "@libp2p/interface-connection-encrypter": "^4.0.0",
+    "@libp2p/interface-connection-gater": "^3.0.0",
+    "@libp2p/interface-connection-manager": "^3.0.0",
+    "@libp2p/interface-content-routing": "^2.1.0",
     "@libp2p/interface-keychain": "^2.0.4",
-    "@libp2p/interface-libp2p": "^1.0.0",
+    "@libp2p/interface-libp2p": "^3.0.0",
     "@libp2p/interface-metrics": "^4.0.0",
-    "@libp2p/interface-peer-discovery": "^1.0.1",
+    "@libp2p/interface-peer-discovery": "^2.0.0",
     "@libp2p/interface-peer-id": "^2.0.1",
     "@libp2p/interface-peer-info": "^1.0.3",
-    "@libp2p/interface-peer-routing": "^1.0.1",
-    "@libp2p/interface-peer-store": "^1.2.2",
-    "@libp2p/interface-pubsub": "^3.0.0",
+    "@libp2p/interface-peer-routing": "^1.1.0",
+    "@libp2p/interface-peer-store": "^2.0.0",
+    "@libp2p/interface-pubsub": "^4.0.0",
     "@libp2p/interface-record": "^2.0.6",
     "@libp2p/interface-registrar": "^2.0.3",
-    "@libp2p/interface-stream-muxer": "^3.0.0",
-    "@libp2p/interface-transport": "^2.1.0",
+    "@libp2p/interface-stream-muxer": "^4.0.0",
+    "@libp2p/interface-transport": "^4.0.0",
     "@libp2p/interfaces": "^3.2.0",
     "@libp2p/keychain": "^2.0.0",
     "@libp2p/logger": "^2.0.1",
-    "@libp2p/multistream-select": "^3.0.0",
+    "@libp2p/multistream-select": "^3.1.8",
     "@libp2p/peer-collections": "^3.0.0",
     "@libp2p/peer-id": "^2.0.0",
     "@libp2p/peer-id-factory": "^2.0.0",
     "@libp2p/peer-record": "^5.0.0",
-    "@libp2p/peer-store": "^7.0.0",
+    "@libp2p/peer-store": "^8.0.0",
     "@libp2p/topology": "^4.0.1",
     "@libp2p/tracked-map": "^3.0.0",
-    "@libp2p/utils": "^3.0.2",
+    "@libp2p/utils": "^3.0.10",
     "@multiformats/mafmt": "^12.0.0",
     "@multiformats/multiaddr": "^12.0.0",
-    "abortable-iterator": "^4.0.2",
-    "any-signal": "^3.0.0",
+    "abortable-iterator": "^5.0.1",
+    "any-signal": "^4.1.1",
     "datastore-core": "^9.0.0",
     "interface-datastore": "^8.0.0",
-    "it-all": "^2.0.0",
-    "it-drain": "^2.0.0",
-    "it-filter": "^2.0.0",
-    "it-first": "^2.0.0",
-    "it-parallel": "^3.0.0",
-    "it-handshake": "^4.1.2",
-    "it-length-prefixed": "^8.0.2",
-    "it-map": "^2.0.0",
-    "it-merge": "^2.0.0",
+    "it-all": "^3.0.1",
+    "it-drain": "^3.0.1",
+    "it-filter": "^3.0.1",
+    "it-first": "^3.0.1",
+    "it-handshake": "^4.1.3",
+    "it-length-prefixed": "^9.0.1",
+    "it-map": "^3.0.2",
+    "it-merge": "^3.0.0",
     "it-pair": "^2.0.2",
-    "it-pb-stream": "^3.2.0",
-    "it-pipe": "^2.0.3",
-    "it-stream-types": "^1.0.4",
+    "it-parallel": "^3.0.0",
+    "it-pb-stream": "^4.0.1",
+    "it-pipe": "^3.0.1",
+    "it-stream-types": "^2.0.1",
     "merge-options": "^3.0.4",
     "multiformats": "^11.0.0",
     "p-defer": "^4.0.0",
-    "p-fifo": "^1.0.0",
     "p-queue": "^7.3.4",
     "p-retry": "^5.0.0",
     "private-ip": "^3.0.0",
     "protons-runtime": "^5.0.0",
     "rate-limiter-flexible": "^2.3.11",
-    "retimer": "^3.0.0",
     "set-delayed-interval": "^1.0.0",
-    "timeout-abort-controller": "^3.0.0",
     "uint8arraylist": "^2.3.2",
     "uint8arrays": "^4.0.2",
     "wherearewe": "^2.0.0",
     "xsalsa20": "^1.1.0"
   },
   "devDependencies": {
-    "@chainsafe/libp2p-gossipsub": "^6.2.0",
+    "@chainsafe/libp2p-gossipsub": "^7.0.0",
     "@chainsafe/libp2p-noise": "^11.0.0",
-    "@chainsafe/libp2p-yamux": "^3.0.3",
-    "@libp2p/bootstrap": "^6.0.0",
-    "@libp2p/daemon-client": "^5.0.0",
-    "@libp2p/daemon-server": "^4.1.0",
-    "@libp2p/floodsub": "^6.0.0",
-    "@libp2p/interface-compliance-tests": "^3.0.2",
-    "@libp2p/interface-connection-compliance-tests": "^2.0.3",
-    "@libp2p/interface-connection-encrypter-compliance-tests": "^4.0.0",
-    "@libp2p/interface-mocks": "^9.0.0",
-    "@libp2p/interop": "^7.0.0",
-    "@libp2p/kad-dht": "^8.0.0",
-    "@libp2p/mdns": "^7.0.0",
-    "@libp2p/mplex": "^7.0.0",
-    "@libp2p/pubsub": "^6.0.0",
-    "@libp2p/tcp": "^6.0.0",
-    "@libp2p/websockets": "^5.0.0",
-    "@types/p-fifo": "^1.0.0",
+    "@chainsafe/libp2p-yamux": "^4.0.0",
+    "@libp2p/bootstrap": "^8.0.0",
+    "@libp2p/daemon-client": "^6.0.2",
+    "@libp2p/daemon-server": "^5.0.2",
+    "@libp2p/floodsub": "^7.0.1",
+    "@libp2p/interface-compliance-tests": "^3.0.6",
+    "@libp2p/interface-connection-compliance-tests": "^2.0.8",
+    "@libp2p/interface-connection-encrypter-compliance-tests": "^5.0.0",
+    "@libp2p/interface-mocks": "^12.0.0",
+    "@libp2p/interop": "^8.0.0",
+    "@libp2p/kad-dht": "^9.1.4",
+    "@libp2p/mdns": "^8.0.0",
+    "@libp2p/mplex": "^8.0.1",
+    "@libp2p/pubsub": "^7.0.1",
+    "@libp2p/tcp": "^7.0.1",
+    "@libp2p/websockets": "^6.0.1",
     "@types/varint": "^6.0.0",
     "@types/xsalsa20": "^1.1.0",
     "aegir": "^38.1.7",
@@ -197,7 +212,7 @@
     "execa": "^7.0.0",
     "go-libp2p": "^1.0.1",
     "it-pushable": "^3.0.0",
-    "it-to-buffer": "^3.0.1",
+    "it-to-buffer": "^4.0.1",
     "npm-run-all": "^4.1.5",
     "p-event": "^5.0.1",
     "p-times": "^4.0.0",
@@ -207,6 +222,7 @@
     "sinon-ts": "^1.0.0"
   },
   "browser": {
+    "./dist/src/config/connection-gater.js": "./dist/src/config/connection-gater.browser.js",
     "nat-api": false
   }
 }

package/src/address-manager/index.ts

@@ -1,10 +1,12 @@
-import type { AddressManagerEvents } from '@libp2p/interface-address-manager'
-import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import { multiaddr } from '@multiformats/multiaddr'
 import { peerIdFromString } from '@libp2p/peer-id'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { TransportManager } from '@libp2p/interface-transport'
+import type { PeerStore } from '@libp2p/interface-peer-store'
+import { logger } from '@libp2p/logger'
+
+const log = logger('libp2p:address-manager')
 
 export interface AddressManagerInit {
   /**
@@ -32,6 +34,7 @@ export interface AddressManagerInit {
 export interface DefaultAddressManagerComponents {
   peerId: PeerId
   transportManager: TransportManager
+  peerStore: PeerStore
 }
 
 /**
@@ -67,7 +70,7 @@ function stripPeerId (ma: Multiaddr, peerId: PeerId): Multiaddr {
   return ma
 }
 
-export class DefaultAddressManager extends EventEmitter<AddressManagerEvents> {
+export class DefaultAddressManager {
   private readonly components: DefaultAddressManagerComponents
   // this is an array to allow for duplicates, e.g. multiples of `/ip4/0.0.0.0/tcp/0`
   private readonly listen: string[]
@@ -81,9 +84,7 @@ export class DefaultAddressManager extends EventEmitter<AddressManagerEvents> {
    * The listen addresses will be used by the libp2p transports to listen for new connections,
    * while the announce addresses will be used for the peer addresses' to other peers in the network.
    */
-  constructor (components: DefaultAddressManagerComponents, init: AddressManagerInit) {
-    super()
-
+  constructor (components: DefaultAddressManagerComponents, init: AddressManagerInit = {}) {
     const { listen = [], announce = [] } = init
 
     this.components = components
@@ -145,9 +146,12 @@ export class DefaultAddressManager extends EventEmitter<AddressManagerEvents> {
       confident: true
     })
 
-    // only trigger the change:addresses event if our confidence in an address has changed
+    // only trigger the 'self:peer:update' event if our confidence in an address has changed
     if (!startingConfidence) {
-      this.dispatchEvent(new CustomEvent('change:addresses'))
+      this.components.peerStore.patch(this.components.peerId, {
+        multiaddrs: this.getAddresses()
+      })
+        .catch(err => { log.error('error updating addresses', err) })
     }
   }
 

package/src/autonat/index.ts

@@ -1,6 +1,6 @@
 import type { AddressManager } from '@libp2p/interface-address-manager'
 import type { Connection } from '@libp2p/interface-connection'
-import type { ConnectionManager, Dialer } from '@libp2p/interface-connection-manager'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { PeerInfo } from '@libp2p/interface-peer-info'
 import type { PeerRouting } from '@libp2p/interface-peer-routing'
@@ -19,11 +19,11 @@ import map from 'it-map'
 import parallel from 'it-parallel'
 import { pipe } from 'it-pipe'
 import isPrivateIp from 'private-ip'
-import { TimeoutController } from 'timeout-abort-controller'
 import {
   PROTOCOL
 } from './constants.js'
 import { Message } from './pb/index.js'
+import { anySignal } from 'any-signal'
 
 const log = logger('libp2p:autonat')
 
@@ -74,7 +74,6 @@ export interface DefaultAutonatComponents {
   registrar: Registrar
   addressManager: AddressManager
   transportManager: TransportManager
-  dialer: Dialer
   peerId: PeerId
   connectionManager: ConnectionManager
   peerRouting: PeerRouting
@@ -133,25 +132,25 @@ export class AutonatService implements Startable {
    * Handle an incoming autonat request
    */
   async handleIncomingAutonatStream (data: IncomingStreamData): Promise<void> {
-    const controller = new TimeoutController(this._init.timeout)
+    const signal = anySignal([AbortSignal.timeout(this._init.timeout)])
 
     // this controller may be used while dialing lots of peers so prevent MaxListenersExceededWarning
     // appearing in the console
     try {
       // fails on node < 15.4
-      setMaxListeners?.(Infinity, controller.signal)
+      setMaxListeners?.(Infinity, signal)
     } catch {}
 
     const ourHosts = this.components.addressManager.getAddresses()
       .map(ma => ma.toOptions().host)
 
     try {
-      const source = abortableDuplex(data.stream, controller.signal)
+      const source = abortableDuplex(data.stream, signal)
       const self = this
 
       await pipe(
         source,
-        lp.decode(),
+        (source) => lp.decode(source),
         async function * (stream) {
           const buf = await first(stream)
 
@@ -319,10 +318,8 @@ export class AutonatService implements Startable {
             lastMultiaddr = multiaddr
 
             try {
-              // use the dialer so we can dial a specific multiaddr instead of every known
-              // multiaddr for the peer
-              connection = await self.components.dialer.dial(multiaddr, {
-                signal: controller.signal
+              connection = await self.components.connectionManager.openConnection(multiaddr, {
+                signal
               })
 
               if (!connection.remoteAddr.equals(multiaddr)) {
@@ -360,13 +357,15 @@ export class AutonatService implements Startable {
             }
           })
         },
-        lp.encode(),
+        (source) => lp.encode(source),
         // pipe to the stream, not the abortable source other wise we
         // can't tell the remote when a dial timed out..
         data.stream
       )
+    } catch (err) {
+      log.error(err)
     } finally {
-      controller.clear()
+      signal.clear()
     }
   }
 
@@ -404,13 +403,13 @@ export class AutonatService implements Startable {
       return
     }
 
-    const controller = new TimeoutController(this._init.timeout)
+    const signal = AbortSignal.timeout(this._init.timeout)
 
     // this controller may be used while dialing lots of peers so prevent MaxListenersExceededWarning
     // appearing in the console
     try {
       // fails on node < 15.4
-      setMaxListeners?.(Infinity, controller.signal)
+      setMaxListeners?.(Infinity, signal)
     } catch {}
 
     const self = this
@@ -439,19 +438,19 @@ export class AutonatService implements Startable {
           log('Asking %p to verify multiaddr', peer.id)
 
           const connection = await self.components.connectionManager.openConnection(peer.id, {
-            signal: controller.signal
+            signal
           })
 
           const stream = await connection.newStream(PROTOCOL, {
-            signal: controller.signal
+            signal
           })
-          const source = abortableDuplex(stream, controller.signal)
+          const source = abortableDuplex(stream, signal)
 
           const buf = await pipe(
             [request],
-            lp.encode(),
+            (source) => lp.encode(source),
             source,
-            lp.decode(),
+            (source) => lp.decode(source),
             async (stream) => await first(stream)
           )
           if (buf == null) {
@@ -496,7 +495,7 @@ export class AutonatService implements Startable {
       }
 
       for await (const dialResponse of parallel(map(this.components.peerRouting.getClosestPeers(randomCid, {
-        signal: controller.signal
+        signal
       }), (peer) => async () => await verifyAddress(peer)), {
         concurrency: REQUIRED_SUCCESSFUL_DIALS
       })) {
@@ -560,7 +559,6 @@ export class AutonatService implements Startable {
         }
       }
     } finally {
-      controller.clear()
       this.verifyAddressTimeout = setTimeout(this._verifyExternalAddresses, this.refreshInterval)
     }
   }

package/src/circuit-relay/server/advert-service.ts

@@ -7,7 +7,7 @@ import {
 } from '../constants.js'
 import type { Startable } from '@libp2p/interfaces/startable'
 import type { ContentRouting } from '@libp2p/interface-content-routing'
-import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
+import { EventEmitter } from '@libp2p/interfaces/events'
 import pRetry from 'p-retry'
 
 const log = logger('libp2p:circuit-relay:advert-service')
@@ -90,7 +90,7 @@ export class AdvertService extends EventEmitter<AdvertServiceEvents> implements
         const cid = await namespaceToCid(RELAY_RENDEZVOUS_NS)
         await this.contentRouting.provide(cid)
 
-        this.dispatchEvent(new CustomEvent('advert:success'))
+        this.safeDispatchEvent('advert:success', { detail: undefined })
       } catch (err: any) {
         this.safeDispatchEvent('advert:error', { detail: err })
 

package/src/circuit-relay/server/index.ts

@@ -24,7 +24,7 @@ import { ReservationVoucherRecord } from './reservation-voucher.js'
 import type { AddressManager } from '@libp2p/interface-address-manager'
 import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 import type { CircuitRelayService, RelayReservation } from '../index.js'
-import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
+import { EventEmitter } from '@libp2p/interfaces/events'
 import { setMaxListeners } from 'events'
 import type { PeerMap } from '@libp2p/peer-collections'
 
@@ -128,7 +128,7 @@ class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Star
     if (init.advertise != null && init.advertise !== false) {
       this.advertService = new AdvertService(components, init.advertise === true ? undefined : init.advertise)
       this.advertService.addEventListener('advert:success', () => {
-        this.dispatchEvent(new CustomEvent('relay:advert:success'))
+        this.safeDispatchEvent('relay:advert:success', {})
       })
       this.advertService.addEventListener('advert:error', (evt) => {
         this.safeDispatchEvent('relay:advert:error', { detail: evt.detail })
@@ -260,7 +260,11 @@ class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Star
       // result.expire is non-null if `ReservationStore.reserve` returns with status == OK
       if (result.expire != null) {
         const ttl = (result.expire * 1000) - Date.now()
-        await this.peerStore.tagPeer(connection.remotePeer, RELAY_SOURCE_TAG, { value: 1, ttl })
+        await this.peerStore.merge(connection.remotePeer, {
+          tags: {
+            [RELAY_SOURCE_TAG]: { value: 1, ttl }
+          }
+        })
       }
 
       hopstr.write({

package/src/circuit-relay/transport/discovery.ts

@@ -113,7 +113,9 @@ export class RelayDiscovery extends EventEmitter<RelayDiscoveryEvents> implement
 
           found++
           log('found relay peer %p in content routing', peerId)
-          await this.peerStore.addressBook.add(peerId, provider.multiaddrs)
+          await this.peerStore.merge(peerId, {
+            multiaddrs: provider.multiaddrs
+          })
 
           this.safeDispatchEvent('relay:discover', { detail: peerId })
         }

package/src/circuit-relay/transport/index.ts

@@ -23,6 +23,8 @@ import { CIRCUIT_PROTO_CODE, RELAY_V2_HOP_CODEC, RELAY_V2_STOP_CODEC } from '../
 import { RelayStoreInit, ReservationStore } from './reservation-store.js'
 import { RelayDiscovery, RelayDiscoveryComponents } from './discovery.js'
 import { CodeError } from '@libp2p/interfaces/errors'
+import type { EventEmitter } from '@libp2p/interfaces/events'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
 
 const log = logger('libp2p:circuit-relay:transport')
 
@@ -49,6 +51,7 @@ export interface CircuitRelayTransportComponents extends RelayDiscoveryComponent
   addressManager: AddressManager
   contentRouting: ContentRouting
   connectionGater: ConnectionGater
+  events: EventEmitter<Libp2pEvents>
 }
 
 interface ConnectOptions {
@@ -81,6 +84,7 @@ class CircuitRelayTransport implements Transport {
   private readonly upgrader: Upgrader
   private readonly addressManager: AddressManager
   private readonly connectionGater: ConnectionGater
+  private readonly events: EventEmitter<Libp2pEvents>
   private readonly reservationStore: ReservationStore
   private started: boolean
 
@@ -92,6 +96,7 @@ class CircuitRelayTransport implements Transport {
     this.upgrader = components.upgrader
     this.addressManager = components.addressManager
     this.connectionGater = components.connectionGater
+    this.events = components.events
 
     if (init.discoverRelays != null && init.discoverRelays > 0) {
       this.discovery = new RelayDiscovery(components)
@@ -178,7 +183,9 @@ class CircuitRelayTransport implements Transport {
     let relayConnection = relayConnections[0]
 
     if (relayConnection == null) {
-      await this.peerStore.addressBook.add(relayPeer, [relayAddr])
+      await this.peerStore.merge(relayPeer, {
+        multiaddrs: [relayAddr]
+      })
       relayConnection = await this.connectionManager.openConnection(relayPeer, options)
       disconnectOnFailure = true
     }
@@ -249,7 +256,8 @@ class CircuitRelayTransport implements Transport {
   createListener (options: CreateListenerOptions): Listener {
     return createListener({
       connectionManager: this.connectionManager,
-      relayStore: this.reservationStore
+      relayStore: this.reservationStore,
+      events: this.events
     })
   }
 

package/src/circuit-relay/transport/listener.ts

@@ -1,4 +1,4 @@
-import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
+import { EventEmitter } from '@libp2p/interfaces/events'
 import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 import type { Listener, ListenerEvents } from '@libp2p/interface-transport'
 import type { Multiaddr } from '@multiformats/multiaddr'
@@ -7,24 +7,28 @@ import type { ReservationStore } from './reservation-store.js'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import { PeerMap } from '@libp2p/peer-collections'
 import { logger } from '@libp2p/logger'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
 
 const log = logger('libp2p:circuit-relay:transport:listener')
 
 export interface CircuitRelayTransportListenerComponents {
   connectionManager: ConnectionManager
   relayStore: ReservationStore
+  events: EventEmitter<Libp2pEvents>
 }
 
 class CircuitRelayTransportListener extends EventEmitter<ListenerEvents> implements Listener {
   private readonly connectionManager: ConnectionManager
   private readonly relayStore: ReservationStore
   private readonly listeningAddrs: PeerMap<Multiaddr>
+  private readonly events: EventEmitter<Libp2pEvents>
 
   constructor (components: CircuitRelayTransportListenerComponents) {
     super()
 
     this.connectionManager = components.connectionManager
     this.relayStore = components.relayStore
+    this.events = components.events
     this.listeningAddrs = new PeerMap()
 
     // remove listening addrs when a relay is removed
@@ -33,7 +37,7 @@ class CircuitRelayTransportListener extends EventEmitter<ListenerEvents> impleme
     })
 
     // remove listening addrs when a peer disconnects
-    this.connectionManager.addEventListener('peer:disconnect', (evt) => {
+    this.events.addEventListener('connection:close', (evt) => {
       this.#removeRelayPeer(evt.detail.remotePeer)
     })
   }
@@ -57,7 +61,7 @@ class CircuitRelayTransportListener extends EventEmitter<ListenerEvents> impleme
     }
 
     this.listeningAddrs.set(relayConn.remotePeer, addr)
-    this.dispatchEvent(new CustomEvent('listening'))
+    this.safeDispatchEvent('listening', {})
   }
 
   /**
@@ -89,7 +93,7 @@ class CircuitRelayTransportListener extends EventEmitter<ListenerEvents> impleme
 
     if (had) {
       // Announce listen addresses change
-      this.dispatchEvent(new CustomEvent('close'))
+      this.safeDispatchEvent('close', {})
     }
   }
 }

package/src/circuit-relay/transport/reservation-store.ts

@@ -10,10 +10,11 @@ import type { Reservation } from '../pb/index.js'
 import { HopMessage, Status } from '../pb/index.js'
 import { getExpirationMilliseconds } from '../utils.js'
 import type { TransportManager } from '@libp2p/interface-transport'
-import type { Startable } from '@libp2p/interfaces/dist/src/startable.js'
-import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
+import type { Startable } from '@libp2p/interfaces/startable'
+import { EventEmitter } from '@libp2p/interfaces/events'
 import type { PeerStore } from '@libp2p/interface-peer-store'
 import { multiaddr } from '@multiformats/multiaddr'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
 
 const log = logger('libp2p:circuit-relay:transport:reservation-store')
 
@@ -31,6 +32,7 @@ export interface RelayStoreComponents {
   connectionManager: ConnectionManager
   transportManager: TransportManager
   peerStore: PeerStore
+  events: EventEmitter<Libp2pEvents>
 }
 
 export interface RelayStoreInit {
@@ -68,6 +70,7 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
   private readonly connectionManager: ConnectionManager
   private readonly transportManager: TransportManager
   private readonly peerStore: PeerStore
+  private readonly events: EventEmitter<Libp2pEvents>
   private readonly reserveQueue: PQueue
   private readonly reservations: PeerMap<RelayEntry>
   private readonly maxDiscoveredRelays: number
@@ -80,6 +83,7 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
     this.connectionManager = components.connectionManager
     this.transportManager = components.transportManager
     this.peerStore = components.peerStore
+    this.events = components.events
     this.reservations = new PeerMap()
     this.maxDiscoveredRelays = init?.discoverRelays ?? 0
     this.started = false
@@ -92,7 +96,7 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
     // When a peer disconnects, if we had a reservation on that peer
     // remove the reservation and multiaddr and maybe trigger search
     // for new relays
-    this.connectionManager.addEventListener('peer:disconnect', (evt) => {
+    this.events.addEventListener('connection:close', (evt) => {
       this.removeRelay(evt.detail.remotePeer)
     })
   }
@@ -184,9 +188,13 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
         })
 
         // ensure we don't close the connection to the relay
-        await this.peerStore.tagPeer(peerId, RELAY_TAG, {
-          value: 1,
-          ttl: expiration
+        await this.peerStore.merge(peerId, {
+          tags: {
+            [RELAY_TAG]: {
+              value: 1,
+              ttl: expiration
+            }
+          }
         })
 
         await this.transportManager.listen(
@@ -250,7 +258,7 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
     this.safeDispatchEvent('relay:removed', { detail: peerId })
 
     if (this.reservations.size < this.maxDiscoveredRelays) {
-      this.dispatchEvent(new CustomEvent('relay:not-enough-relays'))
+      this.safeDispatchEvent('relay:not-enough-relays', {})
     }
   }
 }