@libp2p/webrtc 6.0.2-334f91bdc → 6.0.2-39e2e541a

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 - %e', err)
+      log.error('could not execute setRemoteDescription', 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 - %e', err)
+      log.error('could not execute createAnswer', 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 - %e', err)
+      log.error('could not execute setLocalDescription', 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 - %e', connection.remoteAddr, err)
+      log.error('error while handling signaling stream from peer %a', 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 - %e', connection.remotePeer, err)
+          this.log.error('failed to handle incoming connect from %p', connection.remotePeer, err)
         })
         .finally(() => {
           signal.clear()
@@ -229,7 +229,6 @@ 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,
@@ -246,10 +245,9 @@ 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 - %e', err)
+      this.log.error('incoming signaling error', err)
 
       peerConnection.close()
       stream.abort(err)
@@ -257,12 +255,12 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
     }
   }
 
-  private _closeOnShutdown (pc: globalThis.RTCPeerConnection, webRTCConn: MultiaddrConnection): void {
+  private _closeOnShutdown (pc: RTCPeerConnection, webRTCConn: MultiaddrConnection): void {
     // close the connection on shut down
     const shutDownListener = (): void => {
       webRTCConn.close()
         .catch(err => {
-          this.log.error('could not close WebRTCMultiaddrConnection - %e', err)
+          this.log.error('could not close WebRTCMultiaddrConnection', err)
         })
     }
 

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

@@ -27,7 +27,6 @@ export interface WebRTCDirectListenerComponents {
   keychain?: Keychain
   datastore: Datastore
   metrics?: Metrics
-  events?: CounterGroup
 }
 
 export interface WebRTCDirectListenerInit {
@@ -160,7 +159,7 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
 
             this.incomingConnection(ufrag, remoteHost, remotePort, signal)
               .catch(err => {
-                this.log.error('error processing incoming STUN request - %e', err)
+                this.log.error('error processing incoming STUN request', err)
               })
               .finally(() => {
                 signal.clear()
@@ -185,13 +184,7 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
     signal.throwIfAborted()
 
     // https://github.com/libp2p/specs/blob/master/webrtc/webrtc-direct.md#browser-to-public-server
-    const results = await createDialerRTCPeerConnection('server', ufrag, {
-      rtcConfiguration: this.init.rtcConfiguration,
-      certificate: this.certificate,
-      events: this.metrics?.listenerEvents,
-      dataChannel: this.init.dataChannel
-    })
-    peerConnection = results.peerConnection
+    peerConnection = await createDialerRTCPeerConnection('server', ufrag, this.init.rtcConfiguration, this.certificate)
 
     this.connections.set(key, peerConnection)
 
@@ -208,10 +201,11 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
     })
 
     try {
-      await connect(peerConnection, results.muxerFactory, ufrag, {
+      await connect(peerConnection, 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,19 +163,14 @@ 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,
-      muxerFactory
-    } = await createDialerRTCPeerConnection('client', ufrag, {
-      rtcConfiguration: typeof this.init.rtcConfiguration === 'function' ? await this.init.rtcConfiguration() : this.init.rtcConfiguration ?? {},
-      dataChannel: this.init.dataChannel
-    })
+    const peerConnection = await createDialerRTCPeerConnection('client', ufrag, typeof this.init.rtcConfiguration === 'function' ? await this.init.rtcConfiguration() : this.init.rtcConfiguration ?? {})
 
     try {
-      return await connect(peerConnection, muxerFactory, ufrag, {
+      return await connect(peerConnection, 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,12 +9,13 @@ 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, PeerId, PrivateKey, Upgrader } from '@libp2p/interface'
+import type { ComponentLogger, Connection, CounterGroup, Logger, Metrics, 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'
@@ -36,13 +37,9 @@ export interface ServerOptions extends ConnectOptions {
 
 const CONNECTION_STATE_CHANGE_EVENT = isFirefox ? 'iceconnectionstatechange' : 'connectionstatechange'
 
-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> {
+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> {
   // 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.
@@ -91,7 +88,7 @@ export async function connect (peerConnection: RTCPeerConnection | DirectRTCPeer
 
     options.log.trace('%s handshake channel opened', options.role)
 
-    if (isServer(options, peerConnection)) {
+    if (options.role === 'server') {
       // 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 ?? ''
@@ -127,7 +124,6 @@ export async function connect (peerConnection: RTCPeerConnection | DirectRTCPeer
     // 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,
@@ -141,7 +137,7 @@ export async function connect (peerConnection: RTCPeerConnection | DirectRTCPeer
         case 'disconnected':
         case 'closed':
           maConn.close().catch((err) => {
-            options.log.error('error closing connection - %e', err)
+            options.log.error('error closing connection', err)
             maConn.abort(err)
           })
           break
@@ -153,6 +149,13 @@ export async function connect (peerConnection: RTCPeerConnection | DirectRTCPeer
     // 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,10 +1,4 @@
-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
-
+export async function createDialerRTCPeerConnection (role: 'client' | 'server', ufrag: string, rtcConfiguration?: RTCConfiguration | (() => RTCConfiguration | Promise<RTCConfiguration>), certificate?: RTCCertificate): Promise<RTCPeerConnection> {
   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
@@ -19,21 +13,10 @@ export async function createDialerRTCPeerConnection (role: 'client' | 'server',
     })
   }
 
-  const rtcConfig = typeof options.rtcConfiguration === 'function' ? await options.rtcConfiguration() : options.rtcConfiguration
+  const rtcConfig = typeof rtcConfiguration === 'function' ? await rtcConfiguration() : rtcConfiguration
 
-  const peerConnection = new RTCPeerConnection({
+  return 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,10 +2,8 @@ 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 { DataChannelOptions, TransportCertificate } from '../../index.js'
-import type { CounterGroup } from '@libp2p/interface'
+import type { TransportCertificate } from '../../index.js'
 import type { CertificateFingerprint } from 'node-datachannel'
 
 const crypto = new Crypto()
@@ -87,17 +85,8 @@ function mapIceServers (iceServers?: RTCIceServer[]): string[] {
     .flat() ?? []
 }
 
-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) {
+export async function createDialerRTCPeerConnection (role: 'client' | 'server', ufrag: string, rtcConfiguration?: RTCConfiguration | (() => RTCConfiguration | Promise<RTCConfiguration>), certificate?: TransportCertificate): Promise<DirectRTCPeerConnection> {
+  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 was not supported in Chromium). We use the same hash
@@ -107,36 +96,24 @@ export async function createDialerRTCPeerConnection (role: 'client' | 'server',
       namedCurve: 'P-256'
     }, true, ['sign', 'verify'])
 
-    options.certificate = await generateTransportCertificate(keyPair, {
+    certificate = await generateTransportCertificate(keyPair, {
       days: 365
     })
   }
 
-  const rtcConfig = typeof options.rtcConfiguration === 'function' ? await options.rtcConfiguration() : options.rtcConfiguration
+  const rtcConfig = typeof rtcConfiguration === 'function' ? await rtcConfiguration() : rtcConfiguration
 
-  const peerConnection = new DirectRTCPeerConnection({
+  return new DirectRTCPeerConnection({
     ...rtcConfig,
     ufrag,
     peerConnection: new PeerConnection(`${role}-${Date.now()}`, {
       disableFingerprintVerification: true,
       disableAutoNegotiation: true,
-      certificatePemFile: options.certificate.pem,
-      keyPemFile: options.certificate.privateKey,
+      certificatePemFile: certificate.pem,
+      keyPemFile: 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,4 +1,5 @@
 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,6 +88,23 @@ 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 () => {
@@ -96,7 +113,7 @@ export class WebRTCStream extends AbstractStream {
       }
     })
       .catch(err => {
-        this.log.error('error processing incoming data channel messages - %e', err)
+        this.log.error('error processing incoming data channel messages', err)
       })
 
     // close when both writable ends are closed or an error occurs
@@ -107,26 +124,6 @@ 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 {
@@ -207,13 +204,8 @@ 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 - %e', err)
+      options.log.error('error closing outbound stream', err)
     })
 }