@libp2p/webrtc 3.2.1 → 3.2.2-77e3cbc3

package/src/stream.ts

@@ -3,18 +3,18 @@ import { AbstractStream, type AbstractStreamInit } from '@libp2p/interface/strea
 import { logger } from '@libp2p/logger'
 import * as lengthPrefixed from 'it-length-prefixed'
 import { type Pushable, pushable } from 'it-pushable'
+import pDefer from 'p-defer'
 import { pEvent, TimeoutError } from 'p-event'
+import pTimeout from 'p-timeout'
+import { raceSignal } from 'race-signal'
 import { Uint8ArrayList } from 'uint8arraylist'
 import { Message } from './pb/message.js'
+import type { DataChannelOptions } from './index.js'
+import type { AbortOptions } from '@libp2p/interface'
 import type { Direction } from '@libp2p/interface/connection'
+import type { DeferredPromise } from 'p-defer'
 
-export interface DataChannelOpts {
-  maxMessageSize: number
-  maxBufferedAmount: number
-  bufferedAmountLowEventTimeout: number
-}
-
-export interface WebRTCStreamInit extends AbstractStreamInit {
+export interface WebRTCStreamInit extends AbstractStreamInit, DataChannelOptions {
   /**
    * The network channel used for bidirectional peer-to-peer transfers of
    * arbitrary data
@@ -22,38 +22,46 @@ export interface WebRTCStreamInit extends AbstractStreamInit {
    * {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel}
    */
   channel: RTCDataChannel
-
-  dataChannelOptions?: Partial<DataChannelOpts>
-
-  maxDataSize: number
 }
 
-// Max message size that can be sent to the DataChannel
-export const MAX_MESSAGE_SIZE = 16 * 1024
-
-// How much can be buffered to the DataChannel at once
+/**
+ * How much can be buffered to the DataChannel at once
+ */
 export const MAX_BUFFERED_AMOUNT = 16 * 1024 * 1024
 
-// How long time we wait for the 'bufferedamountlow' event to be emitted
+/**
+ * How long time we wait for the 'bufferedamountlow' event to be emitted
+ */
 export const BUFFERED_AMOUNT_LOW_TIMEOUT = 30 * 1000
 
-// protobuf field definition overhead
+/**
+ * protobuf field definition overhead
+ */
 export const PROTOBUF_OVERHEAD = 5
 
-// Length of varint, in bytes.
+/**
+ * Length of varint, in bytes
+ */
 export const VARINT_LENGTH = 2
 
+/**
+ * Max message size that can be sent to the DataChannel
+ */
+export const MAX_MESSAGE_SIZE = 16 * 1024
+
+/**
+ * When closing streams we send a FIN then wait for the remote to
+ * reply with a FIN_ACK. If that does not happen within this timeout
+ * we close the stream anyway.
+ */
+export const FIN_ACK_TIMEOUT = 5000
+
 export class WebRTCStream extends AbstractStream {
   /**
    * The data channel used to send and receive data
    */
   private readonly channel: RTCDataChannel
 
-  /**
-   * Data channel options
-   */
-  private readonly dataChannelOptions: DataChannelOpts
-
   /**
    * push data from the underlying datachannel to the length prefix decoder
    * and then the protobuf decoder.
@@ -62,24 +70,65 @@ export class WebRTCStream extends AbstractStream {
 
   private messageQueue?: Uint8ArrayList
 
+  private readonly maxBufferedAmount: number
+
+  private readonly bufferedAmountLowEventTimeout: number
+
   /**
    * The maximum size of a message in bytes
    */
-  private readonly maxDataSize: number
+  private readonly maxMessageSize: number
+
+  /**
+   * When this promise is resolved, the remote has sent us a FIN flag
+   */
+  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
+    const originalOnEnd = init.onEnd
+    init.onEnd = (err?: Error): void => {
+      this.log.trace('readable and writeable ends closed', this.status)
+
+      void Promise.resolve(async () => {
+        if (this.timeline.abort != null || this.timeline.reset !== null) {
+          return
+        }
+
+        // wait for FIN_ACK if we haven't received it already
+        try {
+          await pTimeout(this.receiveFinAck.promise, {
+            milliseconds: this.finAckTimeout
+          })
+        } catch (err) {
+          this.log.error('error receiving FIN_ACK', err)
+        }
+      })
+        .then(() => {
+        // stop processing incoming messages
+          this.incomingData.end()
+
+          // final cleanup
+          originalOnEnd?.(err)
+        })
+        .catch(err => {
+          this.log.error('error ending stream', err)
+        })
+    }
+
     super(init)
 
     this.channel = init.channel
     this.channel.binaryType = 'arraybuffer'
     this.incomingData = pushable()
     this.messageQueue = new Uint8ArrayList()
-    this.dataChannelOptions = {
-      bufferedAmountLowEventTimeout: init.dataChannelOptions?.bufferedAmountLowEventTimeout ?? BUFFERED_AMOUNT_LOW_TIMEOUT,
-      maxBufferedAmount: init.dataChannelOptions?.maxBufferedAmount ?? MAX_BUFFERED_AMOUNT,
-      maxMessageSize: init.dataChannelOptions?.maxMessageSize ?? init.maxDataSize
-    }
-    this.maxDataSize = init.maxDataSize
+    this.bufferedAmountLowEventTimeout = init.bufferedAmountLowEventTimeout ?? BUFFERED_AMOUNT_LOW_TIMEOUT
+    this.maxBufferedAmount = init.maxBufferedAmount ?? MAX_BUFFERED_AMOUNT
+    this.maxMessageSize = (init.maxMessageSize ?? MAX_MESSAGE_SIZE) - PROTOBUF_OVERHEAD - VARINT_LENGTH
+    this.receiveFinAck = pDefer()
+    this.finAckTimeout = init.closeTimeout ?? FIN_ACK_TIMEOUT
 
     // set up initial state
     switch (this.channel.readyState) {
@@ -105,17 +154,25 @@ export class WebRTCStream extends AbstractStream {
     this.channel.onopen = (_evt) => {
       this.timeline.open = new Date().getTime()
 
-      if (this.messageQueue != null) {
+      if (this.messageQueue != null && this.messageQueue.byteLength > 0) {
+        this.log.trace('dataChannel opened, sending queued messages', this.messageQueue.byteLength, this.channel.readyState)
+
         // send any queued messages
         this._sendMessage(this.messageQueue)
           .catch(err => {
+            this.log.error('error sending queued messages', err)
             this.abort(err)
           })
-        this.messageQueue = undefined
       }
+
+      this.messageQueue = undefined
     }
 
     this.channel.onclose = (_evt) => {
+      // if the channel has closed we'll never receive a FIN_ACK so resolve the
+      // promise so we don't try to wait later
+      this.receiveFinAck.resolve()
+
       void this.close().catch(err => {
         this.log.error('error closing stream after channel closed', err)
       })
@@ -126,8 +183,6 @@ export class WebRTCStream extends AbstractStream {
       this.abort(err)
     }
 
-    const self = this
-
     this.channel.onmessage = async (event: MessageEvent<ArrayBuffer>) => {
       const { data } = event
 
@@ -138,11 +193,13 @@ export class WebRTCStream extends AbstractStream {
       this.incomingData.push(new Uint8Array(data, 0, data.byteLength))
     }
 
+    const self = this
+
     // pipe framed protobuf messages through a length prefixed decoder, and
     // surface data from the `Message.message` field through a source.
     Promise.resolve().then(async () => {
       for await (const buf of lengthPrefixed.decode(this.incomingData)) {
-        const message = self.processIncomingProtobuf(buf.subarray())
+        const message = self.processIncomingProtobuf(buf)
 
         if (message != null) {
           self.sourcePush(new Uint8ArrayList(message))
@@ -159,12 +216,12 @@ export class WebRTCStream extends AbstractStream {
   }
 
   async _sendMessage (data: Uint8ArrayList, checkBuffer: boolean = true): Promise<void> {
-    if (checkBuffer && this.channel.bufferedAmount > this.dataChannelOptions.maxBufferedAmount) {
+    if (checkBuffer && this.channel.bufferedAmount > this.maxBufferedAmount) {
       try {
-        await pEvent(this.channel, 'bufferedamountlow', { timeout: this.dataChannelOptions.bufferedAmountLowEventTimeout })
+        await pEvent(this.channel, 'bufferedamountlow', { timeout: this.bufferedAmountLowEventTimeout })
       } catch (err: any) {
         if (err instanceof TimeoutError) {
-          throw new Error('Timed out waiting for DataChannel buffer to clear')
+          throw new CodeError(`Timed out waiting for DataChannel buffer to clear after ${this.bufferedAmountLowEventTimeout}ms`, 'ERR_BUFFER_CLEAR_TIMEOUT')
         }
 
         throw err
@@ -172,7 +229,7 @@ export class WebRTCStream extends AbstractStream {
     }
 
     if (this.channel.readyState === 'closed' || this.channel.readyState === 'closing') {
-      throw new CodeError('Invalid datachannel state - closed or closing', 'ERR_INVALID_STATE')
+      throw new CodeError(`Invalid datachannel state - ${this.channel.readyState}`, 'ERR_INVALID_STATE')
     }
 
     if (this.channel.readyState === 'open') {
@@ -194,10 +251,12 @@ export class WebRTCStream extends AbstractStream {
   }
 
   async sendData (data: Uint8ArrayList): Promise<void> {
+    // sending messages is an async operation so use a copy of the list as it
+    // may be changed beneath us
     data = data.sublist()
 
     while (data.byteLength > 0) {
-      const toSend = Math.min(data.byteLength, this.maxDataSize)
+      const toSend = Math.min(data.byteLength, this.maxMessageSize)
       const buf = data.subarray(0, toSend)
       const msgbuf = Message.encode({ message: buf })
       const sendbuf = lengthPrefixed.encode.single(msgbuf)
@@ -211,8 +270,25 @@ export class WebRTCStream extends AbstractStream {
     await this._sendFlag(Message.Flag.RESET)
   }
 
-  async sendCloseWrite (): Promise<void> {
-    await this._sendFlag(Message.Flag.FIN)
+  async sendCloseWrite (options: AbortOptions): Promise<void> {
+    const sent = await this._sendFlag(Message.Flag.FIN)
+
+    if (sent) {
+      this.log.trace('awaiting FIN_ACK')
+      try {
+        await raceSignal(this.receiveFinAck.promise, options?.signal, {
+          errorMessage: 'sending close-write was aborted before FIN_ACK was received',
+          errorCode: 'ERR_FIN_ACK_NOT_RECEIVED'
+        })
+      } catch (err) {
+        this.log.error('failed to await FIN_ACK', err)
+      }
+    } else {
+      this.log.trace('sending FIN failed, not awaiting FIN_ACK')
+    }
+
+    // if we've attempted to receive a FIN_ACK, do not try again
+    this.receiveFinAck.resolve()
   }
 
   async sendCloseRead (): Promise<void> {
@@ -222,14 +298,21 @@ export class WebRTCStream extends AbstractStream {
   /**
    * Handle incoming
    */
-  private processIncomingProtobuf (buffer: Uint8Array): Uint8Array | undefined {
+  private processIncomingProtobuf (buffer: Uint8ArrayList): Uint8Array | undefined {
     const message = Message.decode(buffer)
 
     if (message.flag !== undefined) {
+      this.log.trace('incoming flag %s, write status "%s", read status "%s"', message.flag, this.writeStatus, this.readStatus)
+
       if (message.flag === Message.Flag.FIN) {
         // We should expect no more data from the remote, stop reading
-        this.incomingData.end()
         this.remoteCloseWrite()
+
+        this.log.trace('sending FIN_ACK')
+        void this._sendFlag(Message.Flag.FIN_ACK)
+          .catch(err => {
+            this.log.error('error sending FIN_ACK immediately', err)
+          })
       }
 
       if (message.flag === Message.Flag.RESET) {
@@ -241,21 +324,45 @@ export class WebRTCStream extends AbstractStream {
         // The remote has stopped reading
         this.remoteCloseRead()
       }
+
+      if (message.flag === Message.Flag.FIN_ACK) {
+        this.log.trace('received FIN_ACK')
+        this.receiveFinAck.resolve()
+      }
     }
 
-    return message.message
+    // ignore data messages if we've closed the readable end already
+    if (this.readStatus === 'ready') {
+      return message.message
+    }
   }
 
-  private async _sendFlag (flag: Message.Flag): Promise<void> {
-    this.log.trace('Sending flag: %s', flag.toString())
+  private async _sendFlag (flag: Message.Flag): Promise<boolean> {
+    if (this.channel.readyState !== 'open') {
+      // flags can be sent while we or the remote are closing the datachannel so
+      // if the channel isn't open, don't try to send it but return false to let
+      // the caller know and act if they need to
+      this.log.trace('not sending flag %s because channel is not open', flag.toString())
+      return false
+    }
+
+    this.log.trace('sending flag %s', flag.toString())
     const msgbuf = Message.encode({ flag })
     const prefixedBuf = lengthPrefixed.encode.single(msgbuf)
 
-    await this._sendMessage(prefixedBuf, false)
+    try {
+      await this._sendMessage(prefixedBuf, false)
+
+      return true
+    } catch (err: any) {
+      this.log.error('could not send flag %s', flag.toString(), err)
+    }
+
+    return false
   }
 }
 
-export interface WebRTCStreamOptions {
+export interface WebRTCStreamOptions extends DataChannelOptions {
   /**
    * The network channel used for bidirectional peer-to-peer transfers of
    * arbitrary data
@@ -269,23 +376,18 @@ export interface WebRTCStreamOptions {
    */
   direction: Direction
 
-  dataChannelOptions?: Partial<DataChannelOpts>
-
-  maxMsgSize?: number
-
-  onEnd?: (err?: Error | undefined) => void
+  /**
+   * A callback invoked when the channel ends
+   */
+  onEnd?(err?: Error | undefined): void
 }
 
 export function createStream (options: WebRTCStreamOptions): WebRTCStream {
-  const { channel, direction, onEnd, dataChannelOptions } = options
+  const { channel, direction } = options
 
   return new WebRTCStream({
     id: direction === 'inbound' ? (`i${channel.id}`) : `r${channel.id}`,
-    direction,
-    maxDataSize: (dataChannelOptions?.maxMessageSize ?? MAX_MESSAGE_SIZE) - PROTOBUF_OVERHEAD - VARINT_LENGTH,
-    dataChannelOptions,
-    onEnd,
-    channel,
-    log: logger(`libp2p:webrtc:stream:${direction}:${channel.id}`)
+    log: logger(`libp2p:webrtc:stream:${direction}:${channel.id}`),
+    ...options
   })
 }

package/src/util.ts

@@ -1,4 +1,9 @@
+import { logger } from '@libp2p/logger'
 import { detect } from 'detect-browser'
+import pDefer from 'p-defer'
+import pTimeout from 'p-timeout'
+
+const log = logger('libp2p:webrtc:utils')
 
 const browser = detect()
 export const isFirefox = ((browser != null) && browser.name === 'firefox')
@@ -6,3 +11,58 @@ export const isFirefox = ((browser != null) && browser.name === 'firefox')
 export const nopSource = async function * nop (): AsyncGenerator<Uint8Array, any, unknown> {}
 
 export const nopSink = async (_: any): Promise<void> => {}
+
+export const DATA_CHANNEL_DRAIN_TIMEOUT = 30 * 1000
+
+export function drainAndClose (channel: RTCDataChannel, direction: string, drainTimeout: number = DATA_CHANNEL_DRAIN_TIMEOUT): void {
+  if (channel.readyState !== 'open') {
+    return
+  }
+
+  void Promise.resolve()
+    .then(async () => {
+      // wait for bufferedAmount to become zero
+      if (channel.bufferedAmount > 0) {
+        log('%s drain channel with %d buffered bytes', direction, channel.bufferedAmount)
+        const deferred = pDefer()
+        let drained = false
+
+        channel.bufferedAmountLowThreshold = 0
+
+        const closeListener = (): void => {
+          if (!drained) {
+            log('%s drain channel closed before drain', direction)
+            deferred.resolve()
+          }
+        }
+
+        channel.addEventListener('close', closeListener, {
+          once: true
+        })
+
+        channel.addEventListener('bufferedamountlow', () => {
+          drained = true
+          channel.removeEventListener('close', closeListener)
+          deferred.resolve()
+        })
+
+        await pTimeout(deferred.promise, {
+          milliseconds: drainTimeout
+        })
+      }
+    })
+    .then(async () => {
+      // only close if the channel is still open
+      if (channel.readyState === 'open') {
+        channel.close()
+      }
+    })
+    .catch(err => {
+      log.error('error closing outbound stream', err)
+    })
+}
+
+export interface AbortPromiseOptions {
+  signal?: AbortSignal
+  message?: string
+}

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

@@ -1,26 +0,0 @@
-import { RTCPeerConnection } from '../webrtc/index.js';
-import type { DataChannelOpts } from '../stream.js';
-import type { Stream } from '@libp2p/interface/connection';
-import type { StreamMuxerFactory } from '@libp2p/interface/stream-muxer';
-import type { IncomingStreamData } from '@libp2p/interface-internal/registrar';
-export type IncomingStreamOpts = {
-    rtcConfiguration?: RTCConfiguration;
-    dataChannelOptions?: Partial<DataChannelOpts>;
-} & IncomingStreamData;
-export declare function handleIncomingStream({ rtcConfiguration, dataChannelOptions, stream: rawStream }: IncomingStreamOpts): Promise<{
-    pc: RTCPeerConnection;
-    muxerFactory: StreamMuxerFactory;
-    remoteAddress: string;
-}>;
-export interface ConnectOptions {
-    stream: Stream;
-    signal: AbortSignal;
-    rtcConfiguration?: RTCConfiguration;
-    dataChannelOptions?: Partial<DataChannelOpts>;
-}
-export declare function initiateConnection({ rtcConfiguration, dataChannelOptions, signal, stream: rawStream }: ConnectOptions): Promise<{
-    pc: RTCPeerConnection;
-    muxerFactory: StreamMuxerFactory;
-    remoteAddress: string;
-}>;
-//# sourceMappingURL=handler.d.ts.map

package/dist/src/private-to-private/handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../../../src/private-to-private/handler.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,iBAAiB,EAAyB,MAAM,oBAAoB,CAAA;AAG7E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AACnD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAA;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAA;AACxE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAA;AAM9E,MAAM,MAAM,kBAAkB,GAAG;IAAE,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,CAAA;CAAE,GAAG,kBAAkB,CAAA;AAE5I,wBAAsB,oBAAoB,CAAE,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,kBAAkB,GAAG,OAAO,CAAC;IAAE,EAAE,EAAE,iBAAiB,CAAC;IAAC,YAAY,EAAE,kBAAkB,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,CAAC,CAyExN;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,WAAW,CAAA;IACnB,gBAAgB,CAAC,EAAE,gBAAgB,CAAA;IACnC,kBAAkB,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,CAAA;CAC9C;AAED,wBAAsB,kBAAkB,CAAE,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,cAAc,GAAG,OAAO,CAAC;IAAE,EAAE,EAAE,iBAAiB,CAAC;IAAC,YAAY,EAAE,kBAAkB,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,CAAC,CA6D1N"}

package/dist/src/private-to-private/handler.js

@@ -1,137 +0,0 @@
-import { CodeError } from '@libp2p/interface/errors';
-import { logger } from '@libp2p/logger';
-import { abortableDuplex } from 'abortable-iterator';
-import { pbStream } from 'it-protobuf-stream';
-import pDefer, {} from 'p-defer';
-import { DataChannelMuxerFactory } from '../muxer.js';
-import { RTCPeerConnection, RTCSessionDescription } from '../webrtc/index.js';
-import { Message } from './pb/message.js';
-import { readCandidatesUntilConnected, resolveOnConnected } from './util.js';
-const DEFAULT_TIMEOUT = 30 * 1000;
-const log = logger('libp2p:webrtc:peer');
-export async function handleIncomingStream({ rtcConfiguration, dataChannelOptions, stream: rawStream }) {
-    const signal = AbortSignal.timeout(DEFAULT_TIMEOUT);
-    const stream = pbStream(abortableDuplex(rawStream, signal)).pb(Message);
-    const pc = new RTCPeerConnection(rtcConfiguration);
-    try {
-        const muxerFactory = new DataChannelMuxerFactory({ peerConnection: pc, dataChannelOptions });
-        const connectedPromise = pDefer();
-        const answerSentPromise = pDefer();
-        signal.onabort = () => {
-            connectedPromise.reject(new CodeError('Timed out while trying to connect', 'ERR_TIMEOUT'));
-        };
-        // candidate callbacks
-        pc.onicecandidate = ({ candidate }) => {
-            answerSentPromise.promise.then(async () => {
-                await stream.write({
-                    type: Message.Type.ICE_CANDIDATE,
-                    data: (candidate != null) ? JSON.stringify(candidate.toJSON()) : ''
-                });
-            }, (err) => {
-                log.error('cannot set candidate since sending answer failed', err);
-                connectedPromise.reject(err);
-            });
-        };
-        resolveOnConnected(pc, connectedPromise);
-        // read an SDP offer
-        const pbOffer = await stream.read();
-        if (pbOffer.type !== Message.Type.SDP_OFFER) {
-            throw new Error(`expected message type SDP_OFFER, received: ${pbOffer.type ?? 'undefined'} `);
-        }
-        const offer = new RTCSessionDescription({
-            type: 'offer',
-            sdp: pbOffer.data
-        });
-        await pc.setRemoteDescription(offer).catch(err => {
-            log.error('could not execute setRemoteDescription', err);
-            throw new Error('Failed to set remoteDescription');
-        });
-        // create and write an SDP answer
-        const answer = await pc.createAnswer().catch(err => {
-            log.error('could not execute createAnswer', err);
-            answerSentPromise.reject(err);
-            throw new Error('Failed to create answer');
-        });
-        // write the answer to the remote
-        await stream.write({ type: Message.Type.SDP_ANSWER, data: answer.sdp });
-        await pc.setLocalDescription(answer).catch(err => {
-            log.error('could not execute setLocalDescription', err);
-            answerSentPromise.reject(err);
-            throw new Error('Failed to set localDescription');
-        });
-        answerSentPromise.resolve();
-        // wait until candidates are connected
-        await readCandidatesUntilConnected(connectedPromise, pc, stream);
-        const remoteAddress = parseRemoteAddress(pc.currentRemoteDescription?.sdp ?? '');
-        return { pc, muxerFactory, remoteAddress };
-    }
-    catch (err) {
-        pc.close();
-        throw err;
-    }
-}
-export async function initiateConnection({ rtcConfiguration, dataChannelOptions, signal, stream: rawStream }) {
-    const stream = pbStream(abortableDuplex(rawStream, signal)).pb(Message);
-    // setup peer connection
-    const pc = new RTCPeerConnection(rtcConfiguration);
-    try {
-        const muxerFactory = new DataChannelMuxerFactory({ peerConnection: pc, dataChannelOptions });
-        const connectedPromise = pDefer();
-        resolveOnConnected(pc, connectedPromise);
-        // reject the connectedPromise if the signal aborts
-        signal.onabort = connectedPromise.reject;
-        // we create the channel so that the peerconnection has a component for which
-        // to collect candidates. The label is not relevant to connection initiation
-        // but can be useful for debugging
-        const channel = pc.createDataChannel('init');
-        // setup callback to write ICE candidates to the remote
-        // peer
-        pc.onicecandidate = ({ candidate }) => {
-            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
-        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);
-            throw new Error('Failed to set localDescription');
-        });
-        // read answer
-        const answerMessage = await stream.read();
-        if (answerMessage.type !== Message.Type.SDP_ANSWER) {
-            throw new Error('remote should send an SDP answer');
-        }
-        const answerSdp = new RTCSessionDescription({ type: 'answer', sdp: answerMessage.data });
-        await pc.setRemoteDescription(answerSdp).catch(err => {
-            log.error('could not execute setRemoteDescription', err);
-            throw new Error('Failed to set remoteDescription');
-        });
-        await readCandidatesUntilConnected(connectedPromise, pc, stream);
-        channel.close();
-        const remoteAddress = parseRemoteAddress(pc.currentRemoteDescription?.sdp ?? '');
-        return { pc, muxerFactory, remoteAddress };
-    }
-    catch (err) {
-        pc.close();
-        throw err;
-    }
-}
-function parseRemoteAddress(sdp) {
-    // '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`;
-}
-//# sourceMappingURL=handler.js.map

package/dist/src/private-to-private/handler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"handler.js","sourceRoot":"","sources":["../../../src/private-to-private/handler.ts"],"names":[],"mappings":"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"}

package/dist/typedoc-urls.json

@@ -1,6 +0,0 @@
-{
-  "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"
-}