libp2p 0.39.5 → 0.40.0

package/src/identify/index.ts

@@ -2,7 +2,6 @@ import { logger } from '@libp2p/logger'
 import errCode from 'err-code'
 import * as lp from 'it-length-prefixed'
 import { pipe } from 'it-pipe'
-import drain from 'it-drain'
 import first from 'it-first'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { multiaddr, protocols } from '@multiformats/multiaddr'
@@ -18,15 +17,18 @@ import {
   MULTICODEC_IDENTIFY_PUSH_PROTOCOL_VERSION
 } from './consts.js'
 import { codes } from '../errors.js'
-import type { IncomingStreamData } from '@libp2p/interface-registrar'
+import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
 import type { Connection, Stream } from '@libp2p/interface-connection'
 import type { Startable } from '@libp2p/interfaces/startable'
 import { peerIdFromKeys } from '@libp2p/peer-id'
-import type { Components } from '@libp2p/components'
 import { TimeoutController } from 'timeout-abort-controller'
 import type { AbortOptions } from '@libp2p/interfaces'
 import { abortableDuplex } from 'abortable-iterator'
 import { setMaxListeners } from 'events'
+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:identify')
 
@@ -65,8 +67,16 @@ export interface IdentifyServiceInit {
   maxPushOutgoingStreams: number
 }
 
+export interface IdentifyServiceComponents {
+  peerId: PeerId
+  peerStore: PeerStore
+  connectionManager: ConnectionManager
+  registrar: Registrar
+  addressManager: AddressManager
+}
+
 export class IdentifyService implements Startable {
-  private readonly components: Components
+  private readonly components: IdentifyServiceComponents
   private readonly identifyProtocolStr: string
   private readonly identifyPushProtocolStr: string
   private readonly host: {
@@ -77,7 +87,7 @@ export class IdentifyService implements Startable {
   private readonly init: IdentifyServiceInit
   private started: boolean
 
-  constructor (components: Components, init: IdentifyServiceInit) {
+  constructor (components: IdentifyServiceComponents, init: IdentifyServiceInit) {
     this.components = components
     this.started = false
     this.init = init
@@ -92,25 +102,25 @@ export class IdentifyService implements Startable {
     }
 
     // When a new connection happens, trigger identify
-    this.components.getConnectionManager().addEventListener('peer:connect', (evt) => {
+    this.components.connectionManager.addEventListener('peer:connect', (evt) => {
       const connection = evt.detail
       this.identify(connection).catch(log.error)
     })
 
     // When self multiaddrs change, trigger identify-push
-    this.components.getPeerStore().addEventListener('change:multiaddrs', (evt) => {
+    this.components.peerStore.addEventListener('change:multiaddrs', (evt) => {
       const { peerId } = evt.detail
 
-      if (this.components.getPeerId().equals(peerId)) {
+      if (this.components.peerId.equals(peerId)) {
         void this.pushToPeerStore().catch(err => log.error(err))
       }
     })
 
     // When self protocols change, trigger identify-push
-    this.components.getPeerStore().addEventListener('change:protocols', (evt) => {
+    this.components.peerStore.addEventListener('change:protocols', (evt) => {
       const { peerId } = evt.detail
 
-      if (this.components.getPeerId().equals(peerId)) {
+      if (this.components.peerId.equals(peerId)) {
         void this.pushToPeerStore().catch(err => log.error(err))
       }
     })
@@ -125,10 +135,10 @@ export class IdentifyService implements Startable {
       return
     }
 
-    await this.components.getPeerStore().metadataBook.setValue(this.components.getPeerId(), 'AgentVersion', uint8ArrayFromString(this.host.agentVersion))
-    await this.components.getPeerStore().metadataBook.setValue(this.components.getPeerId(), 'ProtocolVersion', uint8ArrayFromString(this.host.protocolVersion))
+    await this.components.peerStore.metadataBook.setValue(this.components.peerId, 'AgentVersion', uint8ArrayFromString(this.host.agentVersion))
+    await this.components.peerStore.metadataBook.setValue(this.components.peerId, 'ProtocolVersion', uint8ArrayFromString(this.host.protocolVersion))
 
-    await this.components.getRegistrar().handle(this.identifyProtocolStr, (data) => {
+    await this.components.registrar.handle(this.identifyProtocolStr, (data) => {
       void this._handleIdentify(data).catch(err => {
         log.error(err)
       })
@@ -136,7 +146,7 @@ export class IdentifyService implements Startable {
       maxInboundStreams: this.init.maxInboundStreams,
       maxOutboundStreams: this.init.maxOutboundStreams
     })
-    await this.components.getRegistrar().handle(this.identifyPushProtocolStr, (data) => {
+    await this.components.registrar.handle(this.identifyPushProtocolStr, (data) => {
       void this._handlePush(data).catch(err => {
         log.error(err)
       })
@@ -149,8 +159,8 @@ export class IdentifyService implements Startable {
   }
 
   async stop () {
-    await this.components.getRegistrar().unhandle(this.identifyProtocolStr)
-    await this.components.getRegistrar().unhandle(this.identifyPushProtocolStr)
+    await this.components.registrar.unhandle(this.identifyProtocolStr)
+    await this.components.registrar.unhandle(this.identifyPushProtocolStr)
 
     this.started = false
   }
@@ -159,9 +169,9 @@ export class IdentifyService implements Startable {
    * Send an Identify Push update to the list of connections
    */
   async push (connections: Connection[]): Promise<void> {
-    const signedPeerRecord = await this.components.getPeerStore().addressBook.getRawEnvelope(this.components.getPeerId())
-    const listenAddrs = this.components.getAddressManager().getAddresses().map((ma) => ma.bytes)
-    const protocols = await this.components.getPeerStore().protoBook.get(this.components.getPeerId())
+    const signedPeerRecord = await this.components.peerStore.addressBook.getRawEnvelope(this.components.peerId)
+    const listenAddrs = this.components.addressManager.getAddresses().map((ma) => ma.bytes)
+    const protocols = await this.components.peerStore.protoBook.get(this.components.peerId)
 
     const pushes = connections.map(async connection => {
       let stream: Stream | undefined
@@ -180,16 +190,14 @@ export class IdentifyService implements Startable {
         // make stream abortable
         const source = abortableDuplex(stream, timeoutController.signal)
 
-        await pipe(
+        await source.sink(pipe(
           [Identify.encode({
             listenAddrs,
             signedPeerRecord,
             protocols
           })],
-          lp.encode(),
-          source,
-          drain
-        )
+          lp.encode()
+        ))
       } catch (err: any) {
         // Just log errors
         log.error('could not push identify update to peer', err)
@@ -216,9 +224,9 @@ export class IdentifyService implements Startable {
 
     const connections: Connection[] = []
 
-    for (const conn of this.components.getConnectionManager().getConnections()) {
+    for (const conn of this.components.connectionManager.getConnections()) {
       const peerId = conn.remotePeer
-      const peer = await this.components.getPeerStore().get(peerId)
+      const peer = await this.components.peerStore.get(peerId)
 
       if (!peer.protocols.includes(this.identifyPushProtocolStr)) {
         continue
@@ -311,7 +319,7 @@ export class IdentifyService implements Startable {
       throw errCode(new Error('identified peer does not match the expected peer'), codes.ERR_INVALID_PEER)
     }
 
-    if (this.components.getPeerId().equals(id)) {
+    if (this.components.peerId.equals(id)) {
       throw errCode(new Error('identified peer is our own peer id?'), codes.ERR_INVALID_PEER)
     }
 
@@ -328,15 +336,15 @@ export class IdentifyService implements Startable {
           throw errCode(new Error('identified peer does not match the expected peer'), codes.ERR_INVALID_PEER)
         }
 
-        if (await this.components.getPeerStore().addressBook.consumePeerRecord(envelope)) {
-          await this.components.getPeerStore().protoBook.set(id, protocols)
+        if (await this.components.peerStore.addressBook.consumePeerRecord(envelope)) {
+          await this.components.peerStore.protoBook.set(id, protocols)
 
           if (agentVersion != null) {
-            await this.components.getPeerStore().metadataBook.setValue(id, 'AgentVersion', uint8ArrayFromString(agentVersion))
+            await this.components.peerStore.metadataBook.setValue(id, 'AgentVersion', uint8ArrayFromString(agentVersion))
           }
 
           if (protocolVersion != null) {
-            await this.components.getPeerStore().metadataBook.setValue(id, 'ProtocolVersion', uint8ArrayFromString(protocolVersion))
+            await this.components.peerStore.metadataBook.setValue(id, 'ProtocolVersion', uint8ArrayFromString(protocolVersion))
           }
 
           log('identify completed for peer %p and protocols %o', id, protocols)
@@ -354,26 +362,26 @@ export class IdentifyService implements Startable {
 
     // LEGACY: Update peers data in PeerStore
     try {
-      await this.components.getPeerStore().addressBook.set(id, listenAddrs.map((addr) => multiaddr(addr)))
+      await this.components.peerStore.addressBook.set(id, listenAddrs.map((addr) => multiaddr(addr)))
     } catch (err: any) {
       log.error('received invalid addrs', err)
     }
 
-    await this.components.getPeerStore().protoBook.set(id, protocols)
+    await this.components.peerStore.protoBook.set(id, protocols)
 
     if (agentVersion != null) {
-      await this.components.getPeerStore().metadataBook.setValue(id, 'AgentVersion', uint8ArrayFromString(agentVersion))
+      await this.components.peerStore.metadataBook.setValue(id, 'AgentVersion', uint8ArrayFromString(agentVersion))
     }
 
     if (protocolVersion != null) {
-      await this.components.getPeerStore().metadataBook.setValue(id, 'ProtocolVersion', uint8ArrayFromString(protocolVersion))
+      await this.components.peerStore.metadataBook.setValue(id, 'ProtocolVersion', uint8ArrayFromString(protocolVersion))
     }
 
     log('identify completed for peer %p and protocols %o', id, protocols)
 
     // TODO: Add and score our observed addr
     log('received observed address of %s', cleanObservedAddr?.toString())
-    // this.components.getAddressManager().addObservedAddr(observedAddr)
+    // this.components.addressManager.addObservedAddr(observedAddr)
   }
 
   /**
@@ -390,19 +398,19 @@ export class IdentifyService implements Startable {
     } catch {}
 
     try {
-      const publicKey = this.components.getPeerId().publicKey ?? new Uint8Array(0)
-      const peerData = await this.components.getPeerStore().get(this.components.getPeerId())
-      const multiaddrs = this.components.getAddressManager().getAddresses().map(ma => ma.decapsulateCode(protocols('p2p').code))
+      const publicKey = this.components.peerId.publicKey ?? new Uint8Array(0)
+      const peerData = await this.components.peerStore.get(this.components.peerId)
+      const multiaddrs = this.components.addressManager.getAddresses().map(ma => ma.decapsulateCode(protocols('p2p').code))
       let signedPeerRecord = peerData.peerRecordEnvelope
 
       if (multiaddrs.length > 0 && signedPeerRecord == null) {
         const peerRecord = new PeerRecord({
-          peerId: this.components.getPeerId(),
+          peerId: this.components.peerId,
           multiaddrs
         })
 
-        const envelope = await RecordEnvelope.seal(peerRecord, this.components.getPeerId())
-        await this.components.getPeerStore().addressBook.consumePeerRecord(envelope)
+        const envelope = await RecordEnvelope.seal(peerRecord, this.components.peerId)
+        await this.components.peerStore.addressBook.consumePeerRecord(envelope)
         signedPeerRecord = envelope.marshal().subarray()
       }
 
@@ -419,12 +427,8 @@ export class IdentifyService implements Startable {
       // make stream abortable
       const source = abortableDuplex(stream, timeoutController.signal)
 
-      await pipe(
-        [message],
-        lp.encode(),
-        source,
-        drain
-      )
+      const msgWithLenPrefix = pipe([message], lp.encode())
+      await source.sink(msgWithLenPrefix)
     } catch (err: any) {
       log.error('could not respond to identify request', err)
     } finally {
@@ -475,7 +479,7 @@ export class IdentifyService implements Startable {
 
     const id = connection.remotePeer
 
-    if (this.components.getPeerId().equals(id)) {
+    if (this.components.peerId.equals(id)) {
       log('received push from ourselves?')
       return
     }
@@ -488,10 +492,10 @@ export class IdentifyService implements Startable {
       try {
         const envelope = await RecordEnvelope.openAndCertify(message.signedPeerRecord, PeerRecord.DOMAIN)
 
-        if (await this.components.getPeerStore().addressBook.consumePeerRecord(envelope)) {
+        if (await this.components.peerStore.addressBook.consumePeerRecord(envelope)) {
           log('consumed signedPeerRecord sent in push')
 
-          await this.components.getPeerStore().protoBook.set(id, message.protocols)
+          await this.components.peerStore.protoBook.set(id, message.protocols)
           return
         } else {
           log('failed to consume signedPeerRecord sent in push')
@@ -505,7 +509,7 @@ export class IdentifyService implements Startable {
 
     // LEGACY: Update peers data in PeerStore
     try {
-      await this.components.getPeerStore().addressBook.set(id,
+      await this.components.peerStore.addressBook.set(id,
         message.listenAddrs.map((addr) => multiaddr(addr)))
     } catch (err: any) {
       log.error('received invalid addrs', err)
@@ -513,7 +517,7 @@ export class IdentifyService implements Startable {
 
     // Update the protocols
     try {
-      await this.components.getPeerStore().protoBook.set(id, message.protocols)
+      await this.components.peerStore.protoBook.set(id, message.protocols)
     } catch (err: any) {
       log.error('received invalid protocols', err)
     }

package/src/identify/pb/message.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 { encodeMessage, decodeMessage, message } from 'protons-runtime'
 import type { Uint8ArrayList } from 'uint8arraylist'
@@ -20,59 +22,58 @@ export namespace Identify {
 
   export const codec = (): Codec<Identify> => {
     if (_codec == null) {
-      _codec = message<Identify>((obj, writer, opts = {}) => {
+      _codec = message<Identify>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.fork()
         }
 
         if (obj.protocolVersion != null) {
-          writer.uint32(42)
-          writer.string(obj.protocolVersion)
+          w.uint32(42)
+          w.string(obj.protocolVersion)
         }
 
         if (obj.agentVersion != null) {
-          writer.uint32(50)
-          writer.string(obj.agentVersion)
+          w.uint32(50)
+          w.string(obj.agentVersion)
         }
 
         if (obj.publicKey != null) {
-          writer.uint32(10)
-          writer.bytes(obj.publicKey)
+          w.uint32(10)
+          w.bytes(obj.publicKey)
         }
 
         if (obj.listenAddrs != null) {
           for (const value of obj.listenAddrs) {
-            writer.uint32(18)
-            writer.bytes(value)
+            w.uint32(18)
+            w.bytes(value)
           }
-        } else {
-          throw new Error('Protocol error: required field "listenAddrs" was not found in object')
         }
 
         if (obj.observedAddr != null) {
-          writer.uint32(34)
-          writer.bytes(obj.observedAddr)
+          w.uint32(34)
+          w.bytes(obj.observedAddr)
         }
 
         if (obj.protocols != null) {
           for (const value of obj.protocols) {
-            writer.uint32(26)
-            writer.string(value)
+            w.uint32(26)
+            w.string(value)
           }
-        } else {
-          throw new Error('Protocol error: required field "protocols" was not found in object')
         }
 
         if (obj.signedPeerRecord != null) {
-          writer.uint32(66)
-          writer.bytes(obj.signedPeerRecord)
+          w.uint32(66)
+          w.bytes(obj.signedPeerRecord)
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
-        const obj: any = {}
+        const obj: any = {
+          listenAddrs: [],
+          protocols: []
+        }
 
         const end = length == null ? reader.len : reader.pos + length
 
@@ -90,14 +91,12 @@ export namespace Identify {
               obj.publicKey = reader.bytes()
               break
             case 2:
-              obj.listenAddrs = obj.listenAddrs ?? []
               obj.listenAddrs.push(reader.bytes())
               break
             case 4:
               obj.observedAddr = reader.bytes()
               break
             case 3:
-              obj.protocols = obj.protocols ?? []
               obj.protocols.push(reader.string())
               break
             case 8:
@@ -109,17 +108,6 @@ export namespace Identify {
           }
         }
 
-        obj.listenAddrs = obj.listenAddrs ?? []
-        obj.protocols = obj.protocols ?? []
-
-        if (obj.listenAddrs == null) {
-          throw new Error('Protocol error: value for required field "listenAddrs" was not found in protobuf')
-        }
-
-        if (obj.protocols == null) {
-          throw new Error('Protocol error: value for required field "protocols" was not found in protobuf')
-        }
-
         return obj
       })
     }

package/src/index.ts

@@ -26,6 +26,7 @@ import type { KeyChain } from './keychain/index.js'
 import type { ConnectionManagerInit } from './connection-manager/index.js'
 import type { PingServiceInit } from './ping/index.js'
 import type { FetchServiceInit } from './fetch/index.js'
+import type { Components } from './components.js'
 
 export interface PersistentPeerStoreOptions {
   threshold?: number
@@ -113,15 +114,15 @@ export interface Libp2pInit {
   ping: PingServiceInit
   fetch: FetchServiceInit
 
-  transports: Transport[]
-  streamMuxers?: StreamMuxerFactory[]
-  connectionEncryption?: ConnectionEncrypter[]
-  peerDiscovery?: PeerDiscovery[]
-  peerRouters?: PeerRouting[]
-  contentRouters?: ContentRouting[]
-  dht?: DualDHT
-  pubsub?: PubSub
-  connectionProtector?: ConnectionProtector
+  transports: Array<(components: Components) => Transport>
+  streamMuxers?: Array<(components: Components) => StreamMuxerFactory>
+  connectionEncryption?: Array<(components: Components) => ConnectionEncrypter>
+  peerDiscovery?: Array<(components: Components) => PeerDiscovery>
+  peerRouters?: Array<(components: Components) => PeerRouting>
+  contentRouters?: Array<(components: Components) => ContentRouting>
+  dht?: (components: Components) => DualDHT
+  pubsub?: (components: Components) => PubSub
+  connectionProtector?: (components: Components) => ConnectionProtector
 }
 
 export interface Libp2pEvents {

package/src/insecure/index.ts

@@ -88,12 +88,11 @@ async function encrypt (localId: PeerId, conn: Duplex<Uint8Array>, remoteId?: Pe
       sink: shake.stream.sink,
       source: map(shake.stream.source, (buf) => buf.subarray())
     },
-    remotePeer: peerId,
-    remoteEarlyData: new Uint8Array()
+    remotePeer: peerId
   }
 }
 
-export class Plaintext implements ConnectionEncrypter {
+class Plaintext implements ConnectionEncrypter {
   public protocol: string = PROTOCOL
 
   async secureInbound (localId: PeerId, conn: Duplex<Uint8Array>, remoteId?: PeerId): Promise<SecuredConnection> {
@@ -104,3 +103,7 @@ export class Plaintext implements ConnectionEncrypter {
     return await encrypt(localId, conn, remoteId)
   }
 }
+
+export function plaintext (): () => ConnectionEncrypter {
+  return () => new Plaintext()
+}

package/src/insecure/pb/proto.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 { encodeMessage, decodeMessage, message, enumeration } from 'protons-runtime'
 import type { Uint8ArrayList } from 'uint8arraylist'
@@ -15,23 +17,25 @@ export namespace Exchange {
 
   export const codec = (): Codec<Exchange> => {
     if (_codec == null) {
-      _codec = message<Exchange>((obj, writer, opts = {}) => {
+      _codec = message<Exchange>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.fork()
         }
 
         if (obj.id != null) {
-          writer.uint32(10)
-          writer.bytes(obj.id)
+          w.uint32(10)
+          w.bytes(obj.id)
         }
 
         if (obj.pubkey != null) {
-          writer.uint32(18)
-          PublicKey.codec().encode(obj.pubkey, writer)
+          w.uint32(18)
+          PublicKey.codec().encode(obj.pubkey, w, {
+            writeDefaults: false
+          })
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
         const obj: any = {}
@@ -99,30 +103,29 @@ export namespace PublicKey {
 
   export const codec = (): Codec<PublicKey> => {
     if (_codec == null) {
-      _codec = message<PublicKey>((obj, writer, opts = {}) => {
+      _codec = message<PublicKey>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.fork()
         }
 
-        if (obj.Type != null) {
-          writer.uint32(8)
-          KeyType.codec().encode(obj.Type, writer)
-        } else {
-          throw new Error('Protocol error: required field "Type" was not found in object')
+        if (opts.writeDefaults === true || (obj.Type != null && __KeyTypeValues[obj.Type] !== 0)) {
+          w.uint32(8)
+          KeyType.codec().encode(obj.Type, w)
         }
 
-        if (obj.Data != null) {
-          writer.uint32(18)
-          writer.bytes(obj.Data)
-        } else {
-          throw new Error('Protocol error: required field "Data" was not found in object')
+        if (opts.writeDefaults === true || (obj.Data != null && obj.Data.byteLength > 0)) {
+          w.uint32(18)
+          w.bytes(obj.Data)
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
-        const obj: any = {}
+        const obj: any = {
+          Type: KeyType.RSA,
+          Data: new Uint8Array(0)
+        }
 
         const end = length == null ? reader.len : reader.pos + length
 
@@ -142,14 +145,6 @@ export namespace PublicKey {
           }
         }
 
-        if (obj.Type == null) {
-          throw new Error('Protocol error: value for required field "Type" was not found in protobuf')
-        }
-
-        if (obj.Data == null) {
-          throw new Error('Protocol error: value for required field "Data" was not found in protobuf')
-        }
-
         return obj
       })
     }