@libp2p/webrtc 3.2.11 → 4.0.0

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

@@ -1,19 +1,14 @@
-import { CodeError } from '@libp2p/interface/errors'
-import { logger } from '@libp2p/logger'
-import { abortableSource } from 'abortable-iterator'
+import { CodeError } from '@libp2p/interface'
+import { closeSource } from '@libp2p/utils/close-source'
 import { anySignal } from 'any-signal'
-import * as lp from 'it-length-prefixed'
-import { AbortError, raceSignal } from 'race-signal'
 import { isFirefox } from '../util.js'
 import { RTCIceCandidate } from '../webrtc/index.js'
 import { Message } from './pb/message.js'
-import type { Stream } from '@libp2p/interface/connection'
+import type { LoggerOptions, Stream } from '@libp2p/interface'
 import type { AbortOptions, MessageStream } from 'it-protobuf-stream'
 import type { DeferredPromise } from 'p-defer'
 
-const log = logger('libp2p:webrtc:peer:util')
-
-export interface ReadCandidatesOptions extends AbortOptions {
+export interface ReadCandidatesOptions extends AbortOptions, LoggerOptions {
   direction: string
 }
 
@@ -31,71 +26,60 @@ export const readCandidatesUntilConnected = async (connectedPromise: DeferredPro
     options.signal
   ])
 
-  const source = abortableSource(stream.unwrap().unwrap().source, signal, {
-    returnOnAbort: true
-  })
+  const abortListener = (): void => {
+    closeSource(stream.unwrap().unwrap().source, options.log)
+  }
+
+  signal.addEventListener('abort', abortListener)
 
   try {
     // read candidates until we are connected or we reach the end of the stream
-    for await (const buf of lp.decode(source)) {
-      const message = Message.decode(buf)
+    while (true) {
+      const message = await Promise.race([
+        connectedPromise.promise,
+        stream.read()
+      ])
+
+      // stream ended or we became connected
+      if (message == null) {
+        break
+      }
 
       if (message.type !== Message.Type.ICE_CANDIDATE) {
         throw new CodeError('ICE candidate message expected', 'ERR_NOT_ICE_CANDIDATE')
       }
 
-      let candidateInit = JSON.parse(message.data ?? 'null')
+      const candidateInit = JSON.parse(message.data ?? 'null')
 
-      if (candidateInit === '') {
-        log.trace('end-of-candidates for this generation received')
-        candidateInit = {
-          candidate: '',
-          sdpMid: '0',
-          sdpMLineIndex: 0
-        }
-      }
+      // an empty string means this generation of candidates is complete, a null
+      // candidate means candidate gathering has finished
+      // see - https://www.w3.org/TR/webrtc/#rtcpeerconnectioniceevent
+      if (candidateInit === '' || candidateInit === null) {
+        options.log.trace('end-of-candidates received')
 
-      if (candidateInit === null) {
-        log.trace('end-of-candidates received')
-        candidateInit = {
-          candidate: null,
-          sdpMid: '0',
-          sdpMLineIndex: 0
-        }
+        continue
       }
 
-      // a null candidate means end-of-candidates
-      // see - https://www.w3.org/TR/webrtc/#rtcpeerconnectioniceevent
       const candidate = new RTCIceCandidate(candidateInit)
 
-      log.trace('%s received new ICE candidate', options.direction, candidate)
+      options.log.trace('%s received new ICE candidate', options.direction, candidate)
 
       try {
         await pc.addIceCandidate(candidate)
       } catch (err) {
-        log.error('%s bad candidate received', options.direction, err)
+        options.log.error('%s bad candidate received', options.direction, candidateInit, err)
       }
     }
   } catch (err) {
-    log.error('%s error parsing ICE candidate', options.direction, err)
+    options.log.error('%s error parsing ICE candidate', options.direction, err)
   } finally {
+    signal.removeEventListener('abort', abortListener)
     signal.clear()
   }
-
-  if (options.signal?.aborted === true) {
-    throw new AbortError('Aborted while reading ICE candidates', 'ERR_ICE_CANDIDATES_READ_ABORTED')
-  }
-
-  // read all available ICE candidates, wait for connection state change
-  await raceSignal(connectedPromise.promise, options.signal, {
-    errorMessage: 'Aborted before connected',
-    errorCode: 'ERR_ABORTED_BEFORE_CONNECTED'
-  })
 }
 
 export function resolveOnConnected (pc: RTCPeerConnection, promise: DeferredPromise<void>): void {
   pc[isFirefox ? 'oniceconnectionstatechange' : 'onconnectionstatechange'] = (_) => {
-    log.trace('receiver peerConnectionState state change: %s', pc.connectionState)
     switch (isFirefox ? pc.iceConnectionState : pc.connectionState) {
       case 'connected':
         promise.resolve()

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

@@ -1,4 +1,4 @@
-import type { CreateListenerOptions, DialOptions } from '@libp2p/interface/transport'
+import type { CreateListenerOptions, DialOptions } from '@libp2p/interface'
 
 export interface WebRTCListenerOptions extends CreateListenerOptions {}
 export interface WebRTCDialOptions extends DialOptions {}

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

@@ -1,24 +1,22 @@
-import { logger } from '@libp2p/logger'
 import { bases } from 'multiformats/basics'
 import * as multihashes from 'multihashes'
 import { inappropriateMultiaddr, invalidArgument, invalidFingerprint, unsupportedHashAlgorithm } from '../error.js'
 import { CERTHASH_CODE } from './transport.js'
+import type { LoggerOptions } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { HashCode, HashName } from 'multihashes'
 
-const log = logger('libp2p:webrtc:sdp')
-
 /**
  * Get base2 | identity decoders
  */
 // @ts-expect-error - Not easy to combine these types.
 export const mbdecoder: any = Object.values(bases).map(b => b.decoder).reduce((d, b) => d.or(b))
 
-export function getLocalFingerprint (pc: RTCPeerConnection): string | undefined {
+export function getLocalFingerprint (pc: RTCPeerConnection, options: LoggerOptions): string | undefined {
   // try to fetch fingerprint from local certificate
   const localCert = pc.getConfiguration().certificates?.at(0)
   if (localCert == null || localCert.getFingerprints == null) {
-    log.trace('fetching fingerprint from local SDP')
+    options.log.trace('fetching fingerprint from local SDP')
     const localDescription = pc.localDescription
     if (localDescription == null) {
       return undefined
@@ -26,7 +24,7 @@ export function getLocalFingerprint (pc: RTCPeerConnection): string | undefined
     return getFingerprintFromSdp(localDescription.sdp)
   }
 
-  log.trace('fetching fingerprint from local certificate')
+  options.log.trace('fetching fingerprint from local certificate')
 
   if (localCert.getFingerprints().length === 0) {
     return undefined
@@ -55,8 +53,6 @@ function ipv (ma: Multiaddr): string {
     }
   }
 
-  log('Warning: multiaddr does not appear to contain IP4 or IP6, defaulting to IP6', ma)
-
   return 'IP6'
 }
 

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

@@ -1,7 +1,6 @@
-import { noise as Noise } from '@chainsafe/libp2p-noise'
-import { type CreateListenerOptions, symbol, type Transport, type Listener } from '@libp2p/interface/transport'
-import { logger } from '@libp2p/logger'
-import * as p from '@libp2p/peer-id'
+import { noise } from '@chainsafe/libp2p-noise'
+import { transportSymbol } from '@libp2p/interface'
+import { peerIdFromString } from '@libp2p/peer-id'
 import { protocols } from '@multiformats/multiaddr'
 import { WebRTCDirect } from '@multiformats/multiaddr-matcher'
 import * as multihashes from 'multihashes'
@@ -16,14 +15,10 @@ import { RTCPeerConnection } from '../webrtc/index.js'
 import * as sdp from './sdp.js'
 import { genUfrag } from './util.js'
 import type { WebRTCDialOptions } from './options.js'
-import type { DataChannelOptions } from '../index.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 { WebRTCDirectTransportComponents, WebRTCTransportDirectInit } from '../index.js'
+import type { Logger, Connection, CounterGroup, CreateListenerOptions, Transport, Listener } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
-const log = logger('libp2p:webrtc:transport')
-
 /**
  * The time to wait, in milliseconds, for the data channel handshake to complete
  */
@@ -43,27 +38,17 @@ export const WEBRTC_CODE: number = protocols('webrtc-direct').code
  */
 export const CERTHASH_CODE: number = protocols('certhash').code
 
-/**
- * The peer for this transport
- */
-export interface WebRTCDirectTransportComponents {
-  peerId: PeerId
-  metrics?: Metrics
-}
-
 export interface WebRTCMetrics {
   dialerEvents: CounterGroup
 }
 
-export interface WebRTCTransportDirectInit {
-  dataChannel?: DataChannelOptions
-}
-
 export class WebRTCDirectTransport implements Transport {
+  private readonly log: Logger
   private readonly metrics?: WebRTCMetrics
   private readonly components: WebRTCDirectTransportComponents
   private readonly init: WebRTCTransportDirectInit
   constructor (components: WebRTCDirectTransportComponents, init: WebRTCTransportDirectInit = {}) {
+    this.log = components.logger.forComponent('libp2p:webrtc-direct')
     this.components = components
     this.init = init
     if (components.metrics != null) {
@@ -81,7 +66,7 @@ export class WebRTCDirectTransport implements Transport {
    */
   async dial (ma: Multiaddr, options: WebRTCDialOptions): Promise<Connection> {
     const rawConn = await this._connect(ma, options)
-    log('dialing address: %a', ma)
+    this.log('dialing address: %a', ma)
     return rawConn
   }
 
@@ -107,7 +92,7 @@ export class WebRTCDirectTransport implements Transport {
   /**
    * Symbol.for('@libp2p/transport')
    */
-  readonly [symbol] = true
+  readonly [transportSymbol] = true
 
   /**
    * Connect to a peer using a multiaddr
@@ -120,7 +105,7 @@ export class WebRTCDirectTransport implements Transport {
     if (remotePeerString === null) {
       throw inappropriateMultiaddr("we need to have the remote's PeerId")
     }
-    const theirPeerId = p.peerIdFromString(remotePeerString)
+    const theirPeerId = peerIdFromString(remotePeerString)
 
     const remoteCerthash = sdp.decodeCerthash(sdp.certhash(ma))
 
@@ -144,7 +129,7 @@ export class WebRTCDirectTransport implements Transport {
         const handshakeDataChannel = peerConnection.createDataChannel('', { negotiated: true, id: 0 })
         const handshakeTimeout = setTimeout(() => {
           const error = `Data channel was never opened: state: ${handshakeDataChannel.readyState}`
-          log.error(error)
+          this.log.error(error)
           this.metrics?.dialerEvents.increment({ open_error: true })
           reject(dataChannelError('data', error))
         }, HANDSHAKE_TIMEOUT_MS)
@@ -159,7 +144,7 @@ export class WebRTCDirectTransport implements Transport {
           clearTimeout(handshakeTimeout)
           const errorTarget = event.target?.toString() ?? 'not specified'
           const error = `Error opening a data channel for handshaking: ${errorTarget}`
-          log.error(error)
+          this.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))
@@ -192,9 +177,14 @@ export class WebRTCDirectTransport implements Transport {
 
       // Since we use the default crypto interface and do not use a static key or early data,
       // we pass in undefined for these parameters.
-      const noise = Noise({ prologueBytes: fingerprintsPrologue })()
+      const encrypter = noise({ prologueBytes: fingerprintsPrologue })()
 
-      const wrappedChannel = createStream({ channel: handshakeDataChannel, direction: 'inbound', ...(this.init.dataChannel ?? {}) })
+      const wrappedChannel = createStream({
+        channel: handshakeDataChannel,
+        direction: 'inbound',
+        logger: this.components.logger,
+        ...(this.init.dataChannel ?? {})
+      })
       const wrappedDuplex = {
         ...wrappedChannel,
         sink: wrappedChannel.sink.bind(wrappedChannel),
@@ -209,7 +199,7 @@ export class WebRTCDirectTransport implements Transport {
 
       // Creating the connection before completion of the noise
       // handshake ensures that the stream opening callback is set up
-      const maConn = new WebRTCMultiaddrConnection({
+      const maConn = new WebRTCMultiaddrConnection(this.components, {
         peerConnection,
         remoteAddr: ma,
         timeline: {
@@ -226,7 +216,7 @@ export class WebRTCDirectTransport implements Transport {
           case 'disconnected':
           case 'closed':
             maConn.close().catch((err) => {
-              log.error('error closing connection', err)
+              this.log.error('error closing connection', err)
             }).finally(() => {
               // Remove the event listener once the connection is closed
               controller.abort()
@@ -240,11 +230,15 @@ export class WebRTCDirectTransport implements Transport {
       // Track opened peer connection
       this.metrics?.dialerEvents.increment({ peer_connection: true })
 
-      const muxerFactory = new DataChannelMuxerFactory({ peerConnection, metrics: this.metrics?.dialerEvents, dataChannelOptions: this.init.dataChannel })
+      const muxerFactory = new DataChannelMuxerFactory(this.components, {
+        peerConnection,
+        metrics: this.metrics?.dialerEvents,
+        dataChannelOptions: this.init.dataChannel
+      })
 
       // For outbound connections, the remote is expected to start the noise handshake.
       // Therefore, we need to secure an inbound noise connection from the remote.
-      await noise.secureInbound(myPeerId, wrappedDuplex, theirPeerId)
+      await encrypter.secureInbound(myPeerId, wrappedDuplex, theirPeerId)
 
       return await options.upgrader.upgradeOutbound(maConn, { skipProtection: true, skipEncryption: true, muxerFactory })
     } catch (err) {
@@ -262,7 +256,9 @@ export class WebRTCDirectTransport implements Transport {
       throw invalidArgument('no local certificate')
     }
 
-    const localFingerprint = sdp.getLocalFingerprint(pc)
+    const localFingerprint = sdp.getLocalFingerprint(pc, {
+      log: this.log
+    })
     if (localFingerprint == null) {
       throw invalidArgument('no local fingerprint found')
     }

package/src/stream.ts

@@ -1,6 +1,5 @@
-import { CodeError } from '@libp2p/interface/errors'
-import { AbstractStream, type AbstractStreamInit } from '@libp2p/interface/stream-muxer/stream'
-import { logger } from '@libp2p/logger'
+import { CodeError } from '@libp2p/interface'
+import { AbstractStream, type AbstractStreamInit } from '@libp2p/utils/abstract-stream'
 import * as lengthPrefixed from 'it-length-prefixed'
 import { type Pushable, pushable } from 'it-pushable'
 import pDefer from 'p-defer'
@@ -10,8 +9,7 @@ import { raceSignal } from 'race-signal'
 import { Uint8ArrayList } from 'uint8arraylist'
 import { Message } from './pb/message.js'
 import type { DataChannelOptions } from './index.js'
-import type { AbortOptions } from '@libp2p/interface'
-import type { Direction } from '@libp2p/interface/connection'
+import type { AbortOptions, ComponentLogger, Direction } from '@libp2p/interface'
 import type { DeferredPromise } from 'p-defer'
 
 export interface WebRTCStreamInit extends AbstractStreamInit, DataChannelOptions {
@@ -22,6 +20,8 @@ export interface WebRTCStreamInit extends AbstractStreamInit, DataChannelOptions
    * {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel}
    */
   channel: RTCDataChannel
+
+  logger: ComponentLogger
 }
 
 /**
@@ -56,6 +56,12 @@ export const MAX_MESSAGE_SIZE = 16 * 1024
  */
 export const FIN_ACK_TIMEOUT = 5000
 
+/**
+ * When sending data messages, if the channel is not in the "open" state, wait
+ * this long for the "open" event to fire.
+ */
+export const OPEN_TIMEOUT = 5000
+
 export class WebRTCStream extends AbstractStream {
   /**
    * The data channel used to send and receive data
@@ -68,8 +74,6 @@ export class WebRTCStream extends AbstractStream {
    */
   private readonly incomingData: Pushable<Uint8Array>
 
-  private messageQueue?: Uint8ArrayList
-
   private readonly maxBufferedAmount: number
 
   private readonly bufferedAmountLowEventTimeout: number
@@ -84,6 +88,7 @@ export class WebRTCStream extends AbstractStream {
    */
   private readonly receiveFinAck: DeferredPromise<void>
   private readonly finAckTimeout: number
+  private readonly openTimeout: number
 
   constructor (init: WebRTCStreamInit) {
     // override onEnd to send/receive FIN_ACK before closing the stream
@@ -121,17 +126,18 @@ export class WebRTCStream extends AbstractStream {
 
     this.channel = init.channel
     this.channel.binaryType = 'arraybuffer'
-    this.incomingData = pushable()
-    this.messageQueue = new Uint8ArrayList()
+    this.incomingData = pushable<Uint8Array>()
     this.bufferedAmountLowEventTimeout = init.bufferedAmountLowEventTimeout ?? BUFFERED_AMOUNT_LOW_TIMEOUT
     this.maxBufferedAmount = init.maxBufferedAmount ?? MAX_BUFFERED_AMOUNT
     this.maxMessageSize = (init.maxMessageSize ?? MAX_MESSAGE_SIZE) - PROTOBUF_OVERHEAD - VARINT_LENGTH
     this.receiveFinAck = pDefer()
     this.finAckTimeout = init.closeTimeout ?? FIN_ACK_TIMEOUT
+    this.openTimeout = init.openTimeout ?? OPEN_TIMEOUT
 
     // set up initial state
     switch (this.channel.readyState) {
       case 'open':
+        this.timeline.open = new Date().getTime()
         break
 
       case 'closed':
@@ -152,19 +158,6 @@ export class WebRTCStream extends AbstractStream {
     // handle RTCDataChannel events
     this.channel.onopen = (_evt) => {
       this.timeline.open = new Date().getTime()
-
-      if (this.messageQueue != null && this.messageQueue.byteLength > 0) {
-        this.log.trace('dataChannel opened, sending queued messages', this.messageQueue.byteLength, this.channel.readyState)
-
-        // send any queued messages
-        this._sendMessage(this.messageQueue)
-          .catch(err => {
-            this.log.error('error sending queued messages', err)
-            this.abort(err)
-          })
-      }
-
-      this.messageQueue = undefined
     }
 
     this.channel.onclose = (_evt) => {
@@ -217,6 +210,7 @@ export class WebRTCStream extends AbstractStream {
   async _sendMessage (data: Uint8ArrayList, checkBuffer: boolean = true): Promise<void> {
     if (checkBuffer && this.channel.bufferedAmount > this.maxBufferedAmount) {
       try {
+        this.log('channel buffer is %d, wait for "bufferedamountlow" event', this.channel.bufferedAmount)
         await pEvent(this.channel, 'bufferedamountlow', { timeout: this.bufferedAmountLowEventTimeout })
       } catch (err: any) {
         if (err instanceof TimeoutError) {
@@ -231,22 +225,14 @@ export class WebRTCStream extends AbstractStream {
       throw new CodeError(`Invalid datachannel state - ${this.channel.readyState}`, 'ERR_INVALID_STATE')
     }
 
-    if (this.channel.readyState === 'open') {
-      // send message without copying data
-      for (const buf of data) {
-        this.channel.send(buf)
-      }
-    } else if (this.channel.readyState === 'connecting') {
-      // queue message for when we are open
-      if (this.messageQueue == null) {
-        this.messageQueue = new Uint8ArrayList()
-      }
-
-      this.messageQueue.append(data)
-    } else {
-      this.log.error('unknown datachannel state %s', this.channel.readyState)
-      throw new CodeError('Unknown datachannel state', 'ERR_INVALID_STATE')
+    if (this.channel.readyState !== 'open') {
+      this.log('channel state is "%s" and not "open", waiting for "open" event before sending data', this.channel.readyState)
+      await pEvent(this.channel, 'open', { timeout: this.openTimeout })
+      this.log('channel state is now "%s", sending data', this.channel.readyState)
     }
+
+    // send message without copying data
+    this.channel.send(data.subarray())
   }
 
   async sendData (data: Uint8ArrayList): Promise<void> {
@@ -341,7 +327,7 @@ export class WebRTCStream extends AbstractStream {
       // flags can be sent while we or the remote are closing the datachannel so
       // if the channel isn't open, don't try to send it but return false to let
       // the caller know and act if they need to
-      this.log.trace('not sending flag %s because channel is not open', flag.toString())
+      this.log.trace('not sending flag %s because channel is "%s" and not "open"', this.channel.readyState, flag.toString())
       return false
     }
 
@@ -379,6 +365,8 @@ export interface WebRTCStreamOptions extends DataChannelOptions {
    * A callback invoked when the channel ends
    */
   onEnd?(err?: Error | undefined): void
+
+  logger: ComponentLogger
 }
 
 export function createStream (options: WebRTCStreamOptions): WebRTCStream {
@@ -386,7 +374,7 @@ export function createStream (options: WebRTCStreamOptions): WebRTCStream {
 
   return new WebRTCStream({
     id: direction === 'inbound' ? (`i${channel.id}`) : `r${channel.id}`,
-    log: logger(`libp2p:webrtc:stream:${direction}:${channel.id}`),
+    log: options.logger.forComponent(`libp2p:webrtc:stream:${direction}:${channel.id}`),
     ...options
   })
 }

package/src/util.ts

@@ -1,9 +1,7 @@
-import { logger } from '@libp2p/logger'
 import { detect } from 'detect-browser'
 import pDefer from 'p-defer'
 import pTimeout from 'p-timeout'
-
-const log = logger('libp2p:webrtc:utils')
+import type { LoggerOptions } from '@libp2p/interface'
 
 const browser = detect()
 export const isFirefox = ((browser != null) && browser.name === 'firefox')
@@ -14,7 +12,7 @@ export const nopSink = async (_: any): Promise<void> => {}
 
 export const DATA_CHANNEL_DRAIN_TIMEOUT = 30 * 1000
 
-export function drainAndClose (channel: RTCDataChannel, direction: string, drainTimeout: number = DATA_CHANNEL_DRAIN_TIMEOUT): void {
+export function drainAndClose (channel: RTCDataChannel, direction: string, drainTimeout: number = DATA_CHANNEL_DRAIN_TIMEOUT, options: LoggerOptions): void {
   if (channel.readyState !== 'open') {
     return
   }
@@ -23,7 +21,7 @@ export function drainAndClose (channel: RTCDataChannel, direction: string, drain
     .then(async () => {
       // wait for bufferedAmount to become zero
       if (channel.bufferedAmount > 0) {
-        log('%s drain channel with %d buffered bytes', direction, channel.bufferedAmount)
+        options.log('%s drain channel with %d buffered bytes', direction, channel.bufferedAmount)
         const deferred = pDefer()
         let drained = false
 
@@ -31,7 +29,7 @@ export function drainAndClose (channel: RTCDataChannel, direction: string, drain
 
         const closeListener = (): void => {
           if (!drained) {
-            log('%s drain channel closed before drain', direction)
+            options.log('%s drain channel closed before drain', direction)
             deferred.resolve()
           }
         }
@@ -58,7 +56,7 @@ export function drainAndClose (channel: RTCDataChannel, direction: string, drain
       }
     })
     .catch(err => {
-      log.error('error closing outbound stream', err)
+      options.log.error('error closing outbound stream', err)
     })
 }