@libp2p/webrtc 5.2.24-a02cb0461 → 5.2.24-f5932c294

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 '@libp2p/noise'
- * import { yamux } from '@libp2p/yamux'
+ * import { noise } from '@chainsafe/libp2p-noise'
+ * import { yamux } from '@chainsafe/libp2p-yamux'
  * import { echo } from '@libp2p/echo'
  * import { circuitRelayTransport, circuitRelayServer } from '@libp2p/circuit-relay-v2'
  * import { identify } from '@libp2p/identify'
@@ -35,6 +35,7 @@
  * 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'
  *
@@ -133,11 +134,15 @@
  * await relay.stop()
  *
  * // send/receive some data from the remote peer via a direct connection
- * stream.send(new TextEncoder().encode('hello world'))
- *
- * stream.addEventListener('message', (evt) => {
- *   console.info(new TextDecoder().decode(evt.data.subarray()))
- * })
+ * await pipe(
+ *   [new TextEncoder().encode('hello world')],
+ *   stream,
+ *   async source => {
+ *     for await (const buf of source) {
+ *       console.info(new TextDecoder().decode(buf.subarray()))
+ *     }
+ *   }
+ * )
  * ```
  *
  * @example WebRTC Direct
@@ -162,6 +167,7 @@
  * ```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'
  *
@@ -190,11 +196,15 @@
  *   signal: AbortSignal.timeout(10_000)
  * })
  *
- * stream.send(new TextEncoder().encode('hello world'))
- *
- * stream.addEventListener('message', (evt) => {
- *   console.info(new TextDecoder().decode(evt.data.subarray()))
- * })
+ * await pipe(
+ *   [fromString(`Hello js-libp2p-webrtc\n`)],
+ *   stream,
+ *   async function (source) {
+ *     for await (const buf of source) {
+ *       console.info(toString(buf.subarray()))
+ *     }
+ *   }
+ * )
  * ```
  *
  * ## WebRTC Direct certificate hashes

package/src/maconn.ts

@@ -0,0 +1,101 @@
+import { nopSink, nopSource } from './util.js'
+import type { RTCPeerConnection } from './webrtc/index.js'
+import type { ComponentLogger, Logger, MultiaddrConnection, MultiaddrConnectionTimeline, CounterGroup } from '@libp2p/interface'
+import type { AbortOptions, Multiaddr } from '@multiformats/multiaddr'
+import type { Source, Sink } from 'it-stream-types'
+import type { Uint8ArrayList } from 'uint8arraylist'
+
+interface WebRTCMultiaddrConnectionInit {
+  /**
+   * WebRTC Peer Connection
+   */
+  peerConnection: RTCPeerConnection
+
+  /**
+   * The multiaddr address used to communicate with the remote peer
+   */
+  remoteAddr: Multiaddr
+
+  /**
+   * Holds the relevant events timestamps of the connection
+   */
+  timeline: MultiaddrConnectionTimeline
+
+  /**
+   * Optional metrics counter group for this connection
+   */
+  metrics?: CounterGroup
+}
+
+export interface WebRTCMultiaddrConnectionComponents {
+  logger: ComponentLogger
+}
+
+export class WebRTCMultiaddrConnection implements MultiaddrConnection {
+  readonly log: Logger
+
+  /**
+   * WebRTC Peer Connection
+   */
+  readonly peerConnection: RTCPeerConnection
+
+  /**
+   * The multiaddr address used to communicate with the remote peer
+   */
+  remoteAddr: Multiaddr
+
+  /**
+   * Holds the life cycle times of the connection
+   */
+  timeline: MultiaddrConnectionTimeline
+
+  /**
+   * Optional metrics counter group for this connection
+   */
+  metrics?: CounterGroup
+
+  /**
+   * The stream source, a no-op as the transport natively supports multiplexing
+   */
+  source: AsyncGenerator<Uint8Array, any, unknown> = nopSource()
+
+  /**
+   * The stream destination, a no-op as the transport natively supports multiplexing
+   */
+  sink: Sink<Source<Uint8Array | Uint8ArrayList>, Promise<void>> = nopSink
+
+  constructor (components: WebRTCMultiaddrConnectionComponents, init: WebRTCMultiaddrConnectionInit) {
+    this.log = components.logger.forComponent('libp2p:webrtc:maconn')
+    this.remoteAddr = init.remoteAddr
+    this.timeline = init.timeline
+    this.peerConnection = init.peerConnection
+
+    const peerConnection = this.peerConnection
+    const initialState = peerConnection.connectionState
+
+    this.peerConnection.onconnectionstatechange = () => {
+      this.log.trace('peer connection state change', peerConnection.connectionState, 'initial state', initialState)
+
+      if (peerConnection.connectionState === 'disconnected' || peerConnection.connectionState === 'failed' || peerConnection.connectionState === 'closed') {
+        // nothing else to do but close the connection
+        this.timeline.close = Date.now()
+      }
+    }
+  }
+
+  async close (options?: AbortOptions): Promise<void> {
+    this.log.trace('closing connection')
+
+    this.peerConnection.close()
+    this.timeline.close = Date.now()
+    this.metrics?.increment({ close: true })
+  }
+
+  abort (err: Error): void {
+    this.log.error('closing connection due to error', err)
+
+    this.peerConnection.close()
+    this.timeline.close = Date.now()
+    this.metrics?.increment({ abort: true })
+  }
+}

package/src/muxer.ts

@@ -1,9 +1,11 @@
-import { AbstractStreamMuxer } from '@libp2p/utils'
-import { pEvent } from 'p-event'
 import { MUXER_PROTOCOL } from './constants.js'
-import { createStream, WebRTCStream } from './stream.js'
+import { createStream } from './stream.js'
+import { drainAndClose, nopSink, nopSource } from './util.js'
 import type { DataChannelOptions } from './index.js'
-import type { ComponentLogger, CounterGroup, StreamMuxer, StreamMuxerFactory, CreateStreamOptions, MultiaddrConnection } from '@libp2p/interface'
+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'
 
 export interface DataChannelMuxerFactoryInit {
   /**
@@ -21,9 +23,6 @@ export interface DataChannelMuxerFactoryInit {
    */
   metrics?: CounterGroup
 
-  /**
-   * Options used to create data channels
-   */
   dataChannelOptions?: DataChannelOptions
 }
 
@@ -31,6 +30,12 @@ export interface DataChannelMuxerFactoryComponents {
   logger: ComponentLogger
 }
 
+interface BufferedStream {
+  stream: Stream
+  channel: RTCDataChannel
+  onEnd(err?: Error): void
+}
+
 export class DataChannelMuxerFactory implements StreamMuxerFactory {
   public readonly protocol: string
 
@@ -38,28 +43,69 @@ 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 (init: DataChannelMuxerFactoryInit) {
+  constructor (components: DataChannelMuxerFactoryComponents, init: DataChannelMuxerFactoryInit) {
+    this.components = components
     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)
+        },
+        log: this.log,
+        ...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 (maConn: MultiaddrConnection): StreamMuxer {
-    return new DataChannelMuxer(maConn, {
+  createStreamMuxer (init?: StreamMuxerInit): StreamMuxer {
+    return new DataChannelMuxer(this.components, {
+      ...init,
       peerConnection: this.peerConnection,
       dataChannelOptions: this.dataChannelOptions,
       metrics: this.metrics,
+      streams: this.bufferedStreams,
       protocol: this.protocol
     })
   }
 }
 
-export interface DataChannelMuxerInit extends DataChannelMuxerFactoryInit {
-  protocol: string
+export interface DataChannelMuxerInit extends DataChannelMuxerFactoryInit, StreamMuxerInit {
+  streams: BufferedStream[]
 }
 
 export interface DataChannelMuxerComponents {
@@ -69,18 +115,26 @@ export interface DataChannelMuxerComponents {
 /**
  * A libp2p data channel stream muxer
  */
-export class DataChannelMuxer extends AbstractStreamMuxer<WebRTCStream> implements StreamMuxer<WebRTCStream> {
+export class DataChannelMuxer implements StreamMuxer {
+  /**
+   * Array of streams in the data channel
+   */
+  public streams: Stream[]
+  public protocol: string
+
+  private readonly log: Logger
   private readonly peerConnection: RTCPeerConnection
   private readonly dataChannelOptions: DataChannelOptions
+  private readonly metrics?: CounterGroup
+  private readonly logger: ComponentLogger
 
-  constructor (maConn: MultiaddrConnection, init: DataChannelMuxerInit) {
-    super(maConn, {
-      ...init,
-      name: 'muxer'
-    })
-
+  constructor (components: DataChannelMuxerComponents, readonly init: DataChannelMuxerInit) {
+    this.log = init.log?.newScope('muxer') ?? components.logger.forComponent('libp2p:webrtc:muxer')
+    this.logger = components.logger
+    this.streams = init.streams.map(s => s.stream)
     this.peerConnection = init.peerConnection
     this.protocol = init.protocol ?? MUXER_PROTOCOL
+    this.metrics = init.metrics
     this.dataChannelOptions = init.dataChannelOptions ?? {}
 
     /**
@@ -90,7 +144,7 @@ export class DataChannelMuxer extends AbstractStreamMuxer<WebRTCStream> implemen
      * {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/datachannel_event}
      */
     this.peerConnection.ondatachannel = ({ channel }) => {
-      this.log.trace('incoming %s datachannel with channel id %d and status', channel.protocol, channel.id, channel.readyState)
+      this.log.trace('incoming datachannel with channel id %d', channel.id)
 
       // 'init' channel is only used during connection establishment
       if (channel.label === 'init') {
@@ -100,46 +154,115 @@ export class DataChannelMuxer extends AbstractStreamMuxer<WebRTCStream> implemen
         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',
-        log: this.log
+        onEnd: () => {
+          this.#onStreamEnd(stream, channel)
+          this.log('incoming channel %s ended', id)
+        },
+        log: this.log,
+        ...this.dataChannelOptions
       })
 
-      this.onRemoteStream(stream)
+      this.streams.push(stream)
+      this.metrics?.increment({ incoming_stream: true })
+      init?.onIncomingStream?.(stream)
     }
-  }
 
-  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 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)
+        })
+      })
+    }
+  }
 
-    this.log('open channel %d for protocol %s', channel.id, options?.protocol)
+  #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)
+  }
 
-    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)
+  /**
+   * 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)
+    }
+  }
 
-      this.log('channel %d state is now "%s", sending data', channel.id, channel.readyState)
+  /**
+   * Abort all tracked streams and stop the muxer
+   */
+  abort (err: Error): void {
+    for (const stream of this.streams) {
+      stream.abort(err)
     }
+  }
+
+  /**
+   * The stream source, a no-op as the transport natively supports multiplexing
+   */
+  source: AsyncGenerator<Uint8Array, any, unknown> = nopSource()
+
+  /**
+   * The stream destination, a no-op as the transport natively supports multiplexing
+   */
+  sink: Sink<Source<Uint8Array | Uint8ArrayList>, Promise<void>> = nopSink
+
+  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
+
+    this.log.trace('opened outgoing datachannel with channel id %s', id)
 
     const stream = createStream({
-      ...options,
-      ...this.dataChannelOptions,
       channel,
       direction: 'outbound',
-      log: this.log
+      onEnd: () => {
+        this.#onStreamEnd(stream, channel)
+        this.log('outgoing channel %s ended', id)
+      },
+      log: this.log,
+      ...this.dataChannelOptions
     })
+    this.streams.push(stream)
+    this.metrics?.increment({ outgoing_stream: true })
 
     return stream
   }
-
-  onData (): void {
-
-  }
 }

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

@@ -1,5 +1,4 @@
-import { pbStream } from '@libp2p/utils'
-import { pEvent } from 'p-event'
+import { pbStream } from 'it-protobuf-stream'
 import { CustomProgressEvent } from 'progress-events'
 import { SIGNALING_PROTOCOL } from '../constants.js'
 import { SDPHandshakeFailedError } from '../error.js'
@@ -10,14 +9,15 @@ 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 } from '@libp2p/interface'
+import type { LoggerOptions, Connection, ComponentLogger, IncomingStreamData } from '@libp2p/interface'
 import type { ConnectionManager, TransportManager } from '@libp2p/interface-internal'
-import type { AbortOptions, Multiaddr } from '@multiformats/multiaddr'
+import type { Multiaddr } from '@multiformats/multiaddr'
 import type { ProgressOptions } from 'progress-events'
 
-export interface IncomingStreamOptions extends AbortOptions {
+export interface IncomingStreamOpts extends IncomingStreamData {
   rtcConfiguration?: RTCConfiguration
   dataChannelOptions?: Partial<DataChannelOptions>
+  signal: AbortSignal
 }
 
 export interface ConnectOptions extends LoggerOptions, ProgressOptions<WebRTCDialEvents> {
@@ -67,21 +67,9 @@ 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({
-    // @ts-expect-error https://github.com/murat-dogan/node-datachannel/pull/370
+    logger
+  }, {
     peerConnection,
     dataChannelOptions: dataChannel
   })
@@ -109,7 +97,7 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
         signal
       })
         .catch(err => {
-          log.error('error sending ICE candidate - %e', err)
+          log.error('error sending ICE candidate', err)
         })
     }
     peerConnection.onicecandidateerror = (event) => {
@@ -169,17 +157,7 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
       onProgress
     })
 
-    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')
-
+    log.trace('initiator connected, closing init channel')
     channel.close()
 
     onProgress?.(new CustomProgressEvent('webrtc:close-signaling-stream'))

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

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