@libp2p/webrtc 5.2.20 → 5.2.21

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

@@ -1,5 +1,3 @@
-import { InvalidParametersError } from '@libp2p/interface'
-import { peerIdFromString } from '@libp2p/peer-id'
 import { pbStream } from 'it-protobuf-stream'
 import { CustomProgressEvent } from 'progress-events'
 import { SIGNALING_PROTOCOL } from '../constants.js'
@@ -35,21 +33,14 @@ export interface ConnectOptions extends LoggerOptions, ProgressOptions<WebRTCDia
 }
 
 export async function initiateConnection ({ rtcConfiguration, dataChannel, signal, metrics, multiaddr: ma, connectionManager, transportManager, log, logger, onProgress }: ConnectOptions): Promise<{ remoteAddress: Multiaddr, peerConnection: RTCPeerConnection, muxerFactory: DataChannelMuxerFactory }> {
-  const { baseAddr } = splitAddr(ma)
+  const { circuitAddress, targetPeer } = splitAddr(ma)
 
   metrics?.dialerEvents.increment({ open: true })
 
-  log.trace('dialing base address: %a', baseAddr)
+  log.trace('dialing circuit address: %a', circuitAddress)
 
-  const relayPeer = baseAddr.getPeerId()
-
-  if (relayPeer == null) {
-    throw new InvalidParametersError('Relay peer was missing')
-  }
-
-  const connections = connectionManager.getConnections(peerIdFromString(relayPeer))
+  const connections = connectionManager.getConnections(targetPeer)
   let connection: Connection
-  let shouldCloseConnection = false
 
   if (connections.length === 0) {
     onProgress?.(new CustomProgressEvent('webrtc:dial-relay'))
@@ -57,157 +48,140 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
     // use the transport manager to open a connection. Initiating a WebRTC
     // connection takes place in the context of a dial - if we use the
     // connection manager instead we can end up joining our own dial context
-    connection = await transportManager.dial(baseAddr, {
+    connection = await transportManager.dial(circuitAddress, {
       signal,
       onProgress
     })
-    // this connection is unmanaged by the connection manager so we should
-    // close it when we are done
-    shouldCloseConnection = true
   } else {
     onProgress?.(new CustomProgressEvent('webrtc:reuse-relay-connection'))
 
     connection = connections[0]
   }
 
-  try {
-    onProgress?.(new CustomProgressEvent('webrtc:open-signaling-stream'))
+  onProgress?.(new CustomProgressEvent('webrtc:open-signaling-stream'))
 
-    const stream = await connection.newStream(SIGNALING_PROTOCOL, {
-      signal,
-      runOnLimitedConnection: true
-    })
+  const stream = await connection.newStream(SIGNALING_PROTOCOL, {
+    signal,
+    runOnLimitedConnection: true
+  })
 
-    const messageStream = pbStream(stream).pb(Message)
-    const peerConnection = new RTCPeerConnection(rtcConfiguration)
-    const muxerFactory = new DataChannelMuxerFactory({
-      logger
-    }, {
-      peerConnection,
-      dataChannelOptions: dataChannel
-    })
+  const messageStream = pbStream(stream).pb(Message)
+  const peerConnection = new RTCPeerConnection(rtcConfiguration)
+  const muxerFactory = new DataChannelMuxerFactory({
+    logger
+  }, {
+    peerConnection,
+    dataChannelOptions: dataChannel
+  })
 
-    try {
-      // we create the channel so that the RTCPeerConnection has a component for
-      // which to collect candidates. The label is not relevant to connection
-      // initiation but can be useful for debugging
-      const channel = peerConnection.createDataChannel('init')
-
-      // setup callback to write ICE candidates to the remote peer
-      peerConnection.onicecandidate = ({ candidate }) => {
-        // 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
-        const data = JSON.stringify(candidate?.toJSON() ?? null)
-
-        log.trace('initiator sending ICE candidate %o', candidate)
-
-        void messageStream.write({
-          type: Message.Type.ICE_CANDIDATE,
-          data
-        }, {
-          signal
-        })
-          .catch(err => {
-            log.error('error sending ICE candidate', err)
-          })
-      }
-      peerConnection.onicecandidateerror = (event) => {
-        log.error('initiator ICE candidate error', event)
-      }
-
-      // create an offer
-      const offerSdp = await peerConnection.createOffer().catch(err => {
-        log.error('could not execute createOffer', err)
-        throw new SDPHandshakeFailedError('Failed to set createOffer')
+  try {
+    // we create the channel so that the RTCPeerConnection has a component for
+    // which to collect candidates. The label is not relevant to connection
+    // initiation but can be useful for debugging
+    const channel = peerConnection.createDataChannel('init')
+
+    // setup callback to write ICE candidates to the remote peer
+    peerConnection.onicecandidate = ({ candidate }) => {
+      // 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
+      const data = JSON.stringify(candidate?.toJSON() ?? null)
+
+      log.trace('initiator sending ICE candidate %o', candidate)
+
+      void messageStream.write({
+        type: Message.Type.ICE_CANDIDATE,
+        data
+      }, {
+        signal
       })
+        .catch(err => {
+          log.error('error sending ICE candidate', err)
+        })
+    }
+    peerConnection.onicecandidateerror = (event) => {
+      log.error('initiator ICE candidate error', event)
+    }
 
-      log.trace('initiator send SDP offer %s', offerSdp.sdp)
+    // create an offer
+    const offerSdp = await peerConnection.createOffer().catch(err => {
+      log.error('could not execute createOffer', err)
+      throw new SDPHandshakeFailedError('Failed to set createOffer')
+    })
 
-      onProgress?.(new CustomProgressEvent('webrtc:send-sdp-offer'))
+    log.trace('initiator send SDP offer %s', offerSdp.sdp)
 
-      // write the offer to the stream
-      await messageStream.write({ type: Message.Type.SDP_OFFER, data: offerSdp.sdp }, {
-        signal
-      })
+    onProgress?.(new CustomProgressEvent('webrtc:send-sdp-offer'))
 
-      // set offer as local description
-      await peerConnection.setLocalDescription(offerSdp).catch(err => {
-        log.error('could not execute setLocalDescription', err)
-        throw new SDPHandshakeFailedError('Failed to set localDescription')
-      })
+    // write the offer to the stream
+    await messageStream.write({ type: Message.Type.SDP_OFFER, data: offerSdp.sdp }, {
+      signal
+    })
 
-      onProgress?.(new CustomProgressEvent('webrtc:read-sdp-answer'))
+    // set offer as local description
+    await peerConnection.setLocalDescription(offerSdp).catch(err => {
+      log.error('could not execute setLocalDescription', err)
+      throw new SDPHandshakeFailedError('Failed to set localDescription')
+    })
 
-      log.trace('initiator read SDP answer')
+    onProgress?.(new CustomProgressEvent('webrtc:read-sdp-answer'))
 
-      // read answer
-      const answerMessage = await messageStream.read({
-        signal
-      })
+    log.trace('initiator read SDP answer')
 
-      if (answerMessage.type !== Message.Type.SDP_ANSWER) {
-        throw new SDPHandshakeFailedError('Remote should send an SDP answer')
-      }
+    // read answer
+    const answerMessage = await messageStream.read({
+      signal
+    })
 
-      log.trace('initiator received SDP answer %s', answerMessage.data)
+    if (answerMessage.type !== Message.Type.SDP_ANSWER) {
+      throw new SDPHandshakeFailedError('Remote should send an SDP answer')
+    }
 
-      const answerSdp = new RTCSessionDescription({ type: 'answer', sdp: answerMessage.data })
-      await peerConnection.setRemoteDescription(answerSdp).catch(err => {
-        log.error('could not execute setRemoteDescription', err)
-        throw new SDPHandshakeFailedError('Failed to set remoteDescription')
-      })
+    log.trace('initiator received SDP answer %s', answerMessage.data)
 
-      log.trace('initiator read candidates until connected')
+    const answerSdp = new RTCSessionDescription({ type: 'answer', sdp: answerMessage.data })
+    await peerConnection.setRemoteDescription(answerSdp).catch(err => {
+      log.error('could not execute setRemoteDescription', err)
+      throw new SDPHandshakeFailedError('Failed to set remoteDescription')
+    })
 
-      onProgress?.(new CustomProgressEvent('webrtc:read-ice-candidates'))
+    log.trace('initiator read candidates until connected')
 
-      await readCandidatesUntilConnected(peerConnection, messageStream, {
-        direction: 'initiator',
-        signal,
-        log,
-        onProgress
-      })
+    onProgress?.(new CustomProgressEvent('webrtc:read-ice-candidates'))
 
-      log.trace('initiator connected, closing init channel')
-      channel.close()
+    await readCandidatesUntilConnected(peerConnection, messageStream, {
+      direction: 'initiator',
+      signal,
+      log,
+      onProgress
+    })
 
-      onProgress?.(new CustomProgressEvent('webrtc:close-signaling-stream'))
+    log.trace('initiator connected, closing init channel')
+    channel.close()
 
-      log.trace('closing signaling channel')
-      await stream.close({
-        signal
-      })
+    onProgress?.(new CustomProgressEvent('webrtc:close-signaling-stream'))
+
+    log.trace('closing signaling channel')
+    await stream.close({
+      signal
+    })
+
+    log.trace('initiator connected to remote address %s', ma)
 
-      log.trace('initiator connected to remote address %s', ma)
-
-      return {
-        remoteAddress: ma,
-        peerConnection,
-        muxerFactory
-      }
-    } catch (err: any) {
-      log.error('outgoing signaling error', err)
-
-      peerConnection.close()
-      stream.abort(err)
-      throw err
-    } finally {
-      peerConnection.onicecandidate = null
-      peerConnection.onicecandidateerror = null
+    return {
+      remoteAddress: ma,
+      peerConnection,
+      muxerFactory
     }
+  } catch (err: any) {
+    log.error('outgoing signaling error', err)
+
+    peerConnection.close()
+    stream.abort(err)
+    throw err
   } finally {
-    // if we had to open a connection to perform the SDP handshake
-    // close it because it's not tracked by the connection manager
-    if (shouldCloseConnection) {
-      try {
-        await connection.close({
-          signal
-        })
-      } catch (err: any) {
-        connection.abort(err)
-      }
-    }
+    peerConnection.onicecandidate = null
+    peerConnection.onicecandidateerror = null
   }
 }

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

@@ -264,32 +264,20 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
   }
 }
 
-export function splitAddr (ma: Multiaddr): { baseAddr: Multiaddr, peerId: PeerId } {
-  const addrs = ma.toString().split('/webrtc/')
-  if (addrs.length !== 2) {
-    throw new InvalidParametersError('webrtc protocol was not present in multiaddr')
+export function splitAddr (ma: Multiaddr): { circuitAddress: Multiaddr, targetPeer: PeerId } {
+  const target = ma.getComponents()
+    .filter(({ name }) => name === 'p2p')
+    .map(({ value }) => value)
+    .pop()
+
+  if (target == null) {
+    throw new InvalidParametersError('Destination peer id was missing')
   }
 
-  if (!addrs[0].includes('/p2p-circuit')) {
-    throw new InvalidParametersError('p2p-circuit protocol was not present in multiaddr')
-  }
-
-  // look for remote peerId
-  let remoteAddr = multiaddr(addrs[0])
-  const destination = multiaddr('/' + addrs[1])
-
-  const destinationIdString = destination.getPeerId()
-  if (destinationIdString == null) {
-    throw new InvalidParametersError('destination peer id was missing')
-  }
-
-  const lastProtoInRemote = remoteAddr.protos().pop()
-  if (lastProtoInRemote === undefined) {
-    throw new InvalidParametersError('invalid multiaddr')
-  }
-  if (lastProtoInRemote.name !== 'p2p') {
-    remoteAddr = remoteAddr.encapsulate(`/p2p/${destinationIdString}`)
-  }
+  const circuitAddress = multiaddr(
+    ma.getComponents()
+      .filter(({ name }) => name !== 'webrtc')
+  )
 
-  return { baseAddr: remoteAddr, peerId: peerIdFromString(destinationIdString) }
+  return { circuitAddress, targetPeer: peerIdFromString(target) }
 }