@libp2p/webrtc 3.2.11 → 4.0.0

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@libp2p/webrtc",
-  "version": "3.2.11",
+  "version": "4.0.0",
   "description": "A libp2p transport using WebRTC connections",
   "license": "Apache-2.0 OR MIT",
-  "homepage": "https://github.com/libp2p/js-libp2p/tree/master/packages/transport-webrtc#readme",
+  "homepage": "https://github.com/libp2p/js-libp2p/tree/main/packages/transport-webrtc#readme",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/libp2p/js-libp2p.git"
@@ -11,6 +11,10 @@
   "bugs": {
     "url": "https://github.com/libp2p/js-libp2p/issues"
   },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "type": "module",
   "types": "./dist/src/index.d.ts",
   "files": [
@@ -35,7 +39,7 @@
   "scripts": {
     "generate": "protons src/private-to-private/pb/message.proto src/pb/message.proto",
     "build": "aegir build",
-    "test": "aegir test -t node -t browser -t electron-main -- --exit",
+    "test": "aegir test -t node -t browser -- --exit",
     "test:node": "aegir test -t node --cov -- --exit",
     "test:chrome": "aegir test -t browser --cov",
     "test:firefox": "aegir test -t browser -- --browser firefox",
@@ -46,23 +50,23 @@
   },
   "dependencies": {
     "@chainsafe/libp2p-noise": "^13.0.0",
-    "@libp2p/interface": "^0.1.6",
-    "@libp2p/interface-internal": "^0.1.9",
-    "@libp2p/logger": "^3.1.0",
-    "@libp2p/peer-id": "^3.0.6",
-    "@multiformats/mafmt": "^12.1.2",
-    "@multiformats/multiaddr": "^12.1.5",
-    "@multiformats/multiaddr-matcher": "^1.0.1",
-    "abortable-iterator": "^5.0.1",
+    "@libp2p/interface": "^1.0.0",
+    "@libp2p/interface-internal": "^0.1.10",
+    "@libp2p/logger": "^4.0.0",
+    "@libp2p/peer-id": "^4.0.0",
+    "@libp2p/utils": "^5.0.0",
+    "@multiformats/mafmt": "^12.1.6",
+    "@multiformats/multiaddr": "^12.1.10",
+    "@multiformats/multiaddr-matcher": "^1.1.0",
     "any-signal": "^4.1.1",
     "detect-browser": "^5.3.0",
-    "it-length-prefixed": "^9.0.1",
+    "it-length-prefixed": "^9.0.3",
     "it-pipe": "^3.0.1",
-    "it-protobuf-stream": "^1.0.0",
-    "it-pushable": "^3.2.0",
+    "it-protobuf-stream": "^1.0.2",
+    "it-pushable": "^3.2.1",
     "it-stream-types": "^2.0.1",
     "it-to-buffer": "^4.0.2",
-    "multiformats": "^12.0.1",
+    "multiformats": "^12.1.3",
     "multihashes": "^4.0.3",
     "node-datachannel": "^0.5.0-dev",
     "p-defer": "^4.0.0",
@@ -75,9 +79,10 @@
   },
   "devDependencies": {
     "@chainsafe/libp2p-yamux": "^5.0.0",
-    "@libp2p/interface-compliance-tests": "^4.1.5",
-    "@libp2p/peer-id-factory": "^3.0.8",
-    "@libp2p/websockets": "^7.0.13",
+    "@libp2p/circuit-relay-v2": "^1.0.0",
+    "@libp2p/interface-compliance-tests": "^5.0.0",
+    "@libp2p/peer-id-factory": "^3.0.9",
+    "@libp2p/websockets": "^8.0.0",
     "@types/sinon": "^17.0.0",
     "aegir": "^41.0.2",
     "delay": "^6.0.0",
@@ -85,9 +90,9 @@
     "it-length": "^3.0.2",
     "it-map": "^3.0.3",
     "it-pair": "^2.0.6",
-    "libp2p": "^0.46.21",
+    "libp2p": "^1.0.0",
     "p-retry": "^6.1.0",
-    "protons": "^7.0.2",
+    "protons": "^7.3.0",
     "sinon": "^17.0.0",
     "sinon-ts": "^2.0.0"
   },

package/src/error.ts

@@ -1,5 +1,5 @@
-import { CodeError } from '@libp2p/interface/errors'
-import type { Direction } from '@libp2p/interface/connection'
+import { CodeError } from '@libp2p/interface'
+import type { Direction } from '@libp2p/interface'
 
 export enum codes {
   ERR_ALREADY_ABORTED = 'ERR_ALREADY_ABORTED',

package/src/index.ts

@@ -30,9 +30,9 @@
  */
 
 import { WebRTCTransport } from './private-to-private/transport.js'
-import { WebRTCDirectTransport, type WebRTCTransportDirectInit, type WebRTCDirectTransportComponents } from './private-to-public/transport.js'
-import type { WebRTCTransportComponents, WebRTCTransportInit } from './private-to-private/transport.js'
-import type { Transport } from '@libp2p/interface/transport'
+import { WebRTCDirectTransport } from './private-to-public/transport.js'
+import type { ComponentLogger, Metrics, PeerId, Transport, Upgrader } from '@libp2p/interface'
+import type { ConnectionManager, Registrar, TransportManager } from '@libp2p/interface-internal'
 
 export interface DataChannelOptions {
   /**
@@ -66,6 +66,22 @@ export interface DataChannelOptions {
    * controls how long we wait for the acknowledgement in ms (default: 5s)
    */
   closeTimeout?: number
+
+  /**
+   * When sending the first data message, if the channel is not in the "open"
+   * state, wait this long for the "open" event to fire.
+   */
+  openTimeout?: number
+}
+
+export interface WebRTCDirectTransportComponents {
+  peerId: PeerId
+  metrics?: Metrics
+  logger: ComponentLogger
+}
+
+export interface WebRTCTransportDirectInit {
+  dataChannel?: DataChannelOptions
 }
 
 /**
@@ -80,6 +96,27 @@ function webRTCDirect (init?: WebRTCTransportDirectInit): (components: WebRTCDir
   return (components: WebRTCDirectTransportComponents) => new WebRTCDirectTransport(components, init)
 }
 
+export interface WebRTCTransportInit {
+  rtcConfiguration?: RTCConfiguration
+  dataChannel?: DataChannelOptions
+
+  /**
+   * Inbound connections must complete the upgrade within this many ms
+   * (default: 30s)
+   */
+  inboundConnectionTimeout?: number
+}
+
+export interface WebRTCTransportComponents {
+  peerId: PeerId
+  registrar: Registrar
+  upgrader: Upgrader
+  transportManager: TransportManager
+  connectionManager: ConnectionManager
+  metrics?: Metrics
+  logger: ComponentLogger
+}
+
 /**
  * @param {WebRTCTransportInit} init - WebRTC transport configuration
  * @param {RTCConfiguration} init.rtcConfiguration - RTCConfiguration

package/src/maconn.ts

@@ -1,11 +1,8 @@
-import { logger } from '@libp2p/logger'
 import { nopSink, nopSource } from './util.js'
-import type { MultiaddrConnection, MultiaddrConnectionTimeline } from '@libp2p/interface/connection'
-import type { CounterGroup } from '@libp2p/interface/metrics'
+import type { ComponentLogger, Logger, MultiaddrConnection, MultiaddrConnectionTimeline, CounterGroup } from '@libp2p/interface'
 import type { AbortOptions, Multiaddr } from '@multiformats/multiaddr'
 import type { Source, Sink } from 'it-stream-types'
-
-const log = logger('libp2p:webrtc:maconn')
+import type { Uint8ArrayList } from 'uint8arraylist'
 
 interface WebRTCMultiaddrConnectionInit {
   /**
@@ -29,7 +26,13 @@ interface WebRTCMultiaddrConnectionInit {
   metrics?: CounterGroup
 }
 
+export interface WebRTCMultiaddrConnectionComponents {
+  logger: ComponentLogger
+}
+
 export class WebRTCMultiaddrConnection implements MultiaddrConnection {
+  readonly log: Logger
+
   /**
    * WebRTC Peer Connection
    */
@@ -58,9 +61,10 @@ export class WebRTCMultiaddrConnection implements MultiaddrConnection {
   /**
    * The stream destination, a no-op as the transport natively supports multiplexing
    */
-  sink: Sink<Source<Uint8Array>, Promise<void>> = nopSink
+  sink: Sink<Source<Uint8Array | Uint8ArrayList>, Promise<void>> = nopSink
 
-  constructor (init: WebRTCMultiaddrConnectionInit) {
+  constructor (components: WebRTCMultiaddrConnectionComponents, init: WebRTCMultiaddrConnectionInit) {
+    this.log = components.logger.forComponent('libp2p:webrtc:maconn')
     this.remoteAddr = init.remoteAddr
     this.timeline = init.timeline
     this.peerConnection = init.peerConnection
@@ -68,7 +72,7 @@ export class WebRTCMultiaddrConnection implements MultiaddrConnection {
     const initialState = this.peerConnection.connectionState
 
     this.peerConnection.onconnectionstatechange = () => {
-      log.trace('peer connection state change', this.peerConnection.connectionState, 'initial state', initialState)
+      this.log.trace('peer connection state change', this.peerConnection.connectionState, 'initial state', initialState)
 
       if (this.peerConnection.connectionState === 'disconnected' || this.peerConnection.connectionState === 'failed' || this.peerConnection.connectionState === 'closed') {
         // nothing else to do but close the connection
@@ -78,7 +82,7 @@ export class WebRTCMultiaddrConnection implements MultiaddrConnection {
   }
 
   async close (options?: AbortOptions): Promise<void> {
-    log.trace('closing connection')
+    this.log.trace('closing connection')
 
     this.peerConnection.close()
     this.timeline.close = Date.now()
@@ -86,7 +90,7 @@ export class WebRTCMultiaddrConnection implements MultiaddrConnection {
   }
 
   abort (err: Error): void {
-    log.error('closing connection due to error', err)
+    this.log.error('closing connection due to error', err)
 
     this.peerConnection.close()
     this.timeline.close = Date.now()

package/src/muxer.ts

@@ -1,16 +1,11 @@
-import { logger } from '@libp2p/logger'
 import { createStream } from './stream.js'
 import { drainAndClose, nopSink, nopSource } from './util.js'
 import type { DataChannelOptions } from './index.js'
-import type { Stream } from '@libp2p/interface/connection'
-import type { CounterGroup } from '@libp2p/interface/metrics'
-import type { StreamMuxer, StreamMuxerFactory, StreamMuxerInit } from '@libp2p/interface/stream-muxer'
+import type { ComponentLogger, Logger, Stream, CounterGroup, StreamMuxer, StreamMuxerFactory, StreamMuxerInit } from '@libp2p/interface'
 import type { AbortOptions } from '@multiformats/multiaddr'
 import type { Source, Sink } from 'it-stream-types'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
-const log = logger('libp2p:webrtc:muxer')
-
 const PROTOCOL = '/webrtc'
 
 export interface DataChannelMuxerFactoryInit {
@@ -32,6 +27,10 @@ export interface DataChannelMuxerFactoryInit {
   dataChannelOptions?: DataChannelOptions
 }
 
+export interface DataChannelMuxerFactoryComponents {
+  logger: ComponentLogger
+}
+
 interface BufferedStream {
   stream: Stream
   channel: RTCDataChannel
@@ -48,15 +47,29 @@ export class DataChannelMuxerFactory implements StreamMuxerFactory {
   private bufferedStreams: BufferedStream[] = []
   private readonly metrics?: CounterGroup
   private readonly dataChannelOptions?: DataChannelOptions
+  private readonly components: DataChannelMuxerFactoryComponents
+  private readonly log: Logger
 
-  constructor (init: DataChannelMuxerFactoryInit) {
+  constructor (components: DataChannelMuxerFactoryComponents, init: DataChannelMuxerFactoryInit) {
+    this.components = components
     this.peerConnection = init.peerConnection
     this.metrics = init.metrics
     this.protocol = init.protocol ?? PROTOCOL
     this.dataChannelOptions = init.dataChannelOptions ?? {}
+    this.log = components.logger.forComponent('libp2p:webrtc:datachannelmuxerfactory')
 
     // store any datachannels opened before upgrade has been completed
     this.peerConnection.ondatachannel = ({ channel }) => {
+      this.log.trace('incoming early datachannel with channel id %d and label "%s"', channel.id)
+
+      // 'init' channel is only used during connection establishment
+      if (channel.label === 'init') {
+        this.log.trace('closing early init channel')
+        channel.close()
+
+        return
+      }
+
       // @ts-expect-error fields are set below
       const bufferedStream: BufferedStream = {}
 
@@ -66,6 +79,7 @@ export class DataChannelMuxerFactory implements StreamMuxerFactory {
         onEnd: (err) => {
           bufferedStream.onEnd(err)
         },
+        logger: components.logger,
         ...this.dataChannelOptions
       })
 
@@ -80,7 +94,7 @@ export class DataChannelMuxerFactory implements StreamMuxerFactory {
   }
 
   createStreamMuxer (init?: StreamMuxerInit): StreamMuxer {
-    return new DataChannelMuxer({
+    return new DataChannelMuxer(this.components, {
       ...init,
       peerConnection: this.peerConnection,
       dataChannelOptions: this.dataChannelOptions,
@@ -95,6 +109,10 @@ export interface DataChannelMuxerInit extends DataChannelMuxerFactoryInit, Strea
   streams: BufferedStream[]
 }
 
+export interface DataChannelMuxerComponents {
+  logger: ComponentLogger
+}
+
 /**
  * A libp2p data channel stream muxer
  */
@@ -105,11 +123,15 @@ export class DataChannelMuxer implements StreamMuxer {
   public streams: Stream[]
   public protocol: string
 
+  private readonly log: Logger
   private readonly peerConnection: RTCPeerConnection
   private readonly dataChannelOptions: DataChannelOptions
   private readonly metrics?: CounterGroup
+  private readonly logger: ComponentLogger
 
-  constructor (readonly init: DataChannelMuxerInit) {
+  constructor (components: DataChannelMuxerComponents, readonly init: DataChannelMuxerInit) {
+    this.log = components.logger.forComponent('libp2p:webrtc:muxer')
+    this.logger = components.logger
     this.streams = init.streams.map(s => s.stream)
     this.peerConnection = init.peerConnection
     this.protocol = init.protocol ?? PROTOCOL
@@ -123,12 +145,24 @@ export class DataChannelMuxer implements StreamMuxer {
      * {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/datachannel_event}
      */
     this.peerConnection.ondatachannel = ({ channel }) => {
+      this.log.trace('incoming datachannel with channel id %d', channel.id)
+
+      // 'init' channel is only used during connection establishment
+      if (channel.label === 'init') {
+        this.log.trace('closing init channel')
+        channel.close()
+
+        return
+      }
+
       const stream = createStream({
         channel,
         direction: 'inbound',
         onEnd: () => {
+          this.log('incoming channel %s ended with state %s', channel.id, channel.readyState)
           this.#onStreamEnd(stream, channel)
         },
+        logger: this.logger,
         ...this.dataChannelOptions
       })
 
@@ -147,6 +181,7 @@ export class DataChannelMuxer implements StreamMuxer {
       queueMicrotask(() => {
         this.init.streams.forEach(bufferedStream => {
           bufferedStream.onEnd = () => {
+            this.log('incoming early channel %s ended with state %s', bufferedStream.channel.id, bufferedStream.channel.readyState)
             this.#onStreamEnd(bufferedStream.stream, bufferedStream.channel)
           }
 
@@ -158,8 +193,14 @@ export class DataChannelMuxer implements StreamMuxer {
   }
 
   #onStreamEnd (stream: Stream, channel: RTCDataChannel): void {
-    log.trace('stream %s %s %s onEnd', stream.direction, stream.id, stream.protocol)
-    drainAndClose(channel, `${stream.direction} ${stream.id} ${stream.protocol}`, this.dataChannelOptions.drainTimeout)
+    this.log.trace('stream %s %s %s onEnd', stream.direction, stream.id, stream.protocol)
+    drainAndClose(
+      channel,
+      `${stream.direction} ${stream.id} ${stream.protocol}`,
+      this.dataChannelOptions.drainTimeout, {
+        log: this.log
+      }
+    )
     this.streams = this.streams.filter(s => s.id !== stream.id)
     this.metrics?.increment({ stream_end: true })
     this.init?.onStreamEnd?.(stream)
@@ -200,12 +241,17 @@ export class DataChannelMuxer implements StreamMuxer {
   newStream (): Stream {
     // The spec says the label SHOULD be an empty string: https://github.com/libp2p/specs/blob/master/webrtc/README.md#rtcdatachannel-label
     const channel = this.peerConnection.createDataChannel('')
+
+    this.log.trace('opened outgoing datachannel with channel id %s', channel.id)
+
     const stream = createStream({
       channel,
       direction: 'outbound',
       onEnd: () => {
+        this.log('outgoing channel %s ended with state %s', channel.id, channel.readyState)
         this.#onStreamEnd(stream, channel)
       },
+      logger: this.logger,
       ...this.dataChannelOptions
     })
     this.streams.push(stream)

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

@@ -1,5 +1,4 @@
-import { CodeError } from '@libp2p/interface/errors'
-import { logger } from '@libp2p/logger'
+import { CodeError } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { pbStream } from 'it-protobuf-stream'
 import pDefer, { type DeferredPromise } from 'p-defer'
@@ -8,21 +7,17 @@ import { Message } from './pb/message.js'
 import { SIGNALING_PROTO_ID, splitAddr, type WebRTCTransportMetrics } from './transport.js'
 import { readCandidatesUntilConnected, resolveOnConnected } from './util.js'
 import type { DataChannelOptions } from '../index.js'
-import type { Connection } from '@libp2p/interface/connection'
-import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
-import type { IncomingStreamData } from '@libp2p/interface-internal/registrar'
-import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
+import type { LoggerOptions, Connection } from '@libp2p/interface'
+import type { ConnectionManager, IncomingStreamData, TransportManager } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
-const log = logger('libp2p:webrtc:initiate-connection')
-
 export interface IncomingStreamOpts extends IncomingStreamData {
   rtcConfiguration?: RTCConfiguration
   dataChannelOptions?: Partial<DataChannelOptions>
   signal: AbortSignal
 }
 
-export interface ConnectOptions {
+export interface ConnectOptions extends LoggerOptions {
   peerConnection: RTCPeerConnection
   multiaddr: Multiaddr
   connectionManager: ConnectionManager
@@ -32,7 +27,7 @@ export interface ConnectOptions {
   metrics?: WebRTCTransportMetrics
 }
 
-export async function initiateConnection ({ peerConnection, signal, metrics, multiaddr: ma, connectionManager, transportManager }: ConnectOptions): Promise<{ remoteAddress: Multiaddr }> {
+export async function initiateConnection ({ peerConnection, signal, metrics, multiaddr: ma, connectionManager, transportManager, log }: ConnectOptions): Promise<{ remoteAddress: Multiaddr }> {
   const { baseAddr } = splitAddr(ma)
 
   metrics?.dialerEvents.increment({ open: true })
@@ -147,7 +142,8 @@ export async function initiateConnection ({ peerConnection, signal, metrics, mul
 
       await readCandidatesUntilConnected(connectedPromise, peerConnection, messageStream, {
         direction: 'initiator',
-        signal
+        signal,
+        log
       })
 
       log.trace('initiator connected, closing init channel')

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

@@ -1,8 +1,7 @@
-import { TypedEventEmitter } from '@libp2p/interface/events'
+import { TypedEventEmitter } from '@libp2p/interface'
 import { Circuit } from '@multiformats/mafmt'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { ListenerEvents, Listener } from '@libp2p/interface/transport'
-import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
+import type { PeerId, ListenerEvents, Listener } from '@libp2p/interface'
+import type { TransportManager } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 export interface WebRTCPeerListenerComponents {

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

@@ -1,21 +1,20 @@
-import { CodeError } from '@libp2p/interface/errors'
-import { logger } from '@libp2p/logger'
+import { CodeError } from '@libp2p/interface'
 import { multiaddr, type Multiaddr } from '@multiformats/multiaddr'
 import { pbStream } from 'it-protobuf-stream'
 import pDefer, { type DeferredPromise } from 'p-defer'
 import { type RTCPeerConnection, RTCSessionDescription } from '../webrtc/index.js'
 import { Message } from './pb/message.js'
 import { readCandidatesUntilConnected, resolveOnConnected } from './util.js'
-import type { IncomingStreamData } from '@libp2p/interface-internal/registrar'
-
-const log = logger('libp2p:webrtc:signaling-stream-handler')
+import type { Logger } from '@libp2p/interface'
+import type { IncomingStreamData } from '@libp2p/interface-internal'
 
 export interface IncomingStreamOpts extends IncomingStreamData {
   peerConnection: RTCPeerConnection
   signal: AbortSignal
+  log: Logger
 }
 
-export async function handleIncomingStream ({ peerConnection, stream, signal, connection }: IncomingStreamOpts): Promise<{ remoteAddress: Multiaddr }> {
+export async function handleIncomingStream ({ peerConnection, stream, signal, connection, log }: IncomingStreamOpts): Promise<{ remoteAddress: Multiaddr }> {
   log.trace('new inbound signaling stream')
 
   const messageStream = pbStream(stream).pb(Message)
@@ -104,7 +103,8 @@ export async function handleIncomingStream ({ peerConnection, stream, signal, co
     // wait until candidates are connected
     await readCandidatesUntilConnected(connectedPromise, peerConnection, messageStream, {
       direction: 'recipient',
-      signal
+      signal,
+      log
     })
 
     log.trace('recipient connected, closing signaling stream')

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

@@ -1,6 +1,4 @@
-import { CodeError } from '@libp2p/interface/errors'
-import { type CreateListenerOptions, type DialOptions, symbol, type Transport, type Listener, type Upgrader } from '@libp2p/interface/transport'
-import { logger } from '@libp2p/logger'
+import { CodeError, transportSymbol } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { multiaddr, type Multiaddr } from '@multiformats/multiaddr'
 import { WebRTC } from '@multiformats/multiaddr-matcher'
@@ -11,48 +9,22 @@ import { cleanup, RTCPeerConnection } from '../webrtc/index.js'
 import { initiateConnection } from './initiate-connection.js'
 import { WebRTCPeerListener } from './listener.js'
 import { handleIncomingStream } from './signaling-stream-handler.js'
-import type { DataChannelOptions } from '../index.js'
-import type { Connection } from '@libp2p/interface/connection'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { CounterGroup, Metrics } from '@libp2p/interface/src/metrics/index.js'
-import type { Startable } from '@libp2p/interface/startable'
-import type { IncomingStreamData, Registrar } from '@libp2p/interface-internal/registrar'
-import type { ConnectionManager } from '@libp2p/interface-internal/src/connection-manager/index.js'
-import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
-
-const log = logger('libp2p:webrtc:peer')
+import type { WebRTCTransportComponents, WebRTCTransportInit } from '../index.js'
+import type { Logger, Connection, CounterGroup, PeerId, Startable, CreateListenerOptions, DialOptions, Transport, Listener } from '@libp2p/interface'
+import type { IncomingStreamData } from '@libp2p/interface-internal'
 
 const WEBRTC_TRANSPORT = '/webrtc'
 const CIRCUIT_RELAY_TRANSPORT = '/p2p-circuit'
 export const SIGNALING_PROTO_ID = '/webrtc-signaling/0.0.1'
 const INBOUND_CONNECTION_TIMEOUT = 30 * 1000
 
-export interface WebRTCTransportInit {
-  rtcConfiguration?: RTCConfiguration
-  dataChannel?: DataChannelOptions
-
-  /**
-   * Inbound connections must complete the upgrade within this many ms
-   * (default: 30s)
-   */
-  inboundConnectionTimeout?: number
-}
-
-export interface WebRTCTransportComponents {
-  peerId: PeerId
-  registrar: Registrar
-  upgrader: Upgrader
-  transportManager: TransportManager
-  connectionManager: ConnectionManager
-  metrics?: Metrics
-}
-
 export interface WebRTCTransportMetrics {
   dialerEvents: CounterGroup
   listenerEvents: CounterGroup
 }
 
 export class WebRTCTransport implements Transport, Startable {
+  private readonly log: Logger
   private _started = false
   private readonly metrics?: WebRTCTransportMetrics
   private readonly shutdownController: AbortController
@@ -61,6 +33,7 @@ export class WebRTCTransport implements Transport, Startable {
     private readonly components: WebRTCTransportComponents,
     private readonly init: WebRTCTransportInit = {}
   ) {
+    this.log = components.logger.forComponent('libp2p:webrtc')
     this.shutdownController = new AbortController()
 
     if (components.metrics != null) {
@@ -83,7 +56,7 @@ export class WebRTCTransport implements Transport, Startable {
 
   async start (): Promise<void> {
     await this.components.registrar.handle(SIGNALING_PROTO_ID, (data: IncomingStreamData) => {
-      this._onProtocol(data).catch(err => { log.error('failed to handle incoming connect from %p', data.connection.remotePeer, err) })
+      this._onProtocol(data).catch(err => { this.log.error('failed to handle incoming connect from %p', data.connection.remotePeer, err) })
     }, {
       runOnTransientConnection: true
     })
@@ -104,7 +77,7 @@ export class WebRTCTransport implements Transport, Startable {
 
   readonly [Symbol.toStringTag] = '@libp2p/webrtc'
 
-  readonly [symbol] = true
+  readonly [transportSymbol] = true
 
   filter (multiaddrs: Multiaddr[]): Multiaddr[] {
     return multiaddrs.filter(WebRTC.exactMatch)
@@ -118,10 +91,10 @@ export class WebRTCTransport implements Transport, Startable {
    * <relay address>/p2p/<relay-peer>/p2p-circuit/webrtc/p2p/<destination-peer>
   */
   async dial (ma: Multiaddr, options: DialOptions): Promise<Connection> {
-    log.trace('dialing address: %a', ma)
+    this.log.trace('dialing address: %a', ma)
 
     const peerConnection = new RTCPeerConnection(this.init.rtcConfiguration)
-    const muxerFactory = new DataChannelMuxerFactory({
+    const muxerFactory = new DataChannelMuxerFactory(this.components, {
       peerConnection,
       dataChannelOptions: this.init.dataChannel
     })
@@ -132,10 +105,11 @@ export class WebRTCTransport implements Transport, Startable {
       dataChannelOptions: this.init.dataChannel,
       signal: options.signal,
       connectionManager: this.components.connectionManager,
-      transportManager: this.components.transportManager
+      transportManager: this.components.transportManager,
+      log: this.log
     })
 
-    const webRTCConn = new WebRTCMultiaddrConnection({
+    const webRTCConn = new WebRTCMultiaddrConnection(this.components, {
       peerConnection,
       timeline: { open: Date.now() },
       remoteAddr: remoteAddress,
@@ -157,7 +131,7 @@ export class WebRTCTransport implements Transport, Startable {
   async _onProtocol ({ connection, stream }: IncomingStreamData): Promise<void> {
     const signal = AbortSignal.timeout(this.init.inboundConnectionTimeout ?? INBOUND_CONNECTION_TIMEOUT)
     const peerConnection = new RTCPeerConnection(this.init.rtcConfiguration)
-    const muxerFactory = new DataChannelMuxerFactory({
+    const muxerFactory = new DataChannelMuxerFactory(this.components, {
       peerConnection,
       dataChannelOptions: this.init.dataChannel
     })
@@ -167,10 +141,11 @@ export class WebRTCTransport implements Transport, Startable {
         peerConnection,
         connection,
         stream,
-        signal
+        signal,
+        log: this.log
       })
 
-      const webRTCConn = new WebRTCMultiaddrConnection({
+      const webRTCConn = new WebRTCMultiaddrConnection(this.components, {
         peerConnection,
         timeline: { open: (new Date()).getTime() },
         remoteAddr: remoteAddress,
@@ -201,7 +176,7 @@ export class WebRTCTransport implements Transport, Startable {
     const shutDownListener = (): void => {
       webRTCConn.close()
         .catch(err => {
-          log.error('could not close WebRTCMultiaddrConnection', err)
+          this.log.error('could not close WebRTCMultiaddrConnection', err)
         })
     }