@libp2p/webrtc 5.2.23 → 5.2.24-0f07e3df5

package/src/index.ts

@@ -26,8 +26,8 @@
  * WebRTC requires use of a relay to connect two nodes. The listener first discovers a relay server and makes a reservation, then the dialer can connect via the relayed address.
  *
  * ```TypeScript
- * import { noise } from '@chainsafe/libp2p-noise'
- * import { yamux } from '@chainsafe/libp2p-yamux'
+ * import { noise } from '@libp2p/noise'
+ * import { yamux } from '@libp2p/yamux'
  * import { echo } from '@libp2p/echo'
  * import { circuitRelayTransport, circuitRelayServer } from '@libp2p/circuit-relay-v2'
  * import { identify } from '@libp2p/identify'
@@ -35,7 +35,6 @@
  * import { webSockets } from '@libp2p/websockets'
  * import { WebRTC } from '@multiformats/multiaddr-matcher'
  * import delay from 'delay'
- * import { pipe } from 'it-pipe'
  * import { createLibp2p } from 'libp2p'
  * import type { Multiaddr } from '@multiformats/multiaddr'
  *
@@ -134,15 +133,11 @@
  * await relay.stop()
  *
  * // send/receive some data from the remote peer via a direct connection
- * await pipe(
- *   [new TextEncoder().encode('hello world')],
- *   stream,
- *   async source => {
- *     for await (const buf of source) {
- *       console.info(new TextDecoder().decode(buf.subarray()))
- *     }
- *   }
- * )
+ * stream.send(new TextEncoder().encode('hello world'))
+ *
+ * stream.addEventListener('message', (evt) => {
+ *   console.info(new TextDecoder().decode(evt.data.subarray()))
+ * })
  * ```
  *
  * @example WebRTC Direct
@@ -167,7 +162,6 @@
  * ```TypeScript
  * import { createLibp2p } from 'libp2p'
  * import { multiaddr } from '@multiformats/multiaddr'
- * import { pipe } from 'it-pipe'
  * import { fromString, toString } from 'uint8arrays'
  * import { webRTCDirect } from '@libp2p/webrtc'
  *
@@ -196,15 +190,11 @@
  *   signal: AbortSignal.timeout(10_000)
  * })
  *
- * await pipe(
- *   [fromString(`Hello js-libp2p-webrtc\n`)],
- *   stream,
- *   async function (source) {
- *     for await (const buf of source) {
- *       console.info(toString(buf.subarray()))
- *     }
- *   }
- * )
+ * stream.send(new TextEncoder().encode('hello world'))
+ *
+ * stream.addEventListener('message', (evt) => {
+ *   console.info(new TextDecoder().decode(evt.data.subarray()))
+ * })
  * ```
  *
  * ## WebRTC Direct certificate hashes

package/src/muxer.ts

@@ -1,11 +1,9 @@
+import { AbstractStreamMuxer } from '@libp2p/utils'
+import { pEvent } from 'p-event'
 import { MUXER_PROTOCOL } from './constants.js'
-import { createStream } from './stream.js'
-import { drainAndClose, nopSink, nopSource } from './util.js'
+import { createStream, WebRTCStream } from './stream.js'
 import type { DataChannelOptions } from './index.js'
-import type { ComponentLogger, Logger, Stream, CounterGroup, StreamMuxer, StreamMuxerFactory, StreamMuxerInit } from '@libp2p/interface'
-import type { AbortOptions } from '@multiformats/multiaddr'
-import type { Source, Sink } from 'it-stream-types'
-import type { Uint8ArrayList } from 'uint8arraylist'
+import type { ComponentLogger, CounterGroup, StreamMuxer, StreamMuxerFactory, CreateStreamOptions, MultiaddrConnection } from '@libp2p/interface'
 
 export interface DataChannelMuxerFactoryInit {
   /**
@@ -23,6 +21,9 @@ export interface DataChannelMuxerFactoryInit {
    */
   metrics?: CounterGroup
 
+  /**
+   * Options used to create data channels
+   */
   dataChannelOptions?: DataChannelOptions
 }
 
@@ -30,12 +31,6 @@ export interface DataChannelMuxerFactoryComponents {
   logger: ComponentLogger
 }
 
-interface BufferedStream {
-  stream: Stream
-  channel: RTCDataChannel
-  onEnd(err?: Error): void
-}
-
 export class DataChannelMuxerFactory implements StreamMuxerFactory {
   public readonly protocol: string
 
@@ -43,69 +38,28 @@ export class DataChannelMuxerFactory implements StreamMuxerFactory {
    * WebRTC Peer Connection
    */
   private readonly peerConnection: RTCPeerConnection
-  private bufferedStreams: BufferedStream[] = []
   private readonly metrics?: CounterGroup
   private readonly dataChannelOptions?: DataChannelOptions
-  private readonly components: DataChannelMuxerFactoryComponents
-  private readonly log: Logger
 
-  constructor (components: DataChannelMuxerFactoryComponents, init: DataChannelMuxerFactoryInit) {
-    this.components = components
+  constructor (init: DataChannelMuxerFactoryInit) {
     this.peerConnection = init.peerConnection
     this.metrics = init.metrics
     this.protocol = init.protocol ?? MUXER_PROTOCOL
     this.dataChannelOptions = init.dataChannelOptions ?? {}
-    this.log = components.logger.forComponent('libp2p:webrtc:muxerfactory')
-
-    // store any data channels opened before upgrade has been completed
-    this.peerConnection.ondatachannel = ({ channel }) => {
-      this.log.trace('incoming early datachannel with channel id %d and label "%s"', channel.id)
-
-      // 'init' channel is only used during connection establishment
-      if (channel.label === 'init') {
-        this.log.trace('closing early init channel')
-        channel.close()
-
-        return
-      }
-
-      // @ts-expect-error fields are set below
-      const bufferedStream: BufferedStream = {}
-
-      const stream = createStream({
-        channel,
-        direction: 'inbound',
-        onEnd: (err) => {
-          bufferedStream.onEnd(err)
-        },
-        logger: components.logger,
-        ...this.dataChannelOptions
-      })
-
-      bufferedStream.stream = stream
-      bufferedStream.channel = channel
-      bufferedStream.onEnd = () => {
-        this.bufferedStreams = this.bufferedStreams.filter(s => s.stream.id !== stream.id)
-      }
-
-      this.bufferedStreams.push(bufferedStream)
-    }
   }
 
-  createStreamMuxer (init?: StreamMuxerInit): StreamMuxer {
-    return new DataChannelMuxer(this.components, {
-      ...init,
+  createStreamMuxer (maConn: MultiaddrConnection): StreamMuxer {
+    return new DataChannelMuxer(maConn, {
       peerConnection: this.peerConnection,
       dataChannelOptions: this.dataChannelOptions,
       metrics: this.metrics,
-      streams: this.bufferedStreams,
       protocol: this.protocol
     })
   }
 }
 
-export interface DataChannelMuxerInit extends DataChannelMuxerFactoryInit, StreamMuxerInit {
-  streams: BufferedStream[]
+export interface DataChannelMuxerInit extends DataChannelMuxerFactoryInit {
+  protocol: string
 }
 
 export interface DataChannelMuxerComponents {
@@ -115,26 +69,18 @@ export interface DataChannelMuxerComponents {
 /**
  * A libp2p data channel stream muxer
  */
-export class DataChannelMuxer implements StreamMuxer {
-  /**
-   * Array of streams in the data channel
-   */
-  public streams: Stream[]
-  public protocol: string
-
-  private readonly log: Logger
+export class DataChannelMuxer extends AbstractStreamMuxer<WebRTCStream> implements StreamMuxer<WebRTCStream> {
   private readonly peerConnection: RTCPeerConnection
   private readonly dataChannelOptions: DataChannelOptions
-  private readonly metrics?: CounterGroup
-  private readonly logger: ComponentLogger
 
-  constructor (components: DataChannelMuxerComponents, readonly init: DataChannelMuxerInit) {
-    this.log = components.logger.forComponent('libp2p:webrtc:muxer')
-    this.logger = components.logger
-    this.streams = init.streams.map(s => s.stream)
+  constructor (maConn: MultiaddrConnection, init: DataChannelMuxerInit) {
+    super(maConn, {
+      ...init,
+      name: 'muxer'
+    })
+
     this.peerConnection = init.peerConnection
     this.protocol = init.protocol ?? MUXER_PROTOCOL
-    this.metrics = init.metrics
     this.dataChannelOptions = init.dataChannelOptions ?? {}
 
     /**
@@ -144,7 +90,7 @@ export class DataChannelMuxer implements StreamMuxer {
      * {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/datachannel_event}
      */
     this.peerConnection.ondatachannel = ({ channel }) => {
-      this.log.trace('incoming datachannel with channel id %d', channel.id)
+      this.log.trace('incoming %s datachannel with channel id %d and status', channel.protocol, channel.id, channel.readyState)
 
       // 'init' channel is only used during connection establishment
       if (channel.label === 'init') {
@@ -154,115 +100,46 @@ export class DataChannelMuxer implements StreamMuxer {
         return
       }
 
-      // lib-datachannel throws if `.getId` is called on a closed channel so
-      // memoize it
-      const id = channel.id
-
       const stream = createStream({
+        ...this.streamOptions,
+        ...this.dataChannelOptions,
         channel,
         direction: 'inbound',
-        onEnd: () => {
-          this.#onStreamEnd(stream, channel)
-          this.log('incoming channel %s ended', id)
-        },
-        logger: this.logger,
-        ...this.dataChannelOptions
-      })
-
-      this.streams.push(stream)
-      this.metrics?.increment({ incoming_stream: true })
-      init?.onIncomingStream?.(stream)
-    }
-
-    // the DataChannelMuxer constructor is called during set up of the
-    // connection by the upgrader.
-    //
-    // If we invoke `init.onIncomingStream` immediately, the connection object
-    // will not be set up yet so add a tiny delay before letting the
-    // connection know about early streams
-    if (this.init.streams.length > 0) {
-      queueMicrotask(() => {
-        this.init.streams.forEach(bufferedStream => {
-          bufferedStream.onEnd = () => {
-            this.log('incoming early channel %s ended with state %s', bufferedStream.channel.id, bufferedStream.channel.readyState)
-            this.#onStreamEnd(bufferedStream.stream, bufferedStream.channel)
-          }
-
-          this.metrics?.increment({ incoming_stream: true })
-          this.init?.onIncomingStream?.(bufferedStream.stream)
-        })
-      })
-    }
-  }
-
-  #onStreamEnd (stream: Stream, channel: RTCDataChannel): void {
-    this.log.trace('stream %s %s %s onEnd', stream.direction, stream.id, stream.protocol)
-    drainAndClose(
-      channel,
-      `${stream.direction} ${stream.id} ${stream.protocol}`,
-      this.dataChannelOptions.drainTimeout, {
         log: this.log
-      }
-    )
-    this.streams = this.streams.filter(s => s.id !== stream.id)
-    this.metrics?.increment({ stream_end: true })
-    this.init?.onStreamEnd?.(stream)
-  }
-
-  /**
-   * Gracefully close all tracked streams and stop the muxer
-   */
-  async close (options?: AbortOptions): Promise<void> {
-    try {
-      await Promise.all(
-        this.streams.map(async stream => stream.close(options))
-      )
-    } catch (err: any) {
-      this.abort(err)
-    }
-  }
+      })
 
-  /**
-   * Abort all tracked streams and stop the muxer
-   */
-  abort (err: Error): void {
-    for (const stream of this.streams) {
-      stream.abort(err)
+      this.onRemoteStream(stream)
     }
   }
 
-  /**
-   * The stream source, a no-op as the transport natively supports multiplexing
-   */
-  source: AsyncGenerator<Uint8Array, any, unknown> = nopSource()
+  async onCreateStream (options?: CreateStreamOptions): Promise<WebRTCStream> {
+    // The spec says the label MUST be an empty string: https://github.com/libp2p/specs/blob/master/webrtc/README.md#rtcdatachannel-label
+    const channel = this.peerConnection.createDataChannel('wtf', {
+      // TODO: pre-negotiate stream protocol
+      protocol: options?.protocol
+    })
 
-  /**
-   * The stream destination, a no-op as the transport natively supports multiplexing
-   */
-  sink: Sink<Source<Uint8Array | Uint8ArrayList>, Promise<void>> = nopSink
+    this.log('open channel %d for protocol %s', channel.id, options?.protocol)
 
-  newStream (): Stream {
-    // The spec says the label MUST be an empty string: https://github.com/libp2p/specs/blob/master/webrtc/README.md#rtcdatachannel-label
-    const channel = this.peerConnection.createDataChannel('')
-    // lib-datachannel throws if `.getId` is called on a closed channel so
-    // memoize it
-    const id = channel.id
+    if (channel.readyState !== 'open') {
+      this.log('channel %d state is "%s" and not "open", waiting for "open" event before sending data', channel.id, channel.readyState)
+      await pEvent(channel, 'open', options)
 
-    this.log.trace('opened outgoing datachannel with channel id %s', id)
+      this.log('channel %d state is now "%s", sending data', channel.id, channel.readyState)
+    }
 
     const stream = createStream({
+      ...options,
+      ...this.dataChannelOptions,
       channel,
       direction: 'outbound',
-      onEnd: () => {
-        this.#onStreamEnd(stream, channel)
-        this.log('outgoing channel %s ended', id)
-      },
-      logger: this.logger,
-      ...this.dataChannelOptions
+      log: this.log
     })
-    this.streams.push(stream)
-    this.metrics?.increment({ outgoing_stream: true })
 
     return stream
   }
+
+  onData (): void {
+
+  }
 }

package/src/private-to-private/initiate-connection.ts

@@ -1,4 +1,5 @@
-import { pbStream } from 'it-protobuf-stream'
+import { pbStream } from '@libp2p/utils'
+import { pEvent } from 'p-event'
 import { CustomProgressEvent } from 'progress-events'
 import { SIGNALING_PROTOCOL } from '../constants.js'
 import { SDPHandshakeFailedError } from '../error.js'
@@ -9,15 +10,14 @@ import { splitAddr } from './transport.js'
 import { readCandidatesUntilConnected } from './util.js'
 import type { WebRTCDialEvents, WebRTCTransportMetrics } from './transport.js'
 import type { DataChannelOptions } from '../index.js'
-import type { LoggerOptions, Connection, ComponentLogger, IncomingStreamData } from '@libp2p/interface'
+import type { LoggerOptions, Connection, ComponentLogger, AbortOptions } from '@libp2p/interface'
 import type { ConnectionManager, TransportManager } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { ProgressOptions } from 'progress-events'
 
-export interface IncomingStreamOpts extends IncomingStreamData {
+export interface IncomingStreamOptions extends AbortOptions {
   rtcConfiguration?: RTCConfiguration
   dataChannelOptions?: Partial<DataChannelOptions>
-  signal: AbortSignal
 }
 
 export interface ConnectOptions extends LoggerOptions, ProgressOptions<WebRTCDialEvents> {
@@ -67,9 +67,21 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
 
   const messageStream = pbStream(stream).pb(Message)
   const peerConnection = new RTCPeerConnection(rtcConfiguration)
+
+  // make sure C++ peer connection is garbage collected
+  // https://github.com/murat-dogan/node-datachannel/issues/366#issuecomment-3228453155
+  peerConnection.addEventListener('connectionstatechange', () => {
+    switch (peerConnection.connectionState) {
+      case 'closed':
+        peerConnection.close()
+        break
+      default:
+        break
+    }
+  })
+
   const muxerFactory = new DataChannelMuxerFactory({
-    logger
-  }, {
+    // @ts-expect-error https://github.com/murat-dogan/node-datachannel/pull/370
     peerConnection,
     dataChannelOptions: dataChannel
   })
@@ -97,7 +109,7 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
         signal
       })
         .catch(err => {
-          log.error('error sending ICE candidate', err)
+          log.error('error sending ICE candidate - %e', err)
         })
     }
     peerConnection.onicecandidateerror = (event) => {
@@ -157,7 +169,17 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
       onProgress
     })
 
-    log.trace('initiator connected, closing init channel')
+    log.trace('initiator connected')
+
+    if (channel.readyState !== 'open') {
+      log.trace('wait for init channel to open')
+      await pEvent(channel, 'open', {
+        signal
+      })
+    }
+
+    log.trace('closing init channel, starting status')
+
     channel.close()
 
     onProgress?.(new CustomProgressEvent('webrtc:close-signaling-stream'))

package/src/private-to-private/signaling-stream-handler.ts

@@ -1,20 +1,19 @@
+import { pbStream } from '@libp2p/utils'
 import { multiaddr } from '@multiformats/multiaddr'
-import { pbStream } from 'it-protobuf-stream'
 import { SDPHandshakeFailedError } from '../error.js'
 import { RTCSessionDescription } from '../webrtc/index.js'
 import { Message } from './pb/message.js'
-import { getConnectionState, readCandidatesUntilConnected } from './util.js'
+import { getConnectionState, getRemotePeer, readCandidatesUntilConnected } from './util.js'
 import type { RTCPeerConnection } from '../webrtc/index.js'
-import type { Logger, IncomingStreamData } from '@libp2p/interface'
+import type { AbortOptions, Connection, Logger, PeerId, Stream } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
-export interface IncomingStreamOpts extends IncomingStreamData {
+export interface IncomingStreamOptions extends AbortOptions {
   peerConnection: RTCPeerConnection
-  signal: AbortSignal
   log: Logger
 }
 
-export async function handleIncomingStream ({ peerConnection, stream, signal, connection, log }: IncomingStreamOpts): Promise<{ remoteAddress: Multiaddr }> {
+export async function handleIncomingStream (stream: Stream, connection: Connection, { peerConnection, signal, log }: IncomingStreamOptions): Promise<{ remoteAddress: Multiaddr, remotePeer: PeerId }> {
   log.trace('new inbound signaling stream')
 
   const messageStream = pbStream(stream).pb(Message)
@@ -37,7 +36,7 @@ export async function handleIncomingStream ({ peerConnection, stream, signal, co
         signal
       })
         .catch(err => {
-          log.error('error sending ICE candidate', err)
+          log.error('error sending ICE candidate - %e', err)
         })
     }
 
@@ -101,9 +100,13 @@ export async function handleIncomingStream ({ peerConnection, stream, signal, co
     }
   }
 
-  const remoteAddress = multiaddr(`/webrtc/p2p/${connection.remoteAddr.getPeerId()}`)
+  const remotePeer = getRemotePeer(connection.remoteAddr)
+  const remoteAddress = multiaddr(`/webrtc/p2p/${remotePeer}`)
 
   log.trace('recipient connected to remote address %s', remoteAddress)
 
-  return { remoteAddress }
+  return {
+    remoteAddress,
+    remotePeer
+  }
 }

package/src/private-to-private/transport.ts

@@ -4,15 +4,16 @@ import { multiaddr } from '@multiformats/multiaddr'
 import { WebRTC } from '@multiformats/multiaddr-matcher'
 import { setMaxListeners } from 'main-event'
 import { SIGNALING_PROTOCOL } from '../constants.js'
-import { WebRTCMultiaddrConnection } from '../maconn.js'
 import { DataChannelMuxerFactory } from '../muxer.js'
+import { toMultiaddrConnection } from '../rtcpeerconnection-to-conn.ts'
 import { getRtcConfiguration } from '../util.js'
 import { RTCPeerConnection } from '../webrtc/index.js'
 import { initiateConnection } from './initiate-connection.js'
 import { WebRTCPeerListener } from './listener.js'
 import { handleIncomingStream } from './signaling-stream-handler.js'
+import { getRemotePeer } from './util.ts'
 import type { DataChannelOptions } from '../index.js'
-import type { OutboundConnectionUpgradeEvents, CreateListenerOptions, DialTransportOptions, Transport, Listener, Upgrader, ComponentLogger, Logger, Connection, PeerId, CounterGroup, Metrics, Startable, OpenConnectionProgressEvents, IncomingStreamData, Libp2pEvents } from '@libp2p/interface'
+import type { OutboundConnectionUpgradeEvents, CreateListenerOptions, DialTransportOptions, Transport, Listener, Upgrader, ComponentLogger, Logger, Connection, PeerId, CounterGroup, Metrics, Startable, OpenConnectionProgressEvents, Libp2pEvents, MultiaddrConnection, Stream } from '@libp2p/interface'
 import type { Registrar, ConnectionManager, TransportManager } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { TypedEventTarget } from 'main-event'
@@ -115,13 +116,13 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
   }
 
   async start (): Promise<void> {
-    await this.components.registrar.handle(SIGNALING_PROTOCOL, (data: IncomingStreamData) => {
+    await this.components.registrar.handle(SIGNALING_PROTOCOL, (stream: Stream, connection: Connection) => {
       // ensure we don't try to upgrade forever
       const signal = this.components.upgrader.createInboundAbortSignal(this.shutdownController.signal)
 
-      this._onProtocol(data, signal)
+      this._onProtocol(stream, connection, signal)
         .catch(err => {
-          this.log.error('failed to handle incoming connect from %p', data.connection.remotePeer, err)
+          this.log.error('failed to handle incoming connect from %p', connection.remotePeer, err)
         })
         .finally(() => {
           signal.clear()
@@ -180,16 +181,18 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
       onProgress: options.onProgress
     })
 
-    const webRTCConn = new WebRTCMultiaddrConnection(this.components, {
+    const webRTCConn = toMultiaddrConnection({
       peerConnection,
-      timeline: { open: Date.now() },
       remoteAddr: remoteAddress,
-      metrics: this.metrics?.dialerEvents
+      metrics: this.metrics?.dialerEvents,
+      direction: 'outbound',
+      log: this.components.logger.forComponent('libp2p:webrtc:connection')
     })
 
     const connection = await options.upgrader.upgradeOutbound(webRTCConn, {
       skipProtection: true,
       skipEncryption: true,
+      remotePeer: getRemotePeer(ma),
       muxerFactory,
       onProgress: options.onProgress,
       signal: options.signal
@@ -201,18 +204,29 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
     return connection
   }
 
-  async _onProtocol ({ connection, stream }: IncomingStreamData, signal: AbortSignal): Promise<void> {
+  async _onProtocol (stream: Stream, connection: Connection, signal: AbortSignal): Promise<void> {
     const peerConnection = new RTCPeerConnection(await getRtcConfiguration(this.init.rtcConfiguration))
-    const muxerFactory = new DataChannelMuxerFactory(this.components, {
+
+    // make sure C++ peer connection is garbage collected
+    // https://github.com/murat-dogan/node-datachannel/issues/366#issuecomment-3228453155
+    peerConnection.addEventListener('connectionstatechange', () => {
+      switch (peerConnection.connectionState) {
+        case 'closed':
+          peerConnection.close()
+          break
+        default:
+          break
+      }
+    })
+    const muxerFactory = new DataChannelMuxerFactory({
+      // @ts-expect-error https://github.com/murat-dogan/node-datachannel/pull/370
       peerConnection,
       dataChannelOptions: this.init.dataChannel
     })
 
     try {
-      const { remoteAddress } = await handleIncomingStream({
+      const { remoteAddress, remotePeer } = await handleIncomingStream(stream, connection, {
         peerConnection,
-        connection,
-        stream,
         signal,
         log: this.log
       })
@@ -222,16 +236,18 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
         signal
       })
 
-      const webRTCConn = new WebRTCMultiaddrConnection(this.components, {
+      const webRTCConn = toMultiaddrConnection({
         peerConnection,
-        timeline: { open: (new Date()).getTime() },
         remoteAddr: remoteAddress,
-        metrics: this.metrics?.listenerEvents
+        metrics: this.metrics?.listenerEvents,
+        direction: 'inbound',
+        log: this.components.logger.forComponent('libp2p:webrtc:connection')
       })
 
       await this.components.upgrader.upgradeInbound(webRTCConn, {
         skipEncryption: true,
         skipProtection: true,
+        remotePeer,
         muxerFactory,
         signal
       })
@@ -247,7 +263,7 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
     }
   }
 
-  private _closeOnShutdown (pc: RTCPeerConnection, webRTCConn: WebRTCMultiaddrConnection): void {
+  private _closeOnShutdown (pc: RTCPeerConnection, webRTCConn: MultiaddrConnection): void {
     // close the connection on shut down
     const shutDownListener = (): void => {
       webRTCConn.close()

package/src/private-to-private/util.ts

@@ -1,12 +1,13 @@
-import { ConnectionFailedError, InvalidMessageError } from '@libp2p/interface'
-import pDefer from 'p-defer'
+import { ConnectionFailedError, InvalidMessageError, InvalidMultiaddrError } from '@libp2p/interface'
+import { peerIdFromString } from '@libp2p/peer-id'
 import { CustomProgressEvent } from 'progress-events'
 import { isFirefox } from '../util.js'
 import { RTCIceCandidate } from '../webrtc/index.js'
 import { Message } from './pb/message.js'
 import type { WebRTCDialEvents } from './transport.js'
 import type { RTCPeerConnection } from '../webrtc/index.js'
-import type { AbortOptions, LoggerOptions, Stream } from '@libp2p/interface'
+import type { AbortOptions, LoggerOptions, PeerId, Stream } from '@libp2p/interface'
+import type { Multiaddr } from '@multiformats/multiaddr'
 import type { MessageStream } from 'it-protobuf-stream'
 import type { DeferredPromise } from 'p-defer'
 import type { ProgressOptions } from 'progress-events'
@@ -17,7 +18,7 @@ export interface ReadCandidatesOptions extends AbortOptions, LoggerOptions, Prog
 
 export const readCandidatesUntilConnected = async (pc: RTCPeerConnection, stream: MessageStream<Message, Stream>, options: ReadCandidatesOptions): Promise<void> => {
   try {
-    const connectedPromise: DeferredPromise<void> = pDefer()
+    const connectedPromise = Promise.withResolvers<void>()
     resolveOnConnected(pc, connectedPromise)
 
     // read candidates until we are connected or we reach the end of the stream
@@ -94,3 +95,19 @@ function resolveOnConnected (pc: RTCPeerConnection, promise: DeferredPromise<voi
     }
   }
 }
+
+export function getRemotePeer (ma: Multiaddr): PeerId {
+  let remotePeer: PeerId | undefined
+
+  for (const component of ma.getComponents()) {
+    if (component.name === 'p2p') {
+      remotePeer = peerIdFromString(component.value ?? '')
+    }
+  }
+
+  if (remotePeer == null) {
+    throw new InvalidMultiaddrError('Remote peerId must be present in multiaddr')
+  }
+
+  return remotePeer
+}