@libp2p/webrtc 4.1.0 → 4.1.1-ce6da9896

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

@@ -1,15 +1,17 @@
 import { CodeError } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { pbStream } from 'it-protobuf-stream'
+import { CustomProgressEvent } from 'progress-events'
 import { DataChannelMuxerFactory } from '../muxer.js'
 import { RTCPeerConnection, RTCSessionDescription } from '../webrtc/index.js'
 import { Message } from './pb/message.js'
-import { SIGNALING_PROTO_ID, splitAddr, type WebRTCTransportMetrics } from './transport.js'
+import { SIGNALING_PROTO_ID, splitAddr, type WebRTCDialEvents, type WebRTCTransportMetrics } from './transport.js'
 import { readCandidatesUntilConnected } from './util.js'
 import type { DataChannelOptions } from '../index.js'
 import type { LoggerOptions, Connection, ComponentLogger } from '@libp2p/interface'
 import type { ConnectionManager, IncomingStreamData, TransportManager } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'
+import type { ProgressOptions } from 'progress-events'
 
 export interface IncomingStreamOpts extends IncomingStreamData {
   rtcConfiguration?: RTCConfiguration
@@ -17,7 +19,7 @@ export interface IncomingStreamOpts extends IncomingStreamData {
   signal: AbortSignal
 }
 
-export interface ConnectOptions extends LoggerOptions {
+export interface ConnectOptions extends LoggerOptions, ProgressOptions<WebRTCDialEvents> {
   rtcConfiguration?: RTCConfiguration
   dataChannel?: DataChannelOptions
   multiaddr: Multiaddr
@@ -29,7 +31,7 @@ export interface ConnectOptions extends LoggerOptions {
   logger: ComponentLogger
 }
 
-export async function initiateConnection ({ rtcConfiguration, dataChannel, signal, metrics, multiaddr: ma, connectionManager, transportManager, log, logger }: ConnectOptions): Promise<{ remoteAddress: Multiaddr, peerConnection: RTCPeerConnection, muxerFactory: DataChannelMuxerFactory }> {
+export async function initiateConnection ({ rtcConfiguration, dataChannel, signal, metrics, multiaddr: ma, connectionManager, transportManager, log, logger, onProgress }: ConnectOptions): Promise<{ remoteAddress: Multiaddr, peerConnection: RTCPeerConnection, muxerFactory: DataChannelMuxerFactory }> {
   const { baseAddr } = splitAddr(ma)
 
   metrics?.dialerEvents.increment({ open: true })
@@ -47,20 +49,27 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
   let shouldCloseConnection = false
 
   if (connections.length === 0) {
+    onProgress?.(new CustomProgressEvent('webrtc:dial-relay'))
+
     // use the transport manager to open a connection. Initiating a WebRTC
     // connection takes place in the context of a dial - if we use the
     // connection manager instead we can end up joining our own dial context
     connection = await transportManager.dial(baseAddr, {
-      signal
+      signal,
+      onProgress
     })
     // this connection is unmanaged by the connection manager so we should
     // close it when we are done
     shouldCloseConnection = true
   } else {
+    onProgress?.(new CustomProgressEvent('webrtc:reuse-relay-connection'))
+
     connection = connections[0]
   }
 
   try {
+    onProgress?.(new CustomProgressEvent('webrtc:open-signaling-stream'))
+
     const stream = await connection.newStream(SIGNALING_PROTO_ID, {
       signal,
       runOnTransientConnection: true
@@ -113,6 +122,8 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
 
       log.trace('initiator send SDP offer %s', offerSdp.sdp)
 
+      onProgress?.(new CustomProgressEvent('webrtc:send-sdp-offer'))
+
       // write the offer to the stream
       await messageStream.write({ type: Message.Type.SDP_OFFER, data: offerSdp.sdp }, {
         signal
@@ -124,6 +135,8 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
         throw new CodeError('Failed to set localDescription', 'ERR_SDP_HANDSHAKE_FAILED')
       })
 
+      onProgress?.(new CustomProgressEvent('webrtc:read-sdp-answer'))
+
       // read answer
       const answerMessage = await messageStream.read({
         signal
@@ -143,16 +156,21 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
 
       log.trace('initiator read candidates until connected')
 
+      onProgress?.(new CustomProgressEvent('webrtc:read-ice-candidates'))
+
       await readCandidatesUntilConnected(peerConnection, messageStream, {
         direction: 'initiator',
         signal,
-        log
+        log,
+        onProgress
       })
 
       log.trace('initiator connected, closing init channel')
       channel.close()
 
-      log.trace('closing signalling channel')
+      onProgress?.(new CustomProgressEvent('webrtc:close-signaling-stream'))
+
+      log.trace('closing signaling channel')
       await stream.close({
         signal
       })
@@ -165,7 +183,7 @@ export async function initiateConnection ({ rtcConfiguration, dataChannel, signa
         muxerFactory
       }
     } catch (err: any) {
-      log.error('outgoing signalling error', err)
+      log.error('outgoing signaling error', err)
 
       peerConnection.close()
       stream.abort(err)

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

@@ -1,17 +1,19 @@
-import { CodeError, serviceCapabilities, serviceDependencies, setMaxListeners } 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 { CodeError, serviceCapabilities, serviceDependencies, setMaxListeners, transportSymbol } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { multiaddr, type Multiaddr } from '@multiformats/multiaddr'
 import { WebRTC } from '@multiformats/multiaddr-matcher'
 import { codes } from '../error.js'
 import { WebRTCMultiaddrConnection } from '../maconn.js'
 import { DataChannelMuxerFactory } from '../muxer.js'
+import { getRtcConfiguration } from '../util.js'
 import { 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 { IncomingStreamData, Registrar, ConnectionManager, TransportManager } from '@libp2p/interface-internal'
+import type { OutboundConnectionUpgradeEvents, CreateListenerOptions, DialOptions, Transport, Listener, Upgrader, ComponentLogger, Logger, Connection, PeerId, CounterGroup, Metrics, Startable } from '@libp2p/interface'
+import type { IncomingStreamData, Registrar, ConnectionManager, TransportManager, OpenConnectionProgressEvents } from '@libp2p/interface-internal'
+import type { ProgressEvent } from 'progress-events'
 
 const WEBRTC_TRANSPORT = '/webrtc'
 const CIRCUIT_RELAY_TRANSPORT = '/p2p-circuit'
@@ -44,7 +46,20 @@ export interface WebRTCTransportMetrics {
   listenerEvents: CounterGroup
 }
 
-export class WebRTCTransport implements Transport, Startable {
+export type WebRTCDialEvents =
+  OutboundConnectionUpgradeEvents |
+  OpenConnectionProgressEvents |
+  ProgressEvent<'webrtc:dial-relay'> |
+  ProgressEvent<'webrtc:reuse-relay-connection'> |
+  ProgressEvent<'webrtc:open-signaling-stream'> |
+  ProgressEvent<'webrtc:send-sdp-offer'> |
+  ProgressEvent<'webrtc:read-sdp-answer'> |
+  ProgressEvent<'webrtc:read-ice-candidates'> |
+  ProgressEvent<'webrtc:add-ice-candidate', string> |
+  ProgressEvent<'webrtc:end-of-ice-candidates'> |
+  ProgressEvent<'webrtc:close-signaling-stream'>
+
+export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
   private readonly log: Logger
   private _started = false
   private readonly metrics?: WebRTCTransportMetrics
@@ -130,11 +145,11 @@ export class WebRTCTransport implements Transport, Startable {
    * For a circuit relay, this will be of the form
    * <relay address>/p2p/<relay-peer>/p2p-circuit/webrtc/p2p/<destination-peer>
   */
-  async dial (ma: Multiaddr, options: DialOptions): Promise<Connection> {
+  async dial (ma: Multiaddr, options: DialOptions<WebRTCDialEvents>): Promise<Connection> {
     this.log.trace('dialing address: %a', ma)
 
     const { remoteAddress, peerConnection, muxerFactory } = await initiateConnection({
-      rtcConfiguration: typeof this.init.rtcConfiguration === 'function' ? await this.init.rtcConfiguration() : this.init.rtcConfiguration,
+      rtcConfiguration: await getRtcConfiguration(this.init.rtcConfiguration),
       dataChannel: this.init.dataChannel,
       multiaddr: ma,
       dataChannelOptions: this.init.dataChannel,
@@ -142,7 +157,8 @@ export class WebRTCTransport implements Transport, Startable {
       connectionManager: this.components.connectionManager,
       transportManager: this.components.transportManager,
       log: this.log,
-      logger: this.components.logger
+      logger: this.components.logger,
+      onProgress: options.onProgress
     })
 
     const webRTCConn = new WebRTCMultiaddrConnection(this.components, {
@@ -155,7 +171,8 @@ export class WebRTCTransport implements Transport, Startable {
     const connection = await options.upgrader.upgradeOutbound(webRTCConn, {
       skipProtection: true,
       skipEncryption: true,
-      muxerFactory
+      muxerFactory,
+      onProgress: options.onProgress
     })
 
     // close the connection on shut down
@@ -166,7 +183,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(typeof this.init.rtcConfiguration === 'function' ? await this.init.rtcConfiguration() : this.init.rtcConfiguration)
+    const peerConnection = new RTCPeerConnection(await getRtcConfiguration(this.init.rtcConfiguration))
     const muxerFactory = new DataChannelMuxerFactory(this.components, {
       peerConnection,
       dataChannelOptions: this.init.dataChannel
@@ -202,7 +219,7 @@ export class WebRTCTransport implements Transport, Startable {
       // close the connection on shut down
       this._closeOnShutdown(peerConnection, webRTCConn)
     } catch (err: any) {
-      this.log.error('incoming signalling error', err)
+      this.log.error('incoming signaling error', err)
 
       peerConnection.close()
       stream.abort(err)

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

@@ -1,13 +1,16 @@
 import { CodeError } from '@libp2p/interface'
 import pDefer from 'p-defer'
+import { CustomProgressEvent } from 'progress-events'
 import { isFirefox } from '../util.js'
 import { RTCIceCandidate } from '../webrtc/index.js'
 import { Message } from './pb/message.js'
+import type { WebRTCDialEvents } from './transport.js'
 import type { LoggerOptions, Stream } from '@libp2p/interface'
 import type { AbortOptions, MessageStream } from 'it-protobuf-stream'
 import type { DeferredPromise } from 'p-defer'
+import type { ProgressOptions } from 'progress-events'
 
-export interface ReadCandidatesOptions extends AbortOptions, LoggerOptions {
+export interface ReadCandidatesOptions extends AbortOptions, LoggerOptions, ProgressOptions<WebRTCDialEvents> {
   direction: string
 }
 
@@ -44,6 +47,7 @@ export const readCandidatesUntilConnected = async (pc: RTCPeerConnection, stream
       // candidate means candidate gathering has finished
       // see - https://www.w3.org/TR/webrtc/#rtcpeerconnectioniceevent
       if (candidateInit === '' || candidateInit === null) {
+        options.onProgress?.(new CustomProgressEvent('webrtc:end-of-ice-candidates'))
         options.log.trace('end-of-candidates received')
 
         continue
@@ -54,6 +58,7 @@ export const readCandidatesUntilConnected = async (pc: RTCPeerConnection, stream
       options.log.trace('%s received new ICE candidate %o', options.direction, candidateInit)
 
       try {
+        options.onProgress?.(new CustomProgressEvent<string>('webrtc:add-ice-candidate', candidate.candidate))
         await pc.addIceCandidate(candidate)
       } catch (err) {
         options.log.error('%s bad candidate received', options.direction, candidateInit, err)

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

@@ -10,7 +10,7 @@ import { dataChannelError, inappropriateMultiaddr, unimplemented, invalidArgumen
 import { WebRTCMultiaddrConnection } from '../maconn.js'
 import { DataChannelMuxerFactory } from '../muxer.js'
 import { createStream } from '../stream.js'
-import { isFirefox } from '../util.js'
+import { getRtcConfiguration, isFirefox } from '../util.js'
 import { RTCPeerConnection } from '../webrtc/index.js'
 import * as sdp from './sdp.js'
 import { genUfrag } from './util.js'
@@ -139,7 +139,7 @@ export class WebRTCDirectTransport implements Transport {
     } as any)
 
     const peerConnection = new RTCPeerConnection({
-      ...(typeof this.init.rtcConfiguration === 'function' ? await this.init.rtcConfiguration() : this.init.rtcConfiguration ?? {}),
+      ...(await getRtcConfiguration(this.init.rtcConfiguration)),
       certificates: [certificate]
     })
 

package/src/util.ts

@@ -1,6 +1,7 @@
 import { detect } from 'detect-browser'
 import pDefer from 'p-defer'
 import pTimeout from 'p-timeout'
+import { DEFAULT_ICE_SERVERS } from './constants.js'
 import type { LoggerOptions } from '@libp2p/interface'
 
 const browser = detect()
@@ -64,3 +65,19 @@ export interface AbortPromiseOptions {
   signal?: AbortSignal
   message?: string
 }
+
+export async function getRtcConfiguration (config?: RTCConfiguration | (() => RTCConfiguration | Promise<RTCConfiguration>)): Promise<RTCConfiguration> {
+  config = config ?? {}
+
+  if (typeof config === 'function') {
+    config = await config()
+  }
+
+  config.iceServers = config.iceServers ?? DEFAULT_ICE_SERVERS.map(url => ({
+    urls: [
+      url
+    ]
+  }))
+
+  return config
+}

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