libp2p 0.39.5 → 0.40.0

package/src/address-manager/index.ts

@@ -3,7 +3,8 @@ 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 { Components } from '@libp2p/components'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { TransportManager } from '@libp2p/interface-transport'
 
 export interface AddressManagerInit {
   announceFilter?: AddressFilter
@@ -24,6 +25,11 @@ export interface AddressManagerInit {
   noAnnounce?: string[]
 }
 
+export interface DefaultAddressManagerComponents {
+  peerId: PeerId
+  transportManager: TransportManager
+}
+
 export interface AddressFilter {
   (addrs: Multiaddr[]): Multiaddr[]
 }
@@ -31,7 +37,7 @@ export interface AddressFilter {
 const defaultAddressFilter = (addrs: Multiaddr[]): Multiaddr[] => addrs
 
 export class DefaultAddressManager extends EventEmitter<AddressManagerEvents> {
-  private readonly components: Components
+  private readonly components: DefaultAddressManagerComponents
   private readonly listen: Set<string>
   private readonly announce: Set<string>
   private readonly observed: Set<string>
@@ -43,7 +49,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: Components, init: AddressManagerInit) {
+  constructor (components: DefaultAddressManagerComponents, init: AddressManagerInit) {
     super()
 
     const { listen = [], announce = [] } = init
@@ -76,6 +82,23 @@ export class DefaultAddressManager extends EventEmitter<AddressManagerEvents> {
     return Array.from(this.observed).map((a) => multiaddr(a))
   }
 
+  /**
+   * Add peer observed addresses
+   * Signal that we have confidence an observed multiaddr is publicly dialable -
+   * this will make it appear in the output of getAddresses()
+   */
+  confirmObservedAddr (addr: Multiaddr): void {
+
+  }
+
+  /**
+   * Signal that we do not have confidence an observed multiaddr is publicly dialable -
+   * this will remove it from the output of getObservedAddrs()
+   */
+  removeObservedAddr (addr: Multiaddr): void {
+
+  }
+
   /**
    * Add peer observed addresses
    */
@@ -88,8 +111,8 @@ export class DefaultAddressManager extends EventEmitter<AddressManagerEvents> {
       const remotePeerId = peerIdFromString(remotePeer)
 
       // use same encoding for comparison
-      if (remotePeerId.equals(this.components.getPeerId())) {
-        ma = ma.decapsulate(multiaddr(`/p2p/${this.components.getPeerId().toString()}`))
+      if (remotePeerId.equals(this.components.peerId)) {
+        ma = ma.decapsulate(multiaddr(`/p2p/${this.components.peerId.toString()}`))
       }
     }
 
@@ -109,7 +132,7 @@ export class DefaultAddressManager extends EventEmitter<AddressManagerEvents> {
 
     if (addrs.length === 0) {
       // no configured announce addrs, add configured listen addresses
-      addrs = this.components.getTransportManager().getAddrs().map(ma => ma.toString())
+      addrs = this.components.transportManager.getAddrs().map(ma => ma.toString())
     }
 
     addrs = addrs.concat(this.getObservedAddrs().map(ma => ma.toString()))
@@ -121,11 +144,11 @@ export class DefaultAddressManager extends EventEmitter<AddressManagerEvents> {
     return this.announceFilter(Array.from(addrSet)
       .map(str => multiaddr(str)))
       .map(ma => {
-        if (ma.getPeerId() === this.components.getPeerId().toString()) {
+        if (ma.getPeerId() === this.components.peerId.toString()) {
           return ma
         }
 
-        return ma.encapsulate(`/p2p/${this.components.getPeerId().toString()}`)
+        return ma.encapsulate(`/p2p/${this.components.peerId.toString()}`)
       })
   }
 }

package/src/circuit/auto-relay.ts

@@ -13,11 +13,11 @@ import {
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { AddressSorter, PeerProtocolsChangeData } from '@libp2p/interface-peer-store'
 import type { Connection } from '@libp2p/interface-connection'
-import type { Components } from '@libp2p/components'
 import sort from 'it-sort'
 import all from 'it-all'
 import { pipe } from 'it-pipe'
 import { publicAddressesFirst } from '@libp2p/utils/address-sort'
+import type { RelayComponents } from './index.js'
 
 const log = logger('libp2p:auto-relay')
 
@@ -30,13 +30,13 @@ export interface AutoRelayInit {
 }
 
 export class AutoRelay {
-  private readonly components: Components
+  private readonly components: RelayComponents
   private readonly addressSorter: AddressSorter
   private readonly maxListeners: number
   private readonly listenRelays: Set<string>
   private readonly onError: (error: Error, msg?: string) => void
 
-  constructor (components: Components, init: AutoRelayInit) {
+  constructor (components: RelayComponents, init: AutoRelayInit) {
     this.components = components
     this.addressSorter = init.addressSorter ?? publicAddressesFirst
     this.maxListeners = init.maxListeners ?? 1
@@ -46,12 +46,12 @@ export class AutoRelay {
     this._onProtocolChange = this._onProtocolChange.bind(this)
     this._onPeerDisconnected = this._onPeerDisconnected.bind(this)
 
-    this.components.getPeerStore().addEventListener('change:protocols', (evt) => {
+    this.components.peerStore.addEventListener('change:protocols', (evt) => {
       void this._onProtocolChange(evt).catch(err => {
         log.error(err)
       })
     })
-    this.components.getConnectionManager().addEventListener('peer:disconnect', this._onPeerDisconnected)
+    this.components.connectionManager.addEventListener('peer:disconnect', this._onPeerDisconnected)
   }
 
   /**
@@ -85,7 +85,7 @@ export class AutoRelay {
 
     // If protocol, check if can hop, store info in the metadataBook and listen on it
     try {
-      const connections = this.components.getConnectionManager().getConnections(peerId)
+      const connections = this.components.connectionManager.getConnections(peerId)
 
       if (connections.length === 0) {
         return
@@ -102,7 +102,7 @@ export class AutoRelay {
       const supportsHop = await canHop({ connection })
 
       if (supportsHop) {
-        await this.components.getPeerStore().metadataBook.setValue(peerId, HOP_METADATA_KEY, uint8ArrayFromString(HOP_METADATA_VALUE))
+        await this.components.peerStore.metadataBook.setValue(peerId, HOP_METADATA_KEY, uint8ArrayFromString(HOP_METADATA_VALUE))
         await this._addListenRelay(connection, id)
       }
     } catch (err: any) {
@@ -140,7 +140,7 @@ export class AutoRelay {
 
       // Get peer known addresses and sort them with public addresses first
       const remoteAddrs = await pipe(
-        await this.components.getPeerStore().addressBook.get(connection.remotePeer),
+        await this.components.peerStore.addressBook.get(connection.remotePeer),
         (source) => sort(source, this.addressSorter),
         async (source) => await all(source)
       )
@@ -158,7 +158,7 @@ export class AutoRelay {
             multiaddr = multiaddr.encapsulate('/p2p-circuit')
 
             // Announce multiaddrs will update on listen success by TransportManager event being triggered
-            await this.components.getTransportManager().listen([multiaddr])
+            await this.components.transportManager.listen([multiaddr])
             return true
           } catch (err: any) {
             log.error('error listening on circuit address', err)
@@ -203,7 +203,7 @@ export class AutoRelay {
     }
 
     const knownHopsToDial = []
-    const peers = await this.components.getPeerStore().all()
+    const peers = await this.components.peerStore.all()
 
     // Check if we have known hop peers to use and attempt to listen on the already connected
     for (const { id, metadata } of peers) {
@@ -225,7 +225,7 @@ export class AutoRelay {
         continue
       }
 
-      const connections = this.components.getConnectionManager().getConnections(id)
+      const connections = this.components.connectionManager.getConnections(id)
 
       // If not connected, store for possible later use.
       if (connections.length === 0) {
@@ -254,19 +254,19 @@ export class AutoRelay {
     // Try to find relays to hop on the network
     try {
       const cid = await namespaceToCid(RELAY_RENDEZVOUS_NS)
-      for await (const provider of this.components.getContentRouting().findProviders(cid)) {
+      for await (const provider of this.components.contentRouting.findProviders(cid)) {
         if (provider.multiaddrs.length === 0) {
           continue
         }
 
         const peerId = provider.id
 
-        if (peerId.equals(this.components.getPeerId())) {
+        if (peerId.equals(this.components.peerId)) {
           // Skip the provider if it's us as dialing will fail
           continue
         }
 
-        await this.components.getPeerStore().addressBook.add(peerId, provider.multiaddrs)
+        await this.components.peerStore.addressBook.add(peerId, provider.multiaddrs)
 
         await this._tryToListenOnRelay(peerId)
 
@@ -282,7 +282,7 @@ export class AutoRelay {
 
   async _tryToListenOnRelay (peerId: PeerId) {
     try {
-      const connection = await this.components.getConnectionManager().openConnection(peerId)
+      const connection = await this.components.connectionManager.openConnection(peerId)
       await this._addListenRelay(connection, peerId.toString())
     } catch (err: any) {
       log.error('Could not use %p as relay', peerId, err)

package/src/circuit/index.ts

@@ -10,10 +10,13 @@ import { namespaceToCid } from './utils.js'
 import {
   RELAY_RENDEZVOUS_NS
 } from './constants.js'
-import type { AddressSorter } from '@libp2p/interface-peer-store'
+import type { AddressSorter, PeerStore } from '@libp2p/interface-peer-store'
 import type { Startable } from '@libp2p/interfaces/startable'
-import type { Components } from '@libp2p/components'
 import type { RelayConfig } from '../index.js'
+import type { ContentRouting } from '@libp2p/interface-content-routing'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
+import type { TransportManager } from '@libp2p/interface-transport'
+import type { PeerId } from '@libp2p/interface-peer-id'
 
 const log = logger('libp2p:relay')
 
@@ -36,8 +39,16 @@ export interface RelayInit extends RelayConfig {
   addressSorter?: AddressSorter
 }
 
+export interface RelayComponents {
+  peerId: PeerId
+  contentRouting: ContentRouting
+  peerStore: PeerStore
+  connectionManager: ConnectionManager
+  transportManager: TransportManager
+}
+
 export class Relay implements Startable {
-  private readonly components: Components
+  private readonly components: RelayComponents
   private readonly init: RelayInit
   // @ts-expect-error this field isn't used anywhere?
   private readonly autoRelay?: AutoRelay
@@ -47,7 +58,7 @@ export class Relay implements Startable {
   /**
    * Creates an instance of Relay
    */
-  constructor (components: Components, init: RelayInit) {
+  constructor (components: RelayComponents, init: RelayInit) {
     this.components = components
     // Create autoRelay if enabled
     this.autoRelay = init.autoRelay?.enabled !== false
@@ -97,7 +108,7 @@ export class Relay implements Startable {
   async _advertiseService () {
     try {
       const cid = await namespaceToCid(RELAY_RENDEZVOUS_NS)
-      await this.components.getContentRouting().provide(cid)
+      await this.components.contentRouting.provide(cid)
     } catch (err: any) {
       if (err.code === codes.ERR_NO_ROUTERS_AVAILABLE) {
         log.error('a content router, such as a DHT, must be provided in order to advertise the relay service', err)

package/src/circuit/pb/index.ts

@@ -1,5 +1,7 @@
 /* eslint-disable import/export */
+/* eslint-disable complexity */
 /* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 
 import { enumeration, encodeMessage, decodeMessage, message } from 'protons-runtime'
 import type { Uint8ArrayList } from 'uint8arraylist'
@@ -87,32 +89,31 @@ export namespace CircuitRelay {
 
     export const codec = (): Codec<Peer> => {
       if (_codec == null) {
-        _codec = message<Peer>((obj, writer, opts = {}) => {
+        _codec = message<Peer>((obj, w, opts = {}) => {
           if (opts.lengthDelimited !== false) {
-            writer.fork()
+            w.fork()
           }
 
-          if (obj.id != null) {
-            writer.uint32(10)
-            writer.bytes(obj.id)
-          } else {
-            throw new Error('Protocol error: required field "id" was not found in object')
+          if (opts.writeDefaults === true || (obj.id != null && obj.id.byteLength > 0)) {
+            w.uint32(10)
+            w.bytes(obj.id)
           }
 
           if (obj.addrs != null) {
             for (const value of obj.addrs) {
-              writer.uint32(18)
-              writer.bytes(value)
+              w.uint32(18)
+              w.bytes(value)
             }
-          } else {
-            throw new Error('Protocol error: required field "addrs" was not found in object')
           }
 
           if (opts.lengthDelimited !== false) {
-            writer.ldelim()
+            w.ldelim()
           }
         }, (reader, length) => {
-          const obj: any = {}
+          const obj: any = {
+            id: new Uint8Array(0),
+            addrs: []
+          }
 
           const end = length == null ? reader.len : reader.pos + length
 
@@ -124,7 +125,6 @@ export namespace CircuitRelay {
                 obj.id = reader.bytes()
                 break
               case 2:
-                obj.addrs = obj.addrs ?? []
                 obj.addrs.push(reader.bytes())
                 break
               default:
@@ -133,16 +133,6 @@ export namespace CircuitRelay {
             }
           }
 
-          obj.addrs = obj.addrs ?? []
-
-          if (obj.id == null) {
-            throw new Error('Protocol error: value for required field "id" was not found in protobuf')
-          }
-
-          if (obj.addrs == null) {
-            throw new Error('Protocol error: value for required field "addrs" was not found in protobuf')
-          }
-
           return obj
         })
       }
@@ -163,33 +153,37 @@ export namespace CircuitRelay {
 
   export const codec = (): Codec<CircuitRelay> => {
     if (_codec == null) {
-      _codec = message<CircuitRelay>((obj, writer, opts = {}) => {
+      _codec = message<CircuitRelay>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.fork()
         }
 
         if (obj.type != null) {
-          writer.uint32(8)
-          CircuitRelay.Type.codec().encode(obj.type, writer)
+          w.uint32(8)
+          CircuitRelay.Type.codec().encode(obj.type, w)
         }
 
         if (obj.srcPeer != null) {
-          writer.uint32(18)
-          CircuitRelay.Peer.codec().encode(obj.srcPeer, writer)
+          w.uint32(18)
+          CircuitRelay.Peer.codec().encode(obj.srcPeer, w, {
+            writeDefaults: false
+          })
         }
 
         if (obj.dstPeer != null) {
-          writer.uint32(26)
-          CircuitRelay.Peer.codec().encode(obj.dstPeer, writer)
+          w.uint32(26)
+          CircuitRelay.Peer.codec().encode(obj.dstPeer, w, {
+            writeDefaults: false
+          })
         }
 
         if (obj.code != null) {
-          writer.uint32(32)
-          CircuitRelay.Status.codec().encode(obj.code, writer)
+          w.uint32(32)
+          CircuitRelay.Status.codec().encode(obj.code, w)
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
         const obj: any = {}

package/src/circuit/transport.ts

@@ -11,11 +11,10 @@ import { createListener } from './listener.js'
 import { handleCanHop, handleHop, hop } from './circuit/hop.js'
 import { handleStop } from './circuit/stop.js'
 import { StreamHandler } from './circuit/stream-handler.js'
-import { symbol } from '@libp2p/interface-transport'
+import { symbol, Upgrader } from '@libp2p/interface-transport'
 import { peerIdFromString } from '@libp2p/peer-id'
-import { Components, Initializable } from '@libp2p/components'
 import type { AbortOptions } from '@libp2p/interfaces'
-import type { IncomingStreamData } from '@libp2p/interface-registrar'
+import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
 import type { Listener, Transport, CreateListenerOptions, ConnectionHandler } from '@libp2p/interface-transport'
 import type { Connection } from '@libp2p/interface-connection'
 import type { RelayConfig } from '../index.js'
@@ -24,21 +23,47 @@ import { TimeoutController } from 'timeout-abort-controller'
 import { setMaxListeners } from 'events'
 import type { Uint8ArrayList } from 'uint8arraylist'
 import type { Duplex } from 'it-stream-types'
+import type { Startable } from '@libp2p/interfaces/startable'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { PeerStore } from '@libp2p/interface-peer-store'
+import type { AddressManager } from '@libp2p/interface-address-manager'
 
 const log = logger('libp2p:circuit')
 
-export class Circuit implements Transport, Initializable {
+export interface CircuitComponents {
+  peerId: PeerId
+  peerStore: PeerStore
+  registrar: Registrar
+  connectionManager: ConnectionManager
+  upgrader: Upgrader
+  addressManager: AddressManager
+}
+
+export class Circuit implements Transport, Startable {
   private handler?: ConnectionHandler
-  private components: Components = new Components()
+  private readonly components: CircuitComponents
   private readonly _init: RelayConfig
+  private _started: boolean
 
-  constructor (init: RelayConfig) {
+  constructor (components: CircuitComponents, init: RelayConfig) {
     this._init = init
+    this.components = components
+    this._started = false
   }
 
-  init (components: Components): void {
-    this.components = components
-    void this.components.getRegistrar().handle(RELAY_CODEC, (data) => {
+  isStarted () {
+    return this._started
+  }
+
+  async start (): Promise<void> {
+    if (this._started) {
+      return
+    }
+
+    this._started = true
+
+    await this.components.registrar.handle(RELAY_CODEC, (data) => {
       void this._onProtocol(data).catch(err => {
         log.error(err)
       })
@@ -48,6 +73,10 @@ export class Circuit implements Transport, Initializable {
       })
   }
 
+  async stop () {
+    await this.components.registrar.unhandle(RELAY_CODEC)
+  }
+
   hopEnabled () {
     return true
   }
@@ -108,7 +137,7 @@ export class Circuit implements Transport, Initializable {
             request,
             streamHandler,
             circuit: this,
-            connectionManager: this.components.getConnectionManager()
+            connectionManager: this.components.connectionManager
           })
           break
         }
@@ -145,7 +174,7 @@ export class Circuit implements Transport, Initializable {
         const type = request.type === CircuitPB.Type.HOP ? 'relay' : 'inbound'
         log('new %s connection %s', type, maConn.remoteAddr)
 
-        const conn = await this.components.getUpgrader().upgradeInbound(maConn)
+        const conn = await this.components.upgrader.upgradeInbound(maConn)
         log('%s connection %s upgraded', type, maConn.remoteAddr)
 
         if (this.handler != null) {
@@ -178,12 +207,12 @@ export class Circuit implements Transport, Initializable {
     const destinationPeer = peerIdFromString(destinationId)
 
     let disconnectOnFailure = false
-    const relayConnections = this.components.getConnectionManager().getConnections(relayPeer)
+    const relayConnections = this.components.connectionManager.getConnections(relayPeer)
     let relayConnection = relayConnections[0]
 
     if (relayConnection == null) {
-      await this.components.getPeerStore().addressBook.add(relayPeer, [relayAddr])
-      relayConnection = await this.components.getConnectionManager().openConnection(relayPeer, options)
+      await this.components.peerStore.addressBook.add(relayPeer, [relayAddr])
+      relayConnection = await this.components.connectionManager.openConnection(relayPeer, options)
       disconnectOnFailure = true
     }
 
@@ -194,8 +223,8 @@ export class Circuit implements Transport, Initializable {
         request: {
           type: CircuitPB.Type.HOP,
           srcPeer: {
-            id: this.components.getPeerId().toBytes(),
-            addrs: this.components.getAddressManager().getAddresses().map(addr => addr.bytes)
+            id: this.components.peerId.toBytes(),
+            addrs: this.components.addressManager.getAddresses().map(addr => addr.bytes)
           },
           dstPeer: {
             id: destinationPeer.toBytes(),
@@ -204,7 +233,7 @@ export class Circuit implements Transport, Initializable {
         }
       })
 
-      const localAddr = relayAddr.encapsulate(`/p2p-circuit/p2p/${this.components.getPeerId().toString()}`)
+      const localAddr = relayAddr.encapsulate(`/p2p-circuit/p2p/${this.components.peerId.toString()}`)
       const maConn = streamToMaConnection({
         stream: virtualConnection,
         remoteAddr: ma,
@@ -212,7 +241,7 @@ export class Circuit implements Transport, Initializable {
       })
       log('new outbound connection %s', maConn.remoteAddr)
 
-      return await this.components.getUpgrader().upgradeOutbound(maConn)
+      return await this.components.upgrader.upgradeOutbound(maConn)
     } catch (err: any) {
       log.error('Circuit relay dial failed', err)
       disconnectOnFailure && await relayConnection.close()
@@ -228,8 +257,8 @@ export class Circuit implements Transport, Initializable {
     this.handler = options.handler
 
     return createListener({
-      connectionManager: this.components.getConnectionManager(),
-      peerStore: this.components.getPeerStore()
+      connectionManager: this.components.connectionManager,
+      peerStore: this.components.peerStore
     })
   }