@libp2p/webrtc 5.2.24-a02cb0461 → 5.2.24-f5932c294

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

@@ -4,16 +4,15 @@ import { multiaddr } from '@multiformats/multiaddr'
 import { WebRTC } from '@multiformats/multiaddr-matcher'
 import { setMaxListeners } from 'main-event'
 import { SIGNALING_PROTOCOL } from '../constants.js'
+import { WebRTCMultiaddrConnection } from '../maconn.js'
 import { DataChannelMuxerFactory } from '../muxer.js'
-import { toMultiaddrConnection } from '../rtcpeerconnection-to-conn.ts'
 import { getRtcConfiguration } from '../util.js'
 import { RTCPeerConnection } from '../webrtc/index.js'
 import { initiateConnection } from './initiate-connection.js'
 import { WebRTCPeerListener } from './listener.js'
 import { handleIncomingStream } from './signaling-stream-handler.js'
-import { getRemotePeer } from './util.ts'
 import type { DataChannelOptions } from '../index.js'
-import type { OutboundConnectionUpgradeEvents, CreateListenerOptions, DialTransportOptions, Transport, Listener, Upgrader, ComponentLogger, Logger, Connection, PeerId, CounterGroup, Metrics, Startable, OpenConnectionProgressEvents, Libp2pEvents, MultiaddrConnection, Stream } from '@libp2p/interface'
+import type { OutboundConnectionUpgradeEvents, CreateListenerOptions, DialTransportOptions, Transport, Listener, Upgrader, ComponentLogger, Logger, Connection, PeerId, CounterGroup, Metrics, Startable, OpenConnectionProgressEvents, IncomingStreamData, Libp2pEvents } from '@libp2p/interface'
 import type { Registrar, ConnectionManager, TransportManager } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { TypedEventTarget } from 'main-event'
@@ -116,13 +115,13 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
   }
 
   async start (): Promise<void> {
-    await this.components.registrar.handle(SIGNALING_PROTOCOL, (stream: Stream, connection: Connection) => {
+    await this.components.registrar.handle(SIGNALING_PROTOCOL, (data: IncomingStreamData) => {
       // ensure we don't try to upgrade forever
       const signal = this.components.upgrader.createInboundAbortSignal(this.shutdownController.signal)
 
-      this._onProtocol(stream, connection, signal)
+      this._onProtocol(data, 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', data.connection.remotePeer, err)
         })
         .finally(() => {
           signal.clear()
@@ -181,18 +180,16 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
       onProgress: options.onProgress
     })
 
-    const webRTCConn = toMultiaddrConnection({
+    const webRTCConn = new WebRTCMultiaddrConnection(this.components, {
       peerConnection,
+      timeline: { open: Date.now() },
       remoteAddr: remoteAddress,
-      metrics: this.metrics?.dialerEvents,
-      direction: 'outbound',
-      log: this.components.logger.forComponent('libp2p:webrtc:connection')
+      metrics: this.metrics?.dialerEvents
     })
 
     const connection = await options.upgrader.upgradeOutbound(webRTCConn, {
       skipProtection: true,
       skipEncryption: true,
-      remotePeer: getRemotePeer(ma),
       muxerFactory,
       onProgress: options.onProgress,
       signal: options.signal
@@ -204,29 +201,18 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
     return connection
   }
 
-  async _onProtocol (stream: Stream, connection: Connection, signal: AbortSignal): Promise<void> {
+  async _onProtocol ({ connection, stream }: IncomingStreamData, signal: AbortSignal): Promise<void> {
     const peerConnection = new RTCPeerConnection(await getRtcConfiguration(this.init.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
+    const muxerFactory = new DataChannelMuxerFactory(this.components, {
       peerConnection,
       dataChannelOptions: this.init.dataChannel
     })
 
     try {
-      const { remoteAddress, remotePeer } = await handleIncomingStream(stream, connection, {
+      const { remoteAddress } = await handleIncomingStream({
         peerConnection,
+        connection,
+        stream,
         signal,
         log: this.log
       })
@@ -236,18 +222,16 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
         signal
       })
 
-      const webRTCConn = toMultiaddrConnection({
+      const webRTCConn = new WebRTCMultiaddrConnection(this.components, {
         peerConnection,
+        timeline: { open: (new Date()).getTime() },
         remoteAddr: remoteAddress,
-        metrics: this.metrics?.listenerEvents,
-        direction: 'inbound',
-        log: this.components.logger.forComponent('libp2p:webrtc:connection')
+        metrics: this.metrics?.listenerEvents
       })
 
       await this.components.upgrader.upgradeInbound(webRTCConn, {
         skipEncryption: true,
         skipProtection: true,
-        remotePeer,
         muxerFactory,
         signal
       })
@@ -263,7 +247,7 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
     }
   }
 
-  private _closeOnShutdown (pc: RTCPeerConnection, webRTCConn: MultiaddrConnection): void {
+  private _closeOnShutdown (pc: RTCPeerConnection, webRTCConn: WebRTCMultiaddrConnection): void {
     // close the connection on shut down
     const shutDownListener = (): void => {
       webRTCConn.close()

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

@@ -1,13 +1,12 @@
-import { ConnectionFailedError, InvalidMessageError, InvalidMultiaddrError } from '@libp2p/interface'
-import { peerIdFromString } from '@libp2p/peer-id'
+import { ConnectionFailedError, InvalidMessageError } from '@libp2p/interface'
+import pDefer from 'p-defer'
 import { CustomProgressEvent } from 'progress-events'
 import { isFirefox } from '../util.js'
 import { RTCIceCandidate } from '../webrtc/index.js'
 import { Message } from './pb/message.js'
 import type { WebRTCDialEvents } from './transport.js'
 import type { RTCPeerConnection } from '../webrtc/index.js'
-import type { AbortOptions, LoggerOptions, PeerId, Stream } from '@libp2p/interface'
-import type { Multiaddr } from '@multiformats/multiaddr'
+import type { AbortOptions, LoggerOptions, Stream } from '@libp2p/interface'
 import type { MessageStream } from 'it-protobuf-stream'
 import type { DeferredPromise } from 'p-defer'
 import type { ProgressOptions } from 'progress-events'
@@ -18,7 +17,7 @@ export interface ReadCandidatesOptions extends AbortOptions, LoggerOptions, Prog
 
 export const readCandidatesUntilConnected = async (pc: RTCPeerConnection, stream: MessageStream<Message, Stream>, options: ReadCandidatesOptions): Promise<void> => {
   try {
-    const connectedPromise = Promise.withResolvers<void>()
+    const connectedPromise: DeferredPromise<void> = pDefer()
     resolveOnConnected(pc, connectedPromise)
 
     // read candidates until we are connected or we reach the end of the stream
@@ -95,19 +94,3 @@ function resolveOnConnected (pc: RTCPeerConnection, promise: DeferredPromise<voi
     }
   }
 }
-
-export function getRemotePeer (ma: Multiaddr): PeerId {
-  let remotePeer: PeerId | undefined
-
-  for (const component of ma.getComponents()) {
-    if (component.name === 'p2p') {
-      remotePeer = peerIdFromString(component.value ?? '')
-    }
-  }
-
-  if (remotePeer == null) {
-    throw new InvalidMultiaddrError('Remote peerId must be present in multiaddr')
-  }
-
-  return remotePeer
-}

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

@@ -1,6 +1,6 @@
 import { isIPv4 } from '@chainsafe/is-ip'
 import { InvalidParametersError } from '@libp2p/interface'
-import { getThinWaistAddresses } from '@libp2p/utils'
+import { getThinWaistAddresses } from '@libp2p/utils/get-thin-waist-addresses'
 import { multiaddr, fromStringTuples } from '@multiformats/multiaddr'
 import { WebRTCDirect } from '@multiformats/multiaddr-matcher'
 import getPort from 'get-port'
@@ -205,7 +205,7 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
         metrics: this.components.metrics,
         events: this.metrics?.listenerEvents,
         signal,
-        remoteAddr: multiaddr(`/ip${isIPv4(remoteHost) ? 4 : 6}/${remoteHost}/udp/${remotePort}/webrtc-direct`),
+        remoteAddr: multiaddr(`/ip${isIPv4(remoteHost) ? 4 : 6}/${remoteHost}/udp/${remotePort}`),
         dataChannel: this.init.dataChannel,
         upgrader: this.init.upgrader,
         peerId: this.components.peerId,

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

@@ -186,7 +186,7 @@ export class WebRTCDirectTransport implements Transport, Startable {
         dataChannel: this.init.dataChannel,
         upgrader: options.upgrader,
         peerId: this.components.peerId,
-        remotePeer: theirPeerId,
+        remotePeerId: theirPeerId,
         privateKey: this.components.privateKey
       })
     } catch (err) {

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

@@ -1,8 +1,8 @@
-import { noise } from '@libp2p/noise'
-import { pEvent } from 'p-event'
+import { noise } from '@chainsafe/libp2p-noise'
+import { raceEvent } from 'race-event'
 import { WebRTCTransportError } from '../../error.js'
+import { WebRTCMultiaddrConnection } from '../../maconn.js'
 import { DataChannelMuxerFactory } from '../../muxer.js'
-import { toMultiaddrConnection } from '../../rtcpeerconnection-to-conn.ts'
 import { createStream } from '../../stream.js'
 import { isFirefox } from '../../util.js'
 import { generateNoisePrologue } from './generate-noise-prologue.js'
@@ -22,7 +22,7 @@ export interface ConnectOptions {
   dataChannel?: DataChannelOptions
   upgrader: Upgrader
   peerId: PeerId
-  remotePeer?: PeerId
+  remotePeerId?: PeerId
   signal: AbortSignal
   privateKey: PrivateKey
 }
@@ -83,7 +83,7 @@ export async function connect (peerConnection: DirectRTCPeerConnection, ufrag: s
 
     if (handshakeDataChannel.readyState !== 'open') {
       options.log.trace('%s wait for handshake channel to open, starting status %s', options.role, handshakeDataChannel.readyState)
-      await pEvent(handshakeDataChannel, 'open', options)
+      await raceEvent(handshakeDataChannel, 'open', options.signal)
     }
 
     options.log.trace('%s handshake channel opened', options.role)
@@ -116,19 +116,20 @@ export async function connect (peerConnection: DirectRTCPeerConnection, ufrag: s
     const handshakeStream = createStream({
       channel: handshakeDataChannel,
       direction: 'outbound',
-      isHandshake: true,
+      handshake: true,
       log: options.log,
       ...(options.dataChannel ?? {})
     })
 
     // Creating the connection before completion of the noise
     // handshake ensures that the stream opening callback is set up
-    const maConn = toMultiaddrConnection({
+    const maConn = new WebRTCMultiaddrConnection(options, {
       peerConnection,
       remoteAddr: options.remoteAddr,
-      metrics: options.events,
-      direction: options.role === 'client' ? 'outbound' : 'inbound',
-      log: options.logger.forComponent('libp2p:webrtc-direct:connection')
+      timeline: {
+        open: Date.now()
+      },
+      metrics: options.events
     })
 
     peerConnection.addEventListener(CONNECTION_STATE_CHANGE_EVENT, () => {
@@ -149,8 +150,7 @@ 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
+    const muxerFactory = new DataChannelMuxerFactory(options, {
       peerConnection,
       metrics: options.events,
       dataChannelOptions: options.dataChannel
@@ -161,8 +161,8 @@ export async function connect (peerConnection: DirectRTCPeerConnection, ufrag: s
       // handshake. Therefore, we need to secure an inbound noise connection
       // from the server.
       options.log.trace('%s secure inbound', options.role)
-      const result = await connectionEncrypter.secureInbound(handshakeStream, {
-        remotePeer: options.remotePeer,
+      await connectionEncrypter.secureInbound(handshakeStream, {
+        remotePeer: options.remotePeerId,
         signal: options.signal,
         skipStreamMuxerNegotiation: true
       })
@@ -171,7 +171,6 @@ export async function connect (peerConnection: DirectRTCPeerConnection, ufrag: s
       return await options.upgrader.upgradeOutbound(maConn, {
         skipProtection: true,
         skipEncryption: true,
-        remotePeer: result.remotePeer,
         muxerFactory,
         signal: options.signal
       })
@@ -182,7 +181,7 @@ export async function connect (peerConnection: DirectRTCPeerConnection, ufrag: s
     // the client.
     options.log.trace('%s secure outbound', options.role)
     const result = await connectionEncrypter.secureOutbound(handshakeStream, {
-      remotePeer: options.remotePeer,
+      remotePeer: options.remotePeerId,
       signal: options.signal,
       skipStreamMuxerNegotiation: true
     })
@@ -194,13 +193,11 @@ export async function connect (peerConnection: DirectRTCPeerConnection, ufrag: s
     await options.upgrader.upgradeInbound(maConn, {
       skipProtection: true,
       skipEncryption: true,
-      remotePeer: result.remotePeer,
       muxerFactory,
       signal: options.signal
     })
   } catch (err) {
     handshakeDataChannel.close()
-    peerConnection.close()
 
     throw err
   }

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

@@ -1,10 +1,10 @@
+import { PeerConnection } from '@ipshipyard/node-datachannel'
+import { RTCPeerConnection } from '@ipshipyard/node-datachannel/polyfill'
 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 { generateTransportCertificate } from './generate-certificates.js'
 import type { TransportCertificate } from '../../index.js'
-import type { CertificateFingerprint } from 'node-datachannel'
+import type { CertificateFingerprint } from '@ipshipyard/node-datachannel'
 
 const crypto = new Crypto()
 
@@ -14,7 +14,7 @@ interface DirectRTCPeerConnectionInit extends RTCConfiguration {
 }
 
 export class DirectRTCPeerConnection extends RTCPeerConnection {
-  private peerConnection: PeerConnection
+  private readonly peerConnection: PeerConnection
   private readonly ufrag: string
 
   constructor (init: DirectRTCPeerConnectionInit) {
@@ -22,18 +22,6 @@ export class DirectRTCPeerConnection extends RTCPeerConnection {
 
     this.peerConnection = init.peerConnection
     this.ufrag = init.ufrag
-
-    // make sure C++ peer connection is garbage collected
-    // https://github.com/murat-dogan/node-datachannel/issues/366#issuecomment-3228453155
-    this.addEventListener('connectionstatechange', () => {
-      switch (this.connectionState) {
-        case 'closed':
-          this.peerConnection.close()
-          break
-        default:
-          break
-      }
-    })
   }
 
   async createOffer (): Promise<globalThis.RTCSessionDescriptionInit | any> {

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

@@ -166,13 +166,8 @@ export function munge (desc: RTCSessionDescriptionInit, ufrag: string): RTCSessi
 
   const lineBreak = desc.sdp.includes('\r\n') ? '\r\n' : '\n'
 
-  try {
-    desc.sdp = desc.sdp
-      .replace(/\na=ice-ufrag:[^\n]*\n/, '\na=ice-ufrag:' + ufrag + lineBreak)
-      .replace(/\na=ice-pwd:[^\n]*\n/, '\na=ice-pwd:' + ufrag + lineBreak)
-  } catch {
-    // fails under Node.js
-  }
-
+  desc.sdp = desc.sdp
+    .replace(/\na=ice-ufrag:[^\n]*\n/, '\na=ice-ufrag:' + ufrag + lineBreak)
+    .replace(/\na=ice-pwd:[^\n]*\n/, '\na=ice-pwd:' + ufrag + lineBreak)
   return desc
 }

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

@@ -1,5 +1,5 @@
 import { isIPv4 } from '@chainsafe/is-ip'
-import { IceUdpMuxListener } from 'node-datachannel'
+import { IceUdpMuxListener } from '@ipshipyard/node-datachannel'
 import type { Logger } from '@libp2p/interface'
 import type { AddressInfo } from 'node:net'