libp2p 0.44.0 → 0.45.0

package/dist/typedoc-urls.json

@@ -1,4 +1,7 @@
 {
+  "AutoNATComponents": "https://libp2p.github.io/js-libp2p/interfaces/autonat.AutoNATComponents.html",
+  "AutoNATServiceInit": "https://libp2p.github.io/js-libp2p/interfaces/autonat.AutoNATServiceInit.html",
+  "autoNATService": "https://libp2p.github.io/js-libp2p/functions/autonat.autoNATService.html",
   "codec": "https://libp2p.github.io/js-libp2p/functions/circuit_relay._internal_.Limit.codec.html",
   "decode": "https://libp2p.github.io/js-libp2p/functions/circuit_relay._internal_.Limit.decode.html",
   "encode": "https://libp2p.github.io/js-libp2p/functions/circuit_relay._internal_.Limit.encode.html",
@@ -17,25 +20,37 @@
   "RelayReservation": "https://libp2p.github.io/js-libp2p/interfaces/circuit_relay.RelayReservation.html",
   "circuitRelayServer": "https://libp2p.github.io/js-libp2p/functions/circuit_relay.circuitRelayServer.html",
   "circuitRelayTransport": "https://libp2p.github.io/js-libp2p/functions/circuit_relay.circuitRelayTransport.html",
+  "FetchService": "https://libp2p.github.io/js-libp2p/interfaces/fetch.FetchService.html",
+  "FetchServiceComponents": "https://libp2p.github.io/js-libp2p/interfaces/fetch.FetchServiceComponents.html",
+  "FetchServiceInit": "https://libp2p.github.io/js-libp2p/interfaces/fetch.FetchServiceInit.html",
+  "HandleMessageOptions": "https://libp2p.github.io/js-libp2p/interfaces/fetch.HandleMessageOptions.html",
+  "LookupFunction": "https://libp2p.github.io/js-libp2p/interfaces/fetch.LookupFunction.html",
+  "fetchService": "https://libp2p.github.io/js-libp2p/functions/fetch.fetchService-1.html",
+  "Identify": "https://libp2p.github.io/js-libp2p/interfaces/identify._internal_.Identify-1.html",
+  "IdentifyServiceComponents": "https://libp2p.github.io/js-libp2p/interfaces/identify.IdentifyServiceComponents.html",
+  "IdentifyServiceInit": "https://libp2p.github.io/js-libp2p/interfaces/identify.IdentifyServiceInit.html",
+  "Message": "https://libp2p.github.io/js-libp2p/variables/identify.Message.html",
+  "multicodecs": "https://libp2p.github.io/js-libp2p/variables/identify.multicodecs.html",
+  "identifyService": "https://libp2p.github.io/js-libp2p/functions/identify.identifyService.html",
   "AddressFilter": "https://libp2p.github.io/js-libp2p/interfaces/index._internal_.AddressFilter.html",
   "AddressManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/index._internal_.AddressManagerInit.html",
-  "AutonatServiceInit": "https://libp2p.github.io/js-libp2p/interfaces/index._internal_.AutonatServiceInit.html",
   "Components": "https://libp2p.github.io/js-libp2p/interfaces/index._internal_.Components.html",
   "ConnectionManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerInit.html",
-  "FetchServiceInit": "https://libp2p.github.io/js-libp2p/interfaces/index._internal_.FetchServiceInit.html",
-  "HostProperties": "https://libp2p.github.io/js-libp2p/interfaces/index._internal_.HostProperties.html",
-  "IdentifyServiceInit": "https://libp2p.github.io/js-libp2p/interfaces/index._internal_.IdentifyServiceInit.html",
-  "NatManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/index._internal_.NatManagerInit.html",
-  "PeerRoutingInit": "https://libp2p.github.io/js-libp2p/interfaces/index._internal_.PeerRoutingInit.html",
-  "PingServiceInit": "https://libp2p.github.io/js-libp2p/interfaces/index._internal_.PingServiceInit.html",
-  "RefreshManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/index._internal_.RefreshManagerInit.html",
   "TransportManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/index._internal_.TransportManagerInit.html",
-  "Libp2pEvents": "https://libp2p.github.io/js-libp2p/interfaces/index.Libp2pEvents.html",
   "Libp2pInit": "https://libp2p.github.io/js-libp2p/interfaces/index.Libp2pInit.html",
   "Libp2pOptions": "https://libp2p.github.io/js-libp2p/types/index.Libp2pOptions.html",
+  "ServiceFactoryMap": "https://libp2p.github.io/js-libp2p/types/index.ServiceFactoryMap.html",
   "createLibp2p": "https://libp2p.github.io/js-libp2p/functions/index.createLibp2p.html",
   "plaintext": "https://libp2p.github.io/js-libp2p/functions/insecure.plaintext.html",
+  "PingService": "https://libp2p.github.io/js-libp2p/interfaces/ping.PingService.html",
+  "PingServiceComponents": "https://libp2p.github.io/js-libp2p/interfaces/ping.PingServiceComponents.html",
+  "PingServiceInit": "https://libp2p.github.io/js-libp2p/interfaces/ping.PingServiceInit.html",
+  "pingService": "https://libp2p.github.io/js-libp2p/functions/ping.pingService-1.html",
   "ProtectorInit": "https://libp2p.github.io/js-libp2p/interfaces/pnet.ProtectorInit.html",
   "generateKey": "https://libp2p.github.io/js-libp2p/functions/pnet.generateKey.html",
-  "preSharedKey": "https://libp2p.github.io/js-libp2p/functions/pnet.preSharedKey.html"
+  "preSharedKey": "https://libp2p.github.io/js-libp2p/functions/pnet.preSharedKey.html",
+  "PMPOptions": "https://libp2p.github.io/js-libp2p/interfaces/upnp_nat.PMPOptions.html",
+  "UPnPNATComponents": "https://libp2p.github.io/js-libp2p/interfaces/upnp_nat.UPnPNATComponents.html",
+  "UPnPNATInit": "https://libp2p.github.io/js-libp2p/interfaces/upnp_nat.UPnPNATInit.html",
+  "uPnPNATService": "https://libp2p.github.io/js-libp2p/functions/upnp_nat.uPnPNATService.html"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2p",
-  "version": "0.44.0",
+  "version": "0.45.0",
   "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"
@@ -80,7 +100,7 @@
     "clean": "aegir clean",
     "lint": "aegir lint",
     "dep-check": "aegir dep-check -i protons",
-    "prepublishOnly": "node scripts/update-version.js",
+    "prepublishOnly": "node scripts/update-version.js && npm run build",
     "build": "aegir build",
     "docs": "aegir docs",
     "generate": "run-s generate:proto:*",
@@ -101,41 +121,40 @@
   "dependencies": {
     "@achingbrain/nat-port-mapper": "^1.0.3",
     "@libp2p/crypto": "^1.0.4",
-    "@libp2p/interface-address-manager": "^2.0.0",
-    "@libp2p/interface-connection": "^4.0.0",
-    "@libp2p/interface-connection-encrypter": "^3.0.1",
-    "@libp2p/interface-connection-gater": "^2.0.1",
-    "@libp2p/interface-connection-manager": "^2.1.0",
-    "@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.1.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",
+    "abortable-iterator": "^5.0.1",
     "any-signal": "^4.1.1",
     "datastore-core": "^9.0.0",
     "interface-datastore": "^8.0.0",
@@ -143,52 +162,48 @@
     "it-drain": "^3.0.1",
     "it-filter": "^3.0.1",
     "it-first": "^3.0.1",
-    "it-handshake": "^4.1.2",
-    "it-length-prefixed": "^9.0.0",
+    "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-parallel": "^3.0.0",
-    "it-pb-stream": "^3.2.0",
+    "it-pb-stream": "^4.0.1",
     "it-pipe": "^3.0.1",
-    "it-stream-types": "^1.0.4",
+    "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.8",
-    "@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.7",
-    "@libp2p/mdns": "^7.0.0",
-    "@libp2p/mplex": "^7.1.6",
-    "@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.1",
+    "@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.2.0",
+    "@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",
@@ -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,15 @@
-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'
+import type { EventEmitter } from '@libp2p/interfaces/dist/src/events'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
+import { debounce } from './utils.js'
+
+const log = logger('libp2p:address-manager')
 
 export interface AddressManagerInit {
   /**
@@ -32,6 +37,8 @@ export interface AddressManagerInit {
 export interface DefaultAddressManagerComponents {
   peerId: PeerId
   transportManager: TransportManager
+  peerStore: PeerStore
+  events: EventEmitter<Libp2pEvents>
 }
 
 /**
@@ -67,7 +74,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 +88,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
@@ -91,6 +96,43 @@ export class DefaultAddressManager extends EventEmitter<AddressManagerEvents> {
     this.announce = new Set(announce.map(ma => ma.toString()))
     this.observed = new Map()
     this.announceFilter = init.announceFilter ?? defaultAddressFilter
+
+    // this method gets called repeatedly on startup when transports start listening so
+    // debounce it so we don't cause multiple self:peer:update events to be emitted
+    this._updatePeerStoreAddresses = debounce(this._updatePeerStoreAddresses.bind(this), 1000)
+
+    // update our stored addresses when new transports listen
+    components.events.addEventListener('transport:listening', () => {
+      this._updatePeerStoreAddresses()
+    })
+    // update our stored addresses when existing transports stop listening
+    components.events.addEventListener('transport:close', () => {
+      this._updatePeerStoreAddresses()
+    })
+  }
+
+  _updatePeerStoreAddresses (): void {
+    // if announce addresses have been configured, ensure they make it into our peer
+    // record for things like identify
+    const addrs = this.getAnnounceAddrs()
+      .concat(this.components.transportManager.getAddrs())
+      .concat(
+        [...this.observed.entries()]
+          .filter(([_, metadata]) => metadata.confident)
+          .map(([str]) => multiaddr(str))
+      ).map(ma => {
+        // strip our peer id if it is present
+        if (ma.getPeerId() === this.components.peerId.toString()) {
+          return ma.decapsulate(`/p2p/${this.components.peerId.toString()}`)
+        }
+
+        return ma
+      })
+
+    this.components.peerStore.patch(this.components.peerId, {
+      multiaddrs: addrs
+    })
+      .catch(err => { log.error('error updating addresses', err) })
   }
 
   /**
@@ -145,9 +187,9 @@ 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._updatePeerStoreAddresses()
     }
   }
 

package/src/address-manager/utils.ts

@@ -0,0 +1,14 @@
+
+export function debounce (func: () => void, wait: number): () => void {
+  let timeout: ReturnType<typeof setTimeout> | undefined
+
+  return function () {
+    const later = function (): void {
+      timeout = undefined
+      func()
+    }
+
+    clearTimeout(timeout)
+    timeout = setTimeout(later, wait)
+  }
+}

package/src/autonat/constants.ts

@@ -1,4 +1,19 @@
+/**
+ * The prefix to use in the protocol
+ */
+export const PROTOCOL_PREFIX = 'libp2p'
 
-export const PROTOCOL = '/libp2p/autonat/1.0.0'
-export const PROTOCOL_VERSION = '1.0.0'
+/**
+ * The name to use in the protocol
+ */
 export const PROTOCOL_NAME = 'autonat'
+
+/**
+ * The version to use in the protocol
+ */
+export const PROTOCOL_VERSION = '1.0.0'
+export const TIMEOUT = 30000
+export const STARTUP_DELAY = 5000
+export const REFRESH_INTERVAL = 60000
+export const MAX_INBOUND_STREAMS = 1
+export const MAX_OUTBOUND_STREAMS = 1

package/src/autonat/index.ts

@@ -19,11 +19,13 @@ 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
+  MAX_INBOUND_STREAMS,
+  MAX_OUTBOUND_STREAMS,
+  PROTOCOL_NAME, PROTOCOL_PREFIX, PROTOCOL_VERSION, REFRESH_INTERVAL, STARTUP_DELAY, TIMEOUT
 } from './constants.js'
 import { Message } from './pb/index.js'
+import { anySignal } from 'any-signal'
 
 const log = logger('libp2p:autonat')
 
@@ -32,45 +34,39 @@ const log = logger('libp2p:autonat')
 // https://github.com/libp2p/specs/blob/master/autonat/README.md#autonat-protocol
 const REQUIRED_SUCCESSFUL_DIALS = 4
 
-// Wait this long before we start to query autonat nodes
-const AUTONAT_STARTUP_DELAY = 5000
-
-// Only try to verify our external address this often
-const AUTONAT_REFRESH_INTERVAL = 60000
-
-export interface AutonatServiceInit {
+export interface AutoNATServiceInit {
   /**
    * Allows overriding the protocol prefix used
    */
-  protocolPrefix: string
+  protocolPrefix?: string
 
   /**
    * How long we should wait for a remote peer to verify our external address
    */
-  timeout: number
+  timeout?: number
 
   /**
    * How long to wait after startup before trying to verify our external address
    */
-  startupDelay: number
+  startupDelay?: number
 
   /**
    * Verify our external addresses this often
    */
-  refreshInterval: number
+  refreshInterval?: number
 
   /**
-   * How many parallel inbound autonat streams we allow per-connection
+   * How many parallel inbound autoNAT streams we allow per-connection
    */
-  maxInboundStreams: number
+  maxInboundStreams?: number
 
   /**
-   * How many parallel outbound autonat streams we allow per-connection
+   * How many parallel outbound autoNAT streams we allow per-connection
    */
-  maxOutboundStreams: number
+  maxOutboundStreams?: number
 }
 
-export interface DefaultAutonatComponents {
+export interface AutoNATComponents {
   registrar: Registrar
   addressManager: AddressManager
   transportManager: TransportManager
@@ -79,21 +75,26 @@ export interface DefaultAutonatComponents {
   peerRouting: PeerRouting
 }
 
-export class AutonatService implements Startable {
-  private readonly components: DefaultAutonatComponents
-  private readonly _init: AutonatServiceInit
+class DefaultAutoNATService implements Startable {
+  private readonly components: AutoNATComponents
   private readonly startupDelay: number
   private readonly refreshInterval: number
+  private readonly protocol: string
+  private readonly timeout: number
+  private readonly maxInboundStreams: number
+  private readonly maxOutboundStreams: number
   private verifyAddressTimeout?: ReturnType<typeof setTimeout>
   private started: boolean
 
-  constructor (components: DefaultAutonatComponents, init: AutonatServiceInit) {
+  constructor (components: AutoNATComponents, init: AutoNATServiceInit) {
     this.components = components
     this.started = false
-    this._init = init
-    this.startupDelay = init.startupDelay ?? AUTONAT_STARTUP_DELAY
-    this.refreshInterval = init.refreshInterval ?? AUTONAT_REFRESH_INTERVAL
-
+    this.protocol = `/${init.protocolPrefix ?? PROTOCOL_PREFIX}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`
+    this.timeout = init.timeout ?? TIMEOUT
+    this.maxInboundStreams = init.maxInboundStreams ?? MAX_INBOUND_STREAMS
+    this.maxOutboundStreams = init.maxOutboundStreams ?? MAX_OUTBOUND_STREAMS
+    this.startupDelay = init.startupDelay ?? STARTUP_DELAY
+    this.refreshInterval = init.refreshInterval ?? REFRESH_INTERVAL
     this._verifyExternalAddresses = this._verifyExternalAddresses.bind(this)
   }
 
@@ -106,14 +107,14 @@ export class AutonatService implements Startable {
       return
     }
 
-    await this.components.registrar.handle(PROTOCOL, (data) => {
+    await this.components.registrar.handle(this.protocol, (data) => {
       void this.handleIncomingAutonatStream(data)
         .catch(err => {
           log.error(err)
         })
     }, {
-      maxInboundStreams: this._init.maxInboundStreams,
-      maxOutboundStreams: this._init.maxOutboundStreams
+      maxInboundStreams: this.maxInboundStreams,
+      maxOutboundStreams: this.maxOutboundStreams
     })
 
     this.verifyAddressTimeout = setTimeout(this._verifyExternalAddresses, this.startupDelay)
@@ -122,30 +123,30 @@ export class AutonatService implements Startable {
   }
 
   async stop (): Promise<void> {
-    await this.components.registrar.unhandle(PROTOCOL)
+    await this.components.registrar.unhandle(this.protocol)
     clearTimeout(this.verifyAddressTimeout)
 
     this.started = false
   }
 
   /**
-   * Handle an incoming autonat request
+   * Handle an incoming AutoNAT request
    */
   async handleIncomingAutonatStream (data: IncomingStreamData): Promise<void> {
-    const controller = new TimeoutController(this._init.timeout)
+    const signal = anySignal([AbortSignal.timeout(this.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(
@@ -319,7 +320,7 @@ export class AutonatService implements Startable {
 
             try {
               connection = await self.components.connectionManager.openConnection(multiaddr, {
-                signal: controller.signal
+                signal
               })
 
               if (!connection.remoteAddr.equals(multiaddr)) {
@@ -362,8 +363,10 @@ export class AutonatService implements Startable {
         // can't tell the remote when a dial timed out..
         data.stream
       )
+    } catch (err) {
+      log.error(err)
     } finally {
-      controller.clear()
+      signal.clear()
     }
   }
 
@@ -401,13 +404,13 @@ export class AutonatService implements Startable {
       return
     }
 
-    const controller = new TimeoutController(this._init.timeout)
+    const signal = AbortSignal.timeout(this.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
@@ -431,18 +434,18 @@ export class AutonatService implements Startable {
       const results: Record<string, { success: number, failure: number }> = {}
       const networkSegments: string[] = []
 
-      async function verifyAddress (peer: PeerInfo): Promise<Message.DialResponse | undefined> {
+      const verifyAddress = async (peer: PeerInfo): Promise<Message.DialResponse | undefined> => {
         try {
           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
+          const stream = await connection.newStream(this.protocol, {
+            signal
           })
-          const source = abortableDuplex(stream, controller.signal)
+          const source = abortableDuplex(stream, signal)
 
           const buf = await pipe(
             [request],
@@ -493,7 +496,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
       })) {
@@ -557,8 +560,13 @@ export class AutonatService implements Startable {
         }
       }
     } finally {
-      controller.clear()
       this.verifyAddressTimeout = setTimeout(this._verifyExternalAddresses, this.refreshInterval)
     }
   }
 }
+
+export function autoNATService (init: AutoNATServiceInit = {}): (components: AutoNATComponents) => {} {
+  return (components) => {
+    return new DefaultAutoNATService(components, init)
+  }
+}

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 })