libp2p 0.44.0-e3deaa40 → 0.44.0-ef7a5f67

package/src/peer-routing.ts

@@ -9,49 +9,17 @@ import {
 import merge from 'it-merge'
 import { pipe } from 'it-pipe'
 import first from 'it-first'
-import drain from 'it-drain'
 import filter from 'it-filter'
-import {
-  setDelayedInterval,
-  clearDelayedInterval
-// @ts-expect-error module with no types
-} from 'set-delayed-interval'
-import { setMaxListeners } from 'events'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { PeerRouting } from '@libp2p/interface-peer-routing'
 import type { AbortOptions } from '@libp2p/interfaces'
-import type { Startable } from '@libp2p/interfaces/startable'
 import type { PeerInfo } from '@libp2p/interface-peer-info'
 import type { PeerStore } from '@libp2p/interface-peer-store'
-import { anySignal } from 'any-signal'
 
 const log = logger('libp2p:peer-routing')
 
-export interface RefreshManagerInit {
-  /**
-   * Whether to enable the Refresh manager
-   */
-  enabled?: boolean
-
-  /**
-   * Boot delay to start the Refresh Manager (in ms)
-   */
-  bootDelay?: number
-
-  /**
-   * Interval between each Refresh Manager run (in ms)
-   */
-  interval?: number
-
-  /**
-   * How long to let each refresh run (in ms)
-   */
-  timeout?: number
-}
-
 export interface PeerRoutingInit {
   routers?: PeerRouting[]
-  refreshManager?: RefreshManagerInit
 }
 
 export interface DefaultPeerRoutingComponents {
@@ -59,83 +27,13 @@ export interface DefaultPeerRoutingComponents {
   peerStore: PeerStore
 }
 
-export class DefaultPeerRouting implements PeerRouting, Startable {
+export class DefaultPeerRouting implements PeerRouting {
   private readonly components: DefaultPeerRoutingComponents
   private readonly routers: PeerRouting[]
-  private readonly refreshManagerInit: RefreshManagerInit
-  private timeoutId?: ReturnType<typeof setTimeout>
-  private started: boolean
-  private abortController?: AbortController
 
   constructor (components: DefaultPeerRoutingComponents, init: PeerRoutingInit) {
     this.components = components
     this.routers = init.routers ?? []
-    this.refreshManagerInit = init.refreshManager ?? {}
-    this.started = false
-
-    this._findClosestPeersTask = this._findClosestPeersTask.bind(this)
-  }
-
-  isStarted (): boolean {
-    return this.started
-  }
-
-  /**
-   * Start peer routing service.
-   */
-  async start (): Promise<void> {
-    if (this.started || this.routers.length === 0 || this.timeoutId != null || this.refreshManagerInit.enabled === false) {
-      return
-    }
-
-    this.timeoutId = setDelayedInterval(
-      this._findClosestPeersTask, this.refreshManagerInit.interval, this.refreshManagerInit.bootDelay
-    )
-
-    this.started = true
-  }
-
-  /**
-   * Recurrent task to find closest peers and add their addresses to the Address Book.
-   */
-  async _findClosestPeersTask (): Promise<void> {
-    if (this.abortController != null) {
-      // we are already running the query
-      return
-    }
-
-    this.abortController = new AbortController()
-
-    const signal = anySignal([this.abortController.signal, AbortSignal.timeout(this.refreshManagerInit.timeout ?? 10e3)])
-
-    try {
-      // this controller may be used while dialing lots of peers so prevent MaxListenersExceededWarning
-      // appearing in the console
-      try {
-        setMaxListeners?.(Infinity, signal)
-      } catch {}
-
-      // nb getClosestPeers adds the addresses to the address book
-      await drain(this.getClosestPeers(this.components.peerId.toBytes(), { signal }))
-    } catch (err: any) {
-      log.error(err)
-    } finally {
-      this.abortController?.abort()
-      this.abortController = undefined
-      signal.clear()
-    }
-  }
-
-  /**
-   * Stop peer routing service.
-   */
-  async stop (): Promise<void> {
-    clearDelayedInterval(this.timeoutId)
-
-    // abort query if it is in-flight
-    this.abortController?.abort()
-
-    this.started = false
   }
 
   /**

package/src/transport-manager.ts

@@ -12,8 +12,6 @@ import { trackedMap } from '@libp2p/tracked-map'
 import type { Metrics } from '@libp2p/interface-metrics'
 import type { AddressManager } from '@libp2p/interface-address-manager'
 import type { Libp2pEvents } from '@libp2p/interface-libp2p'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { PeerId } from '@libp2p/interface-peer-id'
 
 const log = logger('libp2p:transports')
 
@@ -26,8 +24,6 @@ export interface DefaultTransportManagerComponents {
   addressManager: AddressManager
   upgrader: Upgrader
   events: EventEmitter<Libp2pEvents>
-  peerId: PeerId
-  peerStore: PeerStore
 }
 
 export class DefaultTransportManager implements TransportManager, Startable {
@@ -157,6 +153,13 @@ export class DefaultTransportManager implements TransportManager, Startable {
     return Array.of(...this.transports.values())
   }
 
+  /**
+   * Returns all the listener instances
+   */
+  getListeners (): Listener[] {
+    return Array.of(...this.listeners.values()).flat()
+  }
+
   /**
    * Finds a transport that matches the given Multiaddr
    */
@@ -192,7 +195,7 @@ export class DefaultTransportManager implements TransportManager, Startable {
           upgrader: this.components.upgrader
         })
 
-        let listeners = this.listeners.get(key)
+        let listeners: Listener[] = this.listeners.get(key) ?? []
 
         if (listeners == null) {
           listeners = []
@@ -203,30 +206,19 @@ export class DefaultTransportManager implements TransportManager, Startable {
 
         // Track listen/close events
         listener.addEventListener('listening', () => {
-          this.components.peerStore.patch(this.components.peerId, {
-            multiaddrs: this.getAddrs()
+          this.components.events.safeDispatchEvent('transport:listening', {
+            detail: listener
           })
-            .then(() => {
-              this.components.events.safeDispatchEvent('transport:listening', {
-                detail: listener
-              })
-            })
-            .catch(err => {
-              log.error('error while updating peer record after listener began listening', err)
-            })
         })
         listener.addEventListener('close', () => {
-          this.components.peerStore.patch(this.components.peerId, {
-            multiaddrs: this.getAddrs()
+          const index = listeners.findIndex(l => l === listener)
+
+          // remove the listener
+          listeners.splice(index, 1)
+
+          this.components.events.safeDispatchEvent('transport:close', {
+            detail: listener
           })
-            .then(() => {
-              this.components.events.safeDispatchEvent('transport:close', {
-                detail: listener
-              })
-            })
-            .catch(err => {
-              log.error('error while updating peer record after listener stopped listening', err)
-            })
         })
 
         // We need to attempt to listen on everything

package/src/upgrader.ts

@@ -73,7 +73,6 @@ function findIncomingStreamLimit (protocol: string, registrar: Registrar): numbe
 function findOutgoingStreamLimit (protocol: string, registrar: Registrar): number | undefined {
   try {
     const { options } = registrar.getHandler(protocol)
-
     return options.maxOutboundStreams
   } catch (err: any) {
     if (err.code !== codes.ERR_NO_HANDLER_FOR_PROTOCOL) {
@@ -392,9 +391,10 @@ export class DefaultUpgrader implements Upgrader {
               const streamCount = countStreams(protocol, 'inbound', connection)
 
               if (streamCount === incomingLimit) {
-                muxedStream.abort(new CodeError(`Too many inbound protocol streams for protocol "${protocol}" - limit ${incomingLimit}`, codes.ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS))
+                const err = new CodeError(`Too many inbound protocol streams for protocol "${protocol}" - limit ${incomingLimit}`, codes.ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS)
+                muxedStream.abort(err)
 
-                return
+                throw err
               }
 
               // after the handshake the returned stream can have early data so override

package/src/upnp-nat/index.ts

@@ -50,7 +50,7 @@ export interface UPnPNATInit {
   /**
    * Whether to automatically refresh UPnP port mappings when their TTL is reached
    */
-  keepAlive: boolean
+  keepAlive?: boolean
 
   /**
    * Pass a value to use instead of auto-detection
@@ -205,7 +205,7 @@ class UPnPNAT implements Startable {
   }
 }
 
-export function uPnPNAT (init: UPnPNATInit): (components: UPnPNATComponents) => {} {
+export function uPnPNATService (init: UPnPNATInit = {}): (components: UPnPNATComponents) => {} {
   return (components: UPnPNATComponents) => {
     return new UPnPNAT(components, init)
   }

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '0.44.0-e3deaa40'
+export const version = '0.44.0-ef7a5f67'
 export const name = 'libp2p'