@libp2p/webrtc 3.2.6-f4fac961 → 3.2.6-fdcb801e

package/src/muxer.ts

@@ -32,14 +32,6 @@ export interface DataChannelMuxerFactoryInit {
   dataChannelOptions?: DataChannelOptions
 }
 
-interface BufferedStream {
-  stream: Stream
-  channel: RTCDataChannel
-  onEnd(err?: Error): void
-}
-
-let streamIndex = 0
-
 export class DataChannelMuxerFactory implements StreamMuxerFactory {
   public readonly protocol: string
 
@@ -47,7 +39,7 @@ export class DataChannelMuxerFactory implements StreamMuxerFactory {
    * WebRTC Peer Connection
    */
   private readonly peerConnection: RTCPeerConnection
-  private bufferedStreams: BufferedStream[] = []
+  private streamBuffer: Stream[] = []
   private readonly metrics?: CounterGroup
   private readonly dataChannelOptions?: DataChannelOptions
 
@@ -59,25 +51,15 @@ 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: (err) => {
-          bufferedStream.onEnd(err)
+        onEnd: () => {
+          this.streamBuffer = this.streamBuffer.filter(s => s.id !== stream.id)
         },
         ...this.dataChannelOptions
       })
-
-      bufferedStream.stream = stream
-      bufferedStream.channel = channel
-      bufferedStream.onEnd = () => {
-        this.bufferedStreams = this.bufferedStreams.filter(s => s.stream.id !== stream.id)
-      }
-
-      this.bufferedStreams.push(bufferedStream)
+      this.streamBuffer.push(stream)
     }
   }
 
@@ -87,14 +69,14 @@ export class DataChannelMuxerFactory implements StreamMuxerFactory {
       peerConnection: this.peerConnection,
       dataChannelOptions: this.dataChannelOptions,
       metrics: this.metrics,
-      streams: this.bufferedStreams,
+      streams: this.streamBuffer,
       protocol: this.protocol
     })
   }
 }
 
 export interface DataChannelMuxerInit extends DataChannelMuxerFactoryInit, StreamMuxerInit {
-  streams: BufferedStream[]
+  streams: Stream[]
 }
 
 /**
@@ -112,7 +94,7 @@ export class DataChannelMuxer implements StreamMuxer {
   private readonly metrics?: CounterGroup
 
   constructor (readonly init: DataChannelMuxerInit) {
-    this.streams = init.streams.map(s => s.stream)
+    this.streams = init.streams
     this.peerConnection = init.peerConnection
     this.protocol = init.protocol ?? PROTOCOL
     this.metrics = init.metrics
@@ -129,7 +111,11 @@ export class DataChannelMuxer implements StreamMuxer {
         channel,
         direction: 'inbound',
         onEnd: () => {
-          this.#onStreamEnd(stream, channel)
+          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.dataChannelOptions
       })
@@ -139,22 +125,10 @@ export class DataChannelMuxer implements StreamMuxer {
       init?.onIncomingStream?.(stream)
     }
 
-    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)
+    const onIncomingStream = init?.onIncomingStream
+    if (onIncomingStream != null) {
+      this.streams.forEach(s => { onIncomingStream(s) })
+    }
   }
 
   /**
@@ -190,15 +164,17 @@ export class DataChannelMuxer implements StreamMuxer {
   sink: Sink<Source<Uint8Array | Uint8ArrayList>, Promise<void>> = nopSink
 
   newStream (): Stream {
-    streamIndex++
-
     // 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(`stream-${streamIndex}`)
+    const channel = this.peerConnection.createDataChannel('')
     const stream = createStream({
       channel,
       direction: 'outbound',
       onEnd: () => {
-        this.#onStreamEnd(stream, channel)
+        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.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 { readCandidatesUntilConnected, resolveOnConnected } from './util.js'
+import { parseRemoteAddress, 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 } = splitAddr(ma)
+  const { baseAddr, peerId } = splitAddr(ma)
 
   metrics?.dialerEvents.increment({ open: true })
 
@@ -158,10 +158,12 @@ export async function initiateConnection ({ peerConnection, signal, metrics, mul
         signal
       })
 
-      log.trace('initiator connected to remote address %s', ma)
+      const remoteAddress = parseRemoteAddress(peerConnection.currentRemoteDescription?.sdp ?? '')
+
+      log.trace('initiator connected to remote address %s', remoteAddress)
 
       return {
-        remoteAddress: ma
+        remoteAddress: multiaddr(remoteAddress).encapsulate(`/p2p/${peerId.toString()}`)
       }
     } catch (err: any) {
       peerConnection.close()

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

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

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

@@ -121,6 +121,10 @@ export class WebRTCTransport implements Transport, Startable {
     log.trace('dialing address: %a', ma)
 
     const peerConnection = new RTCPeerConnection(this.init.rtcConfiguration)
+    const muxerFactory = new DataChannelMuxerFactory({
+      peerConnection,
+      dataChannelOptions: this.init.dataChannel
+    })
 
     const { remoteAddress } = await initiateConnection({
       peerConnection,
@@ -141,10 +145,7 @@ export class WebRTCTransport implements Transport, Startable {
     const connection = await options.upgrader.upgradeOutbound(webRTCConn, {
       skipProtection: true,
       skipEncryption: true,
-      muxerFactory: new DataChannelMuxerFactory({
-        peerConnection,
-        dataChannelOptions: this.init.dataChannel
-      })
+      muxerFactory
     })
 
     // close the connection on shut down
@@ -156,6 +157,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({ peerConnection, dataChannelOptions: this.init.dataChannel })
 
     try {
       const { remoteAddress } = await handleIncomingStream({
@@ -168,7 +170,7 @@ export class WebRTCTransport implements Transport, Startable {
       const webRTCConn = new WebRTCMultiaddrConnection({
         peerConnection,
         timeline: { open: (new Date()).getTime() },
-        remoteAddr: remoteAddress,
+        remoteAddr: multiaddr(remoteAddress).encapsulate(`/p2p/${connection.remotePeer.toString()}`),
         metrics: this.metrics?.listenerEvents
       })
 
@@ -178,7 +180,7 @@ export class WebRTCTransport implements Transport, Startable {
       await this.components.upgrader.upgradeInbound(webRTCConn, {
         skipEncryption: true,
         skipProtection: true,
-        muxerFactory: new DataChannelMuxerFactory({ peerConnection, dataChannelOptions: this.init.dataChannel })
+        muxerFactory
       })
 
       // close the stream if SDP messages have been exchanged successfully

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

@@ -110,3 +110,16 @@ 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,6 +84,7 @@ 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