@libp2p/webrtc 3.2.11 → 4.0.0-06e6d235f

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

@@ -1,6 +1,5 @@
-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 { noise } from '@chainsafe/libp2p-noise'
+import { type CreateListenerOptions, transportSymbol, type Transport, type Listener, type ComponentLogger, type Logger, type Connection, type CounterGroup, type Metrics, type PeerId } from '@libp2p/interface'
 import * as p from '@libp2p/peer-id'
 import { protocols } from '@multiformats/multiaddr'
 import { WebRTCDirect } from '@multiformats/multiaddr-matcher'
@@ -17,13 +16,8 @@ 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 { Multiaddr } from '@multiformats/multiaddr'
 
-const log = logger('libp2p:webrtc:transport')
-
 /**
  * The time to wait, in milliseconds, for the data channel handshake to complete
  */
@@ -49,6 +43,7 @@ export const CERTHASH_CODE: number = protocols('certhash').code
 export interface WebRTCDirectTransportComponents {
   peerId: PeerId
   metrics?: Metrics
+  logger: ComponentLogger
 }
 
 export interface WebRTCMetrics {
@@ -60,10 +55,12 @@ export interface WebRTCTransportDirectInit {
 }
 
 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 +78,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 +104,7 @@ export class WebRTCDirectTransport implements Transport {
   /**
    * Symbol.for('@libp2p/transport')
    */
-  readonly [symbol] = true
+  readonly [transportSymbol] = true
 
   /**
    * Connect to a peer using a multiaddr
@@ -144,7 +141,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 +156,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 +189,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 connectionEncrypter = noise({ prologueBytes: fingerprintsPrologue })(this.components)
 
-      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 +211,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 +228,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 +242,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 connectionEncrypter.secureInbound(myPeerId, wrappedDuplex, theirPeerId)
 
       return await options.upgrader.upgradeOutbound(maConn, { skipProtection: true, skipEncryption: true, muxerFactory })
     } catch (err) {
@@ -262,7 +268,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)
     })
 }
 

package/dist/typedoc-urls.json

@@ -1,8 +0,0 @@
-{
-  "DataChannelOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.DataChannelOptions.html",
-  ".:DataChannelOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.DataChannelOptions.html",
-  "webRTC": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTC.html",
-  ".:webRTC": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTC.html",
-  "webRTCDirect": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTCDirect.html",
-  ".:webRTCDirect": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTCDirect.html"
-}