@libp2p/webrtc 3.2.6 → 3.2.7-d25d9510

package/src/muxer.ts

@@ -32,6 +32,12 @@ export interface DataChannelMuxerFactoryInit {
   dataChannelOptions?: DataChannelOptions
 }
 
+interface BufferedStream {
+  stream: Stream
+  channel: RTCDataChannel
+  onEnd(err?: Error): void
+}
+
 export class DataChannelMuxerFactory implements StreamMuxerFactory {
   public readonly protocol: string
 
@@ -39,7 +45,7 @@ export class DataChannelMuxerFactory implements StreamMuxerFactory {
    * WebRTC Peer Connection
    */
   private readonly peerConnection: RTCPeerConnection
-  private streamBuffer: Stream[] = []
+  private bufferedStreams: BufferedStream[] = []
   private readonly metrics?: CounterGroup
   private readonly dataChannelOptions?: DataChannelOptions
 
@@ -51,15 +57,25 @@ export class DataChannelMuxerFactory implements StreamMuxerFactory {
 
     // store any datachannels opened before upgrade has been completed
     this.peerConnection.ondatachannel = ({ channel }) => {
+      // @ts-expect-error fields are set below
+      const bufferedStream: BufferedStream = {}
+
       const stream = createStream({
         channel,
         direction: 'inbound',
-        onEnd: () => {
-          this.streamBuffer = this.streamBuffer.filter(s => s.id !== stream.id)
+        onEnd: (err) => {
+          bufferedStream.onEnd(err)
         },
         ...this.dataChannelOptions
       })
-      this.streamBuffer.push(stream)
+
+      bufferedStream.stream = stream
+      bufferedStream.channel = channel
+      bufferedStream.onEnd = () => {
+        this.bufferedStreams = this.bufferedStreams.filter(s => s.stream.id !== stream.id)
+      }
+
+      this.bufferedStreams.push(bufferedStream)
     }
   }
 
@@ -69,14 +85,14 @@ export class DataChannelMuxerFactory implements StreamMuxerFactory {
       peerConnection: this.peerConnection,
       dataChannelOptions: this.dataChannelOptions,
       metrics: this.metrics,
-      streams: this.streamBuffer,
+      streams: this.bufferedStreams,
       protocol: this.protocol
     })
   }
 }
 
 export interface DataChannelMuxerInit extends DataChannelMuxerFactoryInit, StreamMuxerInit {
-  streams: Stream[]
+  streams: BufferedStream[]
 }
 
 /**
@@ -94,7 +110,7 @@ export class DataChannelMuxer implements StreamMuxer {
   private readonly metrics?: CounterGroup
 
   constructor (readonly init: DataChannelMuxerInit) {
-    this.streams = init.streams
+    this.streams = init.streams.map(s => s.stream)
     this.peerConnection = init.peerConnection
     this.protocol = init.protocol ?? PROTOCOL
     this.metrics = init.metrics
@@ -111,11 +127,7 @@ export class DataChannelMuxer implements StreamMuxer {
         channel,
         direction: 'inbound',
         onEnd: () => {
-          log.trace('stream %s %s %s onEnd', stream.direction, stream.id, stream.protocol)
-          drainAndClose(channel, `inbound ${stream.id} ${stream.protocol}`, this.dataChannelOptions.drainTimeout)
-          this.streams = this.streams.filter(s => s.id !== stream.id)
-          this.metrics?.increment({ stream_end: true })
-          init?.onStreamEnd?.(stream)
+          this.#onStreamEnd(stream, channel)
         },
         ...this.dataChannelOptions
       })
@@ -125,12 +137,34 @@ export class DataChannelMuxer implements StreamMuxer {
       init?.onIncomingStream?.(stream)
     }
 
-    const onIncomingStream = init?.onIncomingStream
-    if (onIncomingStream != null) {
-      this.streams.forEach(s => { onIncomingStream(s) })
+    // the DataChannelMuxer constructor is called during set up of the
+    // connection by the upgrader.
+    //
+    // If we invoke `init.onIncomingStream` immediately, the connection object
+    // will not be set up yet so add a tiny delay before letting the
+    // connection know about early streams
+    if (this.init.streams.length > 0) {
+      queueMicrotask(() => {
+        this.init.streams.forEach(bufferedStream => {
+          bufferedStream.onEnd = () => {
+            this.#onStreamEnd(bufferedStream.stream, bufferedStream.channel)
+          }
+
+          this.metrics?.increment({ incoming_stream: true })
+          this.init?.onIncomingStream?.(bufferedStream.stream)
+        })
+      })
     }
   }
 
+  #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.streams = this.streams.filter(s => s.id !== stream.id)
+    this.metrics?.increment({ stream_end: true })
+    this.init?.onStreamEnd?.(stream)
+  }
+
   /**
    * Gracefully close all tracked streams and stop the muxer
    */
@@ -170,11 +204,7 @@ export class DataChannelMuxer implements StreamMuxer {
       channel,
       direction: 'outbound',
       onEnd: () => {
-        log.trace('stream %s %s %s onEnd', stream.direction, stream.id, stream.protocol)
-        drainAndClose(channel, `outbound ${stream.id} ${stream.protocol}`, this.dataChannelOptions.drainTimeout)
-        this.streams = this.streams.filter(s => s.id !== stream.id)
-        this.metrics?.increment({ stream_end: true })
-        this.init?.onStreamEnd?.(stream)
+        this.#onStreamEnd(stream, channel)
       },
       ...this.dataChannelOptions
     })

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

@@ -1,18 +1,18 @@
 import { CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
 import { peerIdFromString } from '@libp2p/peer-id'
-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 { SIGNALING_PROTO_ID, splitAddr, type WebRTCTransportMetrics } from './transport.js'
-import { parseRemoteAddress, readCandidatesUntilConnected, resolveOnConnected } from './util.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 { Multiaddr } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:webrtc:initiate-connection')
 
@@ -33,7 +33,7 @@ export interface ConnectOptions {
 }
 
 export async function initiateConnection ({ peerConnection, signal, metrics, multiaddr: ma, connectionManager, transportManager }: ConnectOptions): Promise<{ remoteAddress: Multiaddr }> {
-  const { baseAddr, peerId } = splitAddr(ma)
+  const { baseAddr } = splitAddr(ma)
 
   metrics?.dialerEvents.increment({ open: true })
 
@@ -158,12 +158,10 @@ export async function initiateConnection ({ peerConnection, signal, metrics, mul
         signal
       })
 
-      const remoteAddress = parseRemoteAddress(peerConnection.currentRemoteDescription?.sdp ?? '')
-
-      log.trace('initiator connected to remote address %s', remoteAddress)
+      log.trace('initiator connected to remote address %s', ma)
 
       return {
-        remoteAddress: multiaddr(remoteAddress).encapsulate(`/p2p/${peerId.toString()}`)
+        remoteAddress: ma
       }
     } catch (err: any) {
       peerConnection.close()

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

@@ -1,10 +1,11 @@
 import { CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
+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 { parseRemoteAddress, readCandidatesUntilConnected, resolveOnConnected } from './util.js'
+import { readCandidatesUntilConnected, resolveOnConnected } from './util.js'
 import type { IncomingStreamData } from '@libp2p/interface-internal/registrar'
 
 const log = logger('libp2p:webrtc:signaling-stream-handler')
@@ -14,7 +15,7 @@ export interface IncomingStreamOpts extends IncomingStreamData {
   signal: AbortSignal
 }
 
-export async function handleIncomingStream ({ peerConnection, stream, signal, connection }: IncomingStreamOpts): Promise<{ remoteAddress: string }> {
+export async function handleIncomingStream ({ peerConnection, stream, signal, connection }: IncomingStreamOpts): Promise<{ remoteAddress: Multiaddr }> {
   log.trace('new inbound signaling stream')
 
   const messageStream = pbStream(stream).pb(Message)
@@ -121,7 +122,7 @@ export async function handleIncomingStream ({ peerConnection, stream, signal, co
     }
   }
 
-  const remoteAddress = parseRemoteAddress(peerConnection.currentRemoteDescription?.sdp ?? '')
+  const remoteAddress = multiaddr(`/webrtc/p2p/${connection.remoteAddr.getPeerId()}`)
 
   log.trace('recipient connected to remote address %s', remoteAddress)
 

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

@@ -157,7 +157,10 @@ 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({ peerConnection, dataChannelOptions: this.init.dataChannel })
+    const muxerFactory = new DataChannelMuxerFactory({
+      peerConnection,
+      dataChannelOptions: this.init.dataChannel
+    })
 
     try {
       const { remoteAddress } = await handleIncomingStream({
@@ -170,7 +173,7 @@ export class WebRTCTransport implements Transport, Startable {
       const webRTCConn = new WebRTCMultiaddrConnection({
         peerConnection,
         timeline: { open: (new Date()).getTime() },
-        remoteAddr: multiaddr(remoteAddress).encapsulate(`/p2p/${connection.remotePeer.toString()}`),
+        remoteAddr: remoteAddress,
         metrics: this.metrics?.listenerEvents
       })
 

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

@@ -110,16 +110,3 @@ export function resolveOnConnected (pc: RTCPeerConnection, promise: DeferredProm
     }
   }
 }
-
-export function parseRemoteAddress (sdp: string): string {
-  // 'a=candidate:1746876089 1 udp 2113937151 0614fbad-b...ocal 54882 typ host generation 0 network-cost 999'
-  const candidateLine = sdp.split('\r\n').filter(line => line.startsWith('a=candidate')).pop()
-  const candidateParts = candidateLine?.split(' ')
-
-  if (candidateLine == null || candidateParts == null || candidateParts.length < 5) {
-    log('could not parse remote address from', candidateLine)
-    return '/webrtc'
-  }
-
-  return `/dnsaddr/${candidateParts[4]}/${candidateParts[2].toLowerCase()}/${candidateParts[5]}/webrtc`
-}

package/src/stream.ts

@@ -84,7 +84,6 @@ export class WebRTCStream extends AbstractStream {
    */
   private readonly receiveFinAck: DeferredPromise<void>
   private readonly finAckTimeout: number
-  //  private sentFinAck: boolean
 
   constructor (init: WebRTCStreamInit) {
     // override onEnd to send/receive FIN_ACK before closing the stream

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