@libp2p/webrtc 5.2.24-6059227cb → 5.2.24-87bc8d4fb

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/webrtc",
-  "version": "5.2.24-6059227cb",
+  "version": "5.2.24-87bc8d4fb",
   "description": "A libp2p transport using WebRTC connections",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p/tree/main/packages/transport-webrtc#readme",
@@ -45,49 +45,52 @@
   },
   "dependencies": {
     "@chainsafe/is-ip": "^2.1.0",
-    "@libp2p/crypto": "5.1.8-6059227cb",
-    "@libp2p/interface": "2.11.0-6059227cb",
-    "@libp2p/interface-internal": "2.3.19-6059227cb",
-    "@libp2p/keychain": "5.2.9-6059227cb",
-    "@libp2p/noise": "16.1.4-6059227cb",
-    "@libp2p/peer-id": "5.1.9-6059227cb",
-    "@libp2p/utils": "6.7.2-6059227cb",
-    "@multiformats/multiaddr": "^13.0.1",
-    "@multiformats/multiaddr-matcher": "^3.0.1",
+    "@chainsafe/libp2p-noise": "^16.1.3",
+    "@ipshipyard/node-datachannel": "^0.26.6",
+    "@libp2p/crypto": "5.1.8-87bc8d4fb",
+    "@libp2p/interface": "2.11.0-87bc8d4fb",
+    "@libp2p/interface-internal": "2.3.19-87bc8d4fb",
+    "@libp2p/keychain": "5.2.9-87bc8d4fb",
+    "@libp2p/peer-id": "5.1.9-87bc8d4fb",
+    "@libp2p/utils": "6.7.2-87bc8d4fb",
+    "@multiformats/multiaddr": "^12.4.4",
+    "@multiformats/multiaddr-matcher": "^2.0.0",
     "@peculiar/webcrypto": "^1.5.0",
-    "@peculiar/x509": "^1.13.0",
+    "@peculiar/x509": "^1.12.3",
+    "any-signal": "^4.1.1",
     "detect-browser": "^5.3.0",
     "get-port": "^7.1.0",
-    "interface-datastore": "^8.3.2",
+    "interface-datastore": "^8.3.1",
     "it-length-prefixed": "^10.0.1",
-    "it-protobuf-stream": "^2.0.3",
+    "it-protobuf-stream": "^2.0.2",
     "it-pushable": "^3.2.3",
     "it-stream-types": "^2.0.2",
     "main-event": "^1.0.1",
-    "multiformats": "^13.4.0",
-    "node-datachannel": "^0.29.0",
+    "multiformats": "^13.3.6",
     "p-defer": "^4.0.1",
-    "p-event": "^6.0.1",
     "p-timeout": "^6.1.4",
     "p-wait-for": "^5.0.2",
     "progress-events": "^1.0.1",
-    "protons-runtime": "^5.6.0",
-    "race-signal": "^2.0.0",
-    "react-native-webrtc": "^124.0.6",
+    "protons-runtime": "^5.5.0",
+    "race-event": "^1.3.0",
+    "race-signal": "^1.1.3",
+    "react-native-webrtc": "^124.0.5",
     "uint8-varint": "^2.0.4",
     "uint8arraylist": "^2.4.8",
     "uint8arrays": "^5.1.0"
   },
   "devDependencies": {
-    "@libp2p/logger": "5.2.0-6059227cb",
+    "@libp2p/interface-compliance-tests": "6.5.0-87bc8d4fb",
+    "@libp2p/logger": "5.2.0-87bc8d4fb",
     "@types/sinon": "^17.0.4",
-    "aegir": "^47.0.22",
-    "any-signal": "^4.1.1",
-    "datastore-core": "^10.0.4",
+    "aegir": "^47.0.14",
+    "datastore-core": "^10.0.2",
     "delay": "^6.0.0",
-    "p-retry": "^7.0.0",
-    "protons": "^7.7.0",
-    "sinon": "^21.0.0",
+    "it-length": "^3.0.8",
+    "it-pair": "^2.0.6",
+    "p-retry": "^6.2.1",
+    "protons": "^7.6.1",
+    "sinon": "^20.0.0",
     "sinon-ts": "^2.0.0",
     "wherearewe": "^2.0.1"
   },

package/src/constants.ts

@@ -26,11 +26,26 @@ export const UFRAG_ALPHABET = Array.from('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKL
  */
 export const UFRAG_PREFIX = 'libp2p+webrtc+v1/'
 
+/**
+ * The multicodec code for webrtc-direct tuples
+ */
+export const CODEC_WEBRTC_DIRECT = 0x0118
+
+/**
+ * The multicodec code for certhash tuples
+ */
+export const CODEC_CERTHASH = 0x01d2
+
 /**
  * How much can be buffered to the DataChannel at once
  */
 export const MAX_BUFFERED_AMOUNT = 2 * 1024 * 1024
 
+/**
+ * How long time we wait for the 'bufferedamountlow' event to be emitted
+ */
+export const BUFFERED_AMOUNT_LOW_TIMEOUT = 30 * 1000
+
 /**
  * Max message size that can be sent to the DataChannel. In browsers this is
  * 256KiB but go-libp2p and rust-libp2p only support 16KiB at the time of
@@ -68,15 +83,23 @@ function calculateProtobufOverhead (maxMessageSize = MAX_MESSAGE_SIZE): number {
 export const PROTOBUF_OVERHEAD = calculateProtobufOverhead()
 
 /**
- * When closing a stream, we wait for `bufferedAmount` to become 0 before
- * closing the underlying RTCDataChannel - this controls how long we wait in ms
+ * When closing streams we send a FIN then wait for the remote to
+ * reply with a FIN_ACK. If that does not happen within this timeout
+ * we close the stream anyway.
  */
-export const DATA_CHANNEL_DRAIN_TIMEOUT = 30_000
+export const FIN_ACK_TIMEOUT = 5_000
 
 /**
- * Wait for the remote to acknowledge our FIN for this long
+ * When sending data messages, if the channel is not in the "open" state, wait
+ * this long for the "open" event to fire.
  */
-export const DEFAULT_FIN_ACK_TIMEOUT = 10_000
+export const OPEN_TIMEOUT = 5_000
+
+/**
+ * When closing a stream, we wait for `bufferedAmount` to become 0 before
+ * closing the underlying RTCDataChannel - this controls how long we wait in ms
+ */
+export const DATA_CHANNEL_DRAIN_TIMEOUT = 30_000
 
 /**
  * Set as the 'negotiated' muxer protocol name

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
@@ -308,15 +318,6 @@ export interface DataChannelOptions {
    * @default 5_000
    */
   openTimeout?: number
-
-  /**
-   * Due to bugs in WebRTC implementations it's necessary for the remote end of
-   * the connection to acknowledge the FIN message we send during stream
-   * closing. A stream will wait for this many ms.
-   *
-   * @default 10_000
-   */
-  finAckTimeout?: number
 }
 
 /**

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,8 +1,11 @@
-import { AbstractStreamMuxer } from '@libp2p/utils'
 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 {
   /**
@@ -20,9 +23,6 @@ export interface DataChannelMuxerFactoryInit {
    */
   metrics?: CounterGroup
 
-  /**
-   * Options used to create data channels
-   */
   dataChannelOptions?: DataChannelOptions
 }
 
@@ -30,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
 
@@ -37,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 {
@@ -68,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 ?? {}
 
     /**
@@ -89,50 +144,125 @@ 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, protocol %s and status %s', channel.protocol, channel.id, channel.protocol, channel.readyState)
+      this.log.trace('incoming datachannel with channel id %d', channel.id)
 
-      // 'init' channel is only used during connection establishment, it is
-      // closed by the initiator
+      // 'init' channel is only used during connection establishment
       if (channel.label === 'init') {
-        this.log.trace('closing init channel %d', channel.id)
+        this.log.trace('closing init channel')
         channel.close()
 
         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.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)
+  }
 
-      this.onRemoteStream(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)
     }
   }
 
-  async onCreateStream (options?: CreateStreamOptions): Promise<WebRTCStream> {
+  /**
+   * 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('', {
-      // TODO: pre-negotiate stream protocol
-      // protocol: options?.protocol
-    })
+    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('open channel %d for protocol %s', channel.id, options?.protocol)
+    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 {
-
-  }
 }