@libp2p/webrtc 3.2.11 → 4.0.0-06e6d235f

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,5 @@
-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 } from '@libp2p/interface'
+import { type CreateListenerOptions, type DialOptions, transportSymbol, type Transport, type Listener, type Upgrader, type ComponentLogger, type Logger, type Connection, type PeerId, type CounterGroup, type Metrics, type Startable } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { multiaddr, type Multiaddr } from '@multiformats/multiaddr'
 import { WebRTC } from '@multiformats/multiaddr-matcher'
@@ -12,15 +11,7 @@ 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 { IncomingStreamData, Registrar, ConnectionManager, TransportManager } from '@libp2p/interface-internal'
 
 const WEBRTC_TRANSPORT = '/webrtc'
 const CIRCUIT_RELAY_TRANSPORT = '/p2p-circuit'
@@ -45,6 +36,7 @@ export interface WebRTCTransportComponents {
   transportManager: TransportManager
   connectionManager: ConnectionManager
   metrics?: Metrics
+  logger: ComponentLogger
 }
 
 export interface WebRTCTransportMetrics {
@@ -53,6 +45,7 @@ export interface WebRTCTransportMetrics {
 }
 
 export class WebRTCTransport implements Transport, Startable {
+  private readonly log: Logger
   private _started = false
   private readonly metrics?: WebRTCTransportMetrics
   private readonly shutdownController: AbortController
@@ -61,6 +54,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 +77,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 +98,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 +112,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 +126,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 +152,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 +162,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 +197,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)
         })
     }
 

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'
 }