@libp2p/webrtc 5.2.23-cf9aab5c8 → 5.2.24-0f07e3df5

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

@@ -1,12 +1,11 @@
 import { isIPv4 } from '@chainsafe/is-ip'
 import { InvalidParametersError } from '@libp2p/interface'
-import { getThinWaistAddresses } from '@libp2p/utils/get-thin-waist-addresses'
-import { multiaddr, fromStringTuples } from '@multiformats/multiaddr'
+import { getNetConfig, getThinWaistAddresses } from '@libp2p/utils'
+import { CODE_CERTHASH, CODE_WEBRTC_DIRECT, multiaddr } from '@multiformats/multiaddr'
 import { WebRTCDirect } from '@multiformats/multiaddr-matcher'
 import getPort from 'get-port'
 import { TypedEventEmitter, setMaxListeners } from 'main-event'
 import pWaitFor from 'p-wait-for'
-import { CODEC_CERTHASH, CODEC_WEBRTC_DIRECT } from '../constants.js'
 import { connect } from './utils/connect.js'
 import { createDialerRTCPeerConnection } from './utils/get-rtcpeerconnection.js'
 import { stunListener } from './utils/stun-listener.js'
@@ -94,7 +93,11 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
   }
 
   async listen (ma: Multiaddr): Promise<void> {
-    const { host, port, family } = ma.toOptions()
+    const { host, port, type, protocol } = getNetConfig(ma)
+
+    if (port == null || protocol !== 'udp' || (type !== 'ip4' && type !== 'ip6')) {
+      throw new InvalidParametersError(`Multiaddr ${ma} was not an IPv4 or IPv6 address or was missing a UDP port`)
+    }
 
     let udpMuxServer: UDPMuxServer | undefined
 
@@ -106,7 +109,7 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
       udpMuxServer = UDP_MUX_LISTENERS.find(s => s.port === port)
 
       // make sure the port is free for the given family
-      if (udpMuxServer != null && ((udpMuxServer.isIPv4 && family === 4) || (udpMuxServer.isIPv6 && family === 6))) {
+      if (udpMuxServer != null && ((udpMuxServer.isIPv4 && type === 'ip4') || (udpMuxServer.isIPv6 && type === 'ip6'))) {
         throw new InvalidParametersError(`There is already a listener for ${host}:${port}`)
       }
 
@@ -119,13 +122,13 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
     // start the mux server if we don't have one already
     if (udpMuxServer == null) {
       this.log('starting UDP mux server on %s:%p', host, port)
-      udpMuxServer = this.startUDPMuxServer(host, port, family)
+      udpMuxServer = this.startUDPMuxServer(host, port, type === 'ip4' ? 4 : 6)
       UDP_MUX_LISTENERS.push(udpMuxServer)
     }
 
-    if (family === 4) {
+    if (type === 'ip4') {
       udpMuxServer.isIPv4 = true
-    } else if (family === 6) {
+    } else if (type === 'ip6') {
       udpMuxServer.isIPv6 = true
     }
 
@@ -205,7 +208,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}`),
+        remoteAddr: multiaddr(`/ip${isIPv4(remoteHost) ? 4 : 6}/${remoteHost}/udp/${remotePort}/webrtc-direct`),
         dataChannel: this.init.dataChannel,
         upgrader: this.init.upgrader,
         peerId: this.components.peerId,
@@ -238,19 +241,23 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
       }
 
       // add the certhash if it is missing
-      const tuples = ma.stringTuples()
+      const components = ma.getComponents()
 
-      for (let j = 0; j < tuples.length; j++) {
-        if (tuples[j][0] !== CODEC_WEBRTC_DIRECT) {
+      for (let j = 0; j < components.length; j++) {
+        if (components[j].code !== CODE_WEBRTC_DIRECT) {
           continue
         }
 
         const certhashIndex = j + 1
 
-        if (tuples[certhashIndex] == null || tuples[certhashIndex][0] !== CODEC_CERTHASH) {
-          tuples.splice(certhashIndex, 0, [CODEC_CERTHASH, this.certificate?.certhash])
+        if (components[certhashIndex] == null || components[certhashIndex].code !== CODE_CERTHASH) {
+          components.splice(certhashIndex, 0, {
+            code: CODE_CERTHASH,
+            name: 'certhash',
+            value: this.certificate?.certhash
+          })
 
-          ma = fromStringTuples(tuples)
+          ma = multiaddr(components)
           multiaddrs[i] = ma
         }
       }

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

@@ -1,6 +1,7 @@
 import { generateKeyPair, privateKeyToCryptoKeyPair } from '@libp2p/crypto/keys'
 import { InvalidParametersError, NotFoundError, NotStartedError, serviceCapabilities, transportSymbol } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
+import { CODE_P2P } from '@multiformats/multiaddr'
 import { WebRTCDirect } from '@multiformats/multiaddr-matcher'
 import { BasicConstraintsExtension, X509Certificate, X509CertificateGenerator } from '@peculiar/x509'
 import { Key } from 'interface-datastore'
@@ -164,7 +165,7 @@ export class WebRTCDirectTransport implements Transport, Startable {
     options.signal.throwIfAborted()
 
     let theirPeerId: PeerId | undefined
-    const remotePeerString = ma.getPeerId()
+    const remotePeerString = ma.getComponents().findLast(c => c.code === CODE_P2P)?.value
     if (remotePeerString != null) {
       theirPeerId = peerIdFromString(remotePeerString)
     }
@@ -186,7 +187,7 @@ export class WebRTCDirectTransport implements Transport, Startable {
         dataChannel: this.init.dataChannel,
         upgrader: options.upgrader,
         peerId: this.components.peerId,
-        remotePeerId: theirPeerId,
+        remotePeer: theirPeerId,
         privateKey: this.components.privateKey
       })
     } catch (err) {

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

@@ -1,8 +1,8 @@
-import { noise } from '@chainsafe/libp2p-noise'
-import { raceEvent } from 'race-event'
+import { noise } from '@libp2p/noise'
+import { pEvent } from 'p-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
-  remotePeerId?: PeerId
+  remotePeer?: 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 raceEvent(handshakeDataChannel, 'open', options.signal)
+      await pEvent(handshakeDataChannel, 'open', options)
     }
 
     options.log.trace('%s handshake channel opened', options.role)
@@ -116,20 +116,19 @@ export async function connect (peerConnection: DirectRTCPeerConnection, ufrag: s
     const handshakeStream = createStream({
       channel: handshakeDataChannel,
       direction: 'outbound',
-      handshake: true,
+      isHandshake: 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 = new WebRTCMultiaddrConnection(options, {
+    const maConn = toMultiaddrConnection({
       peerConnection,
       remoteAddr: options.remoteAddr,
-      timeline: {
-        open: Date.now()
-      },
-      metrics: options.events
+      metrics: options.events,
+      direction: options.role === 'client' ? 'outbound' : 'inbound',
+      log: options.logger.forComponent('libp2p:webrtc-direct:connection')
     })
 
     peerConnection.addEventListener(CONNECTION_STATE_CHANGE_EVENT, () => {
@@ -150,7 +149,8 @@ export async function connect (peerConnection: DirectRTCPeerConnection, ufrag: s
     // Track opened peer connection
     options.events?.increment({ peer_connection: true })
 
-    const muxerFactory = new DataChannelMuxerFactory(options, {
+    const muxerFactory = new DataChannelMuxerFactory({
+      // @ts-expect-error https://github.com/murat-dogan/node-datachannel/pull/370
       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)
-      await connectionEncrypter.secureInbound(handshakeStream, {
-        remotePeer: options.remotePeerId,
+      const result = await connectionEncrypter.secureInbound(handshakeStream, {
+        remotePeer: options.remotePeer,
         signal: options.signal,
         skipStreamMuxerNegotiation: true
       })
@@ -171,6 +171,7 @@ 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
       })
@@ -181,7 +182,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.remotePeerId,
+      remotePeer: options.remotePeer,
       signal: options.signal,
       skipStreamMuxerNegotiation: true
     })
@@ -193,11 +194,13 @@ 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 '@ipshipyard/node-datachannel'
+import type { CertificateFingerprint } from 'node-datachannel'
 
 const crypto = new Crypto()
 
@@ -14,7 +14,7 @@ interface DirectRTCPeerConnectionInit extends RTCConfiguration {
 }
 
 export class DirectRTCPeerConnection extends RTCPeerConnection {
-  private readonly peerConnection: PeerConnection
+  private peerConnection: PeerConnection
   private readonly ufrag: string
 
   constructor (init: DirectRTCPeerConnectionInit) {
@@ -22,6 +22,18 @@ 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

@@ -1,10 +1,11 @@
 import { InvalidParametersError } from '@libp2p/interface'
-import { multiaddr } from '@multiformats/multiaddr'
+import { getNetConfig } from '@libp2p/utils'
+import { CODE_CERTHASH, multiaddr } from '@multiformats/multiaddr'
 import { base64url } from 'multiformats/bases/base64'
 import { bases, digest } from 'multiformats/basics'
 import * as Digest from 'multiformats/hashes/digest'
 import { sha256 } from 'multiformats/hashes/sha2'
-import { CODEC_CERTHASH, MAX_MESSAGE_SIZE } from '../../constants.js'
+import { MAX_MESSAGE_SIZE } from '../../constants.js'
 import { InvalidFingerprintError, UnsupportedHashAlgorithmError } from '../../error.js'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { MultihashDigest } from 'multiformats/hashes/interface'
@@ -27,8 +28,8 @@ export function getFingerprintFromSdp (sdp: string | undefined): string | undefi
 
 // Extract the certhash from a multiaddr
 export function certhash (ma: Multiaddr): string {
-  const tups = ma.stringTuples()
-  const certhash = tups.filter((tup) => tup[0] === CODEC_CERTHASH).map((tup) => tup[1])[0]
+  const components = ma.getComponents()
+  const certhash = components.find(c => c.code === CODE_CERTHASH)?.value
 
   if (certhash === undefined || certhash === '') {
     throw new InvalidParametersError(`Couldn't find a certhash component of multiaddr: ${ma.toString()}`)
@@ -100,15 +101,20 @@ export function toSupportedHashFunction (code: number): 'sha-1' | 'sha-256' | 's
  * ice-lite mode and DTLS active mode.
  */
 export function serverAnswerFromMultiaddr (ma: Multiaddr, ufrag: string): RTCSessionDescriptionInit {
-  const { host, port, family } = ma.toOptions()
+  const { host, port, type } = getNetConfig(ma)
+
+  if (type !== 'ip4' && type !== 'ip6') {
+    throw new InvalidParametersError(`Multiaddr ${ma} was not an IPv4 or IPv6 address`)
+  }
+
   const fingerprint = ma2Fingerprint(ma)
   const sdp = `v=0
-o=- 0 0 IN IP${family} ${host}
+o=- 0 0 IN IP${type === 'ip4' ? 4 : 6} ${host}
 s=-
 t=0 0
 a=ice-lite
 m=application ${port} UDP/DTLS/SCTP webrtc-datachannel
-c=IN IP${family} ${host}
+c=IN IP${type === 'ip4' ? 4 : 6} ${host}
 a=mid:0
 a=ice-options:ice2
 a=ice-ufrag:${ufrag}
@@ -131,11 +137,16 @@ a=end-of-candidates
  * Create an offer SDP message from a multiaddr
  */
 export function clientOfferFromMultiAddr (ma: Multiaddr, ufrag: string): RTCSessionDescriptionInit {
-  const { host, port, family } = ma.toOptions()
+  const { host, port, type } = getNetConfig(ma)
+
+  if (type !== 'ip4' && type !== 'ip6') {
+    throw new InvalidParametersError(`Multiaddr ${ma} was not an IPv4 or IPv6 address`)
+  }
+
   const sdp = `v=0
-o=- 0 0 IN IP${family} ${host}
+o=- 0 0 IN IP${type === 'ip4' ? 4 : 6} ${host}
 s=-
-c=IN IP${family} ${host}
+c=IN IP${type === 'ip4' ? 4 : 6} ${host}
 t=0 0
 a=ice-options:ice2,trickle
 m=application ${port} UDP/DTLS/SCTP webrtc-datachannel
@@ -166,8 +177,13 @@ export function munge (desc: RTCSessionDescriptionInit, ufrag: string): RTCSessi
 
   const lineBreak = desc.sdp.includes('\r\n') ? '\r\n' : '\n'
 
-  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)
+  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
+  }
+
   return desc
 }

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

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

package/src/rtcpeerconnection-to-conn.ts

@@ -0,0 +1,62 @@
+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'
+
+export interface RTCPeerConnectionMultiaddrConnectionInit extends Omit<AbstractMultiaddrConnectionInit, 'stream'> {
+  peerConnection: RTCPeerConnection
+}
+
+class RTCPeerConnectionMultiaddrConnection extends AbstractMultiaddrConnection {
+  private peerConnection: RTCPeerConnection
+
+  constructor (init: RTCPeerConnectionMultiaddrConnectionInit) {
+    super(init)
+
+    this.peerConnection = init.peerConnection
+
+    const initialState = init.peerConnection.connectionState
+
+    this.peerConnection.onconnectionstatechange = () => {
+      this.log.trace('peer connection state change %s initial state %s', this.peerConnection.connectionState, initialState)
+
+      if (this.peerConnection.connectionState === 'disconnected' || this.peerConnection.connectionState === 'failed' || this.peerConnection.connectionState === 'closed') {
+        // nothing else to do but close the connection
+        this.onTransportClosed()
+      }
+    }
+  }
+
+  sendData (data: Uint8ArrayList): SendResult {
+    return {
+      sentBytes: data.byteLength,
+      canSendMore: true
+    }
+  }
+
+  async sendClose (options?: AbortOptions): Promise<void> {
+    this.peerConnection.close()
+    options?.signal?.throwIfAborted()
+  }
+
+  sendReset (): void {
+    this.peerConnection.close()
+  }
+
+  sendPause (): void {
+    // TODO: readable backpressure?
+  }
+
+  sendResume (): void {
+    // TODO: readable backpressure?
+  }
+}
+
+/**
+ * Convert a RTCPeerConnection into a MultiaddrConnection
+ * https://github.com/libp2p/interface-transport#multiaddrconnection
+ */
+export const toMultiaddrConnection = (init: RTCPeerConnectionMultiaddrConnectionInit): MultiaddrConnection => {
+  return new RTCPeerConnectionMultiaddrConnection(init)
+}