@libp2p/webrtc 1.1.11 → 2.0.0

package/src/peer_transport/transport.ts

@@ -1,4 +1,4 @@
-import { type CreateListenerOptions, type DialOptions, type Listener, symbol, type Transport, type TransportManager, type Upgrader } from '@libp2p/interface-transport'
+import { type CreateListenerOptions, type DialOptions, type Listener, symbol, type Transport, type Upgrader, type TransportManager } from '@libp2p/interface-transport'
 import { CodeError } from '@libp2p/interfaces/errors'
 import { logger } from '@libp2p/logger'
 import { peerIdFromString } from '@libp2p/peer-id'
@@ -8,16 +8,18 @@ import { WebRTCMultiaddrConnection } from '../maconn.js'
 import { initiateConnection, handleIncomingStream } from './handler.js'
 import { WebRTCPeerListener } from './listener.js'
 import type { Connection } from '@libp2p/interface-connection'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerStore } from '@libp2p/interface-peer-store'
 import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
+import type { EventEmitter } from '@libp2p/interfaces/events'
 import type { Startable } from '@libp2p/interfaces/startable'
 
 const log = logger('libp2p:webrtc:peer')
 
-export const TRANSPORT = '/webrtc'
-export const SIGNALING_PROTO_ID = '/webrtc-signaling/0.0.1'
-export const CODE = protocols('webrtc').code
+const WEBRTC_TRANSPORT = '/webrtc'
+const CIRCUIT_RELAY_TRANSPORT = '/p2p-circuit'
+const SIGNALING_PROTO_ID = '/webrtc-signaling/0.0.1'
+const WEBRTC_CODE = protocols('webrtc').code
 
 export interface WebRTCTransportInit {
   rtcConfiguration?: RTCConfiguration
@@ -28,7 +30,7 @@ export interface WebRTCTransportComponents {
   registrar: Registrar
   upgrader: Upgrader
   transportManager: TransportManager
-  peerStore: PeerStore
+  events: EventEmitter<Libp2pEvents>
 }
 
 export class WebRTCTransport implements Transport, Startable {
@@ -67,22 +69,27 @@ export class WebRTCTransport implements Transport, Startable {
   filter (multiaddrs: Multiaddr[]): Multiaddr[] {
     return multiaddrs.filter((ma) => {
       const codes = ma.protoCodes()
-      return codes.includes(CODE)
+      return codes.includes(WEBRTC_CODE)
     })
   }
 
   private splitAddr (ma: Multiaddr): { baseAddr: Multiaddr, peerId: PeerId } {
-    const addrs = ma.toString().split(`${TRANSPORT}/`)
+    const addrs = ma.toString().split(WEBRTC_TRANSPORT)
     if (addrs.length !== 2) {
-      throw new CodeError('invalid multiaddr', codes.ERR_INVALID_MULTIADDR)
+      throw new CodeError('webrtc protocol was not present in multiaddr', codes.ERR_INVALID_MULTIADDR)
+    }
+
+    if (!addrs[0].includes(CIRCUIT_RELAY_TRANSPORT)) {
+      throw new CodeError('p2p-circuit protocol was not present in multiaddr', codes.ERR_INVALID_MULTIADDR)
     }
+
     // look for remote peerId
     let remoteAddr = multiaddr(addrs[0])
-    const destination = multiaddr('/' + addrs[1])
+    const destination = multiaddr(addrs[1])
 
     const destinationIdString = destination.getPeerId()
     if (destinationIdString == null) {
-      throw new CodeError('bad destination', codes.ERR_INVALID_MULTIADDR)
+      throw new CodeError('destination peer id was missing', codes.ERR_INVALID_MULTIADDR)
     }
 
     const lastProtoInRemote = remoteAddr.protos().pop()
@@ -112,22 +119,21 @@ export class WebRTCTransport implements Transport, Startable {
       options.signal = controller.signal
     }
 
-    const connection = await this.components.transportManager.dial(baseAddr)
-
-    const rawStream = await connection.newStream([SIGNALING_PROTO_ID], options)
+    const connection = await this.components.transportManager.dial(baseAddr, options)
+    const signalingStream = await connection.newStream([SIGNALING_PROTO_ID], options)
 
     try {
-      const [pc, muxerFactory] = await initiateConnection({
-        stream: rawStream,
+      const { pc, muxerFactory, remoteAddress } = await initiateConnection({
+        stream: signalingStream,
         rtcConfiguration: this.init.rtcConfiguration,
         signal: options.signal
       })
-      const webrtcMultiaddr = baseAddr.encapsulate(`${TRANSPORT}/p2p/${peerId.toString()}`)
+
       const result = await options.upgrader.upgradeOutbound(
         new WebRTCMultiaddrConnection({
           peerConnection: pc,
           timeline: { open: Date.now() },
-          remoteAddr: webrtcMultiaddr
+          remoteAddr: multiaddr(remoteAddress).encapsulate(`/p2p/${peerId.toString()}`)
         }),
         {
           skipProtection: true,
@@ -137,28 +143,27 @@ export class WebRTCTransport implements Transport, Startable {
       )
 
       // close the stream if SDP has been exchanged successfully
-      rawStream.close()
+      signalingStream.close()
       return result
     } catch (err) {
       // reset the stream in case of any error
-      rawStream.reset()
+      signalingStream.reset()
       throw err
     }
   }
 
   async _onProtocol ({ connection, stream }: IncomingStreamData): Promise<void> {
     try {
-      const [pc, muxerFactory] = await handleIncomingStream({
+      const { pc, muxerFactory, remoteAddress } = await handleIncomingStream({
         rtcConfiguration: this.init.rtcConfiguration,
         connection,
         stream
       })
-      const remotePeerId = connection.remoteAddr.getPeerId()
-      const webrtcMultiaddr = connection.remoteAddr.encapsulate(`${TRANSPORT}/p2p/${remotePeerId}`)
+
       await this.components.upgrader.upgradeInbound(new WebRTCMultiaddrConnection({
         peerConnection: pc,
         timeline: { open: (new Date()).getTime() },
-        remoteAddr: webrtcMultiaddr
+        remoteAddr: multiaddr(remoteAddress).encapsulate(`/p2p/${connection.remotePeer.toString()}`)
       }), {
         skipEncryption: true,
         skipProtection: true,

package/src/peer_transport/util.ts

@@ -53,7 +53,7 @@ export function resolveOnConnected (pc: RTCPeerConnection, promise: DeferredProm
       case 'failed':
       case 'disconnected':
       case 'closed':
-        promise.reject()
+        promise.reject(new Error('RTCPeerConnection was closed'))
         break
       default:
         break

package/src/stream.ts

@@ -268,7 +268,7 @@ export class WebRTCStream implements Stream {
     // surface data from the `Message.message` field through a source.
     this._src = pipe(
       this._innersrc,
-      lengthPrefixed.decode(),
+      (source) => lengthPrefixed.decode(source),
       (source) => (async function * () {
         for await (const buf of source) {
           const message = self.processIncomingProtobuf(buf.subarray())

package/src/transport.ts

@@ -15,6 +15,7 @@ import { WebRTCStream } from './stream.js'
 import { genUfrag } from './util.js'
 import type { WebRTCDialOptions } from './options.js'
 import type { Connection } from '@libp2p/interface-connection'
+import type { CounterGroup, Metrics } from '@libp2p/interface-metrics'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
@@ -42,19 +43,29 @@ export const CERTHASH_CODE: number = protocols('certhash').code
 /**
  * The peer for this transport
  */
-// @TODO(ddimaria): seems like an unnessary abstraction, consider removing
 export interface WebRTCDirectTransportComponents {
   peerId: PeerId
+  metrics?: Metrics
+}
+
+export interface WebRTCMetrics {
+  dialerEvents: CounterGroup
 }
 
 export class WebRTCDirectTransport implements Transport {
-  /**
-   * The peer for this transport
-   */
+  private readonly metrics?: WebRTCMetrics
   private readonly components: WebRTCDirectTransportComponents
 
   constructor (components: WebRTCDirectTransportComponents) {
     this.components = components
+    if (components.metrics != null) {
+      this.metrics = {
+        dialerEvents: components.metrics.registerCounterGroup('libp2p_webrtc_dialer_events_total', {
+          label: 'event',
+          help: 'Total count of WebRTC dial events by type'
+        })
+      }
+    }
   }
 
   /**
@@ -125,6 +136,7 @@ export class WebRTCDirectTransport implements Transport {
       const handshakeTimeout = setTimeout(() => {
         const error = `Data channel was never opened: state: ${handshakeDataChannel.readyState}`
         log.error(error)
+        this.metrics?.dialerEvents.increment({ open_error: true })
         reject(dataChannelError('data', error))
       }, HANDSHAKE_TIMEOUT_MS)
 
@@ -139,6 +151,8 @@ export class WebRTCDirectTransport implements Transport {
         const errorTarget = event.target?.toString() ?? 'not specified'
         const error = `Error opening a data channel for handshaking: ${errorTarget}`
         log.error(error)
+        // NOTE: We use unknown error here but this could potentially be considered a reset by some standards.
+        this.metrics?.dialerEvents.increment({ unknown_error: true })
         reject(dataChannelError('data', error))
       }
     })
@@ -175,15 +189,13 @@ export class WebRTCDirectTransport implements Transport {
     const wrappedDuplex = {
       ...wrappedChannel,
       sink: wrappedChannel.sink.bind(wrappedChannel),
-      source: {
-        [Symbol.asyncIterator]: async function * () {
-          for await (const list of wrappedChannel.source) {
-            for (const buf of list) {
-              yield buf
-            }
+      source: (async function * () {
+        for await (const list of wrappedChannel.source) {
+          for (const buf of list) {
+            yield buf
           }
         }
-      }
+      }())
     }
 
     // Creating the connection before completion of the noise
@@ -193,7 +205,8 @@ export class WebRTCDirectTransport implements Transport {
       remoteAddr: ma,
       timeline: {
         open: Date.now()
-      }
+      },
+      metrics: this.metrics?.dialerEvents
     })
 
     const eventListeningName = isFirefox ? 'iceconnectionstatechange' : 'connectionstatechange'
@@ -215,7 +228,10 @@ export class WebRTCDirectTransport implements Transport {
       }
     }, { signal })
 
-    const muxerFactory = new DataChannelMuxerFactory(peerConnection)
+    // Track opened peer connection
+    this.metrics?.dialerEvents.increment({ peer_connection: true })
+
+    const muxerFactory = new DataChannelMuxerFactory(peerConnection, this.metrics?.dialerEvents)
 
     // For outbound connections, the remote is expected to start the noise handshake.
     // Therefore, we need to secure an inbound noise connection from the remote.