libp2p 0.37.3-e6f646e → 0.38.0

package/src/metrics/index.ts

@@ -6,7 +6,6 @@ import { DefaultStats, StatsInit } from './stats.js'
 import type { ComponentMetricsUpdate, Metrics, Stats, TrackedMetric, TrackStreamOptions } from '@libp2p/interface-metrics'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Startable } from '@libp2p/interfaces/startable'
-import type { Duplex } from 'it-stream-types'
 
 const initialCounters: ['dataReceived', 'dataSent'] = [
   'dataReceived',
@@ -263,11 +262,11 @@ export class DefaultMetrics implements Metrics, Startable {
    * When the `PeerId` is known, `Metrics.updatePlaceholder` should be called
    * with the placeholder string returned from here, and the known `PeerId`.
    */
-  trackStream <T extends Duplex<Uint8Array>> (opts: TrackStreamOptions<T>): T {
+  trackStream (opts: TrackStreamOptions): void {
     const { stream, remotePeer, protocol } = opts
 
     if (!this.running) {
-      return stream
+      return
     }
 
     const source = stream.source
@@ -275,7 +274,7 @@ export class DefaultMetrics implements Metrics, Startable {
       remotePeer,
       protocol,
       direction: 'in',
-      dataLength: chunk.length
+      dataLength: chunk.byteLength
     }))
 
     const sink = stream.sink
@@ -287,14 +286,12 @@ export class DefaultMetrics implements Metrics, Startable {
             remotePeer,
             protocol,
             direction: 'out',
-            dataLength: chunk.length
+            dataLength: chunk.byteLength
           })
         }),
         sink
       )
     }
-
-    return stream
   }
 }
 

package/src/ping/index.ts

@@ -11,8 +11,10 @@ import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Startable } from '@libp2p/interfaces/startable'
 import type { Components } from '@libp2p/components'
 import type { AbortOptions } from '@libp2p/interfaces'
-import type { Duplex } from 'it-stream-types'
 import { abortableDuplex } from 'abortable-iterator'
+import { TimeoutController } from 'timeout-abort-controller'
+import type { Stream } from '@libp2p/interface-connection'
+import { setMaxListeners } from 'events'
 
 const log = logger('libp2p:ping')
 
@@ -20,6 +22,11 @@ export interface PingServiceInit {
   protocolPrefix: string
   maxInboundStreams: number
   maxOutboundStreams: number
+
+  /**
+   * How long we should wait for a ping response
+   */
+  timeout: number
 }
 
 export class PingService implements Startable {
@@ -73,19 +80,32 @@ export class PingService implements Startable {
   async ping (peer: PeerId, options: AbortOptions = {}): Promise<number> {
     log('dialing %s to %p', this.protocol, peer)
 
-    const connection = await this.components.getConnectionManager().openConnection(peer, options)
-    const stream = await connection.newStream([this.protocol], options)
     const start = Date.now()
     const data = randomBytes(PING_LENGTH)
-
-    let source: Duplex<Uint8Array> = stream
-
-    // make stream abortable if AbortSignal passed
-    if (options.signal != null) {
-      source = abortableDuplex(stream, options.signal)
+    const connection = await this.components.getConnectionManager().openConnection(peer, options)
+    let timeoutController
+    let signal = options.signal
+    let stream: Stream | undefined
+
+    // create a timeout if no abort signal passed
+    if (signal == null) {
+      timeoutController = new TimeoutController(this.init.timeout)
+      signal = timeoutController.signal
+
+      try {
+        // fails on node < 15.4
+        setMaxListeners?.(Infinity, timeoutController.signal)
+      } catch {}
     }
 
     try {
+      stream = await connection.newStream([this.protocol], {
+        signal
+      })
+
+      // make stream abortable
+      const source = abortableDuplex(stream, signal)
+
       const result = await pipe(
         [data],
         source,
@@ -93,13 +113,19 @@ export class PingService implements Startable {
       )
       const end = Date.now()
 
-      if (result == null || !uint8ArrayEquals(data, result)) {
+      if (result == null || !uint8ArrayEquals(data, result.subarray())) {
         throw errCode(new Error('Received wrong ping ack'), codes.ERR_WRONG_PING_ACK)
       }
 
       return end - start
     } finally {
-      stream.close()
+      if (timeoutController != null) {
+        timeoutController.clear()
+      }
+
+      if (stream != null) {
+        stream.close()
+      }
     }
   }
 }

package/src/pnet/index.ts

@@ -13,6 +13,7 @@ import {
 import { handshake } from 'it-handshake'
 import { NONCE_LENGTH } from './key-generator.js'
 import type { ConnectionProtector, MultiaddrConnection } from '@libp2p/interface-connection'
+import map from 'it-map'
 
 const log = logger('libp2p:pnet')
 
@@ -83,6 +84,7 @@ export class PreSharedKeyConnectionProtector implements ConnectionProtector {
       // Encrypt all outbound traffic
       createBoxStream(localNonce, this.psk),
       shake.stream,
+      (source) => map(source, (buf) => buf.subarray()),
       // Decrypt all inbound traffic
       createUnboxStream(remoteNonce, this.psk),
       external

package/src/registrar.ts

@@ -10,8 +10,8 @@ import type { Components } from '@libp2p/components'
 
 const log = logger('libp2p:registrar')
 
-export const DEFAULT_MAX_INBOUND_STREAMS = 1
-export const DEFAULT_MAX_OUTBOUND_STREAMS = 1
+export const DEFAULT_MAX_INBOUND_STREAMS = 32
+export const DEFAULT_MAX_OUTBOUND_STREAMS = 64
 
 /**
  * Responsible for notifying registered protocols of events in the network.

package/src/upgrader.ts

@@ -1,6 +1,6 @@
 import { logger } from '@libp2p/logger'
 import errCode from 'err-code'
-import { Dialer, Listener } from '@libp2p/multistream-select'
+import * as mss from '@libp2p/multistream-select'
 import { pipe } from 'it-pipe'
 // @ts-expect-error mutable-proxy does not export types
 import mutableProxy from 'mutable-proxy'
@@ -18,6 +18,9 @@ import { Components, isInitializable } from '@libp2p/components'
 import type { AbortOptions } from '@libp2p/interfaces'
 import type { Registrar } from '@libp2p/interface-registrar'
 import { DEFAULT_MAX_INBOUND_STREAMS, DEFAULT_MAX_OUTBOUND_STREAMS } from './registrar.js'
+import { TimeoutController } from 'timeout-abort-controller'
+import { abortableDuplex } from 'abortable-iterator'
+import { setMaxListeners } from 'events'
 
 const log = logger('libp2p:upgrader')
 
@@ -43,6 +46,12 @@ export interface CryptoResult extends SecuredConnection {
 export interface UpgraderInit {
   connectionEncryption: ConnectionEncrypter[]
   muxers: StreamMuxerFactory[]
+
+  /**
+   * An amount of ms by which an inbound connection upgrade
+   * must complete
+   */
+  inboundUpgradeTimeout: number
 }
 
 function findIncomingStreamLimit (protocol: string, registrar: Registrar) {
@@ -89,6 +98,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
   private readonly components: Components
   private readonly connectionEncryption: Map<string, ConnectionEncrypter>
   private readonly muxers: Map<string, StreamMuxerFactory>
+  private readonly inboundUpgradeTimeout: number
 
   constructor (components: Components, init: UpgraderInit) {
     super()
@@ -105,6 +115,8 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
     init.muxers.forEach(muxer => {
       this.muxers.set(muxer.protocol, muxer)
     })
+
+    this.inboundUpgradeTimeout = init.inboundUpgradeTimeout
   }
 
   /**
@@ -120,82 +132,97 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
     let proxyPeer
     const metrics = this.components.getMetrics()
 
-    if (await this.components.getConnectionGater().denyInboundConnection(maConn)) {
-      throw errCode(new Error('The multiaddr connection is blocked by gater.acceptConnection'), codes.ERR_CONNECTION_INTERCEPTED)
-    }
+    const timeoutController = new TimeoutController(this.inboundUpgradeTimeout)
 
-    if (metrics != null) {
-      ({ setTarget: setPeer, proxy: proxyPeer } = mutableProxy())
-      const idString = `${(Math.random() * 1e9).toString(36)}${Date.now()}`
-      setPeer({ toString: () => idString })
-      maConn = metrics.trackStream({ stream: maConn, remotePeer: proxyPeer })
-    }
+    try {
+      // fails on node < 15.4
+      setMaxListeners?.(Infinity, timeoutController.signal)
+    } catch {}
 
-    log('starting the inbound connection upgrade')
+    try {
+      const abortableStream = abortableDuplex(maConn, timeoutController.signal)
+      maConn.source = abortableStream.source
+      maConn.sink = abortableStream.sink
 
-    // Protect
-    let protectedConn = maConn
-    const protector = this.components.getConnectionProtector()
+      if (await this.components.getConnectionGater().denyInboundConnection(maConn)) {
+        throw errCode(new Error('The multiaddr connection is blocked by gater.acceptConnection'), codes.ERR_CONNECTION_INTERCEPTED)
+      }
 
-    if (protector != null) {
-      log('protecting the inbound connection')
-      protectedConn = await protector.protect(maConn)
-    }
+      if (metrics != null) {
+        ({ setTarget: setPeer, proxy: proxyPeer } = mutableProxy())
+        const idString = `${(Math.random() * 1e9).toString(36)}${Date.now()}`
+        setPeer({ toString: () => idString })
+        metrics.trackStream({ stream: maConn, remotePeer: proxyPeer })
+      }
 
-    try {
-      // Encrypt the connection
-      ({
-        conn: encryptedConn,
-        remotePeer,
-        protocol: cryptoProtocol
-      } = await this._encryptInbound(protectedConn))
+      log('starting the inbound connection upgrade')
+
+      // Protect
+      let protectedConn = maConn
+      const protector = this.components.getConnectionProtector()
 
-      if (await this.components.getConnectionGater().denyInboundEncryptedConnection(remotePeer, {
+      if (protector != null) {
+        log('protecting the inbound connection')
+        protectedConn = await protector.protect(maConn)
+      }
+
+      try {
+        // Encrypt the connection
+        ({
+          conn: encryptedConn,
+          remotePeer,
+          protocol: cryptoProtocol
+        } = await this._encryptInbound(protectedConn))
+
+        if (await this.components.getConnectionGater().denyInboundEncryptedConnection(remotePeer, {
+          ...protectedConn,
+          ...encryptedConn
+        })) {
+          throw errCode(new Error('The multiaddr connection is blocked by gater.acceptEncryptedConnection'), codes.ERR_CONNECTION_INTERCEPTED)
+        }
+
+        // Multiplex the connection
+        if (this.muxers.size > 0) {
+          const multiplexed = await this._multiplexInbound({
+            ...protectedConn,
+            ...encryptedConn
+          }, this.muxers)
+          muxerFactory = multiplexed.muxerFactory
+          upgradedConn = multiplexed.stream
+        } else {
+          upgradedConn = encryptedConn
+        }
+      } catch (err: any) {
+        log.error('Failed to upgrade inbound connection', err)
+        await maConn.close(err)
+        throw err
+      }
+
+      if (await this.components.getConnectionGater().denyInboundUpgradedConnection(remotePeer, {
         ...protectedConn,
         ...encryptedConn
       })) {
         throw errCode(new Error('The multiaddr connection is blocked by gater.acceptEncryptedConnection'), codes.ERR_CONNECTION_INTERCEPTED)
       }
 
-      // Multiplex the connection
-      if (this.muxers.size > 0) {
-        const multiplexed = await this._multiplexInbound({
-          ...protectedConn,
-          ...encryptedConn
-        }, this.muxers)
-        muxerFactory = multiplexed.muxerFactory
-        upgradedConn = multiplexed.stream
-      } else {
-        upgradedConn = encryptedConn
+      if (metrics != null) {
+        metrics.updatePlaceholder(proxyPeer, remotePeer)
+        setPeer(remotePeer)
       }
-    } catch (err: any) {
-      log.error('Failed to upgrade inbound connection', err)
-      await maConn.close(err)
-      throw err
-    }
 
-    if (await this.components.getConnectionGater().denyInboundUpgradedConnection(remotePeer, {
-      ...protectedConn,
-      ...encryptedConn
-    })) {
-      throw errCode(new Error('The multiaddr connection is blocked by gater.acceptEncryptedConnection'), codes.ERR_CONNECTION_INTERCEPTED)
-    }
+      log('Successfully upgraded inbound connection')
 
-    if (metrics != null) {
-      metrics.updatePlaceholder(proxyPeer, remotePeer)
-      setPeer(remotePeer)
+      return this._createConnection({
+        cryptoProtocol,
+        direction: 'inbound',
+        maConn,
+        upgradedConn,
+        muxerFactory,
+        remotePeer
+      })
+    } finally {
+      timeoutController.clear()
     }
-
-    log('Successfully upgraded inbound connection')
-
-    return this._createConnection({
-      cryptoProtocol,
-      direction: 'inbound',
-      maConn,
-      upgradedConn,
-      muxerFactory,
-      remotePeer
-    })
   }
 
   /**
@@ -226,7 +253,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
       ({ setTarget: setPeer, proxy: proxyPeer } = mutableProxy())
       const idString = `${(Math.random() * 1e9).toString(36)}${Date.now()}`
       setPeer({ toB58String: () => idString })
-      maConn = metrics.trackStream({ stream: maConn, remotePeer: proxyPeer })
+      metrics.trackStream({ stream: maConn, remotePeer: proxyPeer })
     }
 
     log('Starting the outbound connection upgrade')
@@ -315,6 +342,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
     if (muxerFactory != null) {
       // Create the muxer
       muxer = muxerFactory.createStreamMuxer({
+        direction,
         // Run anytime a remote stream is created
         onIncomingStream: muxedStream => {
           if (connection == null) {
@@ -323,9 +351,8 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
 
           void Promise.resolve()
             .then(async () => {
-              const mss = new Listener(muxedStream)
               const protocols = this.components.getRegistrar().getProtocols()
-              const { stream, protocol } = await mss.handle(protocols)
+              const { stream, protocol } = await mss.handle(muxedStream, protocols)
               log('%s: incoming stream opened on %s', direction, protocol)
 
               const metrics = this.components.getMetrics()
@@ -342,11 +369,17 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
               const streamCount = countStreams(protocol, 'inbound', connection)
 
               if (streamCount === incomingLimit) {
-                throw errCode(new Error('Too many incoming protocol streams'), codes.ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS)
+                muxedStream.abort(errCode(new Error(`Too many inbound protocol streams for protocol "${protocol}" - limit ${incomingLimit}`), codes.ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS))
+
+                return
               }
 
               muxedStream.stat.protocol = protocol
 
+              // If a protocol stream has been successfully negotiated and is to be passed to the application,
+              // the peerstore should ensure that the peer is registered with that protocol
+              this.components.getPeerStore().protoBook.add(remotePeer, [protocol]).catch(err => log.error(err))
+
               connection.addStream(muxedStream)
               this._onStream({ connection, stream: { ...muxedStream, ...stream }, protocol })
             })
@@ -375,25 +408,44 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
 
         log('%s: starting new stream on %s', direction, protocols)
         const muxedStream = muxer.newStream()
-        const mss = new Dialer(muxedStream)
         const metrics = this.components.getMetrics()
+        let controller: TimeoutController | undefined
 
         try {
-          let { stream, protocol } = await mss.select(protocols, options)
+          if (options.signal == null) {
+            log('No abort signal was passed while trying to negotiate protocols %s falling back to default timeout', protocols)
+
+            controller = new TimeoutController(30000)
+            options.signal = controller.signal
+
+            try {
+              // fails on node < 15.4
+              setMaxListeners?.(Infinity, controller.signal)
+            } catch {}
+          }
+
+          const { stream, protocol } = await mss.select(muxedStream, protocols, options)
 
           if (metrics != null) {
-            stream = metrics.trackStream({ stream, remotePeer, protocol })
+            metrics.trackStream({ stream, remotePeer, protocol })
           }
 
           const outgoingLimit = findOutgoingStreamLimit(protocol, this.components.getRegistrar())
           const streamCount = countStreams(protocol, 'outbound', connection)
 
           if (streamCount === outgoingLimit) {
-            throw errCode(new Error('Too many outgoing protocol streams'), codes.ERR_TOO_MANY_OUTBOUND_PROTOCOL_STREAMS)
+            const err = errCode(new Error(`Too many outbound protocol streams for protocol "${protocol}" - limit ${outgoingLimit}`), codes.ERR_TOO_MANY_OUTBOUND_PROTOCOL_STREAMS)
+            muxedStream.abort(err)
+
+            throw err
           }
 
           muxedStream.stat.protocol = protocol
 
+          // If a protocol stream has been successfully negotiated and is to be passed to the application,
+          // the peerstore should ensure that the peer is registered with that protocol
+          this.components.getPeerStore().protoBook.add(remotePeer, [protocol]).catch(err => log.error(err))
+
           return {
             ...muxedStream,
             ...stream,
@@ -414,6 +466,10 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
           }
 
           throw errCode(err, codes.ERR_UNSUPPORTED_PROTOCOL)
+        } finally {
+          if (controller != null) {
+            controller.clear()
+          }
         }
       }
 
@@ -469,7 +525,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
         await maConn.close()
         // Ensure remaining streams are closed
         if (muxer != null) {
-          muxer.streams.forEach(s => s.close())
+          muxer.close()
         }
       }
     })
@@ -495,12 +551,13 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
    * Attempts to encrypt the incoming `connection` with the provided `cryptos`
    */
   async _encryptInbound (connection: Duplex<Uint8Array>): Promise<CryptoResult> {
-    const mss = new Listener(connection)
     const protocols = Array.from(this.connectionEncryption.keys())
     log('handling inbound crypto protocol selection', protocols)
 
     try {
-      const { stream, protocol } = await mss.handle(protocols)
+      const { stream, protocol } = await mss.handle(connection, protocols, {
+        writeBytes: true
+      })
       const encrypter = this.connectionEncryption.get(protocol)
 
       if (encrypter == null) {
@@ -523,12 +580,13 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
    * The first `ConnectionEncrypter` module to succeed will be used
    */
   async _encryptOutbound (connection: MultiaddrConnection, remotePeerId: PeerId): Promise<CryptoResult> {
-    const mss = new Dialer(connection)
     const protocols = Array.from(this.connectionEncryption.keys())
     log('selecting outbound crypto protocol', protocols)
 
     try {
-      const { stream, protocol } = await mss.select(protocols)
+      const { stream, protocol } = await mss.select(connection, protocols, {
+        writeBytes: true
+      })
       const encrypter = this.connectionEncryption.get(protocol)
 
       if (encrypter == null) {
@@ -551,11 +609,12 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
    * muxer will be used for all future streams on the connection.
    */
   async _multiplexOutbound (connection: MultiaddrConnection, muxers: Map<string, StreamMuxerFactory>): Promise<{ stream: Duplex<Uint8Array>, muxerFactory?: StreamMuxerFactory}> {
-    const dialer = new Dialer(connection)
     const protocols = Array.from(muxers.keys())
     log('outbound selecting muxer %s', protocols)
     try {
-      const { stream, protocol } = await dialer.select(protocols)
+      const { stream, protocol } = await mss.select(connection, protocols, {
+        writeBytes: true
+      })
       log('%s selected as muxer protocol', protocol)
       const muxerFactory = muxers.get(protocol)
       return { stream, muxerFactory }
@@ -570,11 +629,12 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
    * selected muxer will be used for all future streams on the connection.
    */
   async _multiplexInbound (connection: MultiaddrConnection, muxers: Map<string, StreamMuxerFactory>): Promise<{ stream: Duplex<Uint8Array>, muxerFactory?: StreamMuxerFactory}> {
-    const listener = new Listener(connection)
     const protocols = Array.from(muxers.keys())
     log('inbound handling muxers %s', protocols)
     try {
-      const { stream, protocol } = await listener.handle(protocols)
+      const { stream, protocol } = await mss.handle(connection, protocols, {
+        writeBytes: true
+      })
       const muxerFactory = muxers.get(protocol)
       return { stream, muxerFactory }
     } catch (err: any) {

package/src/version.ts

@@ -1,3 +1,2 @@
-
-export const version = '0.0.0'
+export const version = '0.38.0'
 export const name = 'libp2p'