@libp2p/webrtc 6.0.2 → 6.0.3-de2ad9ca5

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

@@ -69,13 +69,13 @@ export async function handleIncomingStream (stream: Stream, connection: Connecti
     })
 
     await peerConnection.setRemoteDescription(offer).catch(err => {
-      log.error('could not execute setRemoteDescription', err)
+      log.error('could not execute setRemoteDescription - %e', err)
       throw new SDPHandshakeFailedError('Failed to set remoteDescription')
     })
 
     // create and write an SDP answer
     const answer = await peerConnection.createAnswer().catch(err => {
-      log.error('could not execute createAnswer', err)
+      log.error('could not execute createAnswer - %e', err)
       throw new SDPHandshakeFailedError('Failed to create answer')
     })
 
@@ -87,7 +87,7 @@ export async function handleIncomingStream (stream: Stream, connection: Connecti
     })
 
     await peerConnection.setLocalDescription(answer).catch(err => {
-      log.error('could not execute setLocalDescription', err)
+      log.error('could not execute setLocalDescription - %e', err)
       throw new SDPHandshakeFailedError('Failed to set localDescription')
     })
 
@@ -101,7 +101,7 @@ export async function handleIncomingStream (stream: Stream, connection: Connecti
     })
   } catch (err: any) {
     if (peerConnection.connectionState !== 'connected') {
-      log.error('error while handling signaling stream from peer %a', connection.remoteAddr, err)
+      log.error('error while handling signaling stream from peer %a - %e', connection.remoteAddr, err)
 
       peerConnection.close()
       throw err

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

@@ -114,7 +114,7 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
 
       this._onProtocol(stream, connection, signal)
         .catch(err => {
-          this.log.error('failed to handle incoming connect from %p', connection.remotePeer, err)
+          this.log.error('failed to handle incoming connect from %p - %e', connection.remotePeer, err)
         })
         .finally(() => {
           signal.clear()
@@ -229,6 +229,7 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
       })
 
       const webRTCConn = toMultiaddrConnection({
+        // @ts-expect-error https://github.com/murat-dogan/node-datachannel/pull/370
         peerConnection,
         remoteAddr: remoteAddress,
         metrics: this.metrics?.listenerEvents,
@@ -245,9 +246,10 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
       })
 
       // close the connection on shut down
+      // @ts-expect-error https://github.com/murat-dogan/node-datachannel/pull/370
       this._closeOnShutdown(peerConnection, webRTCConn)
     } catch (err: any) {
-      this.log.error('incoming signaling error', err)
+      this.log.error('incoming signaling error - %e', err)
 
       peerConnection.close()
       stream.abort(err)
@@ -255,12 +257,12 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
     }
   }
 
-  private _closeOnShutdown (pc: RTCPeerConnection, webRTCConn: MultiaddrConnection): void {
+  private _closeOnShutdown (pc: globalThis.RTCPeerConnection, webRTCConn: MultiaddrConnection): void {
     // close the connection on shut down
     const shutDownListener = (): void => {
       webRTCConn.close()
         .catch(err => {
-          this.log.error('could not close WebRTCMultiaddrConnection', err)
+          this.log.error('could not close WebRTCMultiaddrConnection - %e', err)
         })
     }
 

package/src/private-to-public/listener.ts

@@ -27,6 +27,7 @@ export interface WebRTCDirectListenerComponents {
   keychain?: Keychain
   datastore: Datastore
   metrics?: Metrics
+  events?: CounterGroup
 }
 
 export interface WebRTCDirectListenerInit {
@@ -159,7 +160,7 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
 
             this.incomingConnection(ufrag, remoteHost, remotePort, signal)
               .catch(err => {
-                this.log.error('error processing incoming STUN request', err)
+                this.log.error('error processing incoming STUN request - %e', err)
               })
               .finally(() => {
                 signal.clear()
@@ -184,7 +185,13 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
     signal.throwIfAborted()
 
     // https://github.com/libp2p/specs/blob/master/webrtc/webrtc-direct.md#browser-to-public-server
-    peerConnection = await createDialerRTCPeerConnection('server', ufrag, this.init.rtcConfiguration, this.certificate)
+    const results = await createDialerRTCPeerConnection('server', ufrag, {
+      rtcConfiguration: this.init.rtcConfiguration,
+      certificate: this.certificate,
+      events: this.metrics?.listenerEvents,
+      dataChannel: this.init.dataChannel
+    })
+    peerConnection = results.peerConnection
 
     this.connections.set(key, peerConnection)
 
@@ -201,11 +208,10 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
     })
 
     try {
-      await connect(peerConnection, ufrag, {
+      await connect(peerConnection, results.muxerFactory, ufrag, {
         role: 'server',
         log: this.log,
         logger: this.components.logger,
-        metrics: this.components.metrics,
         events: this.metrics?.listenerEvents,
         signal,
         remoteAddr: multiaddr(`/ip${isIPv4(remoteHost) ? 4 : 6}/${remoteHost}/udp/${remotePort}/webrtc-direct`),

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

@@ -163,14 +163,19 @@ export class WebRTCDirectTransport implements Transport, Startable {
     const ufrag = genUfrag()
 
     // https://github.com/libp2p/specs/blob/master/webrtc/webrtc-direct.md#browser-to-public-server
-    const peerConnection = await createDialerRTCPeerConnection('client', ufrag, typeof this.init.rtcConfiguration === 'function' ? await this.init.rtcConfiguration() : this.init.rtcConfiguration ?? {})
+    const {
+      peerConnection,
+      muxerFactory
+    } = await createDialerRTCPeerConnection('client', ufrag, {
+      rtcConfiguration: typeof this.init.rtcConfiguration === 'function' ? await this.init.rtcConfiguration() : this.init.rtcConfiguration ?? {},
+      dataChannel: this.init.dataChannel
+    })
 
     try {
-      return await connect(peerConnection, ufrag, {
+      return await connect(peerConnection, muxerFactory, ufrag, {
         role: 'client',
         log: this.log,
         logger: this.components.logger,
-        metrics: this.components.metrics,
         events: this.metrics?.dialerEvents,
         signal: options.signal,
         remoteAddr: ma,

package/src/private-to-public/utils/connect.ts

@@ -9,13 +9,12 @@ import { generateNoisePrologue } from './generate-noise-prologue.js'
 import * as sdp from './sdp.js'
 import type { DirectRTCPeerConnection } from './get-rtcpeerconnection.js'
 import type { DataChannelOptions } from '../../index.js'
-import type { ComponentLogger, Connection, CounterGroup, Logger, Metrics, PeerId, PrivateKey, Upgrader } from '@libp2p/interface'
+import type { ComponentLogger, Connection, CounterGroup, Logger, PeerId, PrivateKey, Upgrader } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 export interface ConnectOptions {
   log: Logger
   logger: ComponentLogger
-  metrics?: Metrics
   events?: CounterGroup
   remoteAddr: Multiaddr
   role: 'client' | 'server'
@@ -37,9 +36,13 @@ export interface ServerOptions extends ConnectOptions {
 
 const CONNECTION_STATE_CHANGE_EVENT = isFirefox ? 'iceconnectionstatechange' : 'connectionstatechange'
 
-export async function connect (peerConnection: DirectRTCPeerConnection, ufrag: string, options: ClientOptions): Promise<Connection>
-export async function connect (peerConnection: DirectRTCPeerConnection, ufrag: string, options: ServerOptions): Promise<void>
-export async function connect (peerConnection: DirectRTCPeerConnection, ufrag: string, options: ConnectOptions): Promise<any> {
+function isServer (options: ClientOptions | ServerOptions, peerConnection: any): peerConnection is DirectRTCPeerConnection {
+  return options.role === 'server'
+}
+
+export async function connect (peerConnection: RTCPeerConnection, muxerFactory: DataChannelMuxerFactory, ufrag: string, options: ClientOptions): Promise<Connection>
+export async function connect (peerConnection: DirectRTCPeerConnection, muxerFactory: DataChannelMuxerFactory, ufrag: string, options: ServerOptions): Promise<void>
+export async function connect (peerConnection: RTCPeerConnection | DirectRTCPeerConnection, muxerFactory: DataChannelMuxerFactory, ufrag: string, options: ClientOptions | ServerOptions): Promise<any> {
   // create data channel for running the noise handshake. Once the data
   // channel is opened, the listener will initiate the noise handshake. This
   // is used to confirm the identity of the peer.
@@ -88,7 +91,7 @@ export async function connect (peerConnection: DirectRTCPeerConnection, ufrag: s
 
     options.log.trace('%s handshake channel opened', options.role)
 
-    if (options.role === 'server') {
+    if (isServer(options, peerConnection)) {
       // now that the connection has been opened, add the remote's certhash to
       // it's multiaddr so we can complete the noise handshake
       const remoteFingerprint = peerConnection.remoteFingerprint()?.value ?? ''
@@ -124,6 +127,7 @@ export async function connect (peerConnection: DirectRTCPeerConnection, ufrag: s
     // Creating the connection before completion of the noise
     // handshake ensures that the stream opening callback is set up
     const maConn = toMultiaddrConnection({
+      // @ts-expect-error types are broken
       peerConnection,
       remoteAddr: options.remoteAddr,
       metrics: options.events,
@@ -137,7 +141,7 @@ export async function connect (peerConnection: DirectRTCPeerConnection, ufrag: s
         case 'disconnected':
         case 'closed':
           maConn.close().catch((err) => {
-            options.log.error('error closing connection', err)
+            options.log.error('error closing connection - %e', err)
             maConn.abort(err)
           })
           break
@@ -149,13 +153,6 @@ export async function connect (peerConnection: DirectRTCPeerConnection, ufrag: s
     // Track opened peer connection
     options.events?.increment({ peer_connection: true })
 
-    const muxerFactory = new DataChannelMuxerFactory({
-      // @ts-expect-error https://github.com/murat-dogan/node-datachannel/pull/370
-      peerConnection,
-      metrics: options.events,
-      dataChannelOptions: options.dataChannel
-    })
-
     if (options.role === 'client') {
       // For outbound connections, the remote is expected to start the noise
       // handshake. Therefore, we need to secure an inbound noise connection

package/src/private-to-public/utils/get-rtcpeerconnection.browser.ts

@@ -1,4 +1,10 @@
-export async function createDialerRTCPeerConnection (role: 'client' | 'server', ufrag: string, rtcConfiguration?: RTCConfiguration | (() => RTCConfiguration | Promise<RTCConfiguration>), certificate?: RTCCertificate): Promise<RTCPeerConnection> {
+import { DataChannelMuxerFactory } from '../../muxer.ts'
+import type { CreateDialerRTCPeerConnectionOptions } from './get-rtcpeerconnection.ts'
+
+export async function createDialerRTCPeerConnection (role: 'client' | 'server', ufrag: string, options: CreateDialerRTCPeerConnectionOptions = {}): Promise<{ peerConnection: RTCPeerConnection, muxerFactory: DataChannelMuxerFactory }> {
+  // @ts-expect-error options type is wrong
+  let certificate: RTCCertificate = options.certificate
+
   if (certificate == null) {
     // ECDSA is preferred over RSA here. From our testing we find that P-256 elliptic
     // curve is supported by Pion, webrtc-rs, as well as Chromium (P-228 and P-384
@@ -13,10 +19,21 @@ export async function createDialerRTCPeerConnection (role: 'client' | 'server',
     })
   }
 
-  const rtcConfig = typeof rtcConfiguration === 'function' ? await rtcConfiguration() : rtcConfiguration
+  const rtcConfig = typeof options.rtcConfiguration === 'function' ? await options.rtcConfiguration() : options.rtcConfiguration
 
-  return new RTCPeerConnection({
+  const peerConnection = new RTCPeerConnection({
     ...(rtcConfig ?? {}),
     certificates: [certificate]
   })
+
+  const muxerFactory = new DataChannelMuxerFactory({
+    peerConnection,
+    metrics: options.events,
+    dataChannelOptions: options.dataChannel
+  })
+
+  return {
+    peerConnection,
+    muxerFactory
+  }
 }

package/src/private-to-public/utils/get-rtcpeerconnection.ts

@@ -2,8 +2,10 @@ import { Crypto } from '@peculiar/webcrypto'
 import { PeerConnection } from 'node-datachannel'
 import { RTCPeerConnection } from 'node-datachannel/polyfill'
 import { DEFAULT_ICE_SERVERS, MAX_MESSAGE_SIZE } from '../../constants.js'
+import { DataChannelMuxerFactory } from '../../muxer.ts'
 import { generateTransportCertificate } from './generate-certificates.js'
-import type { TransportCertificate } from '../../index.js'
+import type { DataChannelOptions, TransportCertificate } from '../../index.js'
+import type { CounterGroup } from '@libp2p/interface'
 import type { CertificateFingerprint } from 'node-datachannel'
 
 const crypto = new Crypto()
@@ -85,8 +87,17 @@ function mapIceServers (iceServers?: RTCIceServer[]): string[] {
     .flat() ?? []
 }
 
-export async function createDialerRTCPeerConnection (role: 'client' | 'server', ufrag: string, rtcConfiguration?: RTCConfiguration | (() => RTCConfiguration | Promise<RTCConfiguration>), certificate?: TransportCertificate): Promise<DirectRTCPeerConnection> {
-  if (certificate == null) {
+export interface CreateDialerRTCPeerConnectionOptions {
+  rtcConfiguration?: RTCConfiguration | (() => RTCConfiguration | Promise<RTCConfiguration>)
+  certificate?: TransportCertificate
+  events?: CounterGroup
+  dataChannel?: DataChannelOptions
+}
+
+export async function createDialerRTCPeerConnection (role: 'client', ufrag: string, options?: CreateDialerRTCPeerConnectionOptions): Promise<{ peerConnection: globalThis.RTCPeerConnection, muxerFactory: DataChannelMuxerFactory }>
+export async function createDialerRTCPeerConnection (role: 'server', ufrag: string, options?: CreateDialerRTCPeerConnectionOptions): Promise<{ peerConnection: DirectRTCPeerConnection, muxerFactory: DataChannelMuxerFactory }>
+export async function createDialerRTCPeerConnection (role: 'client' | 'server', ufrag: string, options: CreateDialerRTCPeerConnectionOptions = {}): Promise<{ peerConnection: globalThis.RTCPeerConnection | DirectRTCPeerConnection, muxerFactory: DataChannelMuxerFactory }> {
+  if (options.certificate == null) {
     // ECDSA is preferred over RSA here. From our testing we find that P-256
     // elliptic curve is supported by Pion, webrtc-rs, as well as Chromium
     // (P-228 and P-384 was not supported in Chromium). We use the same hash
@@ -96,24 +107,36 @@ export async function createDialerRTCPeerConnection (role: 'client' | 'server',
       namedCurve: 'P-256'
     }, true, ['sign', 'verify'])
 
-    certificate = await generateTransportCertificate(keyPair, {
+    options.certificate = await generateTransportCertificate(keyPair, {
       days: 365
     })
   }
 
-  const rtcConfig = typeof rtcConfiguration === 'function' ? await rtcConfiguration() : rtcConfiguration
+  const rtcConfig = typeof options.rtcConfiguration === 'function' ? await options.rtcConfiguration() : options.rtcConfiguration
 
-  return new DirectRTCPeerConnection({
+  const peerConnection = new DirectRTCPeerConnection({
     ...rtcConfig,
     ufrag,
     peerConnection: new PeerConnection(`${role}-${Date.now()}`, {
       disableFingerprintVerification: true,
       disableAutoNegotiation: true,
-      certificatePemFile: certificate.pem,
-      keyPemFile: certificate.privateKey,
+      certificatePemFile: options.certificate.pem,
+      keyPemFile: options.certificate.privateKey,
       enableIceUdpMux: role === 'server',
       maxMessageSize: MAX_MESSAGE_SIZE,
       iceServers: mapIceServers(rtcConfig?.iceServers ?? DEFAULT_ICE_SERVERS.map(urls => ({ urls })))
     })
   })
+
+  const muxerFactory = new DataChannelMuxerFactory({
+    // @ts-expect-error https://github.com/murat-dogan/node-datachannel/pull/370
+    peerConnection,
+    metrics: options.events,
+    dataChannelOptions: options.dataChannel
+  })
+
+  return {
+    peerConnection,
+    muxerFactory
+  }
 }

package/src/rtcpeerconnection-to-conn.ts

@@ -1,5 +1,4 @@
 import { AbstractMultiaddrConnection } from '@libp2p/utils'
-import type { RTCPeerConnection } from './webrtc/index.js'
 import type { AbortOptions, MultiaddrConnection } from '@libp2p/interface'
 import type { AbstractMultiaddrConnectionInit, SendResult } from '@libp2p/utils'
 import type { Uint8ArrayList } from 'uint8arraylist'

package/src/stream.ts

@@ -88,23 +88,6 @@ export class WebRTCStream extends AbstractStream {
       }
     }
 
-    if (this.channel.readyState !== 'open') {
-      this.log('channel ready state is "%s" and not "open", waiting for "open" event before sending data', this.channel.readyState)
-      pEvent(this.channel, 'open', {
-        rejectionEvents: [
-          'close',
-          'error'
-        ]
-      })
-        .then(() => {
-          this.log('channel ready state is now "%s", dispatching drain', this.channel.readyState)
-          this.safeDispatchEvent('drain')
-        })
-        .catch(err => {
-          this.abort(err.error ?? err)
-        })
-    }
-
     // pipe framed protobuf messages through a length prefixed decoder, and
     // surface data from the `Message.message` field through a source.
     Promise.resolve().then(async () => {
@@ -113,7 +96,7 @@ export class WebRTCStream extends AbstractStream {
       }
     })
       .catch(err => {
-        this.log.error('error processing incoming data channel messages', err)
+        this.log.error('error processing incoming data channel messages - %e', err)
       })
 
     // close when both writable ends are closed or an error occurs
@@ -124,6 +107,26 @@ export class WebRTCStream extends AbstractStream {
       }
     }
     this.addEventListener('close', cleanUpDatachannelOnClose)
+
+    // chrome can receive message events before the open even is fired - calling
+    // code needs to attach message event listeners before these events occur
+    // but we need to wait before sending any data so this has to be done async
+    if (this.channel.readyState !== 'open') {
+      this.log('channel ready state is "%s" and not "open", waiting for "open" event before sending data', this.channel.readyState)
+      pEvent(this.channel, 'open', {
+        rejectionEvents: [
+          'close',
+          'error'
+        ]
+      })
+        .then(() => {
+          this.log('channel ready state is now "%s", dispatching drain', this.channel.readyState)
+          this.safeDispatchEvent('drain')
+        })
+        .catch(err => {
+          this.abort(err.error ?? err)
+        })
+    }
   }
 
   sendNewStream (): void {
@@ -204,8 +207,13 @@ export class WebRTCStream extends AbstractStream {
     options?.signal?.throwIfAborted()
     this.receivedFinAck = Promise.withResolvers<void>()
 
+    // wait for either:
+    // 1. the FIN_ACK to be received
+    // 2. the datachannel to close
+    // 3. timeout
     await Promise.any([
       raceSignal(this.receivedFinAck.promise, options?.signal),
+      pEvent(this.channel, 'close'),
       new Promise<void>(resolve => {
         AbortSignal.timeout(this.finAckTimeout)
           .addEventListener('abort', () => {

package/src/util.ts

@@ -77,7 +77,7 @@ export function drainAndClose (channel: RTCDataChannel, direction: string, drain
       }
     })
     .catch(err => {
-      options.log.error('error closing outbound stream', err)
+      options.log.error('error closing outbound stream - %e', err)
     })
 }
 

package/dist/typedoc-urls.json

@@ -1,14 +0,0 @@
-{
-  "DataChannelOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.DataChannelOptions.html",
-  ".:DataChannelOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.DataChannelOptions.html",
-  "TransportCertificate": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.TransportCertificate.html",
-  ".:TransportCertificate": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.TransportCertificate.html",
-  "WebRTCDirectTransportComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.WebRTCDirectTransportComponents.html",
-  "WebRTCTransportComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.WebRTCTransportComponents.html",
-  "WebRTCTransportDirectInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.WebRTCTransportDirectInit.html",
-  "WebRTCTransportInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.WebRTCTransportInit.html",
-  "webRTC": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTC.html",
-  ".:webRTC": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTC.html",
-  "webRTCDirect": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTCDirect.html",
-  ".:webRTCDirect": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTCDirect.html"
-}