@libp2p/webrtc 6.0.2-8543df06b → 6.0.2-8d66d5ff1

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 () => {
@@ -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', () => {