libp2p 2.9.0 → 2.10.0-8484de8a2

package/src/connection-manager/utils.ts

@@ -1,38 +1,146 @@
-import { multiaddr } from '@multiformats/multiaddr'
-import { convertToIpNet } from '@multiformats/multiaddr/convert'
-import type { IpNet } from '@chainsafe/netmask'
+import { IpNet } from '@chainsafe/netmask'
+import { InvalidParametersError } from '@libp2p/interface'
+import { getNetConfig } from '@libp2p/utils'
+import { Circuit } from '@multiformats/multiaddr-matcher'
+import type { Connection, AbortOptions, PeerId } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
+/**
+ * These are speculative protocols that are run automatically on connection open
+ * so are usually not the reason the connection was opened.
+ *
+ * Consequently when requested it should be safe to close connections that only
+ * have these protocol streams open.
+ */
+const DEFAULT_CLOSABLE_PROTOCOLS = [
+  // identify
+  '/ipfs/id/1.0.0',
+
+  // identify-push
+  '/ipfs/id/push/1.0.0',
+
+  // autonat
+  '/libp2p/autonat/1.0.0',
+
+  // dcutr
+  '/libp2p/dcutr'
+]
+
+export interface SafelyCloseConnectionOptions extends AbortOptions {
+  /**
+   * Only close the stream if it either has no protocol streams open or only
+   * ones in this list.
+   *
+   * @default ['/ipfs/id/1.0.0']
+   */
+  closableProtocols?: string[]
+}
+
+/**
+ * Close the passed connection if it has no streams, or only closable protocol
+ * streams, falling back to aborting the connection if closing it cleanly fails.
+ */
+export async function safelyCloseConnectionIfUnused (connection?: Connection, options?: SafelyCloseConnectionOptions): Promise<void> {
+  const streamProtocols = connection?.streams?.map(stream => stream.protocol) ?? []
+  const closableProtocols = options?.closableProtocols ?? DEFAULT_CLOSABLE_PROTOCOLS
+
+  // if the connection has protocols not in the closable protocols list, do not
+  // close the connection
+  if (streamProtocols.filter(proto => proto != null && !closableProtocols.includes(proto)).length > 0) {
+    return
+  }
+
+  try {
+    await connection?.close(options)
+  } catch (err: any) {
+    connection?.abort(err)
+  }
+}
+
 /**
  * Converts a multiaddr string or object to an IpNet object.
  * If the multiaddr doesn't include /ipcidr, it will encapsulate with the appropriate CIDR:
  * - /ipcidr/32 for IPv4
  * - /ipcidr/128 for IPv6
  *
- * @param {string | Multiaddr} ma - The multiaddr string or object to convert.
+ * @param {string | Multiaddr} ma - The multiaddr object to convert.
  * @returns {IpNet} The converted IpNet object.
  * @throws {Error} Throws an error if the multiaddr is not valid.
  */
-export function multiaddrToIpNet (ma: string | Multiaddr): IpNet {
-  try {
-    let parsedMa: Multiaddr
-    if (typeof ma === 'string') {
-      parsedMa = multiaddr(ma)
-    } else {
-      parsedMa = ma
-    }
+export function multiaddrToIpNet (ma: Multiaddr): IpNet {
+  const config = getNetConfig(ma)
+  let mask = config.cidr
 
-    const protoNames = new Set([...parsedMa.getComponents().map(component => component.name)])
+  if (config.type !== 'ip4' && config.type !== 'ip6') {
+    throw new InvalidParametersError(`Multiaddr ${ma} was not an IPv4 or IPv6 address`)
+  }
 
-    // Check if /ipcidr is already present
-    if (!protoNames.has('ipcidr')) {
-      const isIPv6 = protoNames.has('ip6')
-      const cidr = isIPv6 ? '/ipcidr/128' : '/ipcidr/32'
-      parsedMa = parsedMa.encapsulate(cidr)
+  // Check if /ipcidr is already present
+  if (mask == null) {
+    switch (config.type) {
+      case 'ip4': {
+        mask = 32
+        break
+      }
+      case 'ip6': {
+        mask = 128
+        break
+      }
+      default: {
+        throw new InvalidParametersError(`Multiaddr ${ma} was not an IPv4 or IPv6 address`)
+      }
     }
+  }
+
+  return new IpNet(config.host, mask)
+}
+
+/**
+ * Returns true if the passed multiaddr would result in a direct connection to
+ * the peer.
+ *
+ * Currently only circuit relay addresses are supported as indirect connections.
+ */
+export function isDirect (ma: Multiaddr): boolean {
+  return !Circuit.exactMatch(ma)
+}
+
+/**
+ * If there is an existing non-limited connection to the remote peer return it,
+ * unless it is indirect and at least one of the passed dial addresses would
+ * result in a direct connection
+ */
+export function findExistingConnection (peerId?: PeerId, connections?: Connection[], dialAddresses?: Multiaddr[]): Connection | undefined {
+  if (peerId == null || connections == null) {
+    return
+  }
+
+  const existingConnection = connections
+    .sort((a, b) => {
+      if (a.direct) {
+        return -1
+      }
+
+      if (b.direct) {
+        return 1
+      }
 
-    return convertToIpNet(parsedMa)
-  } catch (error) {
-    throw new Error(`Can't convert to IpNet, Invalid multiaddr format: ${ma}`)
+      return 0
+    })
+    .find(con => con.limits == null)
+
+  if (existingConnection == null || existingConnection.direct || dialAddresses == null) {
+    return existingConnection
   }
+
+  // we have an indirect, but unlimited connection - test the dial addresses to
+  // see if any of them would result in a direct connection, in which case allow
+  // the attempt to upgrade to a direct connection
+  const wouldUpgradeToDirect = dialAddresses.some(ma => isDirect(ma))
+
+  if (wouldUpgradeToDirect) {
+    return
+  }
+
+  return existingConnection
 }

package/src/connection-monitor.ts

@@ -1,11 +1,10 @@
 import { randomBytes } from '@libp2p/crypto'
 import { serviceCapabilities } from '@libp2p/interface'
-import { AdaptiveTimeout } from '@libp2p/utils/adaptive-timeout'
-import { byteStream } from 'it-byte-stream'
+import { AdaptiveTimeout, byteStream } from '@libp2p/utils'
 import { setMaxListeners } from 'main-event'
 import type { ComponentLogger, Logger, Metrics, Startable } from '@libp2p/interface'
 import type { ConnectionManager } from '@libp2p/interface-internal'
-import type { AdaptiveTimeoutInit } from '@libp2p/utils/adaptive-timeout'
+import type { AdaptiveTimeoutInit } from '@libp2p/utils'
 
 const DEFAULT_PING_INTERVAL_MS = 10000
 const PROTOCOL_VERSION = '1.0.0'
@@ -120,7 +119,7 @@ export class ConnectionMonitor implements Startable {
 
             conn.rtt = Date.now() - start
 
-            await bs.unwrap().close({
+            await stream.close({
               signal
             })
           } catch (err: any) {

package/src/connection.ts

@@ -0,0 +1,316 @@
+import { connectionSymbol, LimitedConnectionError, ConnectionClosedError, TooManyOutboundProtocolStreamsError, TooManyInboundProtocolStreamsError, StreamCloseEvent } from '@libp2p/interface'
+import * as mss from '@libp2p/multistream-select'
+import { CODE_P2P } from '@multiformats/multiaddr'
+import { setMaxListeners, TypedEventEmitter } from 'main-event'
+import { CONNECTION_CLOSE_TIMEOUT, PROTOCOL_NEGOTIATION_TIMEOUT } from './connection-manager/constants.defaults.ts'
+import { isDirect } from './connection-manager/utils.ts'
+import { MuxerUnavailableError } from './errors.ts'
+import { DEFAULT_MAX_INBOUND_STREAMS, DEFAULT_MAX_OUTBOUND_STREAMS } from './registrar.ts'
+import type { AbortOptions, Logger, MessageStreamDirection, Connection as ConnectionInterface, Stream, NewStreamOptions, PeerId, ConnectionLimits, StreamMuxer, Metrics, PeerStore, MultiaddrConnection, MessageStreamEvents, MultiaddrConnectionTimeline, ConnectionStatus, MessageStream } from '@libp2p/interface'
+import type { Registrar } from '@libp2p/interface-internal'
+import type { Multiaddr } from '@multiformats/multiaddr'
+
+export interface ConnectionComponents {
+  peerStore: PeerStore
+  registrar: Registrar
+  metrics?: Metrics
+}
+
+export interface ConnectionInit {
+  id: string
+  maConn: MultiaddrConnection
+  stream: MessageStream
+  remotePeer: PeerId
+  direction?: MessageStreamDirection
+  muxer?: StreamMuxer
+  cryptoProtocol?: string
+  limits?: ConnectionLimits
+  outboundStreamProtocolNegotiationTimeout?: number
+  inboundStreamProtocolNegotiationTimeout?: number
+  closeTimeout?: number
+}
+
+/**
+ * An implementation of the js-libp2p connection.
+ * Any libp2p transport should use an upgrader to return this connection.
+ */
+export class Connection extends TypedEventEmitter<MessageStreamEvents> implements ConnectionInterface {
+  public readonly id: string
+  public readonly remoteAddr: Multiaddr
+  public readonly remotePeer: PeerId
+  public direction: MessageStreamDirection
+  public timeline: MultiaddrConnectionTimeline
+  public direct: boolean
+  public multiplexer?: string
+  public encryption?: string
+  public limits?: ConnectionLimits
+  public readonly log: Logger
+
+  private readonly maConn: MultiaddrConnection
+  private readonly muxer?: StreamMuxer
+  private readonly components: ConnectionComponents
+  private readonly outboundStreamProtocolNegotiationTimeout: number
+  private readonly inboundStreamProtocolNegotiationTimeout: number
+  private readonly closeTimeout: number
+
+  constructor (components: ConnectionComponents, init: ConnectionInit) {
+    super()
+
+    this.components = components
+
+    this.id = init.id
+    this.remoteAddr = init.maConn.remoteAddr
+    this.remotePeer = init.remotePeer
+    this.direction = init.direction ?? 'outbound'
+    this.timeline = init.maConn.timeline
+    this.encryption = init.cryptoProtocol
+    this.limits = init.limits
+    this.maConn = init.maConn
+    this.log = init.maConn.log
+    this.outboundStreamProtocolNegotiationTimeout = init.outboundStreamProtocolNegotiationTimeout ?? PROTOCOL_NEGOTIATION_TIMEOUT
+    this.inboundStreamProtocolNegotiationTimeout = init.inboundStreamProtocolNegotiationTimeout ?? PROTOCOL_NEGOTIATION_TIMEOUT
+    this.closeTimeout = init.closeTimeout ?? CONNECTION_CLOSE_TIMEOUT
+    this.direct = isDirect(init.maConn.remoteAddr)
+
+    this.onIncomingStream = this.onIncomingStream.bind(this)
+
+    if (this.remoteAddr.getComponents().find(component => component.code === CODE_P2P) == null) {
+      this.remoteAddr = this.remoteAddr.encapsulate(`/p2p/${this.remotePeer}`)
+    }
+
+    if (init.muxer != null) {
+      this.multiplexer = init.muxer.protocol
+      this.muxer = init.muxer
+      this.muxer.addEventListener('stream', this.onIncomingStream)
+    }
+
+    this.maConn.addEventListener('close', (evt) => {
+      this.dispatchEvent(new StreamCloseEvent(evt.local, evt.error))
+    })
+  }
+
+  readonly [Symbol.toStringTag] = 'Connection'
+
+  readonly [connectionSymbol] = true
+
+  get streams (): Stream[] {
+    return this.muxer?.streams ?? []
+  }
+
+  get status (): ConnectionStatus {
+    return this.maConn.status
+  }
+
+  /**
+   * Create a new stream over this connection
+   */
+  newStream = async (protocols: string[], options: NewStreamOptions = {}): Promise<Stream> => {
+    if (this.muxer == null) {
+      throw new MuxerUnavailableError('Connection is not multiplexed')
+    }
+
+    if (this.muxer.status !== 'open') {
+      throw new ConnectionClosedError(`The connection muxer is "${this.muxer.status}" and not "open"`)
+    }
+
+    if (this.maConn.status !== 'open') {
+      throw new ConnectionClosedError(`The connection is "${this.status}" and not "open"`)
+    }
+
+    if (this.limits != null && options?.runOnLimitedConnection !== true) {
+      throw new LimitedConnectionError('Cannot open protocol stream on limited connection')
+    }
+
+    if (!Array.isArray(protocols)) {
+      protocols = [protocols]
+    }
+
+    this.log.trace('starting new stream for protocols %s', protocols)
+    const muxedStream = await this.muxer.createStream({
+      ...options,
+
+      // most underlying transports only support negotiating a single protocol
+      // so only pass the early protocol if a single protocol has been requested
+      // otherwise fall back to mss
+      protocol: protocols.length === 1 ? protocols[0] : undefined
+    })
+    this.log.trace('started new stream %s for protocols %s', muxedStream.id, protocols)
+
+    try {
+      if (options.signal == null) {
+        muxedStream.log('no abort signal was passed while trying to negotiate protocols %s falling back to default timeout', protocols)
+
+        const signal = AbortSignal.timeout(this.outboundStreamProtocolNegotiationTimeout)
+        setMaxListeners(Infinity, signal)
+
+        options = {
+          ...options,
+          signal
+        }
+      }
+
+      if (muxedStream.protocol === '') {
+        muxedStream.log.trace('selecting protocol from protocols %s', protocols)
+
+        muxedStream.protocol = await mss.select(muxedStream, protocols, options)
+
+        muxedStream.log('negotiated protocol %s', muxedStream.protocol)
+      } else {
+        muxedStream.log('pre-negotiated protocol %s', muxedStream.protocol)
+      }
+
+      const outgoingLimit = findOutgoingStreamLimit(muxedStream.protocol, this.components.registrar, options)
+      const streamCount = countStreams(muxedStream.protocol, 'outbound', this)
+
+      if (streamCount > outgoingLimit) {
+        const err = new TooManyOutboundProtocolStreamsError(`Too many outbound protocol streams for protocol "${muxedStream.protocol}" - ${streamCount}/${outgoingLimit}`)
+        muxedStream.abort(err)
+
+        throw err
+      }
+
+      // If a protocol stream has been successfully negotiated and is to be passed to the application,
+      // the peer store should ensure that the peer is registered with that protocol
+      await this.components.peerStore.merge(this.remotePeer, {
+        protocols: [muxedStream.protocol]
+      })
+
+      this.components.metrics?.trackProtocolStream(muxedStream)
+
+      return muxedStream
+    } catch (err: any) {
+      if (muxedStream.status === 'open') {
+        muxedStream.abort(err)
+      } else {
+        this.log.error('could not create new outbound stream on connection %s %a for protocols %s - %e', this.direction === 'inbound' ? 'from' : 'to', this.remoteAddr, protocols, err)
+      }
+
+      throw err
+    }
+  }
+
+  private async onIncomingStream (evt: CustomEvent<Stream>): Promise<void> {
+    const muxedStream = evt.detail
+
+    const signal = AbortSignal.timeout(this.inboundStreamProtocolNegotiationTimeout)
+    setMaxListeners(Infinity, signal)
+
+    muxedStream.log('start protocol negotiation, timing out after %dms', this.inboundStreamProtocolNegotiationTimeout)
+
+    try {
+      if (muxedStream.protocol === '') {
+        const protocols = this.components.registrar.getProtocols()
+
+        muxedStream.log.trace('selecting protocol from protocols %s', protocols)
+
+        muxedStream.protocol = await mss.handle(muxedStream, protocols, {
+          signal
+        })
+
+        muxedStream.log('negotiated protocol %s', muxedStream.protocol)
+      } else {
+        muxedStream.log('pre-negotiated protocol %s', muxedStream.protocol)
+      }
+
+      const incomingLimit = findIncomingStreamLimit(muxedStream.protocol, this.components.registrar)
+      const streamCount = countStreams(muxedStream.protocol, 'inbound', this)
+
+      if (streamCount > incomingLimit) {
+        throw new TooManyInboundProtocolStreamsError(`Too many inbound protocol streams for protocol "${muxedStream.protocol}" - limit ${incomingLimit}`)
+      }
+
+      // If a protocol stream has been successfully negotiated and is to be passed to the application,
+      // the peer store should ensure that the peer is registered with that protocol
+      await this.components.peerStore.merge(this.remotePeer, {
+        protocols: [muxedStream.protocol]
+      }, {
+        signal
+      })
+
+      this.components.metrics?.trackProtocolStream(muxedStream)
+
+      const { handler, options } = this.components.registrar.getHandler(muxedStream.protocol)
+
+      if (this.limits != null && options.runOnLimitedConnection !== true) {
+        throw new LimitedConnectionError('Cannot open protocol stream on limited connection')
+      }
+
+      await handler(muxedStream, this)
+    } catch (err: any) {
+      muxedStream.abort(err)
+    }
+  }
+
+  /**
+   * Close the connection
+   */
+  async close (options: AbortOptions = {}): Promise<void> {
+    this.log('closing connection to %a', this.remoteAddr)
+
+    if (options.signal == null) {
+      const signal = AbortSignal.timeout(this.closeTimeout)
+      setMaxListeners(Infinity, signal)
+
+      options = {
+        ...options,
+        signal
+      }
+    }
+
+    await this.muxer?.close(options)
+    await this.maConn.close(options)
+  }
+
+  abort (err: Error): void {
+    this.muxer?.abort(err)
+    this.maConn.abort(err)
+  }
+}
+
+export function createConnection (components: ConnectionComponents, init: ConnectionInit): ConnectionInterface {
+  return new Connection(components, init)
+}
+
+function findIncomingStreamLimit (protocol: string, registrar: Registrar): number {
+  try {
+    const { options } = registrar.getHandler(protocol)
+
+    if (options.maxInboundStreams != null) {
+      return options.maxInboundStreams
+    }
+  } catch (err: any) {
+    if (err.name !== 'UnhandledProtocolError') {
+      throw err
+    }
+  }
+
+  return DEFAULT_MAX_INBOUND_STREAMS
+}
+
+function findOutgoingStreamLimit (protocol: string, registrar: Registrar, options: NewStreamOptions = {}): number {
+  try {
+    const { options } = registrar.getHandler(protocol)
+
+    if (options.maxOutboundStreams != null) {
+      return options.maxOutboundStreams
+    }
+  } catch (err: any) {
+    if (err.name !== 'UnhandledProtocolError') {
+      throw err
+    }
+  }
+
+  return options.maxOutboundStreams ?? DEFAULT_MAX_OUTBOUND_STREAMS
+}
+
+function countStreams (protocol: string, direction: 'inbound' | 'outbound', connection: Connection): number {
+  let streamCount = 0
+
+  connection.streams.forEach(stream => {
+    if (stream.direction === direction && stream.protocol === protocol) {
+      streamCount++
+    }
+  })
+
+  return streamCount
+}

package/src/get-peer.ts

@@ -1,6 +1,6 @@
 import { InvalidMultiaddrError, InvalidParametersError, isPeerId } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
-import { isMultiaddr } from '@multiformats/multiaddr'
+import { CODE_P2P, isMultiaddr } from '@multiformats/multiaddr'
 import { PEER_ID } from '@multiformats/multiaddr-matcher'
 import type { PeerId } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
@@ -24,7 +24,7 @@ export function getPeerAddress (peer: PeerId | Multiaddr | Multiaddr[]): PeerAdd
   let peerId: PeerId | undefined
 
   if (multiaddrs.length > 0) {
-    const peerIdStr = multiaddrs[0].getPeerId()
+    const peerIdStr = multiaddrs[0].getComponents().findLast(c => c.code === CODE_P2P)?.value
     peerId = peerIdStr == null ? undefined : peerIdFromString(peerIdStr)
 
     // ensure PeerId is either not set or is consistent
@@ -33,7 +33,7 @@ export function getPeerAddress (peer: PeerId | Multiaddr | Multiaddr[]): PeerAdd
         throw new InvalidMultiaddrError('Invalid multiaddr')
       }
 
-      const maPeerIdStr = ma.getPeerId()
+      const maPeerIdStr = ma.getComponents().findLast(c => c.code === CODE_P2P)?.value
 
       if (maPeerIdStr == null) {
         if (peerId != null) {

package/src/index.ts

@@ -184,8 +184,8 @@ export type Libp2pOptions<T extends ServiceMap = ServiceMap> = Libp2pInit<T> & {
  * import { createLibp2p } from 'libp2p'
  * import { tcp } from '@libp2p/tcp'
  * import { mplex } from '@libp2p/mplex'
- * import { noise } from '@chainsafe/libp2p-noise'
- * import { yamux } from '@chainsafe/libp2p-yamux'
+ * import { noise } from '@libp2p/noise'
+ * import { yamux } from '@libp2p/yamux'
  *
  * // specify options
  * const options = {

package/src/libp2p.ts

@@ -4,7 +4,7 @@ import { defaultLogger } from '@libp2p/logger'
 import { PeerSet } from '@libp2p/peer-collections'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { persistentPeerStore } from '@libp2p/peer-store'
-import { isMultiaddr } from '@multiformats/multiaddr'
+import { CODE_P2P, isMultiaddr } from '@multiformats/multiaddr'
 import { MemoryDatastore } from 'datastore-core/memory'
 import { TypedEventEmitter, setMaxListeners } from 'main-event'
 import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
@@ -120,7 +120,8 @@ export class Libp2p<T extends ServiceMap = ServiceMap> extends TypedEventEmitter
       streamMuxers: (init.streamMuxers ?? []).map((fn, index) => this.configureComponent(`stream-muxers-${index}`, fn(this.components))),
       inboundUpgradeTimeout: init.connectionManager?.inboundUpgradeTimeout,
       inboundStreamProtocolNegotiationTimeout: init.connectionManager?.inboundStreamProtocolNegotiationTimeout ?? init.connectionManager?.protocolNegotiationTimeout,
-      outboundStreamProtocolNegotiationTimeout: init.connectionManager?.outboundStreamProtocolNegotiationTimeout ?? init.connectionManager?.protocolNegotiationTimeout
+      outboundStreamProtocolNegotiationTimeout: init.connectionManager?.outboundStreamProtocolNegotiationTimeout ?? init.connectionManager?.protocolNegotiationTimeout,
+      connectionCloseTimeout: init.connectionManager?.connectionCloseTimeout
     })
 
     // Setup the transport manager
@@ -304,9 +305,7 @@ export class Libp2p<T extends ServiceMap = ServiceMap> extends TypedEventEmitter
       throw new InvalidParametersError('no protocols were provided to open a stream')
     }
 
-    const connection = await this.dial(peer, options)
-
-    return connection.newStream(protocols, options)
+    return this.components.connectionManager.openStream(peer, protocols, options)
   }
 
   getMultiaddrs (): Multiaddr[] {
@@ -319,7 +318,7 @@ export class Libp2p<T extends ServiceMap = ServiceMap> extends TypedEventEmitter
 
   async hangUp (peer: PeerId | Multiaddr, options: AbortOptions = {}): Promise<void> {
     if (isMultiaddr(peer)) {
-      peer = peerIdFromString(peer.getPeerId() ?? '')
+      peer = peerIdFromString(peer.getComponents().findLast(c => c.code === CODE_P2P)?.value ?? '')
     }
 
     await this.components.connectionManager.closeConnections(peer, options)

package/src/peer-routing.ts

@@ -1,5 +1,5 @@
 import { NotFoundError } from '@libp2p/interface'
-import { createScalableCuckooFilter } from '@libp2p/utils/filters'
+import { createScalableCuckooFilter } from '@libp2p/utils'
 import merge from 'it-merge'
 import parallel from 'it-parallel'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'

package/src/random-walk.ts

@@ -2,7 +2,7 @@ import { randomBytes } from '@libp2p/crypto'
 import { anySignal } from 'any-signal'
 import { TypedEventEmitter, setMaxListeners } from 'main-event'
 import pDefer from 'p-defer'
-import { raceEvent } from 'race-event'
+import { pEvent } from 'p-event'
 import { raceSignal } from 'race-signal'
 import type { AbortOptions, ComponentLogger, Logger, PeerInfo, PeerRouting, Startable } from '@libp2p/interface'
 import type { RandomWalk as RandomWalkInterface } from '@libp2p/interface-internal'
@@ -68,12 +68,22 @@ export class RandomWalk extends TypedEventEmitter<RandomWalkEvents> implements R
         this.needNext = pDefer()
 
         // wait for a walk:peer or walk:error event
-        const event = await raceEvent<CustomEvent<PeerInfo>>(this, 'walk:peer', signal, {
-          errorEvent: 'walk:error'
+        const event = await pEvent<'walk:peer', CustomEvent<PeerInfo>>(this, 'walk:peer', {
+          signal,
+          rejectionEvents: [
+            'walk:error'
+          ]
         })
 
         yield event.detail
       }
+    } catch (err: any) {
+      // test for walk:error event
+      if (err.detail != null) {
+        throw err.detail
+      }
+
+      throw err
     } finally {
       signal.clear()
       this.walkers--