@libp2p/webrtc 2.0.10-5eee70a4 → 2.0.10-69c93ac5

package/src/muxer.ts

@@ -4,6 +4,7 @@ import type { DataChannelOpts } from './stream.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 { AbortOptions } from '@multiformats/multiaddr'
 import type { Source, Sink } from 'it-stream-types'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
@@ -93,9 +94,14 @@ export class DataChannelMuxer implements StreamMuxer {
   private readonly metrics?: CounterGroup
 
   /**
-   * Close or abort all tracked streams and stop the muxer
+   * Gracefully close all tracked streams and stop the muxer
    */
-  close: (err?: Error | undefined) => void = () => { }
+  close: (options?: AbortOptions) => Promise<void> = async () => { }
+
+  /**
+   * Abort all tracked streams and stop the muxer
+   */
+  abort: (err: Error) => void = () => { }
 
   /**
    * The stream source, a no-op as the transport natively supports multiplexing

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

@@ -1,6 +1,6 @@
 import { logger } from '@libp2p/logger'
 import { abortableDuplex } from 'abortable-iterator'
-import { pbStream } from 'it-pb-stream'
+import { pbStream } from 'it-protobuf-stream'
 import pDefer, { type DeferredPromise } from 'p-defer'
 import { DataChannelMuxerFactory } from '../muxer.js'
 import { Message } from './pb/message.js'
@@ -28,8 +28,8 @@ export async function handleIncomingStream ({ rtcConfiguration, dataChannelOptio
   // candidate callbacks
   pc.onicecandidate = ({ candidate }) => {
     answerSentPromise.promise.then(
-      () => {
-        stream.write({
+      async () => {
+        await stream.write({
           type: Message.Type.ICE_CANDIDATE,
           data: (candidate != null) ? JSON.stringify(candidate.toJSON()) : ''
         })
@@ -64,7 +64,7 @@ export async function handleIncomingStream ({ rtcConfiguration, dataChannelOptio
     throw new Error('Failed to create answer')
   })
   // write the answer to the remote
-  stream.write({ type: Message.Type.SDP_ANSWER, data: answer.sdp })
+  await stream.write({ type: Message.Type.SDP_ANSWER, data: answer.sdp })
 
   await pc.setLocalDescription(answer).catch(err => {
     log.error('could not execute setLocalDescription', err)
@@ -107,15 +107,18 @@ export async function initiateConnection ({ rtcConfiguration, dataChannelOptions
   // setup callback to write ICE candidates to the remote
   // peer
   pc.onicecandidate = ({ candidate }) => {
-    stream.write({
+    void stream.write({
       type: Message.Type.ICE_CANDIDATE,
       data: (candidate != null) ? JSON.stringify(candidate.toJSON()) : ''
     })
+      .catch(err => {
+        log.error('error sending ICE candidate', err)
+      })
   }
   // create an offer
   const offerSdp = await pc.createOffer()
   // write the offer to the stream
-  stream.write({ type: Message.Type.SDP_OFFER, data: offerSdp.sdp })
+  await stream.write({ type: Message.Type.SDP_OFFER, data: offerSdp.sdp })
   // set offer as local description
   await pc.setLocalDescription(offerSdp).catch(err => {
     log.error('could not execute setLocalDescription', err)

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

@@ -49,6 +49,8 @@ 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) })
+    }, {
+      runOnTransientConnection: true
     })
     this._started = true
   }
@@ -90,7 +92,10 @@ export class WebRTCTransport implements Transport, Startable {
     }
 
     const connection = await this.components.transportManager.dial(baseAddr, options)
-    const signalingStream = await connection.newStream([SIGNALING_PROTO_ID], options)
+    const signalingStream = await connection.newStream(SIGNALING_PROTO_ID, {
+      ...options,
+      runOnTransientConnection: true
+    })
 
     try {
       const { pc, muxerFactory, remoteAddress } = await initiateConnection({
@@ -114,11 +119,11 @@ export class WebRTCTransport implements Transport, Startable {
       )
 
       // close the stream if SDP has been exchanged successfully
-      signalingStream.close()
+      await signalingStream.close()
       return result
-    } catch (err) {
+    } catch (err: any) {
       // reset the stream in case of any error
-      signalingStream.reset()
+      signalingStream.abort(err)
       throw err
     } finally {
       // Close the signaling connection
@@ -144,8 +149,8 @@ export class WebRTCTransport implements Transport, Startable {
         skipProtection: true,
         muxerFactory
       })
-    } catch (err) {
-      stream.reset()
+    } catch (err: any) {
+      stream.abort(err)
       throw err
     } finally {
       // Close the signaling connection

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

@@ -1,3 +1,2 @@
-
 const charset = Array.from('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/')
 export const genUfrag = (len: number): string => [...Array(len)].map(() => charset.at(Math.floor(Math.random() * charset.length))).join('')

package/src/stream.ts

@@ -6,7 +6,7 @@ import { type Pushable, pushable } from 'it-pushable'
 import { pEvent, TimeoutError } from 'p-event'
 import { Uint8ArrayList } from 'uint8arraylist'
 import { Message } from './pb/message.js'
-import type { Direction, Stream } from '@libp2p/interface/connection'
+import type { Direction } from '@libp2p/interface/connection'
 
 const log = logger('libp2p:webrtc:stream')
 
@@ -26,6 +26,8 @@ export interface WebRTCStreamInit extends AbstractStreamInit {
   channel: RTCDataChannel
 
   dataChannelOptions?: Partial<DataChannelOpts>
+
+  maxDataSize: number
 }
 
 // Max message size that can be sent to the DataChannel
@@ -40,7 +42,7 @@ const BUFFERED_AMOUNT_LOW_TIMEOUT = 30 * 1000
 // protobuf field definition overhead
 const PROTOBUF_OVERHEAD = 3
 
-class WebRTCStream extends AbstractStream {
+export class WebRTCStream extends AbstractStream {
   /**
    * The data channel used to send and receive data
    */
@@ -58,6 +60,7 @@ class WebRTCStream extends AbstractStream {
   private readonly incomingData: Pushable<Uint8Array>
 
   private messageQueue?: Uint8ArrayList
+  private readonly maxDataSize: number
 
   constructor (init: WebRTCStreamInit) {
     super(init)
@@ -71,6 +74,7 @@ class WebRTCStream extends AbstractStream {
       maxBufferedAmount: init.dataChannelOptions?.maxBufferedAmount ?? MAX_BUFFERED_AMOUNT,
       maxMessageSize: init.dataChannelOptions?.maxMessageSize ?? MAX_MESSAGE_SIZE
     }
+    this.maxDataSize = init.maxDataSize
 
     // set up initial state
     switch (this.channel.readyState) {
@@ -79,8 +83,8 @@ class WebRTCStream extends AbstractStream {
 
       case 'closed':
       case 'closing':
-        if (this.stat.timeline.close === undefined || this.stat.timeline.close === 0) {
-          this.stat.timeline.close = Date.now()
+        if (this.timeline.close === undefined || this.timeline.close === 0) {
+          this.timeline.close = Date.now()
         }
         break
       case 'connecting':
@@ -94,7 +98,7 @@ class WebRTCStream extends AbstractStream {
 
     // handle RTCDataChannel events
     this.channel.onopen = (_evt) => {
-      this.stat.timeline.open = new Date().getTime()
+      this.timeline.open = new Date().getTime()
 
       if (this.messageQueue != null) {
         // send any queued messages
@@ -107,7 +111,9 @@ class WebRTCStream extends AbstractStream {
     }
 
     this.channel.onclose = (_evt) => {
-      this.close()
+      void this.close().catch(err => {
+        log.error('error closing stream after channel closed', err)
+      })
     }
 
     this.channel.onerror = (evt) => {
@@ -153,7 +159,6 @@ class WebRTCStream extends AbstractStream {
         await pEvent(this.channel, 'bufferedamountlow', { timeout: this.dataChannelOptions.bufferedAmountLowEventTimeout })
       } catch (err: any) {
         if (err instanceof TimeoutError) {
-          this.abort(err)
           throw new Error('Timed out waiting for DataChannel buffer to clear')
         }
 
@@ -184,10 +189,17 @@ class WebRTCStream extends AbstractStream {
   }
 
   async sendData (data: Uint8ArrayList): Promise<void> {
-    const msgbuf = Message.encode({ message: data.subarray() })
-    const sendbuf = lengthPrefixed.encode.single(msgbuf)
+    data = data.sublist()
 
-    await this._sendMessage(sendbuf)
+    while (data.byteLength > 0) {
+      const toSend = Math.min(data.byteLength, this.maxDataSize)
+      const buf = data.subarray(0, toSend)
+      const msgbuf = Message.encode({ message: buf })
+      const sendbuf = lengthPrefixed.encode.single(msgbuf)
+      await this._sendMessage(sendbuf)
+
+      data.consume(toSend)
+    }
   }
 
   async sendReset (): Promise<void> {
@@ -212,7 +224,7 @@ class WebRTCStream extends AbstractStream {
       if (message.flag === Message.Flag.FIN) {
         // We should expect no more data from the remote, stop reading
         this.incomingData.end()
-        this.closeRead()
+        this.remoteCloseWrite()
       }
 
       if (message.flag === Message.Flag.RESET) {
@@ -222,7 +234,7 @@ class WebRTCStream extends AbstractStream {
 
       if (message.flag === Message.Flag.STOP_SENDING) {
         // The remote has stopped reading
-        this.closeWrite()
+        this.remoteCloseRead()
       }
     }
 
@@ -259,7 +271,7 @@ export interface WebRTCStreamOptions {
   onEnd?: (err?: Error | undefined) => void
 }
 
-export function createStream (options: WebRTCStreamOptions): Stream {
+export function createStream (options: WebRTCStreamOptions): WebRTCStream {
   const { channel, direction, onEnd, dataChannelOptions } = options
 
   return new WebRTCStream({
@@ -268,6 +280,7 @@ export function createStream (options: WebRTCStreamOptions): Stream {
     maxDataSize: (dataChannelOptions?.maxMessageSize ?? MAX_MESSAGE_SIZE) - PROTOBUF_OVERHEAD,
     dataChannelOptions,
     onEnd,
-    channel
+    channel,
+    log: logger(`libp2p:mplex:stream:${direction}:${channel.id}`)
   })
 }