@libp2p/webrtc 5.2.24-87bc8d4fb → 5.2.24-9a9b11fd4

package/src/private-to-private/initiate-connection.ts

@@ -1,4 +1,5 @@
-import { pbStream } from 'it-protobuf-stream'
+import { pbStream } from '@libp2p/utils'
+import { pEvent } from 'p-event'
 import { CustomProgressEvent } from 'progress-events'
 import { SIGNALING_PROTOCOL } from '../constants.js'
 import { SDPHandshakeFailedError } from '../error.js'
@@ -9,15 +10,14 @@ import { splitAddr } from './transport.js'
 import { readCandidatesUntilConnected } from './util.js'
 import type { WebRTCDialEvents, WebRTCTransportMetrics } from './transport.js'
 import type { DataChannelOptions } from '../index.js'
-import type { LoggerOptions, Connection, ComponentLogger, IncomingStreamData } from '@libp2p/interface'
+import type { LoggerOptions, Connection, ComponentLogger, AbortOptions } from '@libp2p/interface'
 import type { ConnectionManager, TransportManager } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { ProgressOptions } from 'progress-events'
 
-export interface IncomingStreamOpts extends IncomingStreamData {
+export interface IncomingStreamOptions extends AbortOptions {
   rtcConfiguration?: RTCConfiguration
   dataChannelOptions?: Partial<DataChannelOptions>
-  signal: AbortSignal
 }
 
 export interface ConnectOptions extends LoggerOptions, ProgressOptions<WebRTCDialEvents> {
@@ -67,9 +67,21 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
 
   const messageStream = pbStream(stream).pb(Message)
   const peerConnection = new RTCPeerConnection(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({
-    logger
-  }, {
+    // @ts-expect-error https://github.com/murat-dogan/node-datachannel/pull/370
     peerConnection,
     dataChannelOptions: dataChannel
   })
@@ -82,10 +94,20 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
 
     // setup callback to write ICE candidates to the remote peer
     peerConnection.onicecandidate = ({ candidate }) => {
+      if (peerConnection.connectionState === 'connected') {
+        log.trace('ignore new ice candidate as peer connection is already connected')
+        return
+      }
+
       // a null candidate means end-of-candidates, an empty string candidate
       // means end-of-candidates for this generation, otherwise this should
       // be a valid candidate object
       // see - https://www.w3.org/TR/webrtc/#rtcpeerconnectioniceevent
+      if (candidate == null || candidate?.candidate === '') {
+        log.trace('initiator detected end of ICE candidates')
+        return
+      }
+
       const data = JSON.stringify(candidate?.toJSON() ?? null)
 
       log.trace('initiator sending ICE candidate %o', candidate)
@@ -97,7 +119,7 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
         signal
       })
         .catch(err => {
-          log.error('error sending ICE candidate', err)
+          log.error('error sending ICE candidate - %e', err)
         })
     }
     peerConnection.onicecandidateerror = (event) => {
@@ -157,9 +179,25 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
       onProgress
     })
 
-    log.trace('initiator connected, closing init channel')
+    log.trace('initiator connected')
+
+    if (channel.readyState !== 'open') {
+      log.trace('wait for init channel to open')
+      await pEvent(channel, 'open', {
+        signal
+      })
+    }
+
+    log.trace('closing init channel')
     channel.close()
 
+    // wait for init channel to close before proceeding, otherwise the channel
+    // id can be reused before both sides have seen the channel close
+    log.trace('waiting for init channel to close')
+    await pEvent(channel, 'close', {
+      signal
+    })
+
     onProgress?.(new CustomProgressEvent('webrtc:close-signaling-stream'))
 
     log.trace('closing signaling channel')

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

@@ -1,20 +1,19 @@
+import { pbStream } from '@libp2p/utils'
 import { multiaddr } from '@multiformats/multiaddr'
-import { pbStream } from 'it-protobuf-stream'
 import { SDPHandshakeFailedError } from '../error.js'
 import { RTCSessionDescription } from '../webrtc/index.js'
 import { Message } from './pb/message.js'
-import { getConnectionState, readCandidatesUntilConnected } from './util.js'
+import { getRemotePeer, readCandidatesUntilConnected } from './util.js'
 import type { RTCPeerConnection } from '../webrtc/index.js'
-import type { Logger, IncomingStreamData } from '@libp2p/interface'
+import type { AbortOptions, Connection, Logger, PeerId, Stream } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
-export interface IncomingStreamOpts extends IncomingStreamData {
+export interface IncomingStreamOptions extends AbortOptions {
   peerConnection: RTCPeerConnection
-  signal: AbortSignal
   log: Logger
 }
 
-export async function handleIncomingStream ({ peerConnection, stream, signal, connection, log }: IncomingStreamOpts): Promise<{ remoteAddress: Multiaddr }> {
+export async function handleIncomingStream (stream: Stream, connection: Connection, { peerConnection, signal, log }: IncomingStreamOptions): Promise<{ remoteAddress: Multiaddr, remotePeer: PeerId }> {
   log.trace('new inbound signaling stream')
 
   const messageStream = pbStream(stream).pb(Message)
@@ -22,10 +21,20 @@ export async function handleIncomingStream ({ peerConnection, stream, signal, co
   try {
     // candidate callbacks
     peerConnection.onicecandidate = ({ candidate }) => {
+      if (peerConnection.connectionState === 'connected') {
+        log.trace('ignore new ice candidate as peer connection is already connected')
+        return
+      }
+
       // a null candidate means end-of-candidates, an empty string candidate
       // means end-of-candidates for this generation, otherwise this should
       // be a valid candidate object
       // see - https://www.w3.org/TR/webrtc/#rtcpeerconnectioniceevent
+      if (candidate == null || candidate?.candidate === '') {
+        log.trace('recipient detected end of ICE candidates')
+        return
+      }
+
       const data = JSON.stringify(candidate?.toJSON() ?? null)
 
       log.trace('recipient sending ICE candidate %s', data)
@@ -37,7 +46,7 @@ export async function handleIncomingStream ({ peerConnection, stream, signal, co
         signal
       })
         .catch(err => {
-          log.error('error sending ICE candidate', err)
+          log.error('error sending ICE candidate - %e', err)
         })
     }
 
@@ -91,7 +100,7 @@ export async function handleIncomingStream ({ peerConnection, stream, signal, co
       log
     })
   } catch (err: any) {
-    if (getConnectionState(peerConnection) !== 'connected') {
+    if (peerConnection.connectionState !== 'connected') {
       log.error('error while handling signaling stream from peer %a', connection.remoteAddr, err)
 
       peerConnection.close()
@@ -101,9 +110,13 @@ export async function handleIncomingStream ({ peerConnection, stream, signal, co
     }
   }
 
-  const remoteAddress = multiaddr(`/webrtc/p2p/${connection.remoteAddr.getPeerId()}`)
+  const remotePeer = getRemotePeer(connection.remoteAddr)
+  const remoteAddress = multiaddr(`/webrtc/p2p/${remotePeer}`)
 
   log.trace('recipient connected to remote address %s', remoteAddress)
 
-  return { remoteAddress }
+  return {
+    remoteAddress,
+    remotePeer
+  }
 }

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

@@ -4,15 +4,16 @@ 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, IncomingStreamData, Libp2pEvents } from '@libp2p/interface'
+import type { OutboundConnectionUpgradeEvents, CreateListenerOptions, DialTransportOptions, Transport, Listener, Upgrader, ComponentLogger, Logger, Connection, PeerId, CounterGroup, Metrics, Startable, OpenConnectionProgressEvents, Libp2pEvents, MultiaddrConnection, Stream } from '@libp2p/interface'
 import type { Registrar, ConnectionManager, TransportManager } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { TypedEventTarget } from 'main-event'
@@ -30,14 +31,6 @@ export interface WebRTCTransportInit {
    * Any options here will be applied to any RTCDataChannels that are opened.
    */
   dataChannel?: DataChannelOptions
-
-  /**
-   * Inbound connections must complete the upgrade within this many ms
-   *
-   * @default 30_000
-   * @deprecated configure `connectionManager.inboundUpgradeTimeout` instead
-   */
-  inboundConnectionTimeout?: number
 }
 
 export interface WebRTCTransportComponents {
@@ -115,13 +108,13 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
   }
 
   async start (): Promise<void> {
-    await this.components.registrar.handle(SIGNALING_PROTOCOL, (data: IncomingStreamData) => {
+    await this.components.registrar.handle(SIGNALING_PROTOCOL, (stream: Stream, connection: Connection) => {
       // ensure we don't try to upgrade forever
       const signal = this.components.upgrader.createInboundAbortSignal(this.shutdownController.signal)
 
-      this._onProtocol(data, signal)
+      this._onProtocol(stream, connection, signal)
         .catch(err => {
-          this.log.error('failed to handle incoming connect from %p', data.connection.remotePeer, err)
+          this.log.error('failed to handle incoming connect from %p', connection.remotePeer, err)
         })
         .finally(() => {
           signal.clear()
@@ -180,16 +173,18 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
       onProgress: options.onProgress
     })
 
-    const webRTCConn = new WebRTCMultiaddrConnection(this.components, {
+    const webRTCConn = toMultiaddrConnection({
       peerConnection,
-      timeline: { open: Date.now() },
       remoteAddr: remoteAddress,
-      metrics: this.metrics?.dialerEvents
+      metrics: this.metrics?.dialerEvents,
+      direction: 'outbound',
+      log: this.components.logger.forComponent('libp2p:webrtc:connection')
     })
 
     const connection = await options.upgrader.upgradeOutbound(webRTCConn, {
       skipProtection: true,
       skipEncryption: true,
+      remotePeer: getRemotePeer(ma),
       muxerFactory,
       onProgress: options.onProgress,
       signal: options.signal
@@ -201,18 +196,29 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
     return connection
   }
 
-  async _onProtocol ({ connection, stream }: IncomingStreamData, signal: AbortSignal): Promise<void> {
+  async _onProtocol (stream: Stream, connection: Connection, signal: AbortSignal): Promise<void> {
     const peerConnection = new RTCPeerConnection(await getRtcConfiguration(this.init.rtcConfiguration))
-    const muxerFactory = new DataChannelMuxerFactory(this.components, {
+
+    // 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
       peerConnection,
       dataChannelOptions: this.init.dataChannel
     })
 
     try {
-      const { remoteAddress } = await handleIncomingStream({
+      const { remoteAddress, remotePeer } = await handleIncomingStream(stream, connection, {
         peerConnection,
-        connection,
-        stream,
         signal,
         log: this.log
       })
@@ -222,16 +228,18 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
         signal
       })
 
-      const webRTCConn = new WebRTCMultiaddrConnection(this.components, {
+      const webRTCConn = toMultiaddrConnection({
         peerConnection,
-        timeline: { open: (new Date()).getTime() },
         remoteAddr: remoteAddress,
-        metrics: this.metrics?.listenerEvents
+        metrics: this.metrics?.listenerEvents,
+        direction: 'inbound',
+        log: this.components.logger.forComponent('libp2p:webrtc:connection')
       })
 
       await this.components.upgrader.upgradeInbound(webRTCConn, {
         skipEncryption: true,
         skipProtection: true,
+        remotePeer,
         muxerFactory,
         signal
       })
@@ -247,7 +255,7 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
     }
   }
 
-  private _closeOnShutdown (pc: RTCPeerConnection, webRTCConn: WebRTCMultiaddrConnection): void {
+  private _closeOnShutdown (pc: RTCPeerConnection, webRTCConn: MultiaddrConnection): void {
     // close the connection on shut down
     const shutDownListener = (): void => {
       webRTCConn.close()

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

@@ -1,12 +1,12 @@
-import { ConnectionFailedError, InvalidMessageError } from '@libp2p/interface'
-import pDefer from 'p-defer'
+import { ConnectionFailedError, InvalidMessageError, InvalidMultiaddrError } from '@libp2p/interface'
+import { peerIdFromString } from '@libp2p/peer-id'
 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, Stream } from '@libp2p/interface'
+import type { AbortOptions, LoggerOptions, PeerId, Stream } from '@libp2p/interface'
+import type { Multiaddr } from '@multiformats/multiaddr'
 import type { MessageStream } from 'it-protobuf-stream'
 import type { DeferredPromise } from 'p-defer'
 import type { ProgressOptions } from 'progress-events'
@@ -17,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: DeferredPromise<void> = pDefer()
+    const connectedPromise = Promise.withResolvers<void>()
     resolveOnConnected(pc, connectedPromise)
 
     // read candidates until we are connected or we reach the end of the stream
@@ -27,7 +27,7 @@ export const readCandidatesUntilConnected = async (pc: RTCPeerConnection, stream
         connectedPromise.promise,
         stream.read({
           signal: options.signal
-        }).catch(() => {})
+        })
       ])
 
       // stream ended or we became connected
@@ -62,35 +62,52 @@ export const readCandidatesUntilConnected = async (pc: RTCPeerConnection, stream
         options.onProgress?.(new CustomProgressEvent<string>('webrtc:add-ice-candidate', candidate.candidate))
         await pc.addIceCandidate(candidate)
       } catch (err) {
-        options.log.error('%s bad candidate received', options.direction, candidateInit, err)
+        options.log.error('%s bad candidate received %o - %e', options.direction, candidateInit, err)
       }
     }
   } catch (err) {
-    options.log.error('%s error parsing ICE candidate', options.direction, err)
+    options.log.error('%s error parsing ICE candidate - %e', options.direction, err)
 
-    if (options.signal?.aborted === true && getConnectionState(pc) !== 'connected') {
+    if (options.signal?.aborted === true && pc.connectionState !== 'connected') {
       throw err
     }
   }
 }
 
-export function getConnectionState (pc: RTCPeerConnection): string {
-  return isFirefox ? pc.iceConnectionState : pc.connectionState
-}
-
 function resolveOnConnected (pc: RTCPeerConnection, promise: DeferredPromise<void>): void {
-  pc[isFirefox ? 'oniceconnectionstatechange' : 'onconnectionstatechange'] = (_) => {
-    switch (getConnectionState(pc)) {
+  if (pc.connectionState === 'connected') {
+    promise.resolve()
+    return
+  }
+
+  pc.onconnectionstatechange = (_) => {
+    switch (pc.connectionState) {
       case 'connected':
         promise.resolve()
         break
       case 'failed':
       case 'disconnected':
       case 'closed':
-        promise.reject(new ConnectionFailedError('RTCPeerConnection was closed'))
+        promise.reject(new ConnectionFailedError(`RTCPeerConnection connection state became "${pc.connectionState}"`))
         break
       default:
         break
     }
   }
 }
+
+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,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'
@@ -50,11 +51,6 @@ export interface WebRTCTransportDirectInit {
    */
   dataChannel?: DataChannelOptions
 
-  /**
-   * @deprecated use `certificate` instead - this option will be removed in a future release
-   */
-  certificates?: TransportCertificate[]
-
   /**
    * Use an existing TLS certificate to secure incoming connections or supply
    * settings to generate one.
@@ -67,11 +63,6 @@ export interface WebRTCTransportDirectInit {
    */
   certificate?: TransportCertificate
 
-  /**
-   * @deprecated this setting is ignored and will be removed in a future release
-   */
-  useLibjuice?: boolean
-
   /**
    * The key the certificate is stored in the datastore under
    *
@@ -164,7 +155,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 +177,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
   }