libp2p 0.37.0-b09eb8f → 0.37.1

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/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)
         }
       }