@libp2p/webrtc 4.0.8 → 4.0.9-341581166

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

@@ -1,10 +1,9 @@
 import { CodeError } from '@libp2p/interface'
 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 { readCandidatesUntilConnected } from './util.js'
 import type { Logger } from '@libp2p/interface'
 import type { IncomingStreamData } from '@libp2p/interface-internal'
 
@@ -20,41 +19,27 @@ export async function handleIncomingStream ({ peerConnection, stream, signal, co
   const messageStream = pbStream(stream).pb(Message)
 
   try {
-    const connectedPromise: DeferredPromise<void> = pDefer()
-    const answerSentPromise: DeferredPromise<void> = pDefer()
-
-    signal.onabort = () => {
-      connectedPromise.reject(new CodeError('Timed out while trying to connect', 'ERR_TIMEOUT'))
-    }
-
     // candidate callbacks
     peerConnection.onicecandidate = ({ candidate }) => {
-      answerSentPromise.promise.then(
-        async () => {
-          // a null candidate means end-of-candidates, an empty string candidate
-          // means end-of-candidates for this generation, otherwise this should
-          // be a valid candidate object
-          // see - https://www.w3.org/TR/webrtc/#rtcpeerconnectioniceevent
-          const data = JSON.stringify(candidate?.toJSON() ?? null)
-
-          log.trace('recipient sending ICE candidate %s', data)
-
-          await messageStream.write({
-            type: Message.Type.ICE_CANDIDATE,
-            data
-          }, {
-            signal
-          })
-        },
-        (err) => {
-          log.error('cannot set candidate since sending answer failed', err)
-          connectedPromise.reject(err)
-        }
-      )
+      // a null candidate means end-of-candidates, an empty string candidate
+      // means end-of-candidates for this generation, otherwise this should
+      // be a valid candidate object
+      // see - https://www.w3.org/TR/webrtc/#rtcpeerconnectioniceevent
+      const data = JSON.stringify(candidate?.toJSON() ?? null)
+
+      log.trace('recipient sending ICE candidate %s', data)
+
+      messageStream.write({
+        type: Message.Type.ICE_CANDIDATE,
+        data
+      }, {
+        signal
+      })
+        .catch(err => {
+          log.error('error sending ICE candidate', err)
+        })
     }
 
-    resolveOnConnected(peerConnection, connectedPromise)
-
     // read an SDP offer
     const pbOffer = await messageStream.read({
       signal
@@ -79,7 +64,6 @@ export async function handleIncomingStream ({ peerConnection, stream, signal, co
     // create and write an SDP answer
     const answer = await peerConnection.createAnswer().catch(err => {
       log.error('could not execute createAnswer', err)
-      answerSentPromise.reject(err)
       throw new CodeError('Failed to create answer', 'ERR_SDP_HANDSHAKE_FAILED')
     })
 
@@ -92,25 +76,17 @@ export async function handleIncomingStream ({ peerConnection, stream, signal, co
 
     await peerConnection.setLocalDescription(answer).catch(err => {
       log.error('could not execute setLocalDescription', err)
-      answerSentPromise.reject(err)
       throw new CodeError('Failed to set localDescription', 'ERR_SDP_HANDSHAKE_FAILED')
     })
 
-    answerSentPromise.resolve()
-
     log.trace('recipient read candidates until connected')
 
     // wait until candidates are connected
-    await readCandidatesUntilConnected(connectedPromise, peerConnection, messageStream, {
+    await readCandidatesUntilConnected(peerConnection, messageStream, {
       direction: 'recipient',
       signal,
       log
     })
-
-    log.trace('recipient connected, closing signaling stream')
-    await messageStream.unwrap().unwrap().close({
-      signal
-    })
   } catch (err: any) {
     if (peerConnection.connectionState !== 'connected') {
       log.error('error while handling signaling stream from peer %a', connection.remoteAddr, err)

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

@@ -1,4 +1,4 @@
-import { CodeError } from '@libp2p/interface'
+import { CodeError, 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 { peerIdFromString } from '@libp2p/peer-id'
 import { multiaddr, type Multiaddr } from '@multiformats/multiaddr'
@@ -56,6 +56,7 @@ export class WebRTCTransport implements Transport, Startable {
   ) {
     this.log = components.logger.forComponent('libp2p:webrtc')
     this.shutdownController = new AbortController()
+    setMaxListeners(Infinity, this.shutdownController.signal)
 
     if (components.metrics != null) {
       this.metrics = {

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

@@ -1,6 +1,5 @@
 import { CodeError } from '@libp2p/interface'
-import { closeSource } from '@libp2p/utils/close-source'
-import { anySignal } from 'any-signal'
+import pDefer from 'p-defer'
 import { isFirefox } from '../util.js'
 import { RTCIceCandidate } from '../webrtc/index.js'
 import { Message } from './pb/message.js'
@@ -12,32 +11,19 @@ export interface ReadCandidatesOptions extends AbortOptions, LoggerOptions {
   direction: string
 }
 
-export const readCandidatesUntilConnected = async (connectedPromise: DeferredPromise<void>, pc: RTCPeerConnection, stream: MessageStream<Message, Stream>, options: ReadCandidatesOptions): Promise<void> => {
-  // if we connect, stop trying to read from the stream
-  const controller = new AbortController()
-  connectedPromise.promise.then(() => {
-    controller.abort()
-  }, () => {
-    controller.abort()
-  })
-
-  const signal = anySignal([
-    controller.signal,
-    options.signal
-  ])
-
-  const abortListener = (): void => {
-    closeSource(stream.unwrap().unwrap().source, options.log)
-  }
-
-  signal.addEventListener('abort', abortListener)
-
+export const readCandidatesUntilConnected = async (pc: RTCPeerConnection, stream: MessageStream<Message, Stream>, options: ReadCandidatesOptions): Promise<void> => {
   try {
+    const connectedPromise: DeferredPromise<void> = pDefer()
+    resolveOnConnected(pc, connectedPromise)
+
     // read candidates until we are connected or we reach the end of the stream
     while (true) {
+      // if we connect, stop trying to read from the stream
       const message = await Promise.race([
         connectedPromise.promise,
-        stream.read()
+        stream.read({
+          signal: options.signal
+        })
       ])
 
       // stream ended or we became connected
@@ -72,15 +58,20 @@ export const readCandidatesUntilConnected = async (connectedPromise: DeferredPro
     }
   } catch (err) {
     options.log.error('%s error parsing ICE candidate', options.direction, err)
-  } finally {
-    signal.removeEventListener('abort', abortListener)
-    signal.clear()
+
+    if (options.signal?.aborted === true) {
+      throw err
+    }
   }
 }
 
-export function resolveOnConnected (pc: RTCPeerConnection, promise: DeferredPromise<void>): void {
+function getConnectionState (pc: RTCPeerConnection): string {
+  return isFirefox ? pc.iceConnectionState : pc.connectionState
+}
+
+function resolveOnConnected (pc: RTCPeerConnection, promise: DeferredPromise<void>): void {
   pc[isFirefox ? 'oniceconnectionstatechange' : 'onconnectionstatechange'] = (_) => {
-    switch (isFirefox ? pc.iceConnectionState : pc.connectionState) {
+    switch (getConnectionState(pc)) {
       case 'connected':
         promise.resolve()
         break

package/src/webrtc/index.react-native.ts

@@ -0,0 +1,5 @@
+export {
+  RTCIceCandidate,
+  RTCPeerConnection,
+  RTCSessionDescription
+} from 'react-native-webrtc'

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