libp2p 0.37.0 → 0.37.2

package/src/identify/index.ts

@@ -2,8 +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 all from 'it-all'
-import take from 'it-take'
 import drain from 'it-drain'
 import first from 'it-first'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
@@ -21,20 +19,47 @@ import {
 } from './consts.js'
 import { codes } from '../errors.js'
 import type { IncomingStreamData } from '@libp2p/interfaces/registrar'
-import type { Connection } from '@libp2p/interfaces/connection'
+import type { Connection, Stream } from '@libp2p/interfaces/connection'
 import type { Startable } from '@libp2p/interfaces/startable'
 import { peerIdFromKeys } from '@libp2p/peer-id'
 import type { Components } from '@libp2p/interfaces/components'
+import { TimeoutController } from 'timeout-abort-controller'
+import type { AbortOptions } from '@libp2p/interfaces'
+import { abortableDuplex } from 'abortable-iterator'
+import type { Duplex } from 'it-stream-types'
 
 const log = logger('libp2p:identify')
 
+// https://github.com/libp2p/go-libp2p/blob/8d2e54e1637041d5cf4fac1e531287560bd1f4ac/p2p/protocol/identify/id.go#L48
+const IDENTIFY_TIMEOUT = 60000
+
+// https://github.com/libp2p/go-libp2p/blob/8d2e54e1637041d5cf4fac1e531287560bd1f4ac/p2p/protocol/identify/id.go#L52
+const MAX_IDENTIFY_MESSAGE_SIZE = 1024 * 8
+
 export interface HostProperties {
   agentVersion: string
 }
 
 export interface IdentifyServiceInit {
+  /**
+   * The prefix to use for the protocol (default: 'ipfs')
+   */
   protocolPrefix: string
+
+  /**
+   * What details we should send as part of an identify message
+   */
   host: HostProperties
+
+  /**
+   * How long we should wait for a remote peer to send their identify response
+   */
+  timeout?: number
+
+  /**
+   * Identify responses larger than this in bytes will be rejected (default: 8192)
+   */
+  maxIdentifyMessageSize?: number
 }
 
 export class IdentifyService implements Startable {
@@ -46,11 +71,13 @@ export class IdentifyService implements Startable {
     agentVersion: string
   }
 
+  private readonly init: IdentifyServiceInit
   private started: boolean
 
   constructor (components: Components, init: IdentifyServiceInit) {
     this.components = components
     this.started = false
+    this.init = init
 
     this.handleMessage = this.handleMessage.bind(this)
 
@@ -128,8 +155,17 @@ export class IdentifyService implements Startable {
     const protocols = await this.components.getPeerStore().protoBook.get(this.components.getPeerId())
 
     const pushes = connections.map(async connection => {
+      const timeoutController = new TimeoutController(this.init.timeout ?? IDENTIFY_TIMEOUT)
+      let stream: Stream | undefined
+
       try {
-        const { stream } = await connection.newStream([this.identifyPushProtocolStr])
+        const data = await connection.newStream([this.identifyPushProtocolStr], {
+          signal: timeoutController.signal
+        })
+        stream = data.stream
+
+        // make stream abortable
+        const source: Duplex<Uint8Array> = abortableDuplex(stream, timeoutController.signal)
 
         await pipe(
           [Identify.encode({
@@ -138,12 +174,18 @@ export class IdentifyService implements Startable {
             protocols
           })],
           lp.encode(),
-          stream,
+          source,
           drain
         )
       } catch (err: any) {
         // Just log errors
         log.error('could not push identify update to peer', err)
+      } finally {
+        if (stream != null) {
+          stream.close()
+        }
+
+        timeoutController.clear()
       }
     })
 
@@ -175,31 +217,56 @@ export class IdentifyService implements Startable {
     await this.push(connections)
   }
 
+  async _identify (connection: Connection, options: AbortOptions = {}): Promise<Identify> {
+    const { stream } = await connection.newStream([this.identifyProtocolStr], options)
+    let source: Duplex<Uint8Array> = stream
+    let timeoutController
+    let signal = options.signal
+
+    // create a timeout if no abort signal passed
+    if (signal == null) {
+      timeoutController = new TimeoutController(this.init.timeout ?? IDENTIFY_TIMEOUT)
+      signal = timeoutController.signal
+    }
+
+    // make stream abortable if AbortSignal passed
+    source = abortableDuplex(stream, signal)
+
+    try {
+      const data = await pipe(
+        [],
+        source,
+        lp.decode({
+          maxDataLength: this.init.maxIdentifyMessageSize ?? MAX_IDENTIFY_MESSAGE_SIZE
+        }),
+        async (source) => await first(source)
+      )
+
+      if (data == null) {
+        throw errCode(new Error('No data could be retrieved'), codes.ERR_CONNECTION_ENDED)
+      }
+
+      try {
+        return Identify.decode(data)
+      } catch (err: any) {
+        throw errCode(err, codes.ERR_INVALID_MESSAGE)
+      }
+    } finally {
+      if (timeoutController != null) {
+        timeoutController.clear()
+      }
+
+      stream.close()
+    }
+  }
+
   /**
    * Requests the `Identify` message from peer associated with the given `connection`.
    * If the identified peer does not match the `PeerId` associated with the connection,
    * an error will be thrown.
    */
-  async identify (connection: Connection): Promise<void> {
-    const { stream } = await connection.newStream([this.identifyProtocolStr])
-    const [data] = await pipe(
-      [],
-      stream,
-      lp.decode(),
-      (source) => take(source, 1),
-      async (source) => await all(source)
-    )
-
-    if (data == null) {
-      throw errCode(new Error('No data could be retrieved'), codes.ERR_CONNECTION_ENDED)
-    }
-
-    let message: Identify
-    try {
-      message = Identify.decode(data)
-    } catch (err: any) {
-      throw errCode(err, codes.ERR_INVALID_MESSAGE)
-    }
+  async identify (connection: Connection, options: AbortOptions = {}): Promise<void> {
+    const message = await this._identify(connection, options)
 
     const {
       publicKey,
@@ -308,6 +375,8 @@ export class IdentifyService implements Startable {
    */
   async _handleIdentify (data: IncomingStreamData) {
     const { connection, stream } = data
+    const timeoutController = new TimeoutController(this.init.timeout ?? IDENTIFY_TIMEOUT)
+
     try {
       const publicKey = this.components.getPeerId().publicKey ?? new Uint8Array(0)
       const peerData = await this.components.getPeerStore().get(this.components.getPeerId())
@@ -335,14 +404,20 @@ export class IdentifyService implements Startable {
         protocols: peerData.protocols
       })
 
+      // make stream abortable
+      const source: Duplex<Uint8Array> = abortableDuplex(stream, timeoutController.signal)
+
       await pipe(
         [message],
         lp.encode(),
-        stream,
+        source,
         drain
       )
     } catch (err: any) {
       log.error('could not respond to identify request', err)
+    } finally {
+      stream.close()
+      timeoutController.clear()
     }
   }
 
@@ -351,13 +426,19 @@ export class IdentifyService implements Startable {
    */
   async _handlePush (data: IncomingStreamData) {
     const { connection, stream } = data
+    const timeoutController = new TimeoutController(this.init.timeout ?? IDENTIFY_TIMEOUT)
 
     let message: Identify | undefined
     try {
+      // make stream abortable
+      const source: Duplex<Uint8Array> = abortableDuplex(stream, timeoutController.signal)
+
       const data = await pipe(
         [],
-        stream,
-        lp.decode(),
+        source,
+        lp.decode({
+          maxDataLength: this.init.maxIdentifyMessageSize ?? MAX_IDENTIFY_MESSAGE_SIZE
+        }),
         async (source) => await first(source)
       )
 
@@ -366,6 +447,9 @@ export class IdentifyService implements Startable {
       }
     } catch (err: any) {
       return log.error('received invalid message', err)
+    } finally {
+      stream.close()
+      timeoutController.clear()
     }
 
     if (message == null) {

package/src/index.ts

@@ -4,7 +4,7 @@ import type { EventEmitter } from '@libp2p/interfaces/events'
 import type { Startable } from '@libp2p/interfaces/startable'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { FaultTolerance } from './transport-manager.js'
-import type { HostProperties } from './identify/index.js'
+import type { IdentifyServiceInit } from './identify/index.js'
 import type { DualDHT } from '@libp2p/interfaces/dht'
 import type { Datastore } from 'interface-datastore'
 import type { PeerStore, PeerStoreInit } from '@libp2p/interfaces/peer-store'
@@ -24,6 +24,8 @@ import type { Metrics, MetricsInit } from '@libp2p/interfaces/metrics'
 import type { PeerInfo } from '@libp2p/interfaces/peer-info'
 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'
 
 export interface PersistentPeerStoreOptions {
   threshold?: number
@@ -95,7 +97,6 @@ export interface RefreshManagerConfig {
 
 export interface Libp2pInit {
   peerId: PeerId
-  host: HostProperties
   addresses: AddressesConfig
   connectionManager: ConnectionManagerInit
   connectionGater: Partial<ConnectionGater>
@@ -105,9 +106,11 @@ export interface Libp2pInit {
   peerStore: PeerStoreInit
   peerRouting: PeerRoutingConfig
   keychain: KeychainConfig
-  protocolPrefix: string
   nat: NatManagerConfig
   relay: RelayConfig
+  identify: IdentifyServiceInit
+  ping: PingServiceInit
+  fetch: FetchServiceInit
 
   transports: Transport[]
   streamMuxers?: StreamMuxerFactory[]
@@ -195,12 +198,12 @@ export interface Libp2p extends Startable, EventEmitter<Libp2pEvents> {
   /**
    * Pings the given peer in order to obtain the operation latency
    */
-  ping: (peer: Multiaddr |PeerId) => Promise<number>
+  ping: (peer: Multiaddr | PeerId, options?: AbortOptions) => Promise<number>
 
   /**
    * Sends a request to fetch the value associated with the given key from the given peer.
    */
-  fetch: (peer: PeerId | Multiaddr | string, key: string) => Promise<Uint8Array | null>
+  fetch: (peer: PeerId | Multiaddr | string, key: string, options?: AbortOptions) => Promise<Uint8Array | null>
 
   /**
    * Returns the public key for the passed PeerId. If the PeerId is of the 'RSA' type

package/src/libp2p.ts

@@ -166,10 +166,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     if (init.streamMuxers != null && init.streamMuxers.length > 0) {
       // Add the identify service since we can multiplex
       this.identifyService = new IdentifyService(this.components, {
-        protocolPrefix: init.protocolPrefix,
-        host: {
-          agentVersion: init.host.agentVersion
-        }
+        ...init.identify
       })
       this.configureComponent(this.identifyService)
     }
@@ -229,11 +226,11 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     }
 
     this.fetchService = this.configureComponent(new FetchService(this.components, {
-      protocolPrefix: init.protocolPrefix
+      ...init.fetch
     }))
 
     this.pingService = this.configureComponent(new PingService(this.components, {
-      protocolPrefix: init.protocolPrefix
+      ...init.ping
     }))
 
     const autoDialer = this.configureComponent(new AutoDialer(this.components, {
@@ -419,9 +416,9 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
       throw errCode(new Error('no protocols were provided to open a stream'), codes.ERR_INVALID_PROTOCOLS_FOR_STREAM)
     }
 
-    const connection = await this.dial(peer)
+    const connection = await this.dial(peer, options)
 
-    return await connection.newStream(protocols)
+    return await connection.newStream(protocols, options)
   }
 
   getMultiaddrs (): Multiaddr[] {
@@ -473,24 +470,24 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     throw errCode(new Error(`Node not responding with its public key: ${peer.toString()}`), codes.ERR_INVALID_RECORD)
   }
 
-  async fetch (peer: PeerId | Multiaddr | string, key: string): Promise<Uint8Array | null> {
+  async fetch (peer: PeerId | Multiaddr | string, key: string, options: AbortOptions = {}): Promise<Uint8Array | null> {
     const { id, multiaddrs } = getPeer(peer)
 
     if (multiaddrs != null) {
       await this.components.getPeerStore().addressBook.add(id, multiaddrs)
     }
 
-    return await this.fetchService.fetch(id, key)
+    return await this.fetchService.fetch(id, key, options)
   }
 
-  async ping (peer: PeerId | Multiaddr | string): Promise<number> {
+  async ping (peer: PeerId | Multiaddr | string, options: AbortOptions = {}): Promise<number> {
     const { id, multiaddrs } = getPeer(peer)
 
     if (multiaddrs.length > 0) {
       await this.components.getPeerStore().addressBook.add(id, multiaddrs)
     }
 
-    return await this.pingService.ping(id)
+    return await this.pingService.ping(id, options)
   }
 
   async handle (protocols: string | string[], handler: StreamHandler): Promise<void> {

package/src/nat-manager.ts

@@ -94,10 +94,14 @@ export class NatManager implements Startable {
     return this.started
   }
 
+  start () {}
+
   /**
-   * Starts the NAT manager
+   * Attempt to use uPnP to configure port mapping using the current gateway.
+   *
+   * Run after start to ensure the transport manager has all addresses configured.
    */
-  start () {
+  afterStart () {
     if (isBrowser || !this.enabled || this.started) {
       return
     }
@@ -105,7 +109,7 @@ export class NatManager implements Startable {
     this.started = true
 
     // done async to not slow down startup
-    this._start().catch((err) => {
+    void this._start().catch((err) => {
       // hole punching errors are non-fatal
       log.error(err)
     })

package/src/peer-routing.ts

@@ -17,7 +17,6 @@ import {
   clearDelayedInterval
 // @ts-expect-error module with no types
 } from 'set-delayed-interval'
-// @ts-expect-error setMaxListeners is missing from the node 16 types
 import { setMaxListeners } from 'events'
 import type { PeerId } from '@libp2p/interfaces/peer-id'
 import type { PeerRouting } from '@libp2p/interfaces/peer-routing'

package/src/ping/index.ts

@@ -10,6 +10,9 @@ import type { IncomingStreamData } from '@libp2p/interfaces/registrar'
 import type { PeerId } from '@libp2p/interfaces/peer-id'
 import type { Startable } from '@libp2p/interfaces/startable'
 import type { Components } from '@libp2p/interfaces/components'
+import type { AbortOptions } from '@libp2p/interfaces'
+import type { Duplex } from 'it-stream-types'
+import { abortableDuplex } from 'abortable-iterator'
 
 const log = logger('libp2p:ping')
 
@@ -18,8 +21,8 @@ export interface PingServiceInit {
 }
 
 export class PingService implements Startable {
+  public readonly protocol: string
   private readonly components: Components
-  private readonly protocol: string
   private started: boolean
 
   constructor (components: Components, init: PingServiceInit) {
@@ -60,25 +63,36 @@ export class PingService implements Startable {
    * @param {PeerId|Multiaddr} peer
    * @returns {Promise<number>}
    */
-  async ping (peer: PeerId): Promise<number> {
+  async ping (peer: PeerId, options: AbortOptions = {}): Promise<number> {
     log('dialing %s to %p', this.protocol, peer)
 
-    const connection = await this.components.getConnectionManager().openConnection(peer)
-    const { stream } = await connection.newStream([this.protocol])
+    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)
 
-    const result = await pipe(
-      [data],
-      stream,
-      async (source) => await first(source)
-    )
-    const end = Date.now()
+    let source: Duplex<Uint8Array> = stream
 
-    if (result == null || !uint8ArrayEquals(data, result)) {
-      throw errCode(new Error('Received wrong ping ack'), codes.ERR_WRONG_PING_ACK)
+    // make stream abortable if AbortSignal passed
+    if (options.signal != null) {
+      source = abortableDuplex(stream, options.signal)
     }
 
-    return end - start
+    try {
+      const result = await pipe(
+        [data],
+        source,
+        async (source) => await first(source)
+      )
+      const end = Date.now()
+
+      if (result == null || !uint8ArrayEquals(data, result)) {
+        throw errCode(new Error('Received wrong ping ack'), codes.ERR_WRONG_PING_ACK)
+      }
+
+      return end - start
+    } finally {
+      stream.close()
+    }
   }
 }

package/src/upgrader.ts

@@ -15,6 +15,7 @@ import type { PeerId } from '@libp2p/interfaces/peer-id'
 import type { MultiaddrConnection, Upgrader, UpgraderEvents } from '@libp2p/interfaces/transport'
 import type { Duplex } from 'it-stream-types'
 import type { Components } from '@libp2p/interfaces/components'
+import type { AbortOptions } from '@libp2p/interfaces'
 
 const log = logger('libp2p:upgrader')
 
@@ -266,7 +267,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
     } = opts
 
     let muxer: StreamMuxer | undefined
-    let newStream: ((multicodecs: string[]) => Promise<ProtocolStream>) | undefined
+    let newStream: ((multicodecs: string[], options?: AbortOptions) => Promise<ProtocolStream>) | undefined
     let connection: Connection // eslint-disable-line prefer-const
 
     if (muxerFactory != null) {
@@ -308,7 +309,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
         }
       })
 
-      newStream = async (protocols: string[]): Promise<ProtocolStream> => {
+      newStream = async (protocols: string[], options: AbortOptions = {}): Promise<ProtocolStream> => {
         if (muxer == null) {
           throw errCode(new Error('Stream is not multiplexed'), codes.ERR_MUXER_UNAVAILABLE)
         }
@@ -319,7 +320,7 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
         const metrics = this.components.getMetrics()
 
         try {
-          let { stream, protocol } = await mss.select(protocols)
+          let { stream, protocol } = await mss.select(protocols, options)
 
           if (metrics != null) {
             stream = metrics.trackStream({ stream, remotePeer, protocol })
@@ -328,6 +329,11 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
           return { stream: { ...muxedStream, ...stream }, protocol }
         } catch (err: any) {
           log.error('could not create new stream', err)
+
+          if (err.code != null) {
+            throw err
+          }
+
           throw errCode(err, codes.ERR_UNSUPPORTED_PROTOCOL)
         }
       }
@@ -382,9 +388,11 @@ export class DefaultUpgrader extends EventEmitter<UpgraderEvents> implements Upg
       getStreams: () => muxer != null ? muxer.streams : errConnectionNotMultiplexed(),
       close: async () => {
         await maConn.close()
-        // Ensure remaining streams are aborted
+        // Ensure remaining streams are closed
         if (muxer != null) {
-          muxer.streams.map(stream => stream.abort())
+          await Promise.all(muxer.streams.map(async stream => {
+            await stream.close()
+          }))
         }
       }
     })