@libp2p/webrtc 6.0.16 → 6.0.18-20bfcb3f9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/webrtc",
-  "version": "6.0.16",
+  "version": "6.0.18-20bfcb3f9",
   "description": "A libp2p transport using WebRTC connections",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p/tree/main/packages/transport-webrtc#readme",
@@ -26,7 +26,8 @@
   "exports": {
     ".": {
       "types": "./dist/src/index.d.ts",
-      "import": "./dist/src/index.js"
+      "import": "./dist/src/index.js",
+      "module-sync": "./dist/src/index.js"
     }
   },
   "scripts": {
@@ -45,18 +46,17 @@
   },
   "dependencies": {
     "@chainsafe/is-ip": "^2.1.0",
-    "@libp2p/crypto": "^5.1.15",
-    "@libp2p/interface": "^3.2.0",
-    "@libp2p/interface-internal": "^3.1.0",
-    "@libp2p/keychain": "^6.0.12",
     "@chainsafe/libp2p-noise": "^17.0.0",
-    "@libp2p/peer-id": "^6.0.6",
-    "@libp2p/utils": "^7.0.15",
+    "@libp2p/crypto": "5.1.17-20bfcb3f9",
+    "@libp2p/interface": "3.2.2-20bfcb3f9",
+    "@libp2p/interface-internal": "3.1.2-20bfcb3f9",
+    "@libp2p/keychain": "6.0.14-20bfcb3f9",
+    "@libp2p/peer-id": "6.0.8-20bfcb3f9",
+    "@libp2p/utils": "7.0.17-20bfcb3f9",
     "@multiformats/multiaddr": "^13.0.1",
     "@multiformats/multiaddr-matcher": "^3.0.1",
     "@peculiar/webcrypto": "^1.5.0",
-    "@peculiar/x509": "^1.13.0",
-    "detect-browser": "^5.3.0",
+    "@peculiar/x509": "^2.0.0",
     "get-port": "^7.1.0",
     "interface-datastore": "^9.0.1",
     "it-length-prefixed": "^10.0.1",
@@ -74,18 +74,19 @@
     "protons-runtime": "^6.0.1",
     "race-signal": "^2.0.0",
     "react-native-webrtc": "^124.0.6",
+    "reflect-metadata": "^0.2.2",
     "uint8-varint": "^2.0.4",
     "uint8arraylist": "^2.4.8",
     "uint8arrays": "^5.1.0"
   },
   "devDependencies": {
-    "@libp2p/logger": "^6.2.4",
-    "@types/sinon": "^20.0.0",
+    "@libp2p/logger": "6.2.6-20bfcb3f9",
+    "@types/sinon": "^21.0.1",
     "aegir": "^47.0.22",
     "any-signal": "^4.1.1",
     "datastore-core": "^11.0.1",
     "delay": "^7.0.0",
-    "p-retry": "^7.0.0",
+    "p-retry": "^8.0.0",
     "protons": "^8.1.1",
     "sinon": "^21.0.0",
     "sinon-ts": "^2.0.0",

package/src/constants.ts

@@ -1,5 +1,5 @@
 import { encodingLength } from 'uint8-varint'
-import { Message } from './private-to-public/pb/message.js'
+import { Message } from './private-to-public/pb/message.ts'
 
 /**
  * STUN servers help clients discover their own public IPs.

package/src/index.ts

@@ -252,10 +252,10 @@
  * ```
  */
 
-import { WebRTCTransport } from './private-to-private/transport.js'
-import { WebRTCDirectTransport } from './private-to-public/transport.js'
-import type { WebRTCTransportComponents, WebRTCTransportInit } from './private-to-private/transport.js'
-import type { WebRTCTransportDirectInit, WebRTCDirectTransportComponents } from './private-to-public/transport.js'
+import { WebRTCTransport } from './private-to-private/transport.ts'
+import { WebRTCDirectTransport } from './private-to-public/transport.ts'
+import type { WebRTCTransportComponents, WebRTCTransportInit } from './private-to-private/transport.ts'
+import type { WebRTCTransportDirectInit, WebRTCDirectTransportComponents } from './private-to-public/transport.ts'
 import type { Transport } from '@libp2p/interface'
 
 export interface DataChannelOptions {

package/src/muxer.ts

@@ -1,7 +1,7 @@
 import { AbstractStreamMuxer } from '@libp2p/utils'
-import { MUXER_PROTOCOL } from './constants.js'
-import { createStream, WebRTCStream } from './stream.js'
-import type { DataChannelOptions } from './index.js'
+import { MUXER_PROTOCOL } from './constants.ts'
+import { createStream, WebRTCStream } from './stream.ts'
+import type { DataChannelOptions } from './index.ts'
 import type { ComponentLogger, CounterGroup, StreamMuxer, StreamMuxerFactory, CreateStreamOptions, MultiaddrConnection } from '@libp2p/interface'
 
 export interface DataChannelMuxerFactoryInit {

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

@@ -5,10 +5,10 @@ import { SIGNALING_PROTOCOL } from '../constants.js'
 import { SDPHandshakeFailedError } from '../error.js'
 import { DataChannelMuxerFactory } from '../muxer.js'
 import { RTCPeerConnection, RTCSessionDescription } from '../webrtc/index.js'
-import { Message } from './pb/message.js'
-import { splitAddr } from './transport.js'
-import { readCandidatesUntilConnected } from './util.js'
-import type { WebRTCDialEvents, WebRTCTransportMetrics } from './transport.js'
+import { Message } from './pb/message.ts'
+import { splitAddr } from './transport.ts'
+import { readCandidatesUntilConnected } from './util.ts'
+import type { WebRTCDialEvents, WebRTCTransportMetrics } from './transport.ts'
 import type { DataChannelOptions } from '../index.js'
 import type { LoggerOptions, Connection, ComponentLogger, AbortOptions } from '@libp2p/interface'
 import type { ConnectionManager, TransportManager } from '@libp2p/interface-internal'

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

@@ -2,8 +2,8 @@ import { pbStream } from '@libp2p/utils'
 import { multiaddr } from '@multiformats/multiaddr'
 import { SDPHandshakeFailedError } from '../error.js'
 import { RTCSessionDescription } from '../webrtc/index.js'
-import { Message } from './pb/message.js'
-import { getRemotePeer, readCandidatesUntilConnected } from './util.js'
+import { Message } from './pb/message.ts'
+import { getRemotePeer, readCandidatesUntilConnected } from './util.ts'
 import type { RTCPeerConnection } from '../webrtc/index.js'
 import type { AbortOptions, Connection, Logger, PeerId, Stream } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'

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

@@ -8,9 +8,9 @@ import { DataChannelMuxerFactory } from '../muxer.js'
 import { toMultiaddrConnection } from '../rtcpeerconnection-to-conn.ts'
 import { getRtcConfiguration } from '../util.js'
 import { RTCPeerConnection } from '../webrtc/index.js'
-import { initiateConnection } from './initiate-connection.js'
-import { WebRTCPeerListener } from './listener.js'
-import { handleIncomingStream } from './signaling-stream-handler.js'
+import { initiateConnection } from './initiate-connection.ts'
+import { WebRTCPeerListener } from './listener.ts'
+import { handleIncomingStream } from './signaling-stream-handler.ts'
 import { getRemotePeer } from './util.ts'
 import type { DataChannelOptions } from '../index.js'
 import type { OutboundConnectionUpgradeEvents, CreateListenerOptions, DialTransportOptions, Transport, Listener, Upgrader, ComponentLogger, Logger, Connection, PeerId, CounterGroup, Metrics, Startable, OpenConnectionProgressEvents, Libp2pEvents, MultiaddrConnection, Stream } from '@libp2p/interface'

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

@@ -2,8 +2,8 @@ import { ConnectionFailedError, InvalidMessageError, InvalidMultiaddrError } fro
 import { peerIdFromString } from '@libp2p/peer-id'
 import { CustomProgressEvent } from 'progress-events'
 import { RTCIceCandidate } from '../webrtc/index.js'
-import { Message } from './pb/message.js'
-import type { WebRTCDialEvents } from './transport.js'
+import { Message } from './pb/message.ts'
+import type { WebRTCDialEvents } from './transport.ts'
 import type { RTCPeerConnection } from '../webrtc/index.js'
 import type { AbortOptions, LoggerOptions, PeerId, Stream } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
@@ -86,7 +86,6 @@ function resolveOnConnected (pc: RTCPeerConnection, promise: DeferredPromise<voi
         promise.resolve()
         break
       case 'failed':
-      case 'disconnected':
       case 'closed':
         promise.reject(new ConnectionFailedError(`RTCPeerConnection connection state became "${pc.connectionState}"`))
         break

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

@@ -6,13 +6,13 @@ import { WebRTCDirect } from '@multiformats/multiaddr-matcher'
 import getPort from 'get-port'
 import { TypedEventEmitter, setMaxListeners } from 'main-event'
 import pWaitFor from 'p-wait-for'
-import { connect } from './utils/connect.js'
-import { createDialerRTCPeerConnection } from './utils/get-rtcpeerconnection.js'
-import { stunListener } from './utils/stun-listener.js'
+import { connect } from './utils/connect.ts'
+import { createDialerRTCPeerConnection } from './utils/get-rtcpeerconnection.ts'
+import { stunListener } from './utils/stun-listener.ts'
 import type { DataChannelOptions, TransportCertificate } from '../index.js'
-import type { WebRTCDirectTransportCertificateEvents } from './transport.js'
-import type { DirectRTCPeerConnection } from './utils/get-rtcpeerconnection.js'
-import type { StunServer } from './utils/stun-listener.js'
+import type { WebRTCDirectTransportCertificateEvents } from './transport.ts'
+import type { DirectRTCPeerConnection } from './utils/get-rtcpeerconnection.ts'
+import type { StunServer } from './utils/stun-listener.ts'
 import type { PeerId, ListenerEvents, Listener, Upgrader, ComponentLogger, Logger, CounterGroup, Metrics, PrivateKey } from '@libp2p/interface'
 import type { Keychain } from '@libp2p/keychain'
 import type { Multiaddr } from '@multiformats/multiaddr'

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

@@ -4,8 +4,8 @@ import { CODE_P2P } from '@multiformats/multiaddr'
 import { WebRTCDirect } from '@multiformats/multiaddr-matcher'
 import { UnimplementedError } from '../error.ts'
 import { genUfrag } from '../util.js'
-import { connect } from './utils/connect.js'
-import { createDialerRTCPeerConnection } from './utils/get-rtcpeerconnection.js'
+import { connect } from './utils/connect.ts'
+import { createDialerRTCPeerConnection } from './utils/get-rtcpeerconnection.ts'
 import type { DataChannelOptions } from '../index.js'
 import type { WebRTCDialEvents } from '../private-to-private/transport.js'
 import type { CreateListenerOptions, Transport, Listener, ComponentLogger, Logger, Connection, CounterGroup, Metrics, PeerId, DialTransportOptions, PrivateKey, Upgrader } from '@libp2p/interface'

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

@@ -1,3 +1,4 @@
+import 'reflect-metadata'
 import { generateKeyPair, privateKeyToCryptoKeyPair } from '@libp2p/crypto/keys'
 import { InvalidParametersError, NotFoundError, NotStartedError } from '@libp2p/interface'
 import { WebRTCDirect } from '@multiformats/multiaddr-matcher'
@@ -9,9 +10,9 @@ import { sha256 } from 'multiformats/hashes/sha2'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { DEFAULT_CERTIFICATE_DATASTORE_KEY, DEFAULT_CERTIFICATE_LIFESPAN, DEFAULT_CERTIFICATE_PRIVATE_KEY_NAME, DEFAULT_CERTIFICATE_RENEWAL_THRESHOLD } from '../constants.js'
-import { WebRTCDirectListener } from './listener.js'
-import { WebRTCDirectTransport as WebRTCDirectBrowserTransport } from './transport.browser.js'
-import { formatAsPem } from './utils/pem.js'
+import { WebRTCDirectListener } from './listener.ts'
+import { WebRTCDirectTransport as WebRTCDirectBrowserTransport } from './transport.browser.ts'
+import { formatAsPem } from './utils/pem.ts'
 import type { TransportCertificate } from '../index.js'
 import type { WebRTCTransportDirectInit as WebRTCTransportDirectBrowserInit, WebRTCMetrics, WebRTCDirectTransportComponents } from './transport.browser.ts'
 import type { CreateListenerOptions, Transport, Listener, PrivateKey, Startable } from '@libp2p/interface'

package/src/private-to-public/utils/connect.ts

@@ -4,10 +4,9 @@ import { WebRTCTransportError } from '../../error.js'
 import { DataChannelMuxerFactory } from '../../muxer.js'
 import { toMultiaddrConnection } from '../../rtcpeerconnection-to-conn.ts'
 import { createStream } from '../../stream.js'
-import { isFirefox } from '../../util.js'
-import { generateNoisePrologue } from './generate-noise-prologue.js'
-import * as sdp from './sdp.js'
-import type { DirectRTCPeerConnection } from './get-rtcpeerconnection.js'
+import { generateNoisePrologue } from './generate-noise-prologue.ts'
+import * as sdp from './sdp.ts'
+import type { DirectRTCPeerConnection } from './get-rtcpeerconnection.ts'
 import type { DataChannelOptions } from '../../index.js'
 import type { ComponentLogger, Connection, CounterGroup, Logger, PeerId, PrivateKey, Upgrader } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
@@ -34,8 +33,6 @@ export interface ServerOptions extends ConnectOptions {
   role: 'server'
 }
 
-const CONNECTION_STATE_CHANGE_EVENT = isFirefox ? 'iceconnectionstatechange' : 'connectionstatechange'
-
 function isServer (options: ClientOptions | ServerOptions, peerConnection: any): peerConnection is DirectRTCPeerConnection {
   return options.role === 'server'
 }
@@ -135,7 +132,7 @@ export async function connect (peerConnection: RTCPeerConnection | DirectRTCPeer
       log: options.logger.forComponent('libp2p:webrtc-direct:connection')
     })
 
-    peerConnection.addEventListener(CONNECTION_STATE_CHANGE_EVENT, () => {
+    peerConnection.addEventListener('connectionstatechange', () => {
       switch (peerConnection.connectionState) {
         case 'failed':
         case 'disconnected':

package/src/private-to-public/utils/generate-certificates.ts

@@ -1,3 +1,4 @@
+import 'reflect-metadata'
 import { Crypto } from '@peculiar/webcrypto'
 import * as x509 from '@peculiar/x509'
 import { base64url } from 'multiformats/bases/base64'

package/src/private-to-public/utils/generate-noise-prologue.ts

@@ -2,7 +2,7 @@ import * as Digest from 'multiformats/hashes/digest'
 import { sha256 } from 'multiformats/hashes/sha2'
 import { concat } from 'uint8arrays/concat'
 import { fromString as uint8arrayFromString } from 'uint8arrays/from-string'
-import * as sdp from './sdp.js'
+import * as sdp from './sdp.ts'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 const PREFIX = uint8arrayFromString('libp2p-webrtc-noise:')

package/src/private-to-public/utils/get-rtcpeerconnection.ts

@@ -3,7 +3,7 @@ import { PeerConnection } from 'node-datachannel'
 import { RTCPeerConnection } from 'node-datachannel/polyfill'
 import { DEFAULT_ICE_SERVERS, MAX_MESSAGE_SIZE } from '../../constants.js'
 import { DataChannelMuxerFactory } from '../../muxer.ts'
-import { generateTransportCertificate } from './generate-certificates.js'
+import { generateTransportCertificate } from './generate-certificates.ts'
 import type { DataChannelOptions, TransportCertificate } from '../../index.js'
 import type { CounterGroup } from '@libp2p/interface'
 import type { CertificateFingerprint } from 'node-datachannel'

package/src/rtcpeerconnection-to-conn.ts

@@ -20,7 +20,7 @@ class RTCPeerConnectionMultiaddrConnection extends AbstractMultiaddrConnection {
     this.peerConnection.onconnectionstatechange = () => {
       this.log.trace('peer connection state change %s initial state %s', this.peerConnection.connectionState, initialState)
 
-      if (this.peerConnection.connectionState === 'disconnected' || this.peerConnection.connectionState === 'failed' || this.peerConnection.connectionState === 'closed') {
+      if (this.peerConnection.connectionState === 'failed' || this.peerConnection.connectionState === 'closed') {
         // nothing else to do but close the connection
         this.onTransportClosed()
 

package/src/stream.ts

@@ -5,10 +5,9 @@ import { pushable } from 'it-pushable'
 import { pEvent } from 'p-event'
 import { raceSignal } from 'race-signal'
 import { Uint8ArrayList } from 'uint8arraylist'
-import { DEFAULT_FIN_ACK_TIMEOUT, MAX_BUFFERED_AMOUNT, MAX_MESSAGE_SIZE, PROTOBUF_OVERHEAD } from './constants.js'
-import { Message } from './private-to-public/pb/message.js'
-import { isFirefox } from './util.js'
-import type { DataChannelOptions } from './index.js'
+import { DEFAULT_FIN_ACK_TIMEOUT, MAX_BUFFERED_AMOUNT, MAX_MESSAGE_SIZE, PROTOBUF_OVERHEAD } from './constants.ts'
+import { Message } from './private-to-public/pb/message.ts'
+import type { DataChannelOptions } from './index.ts'
 import type { AbortOptions, MessageStreamDirection, Logger } from '@libp2p/interface'
 import type { AbstractStreamInit, SendResult } from '@libp2p/utils'
 import type { Pushable } from 'it-pushable'
@@ -140,17 +139,15 @@ export class WebRTCStream extends AbstractStream {
 
     this.log.trace('sending message, channel state "%s"', this.channel.readyState)
 
-    if (isFirefox) {
-      // TODO: firefox can deliver small messages out of order - remove once a
-      // browser with https://bugzilla.mozilla.org/show_bug.cgi?id=1983831 is
-      // available in playwright-test
-      this.channel.send(data.subarray())
-      return
-    }
-
-    // send message without copying data
-    for (const buf of data) {
-      this.channel.send(buf)
+    try {
+      // send message without copying data
+      for (const buf of data) {
+        this.channel.send(buf)
+      }
+    } catch (err: any) {
+      // channel.send can throw synchronously if the polyfill's cached readyState is stale
+      this.log.error('error sending datachannel message - %e', err)
+      this.abort(err)
     }
   }
 

package/src/util.ts

@@ -1,14 +1,10 @@
-import { detect } from 'detect-browser'
 import pDefer from 'p-defer'
 import pTimeout from 'p-timeout'
-import { DATA_CHANNEL_DRAIN_TIMEOUT, DEFAULT_ICE_SERVERS, UFRAG_ALPHABET, UFRAG_PREFIX } from './constants.js'
+import { DATA_CHANNEL_DRAIN_TIMEOUT, DEFAULT_ICE_SERVERS, UFRAG_ALPHABET, UFRAG_PREFIX } from './constants.ts'
 import type { LoggerOptions } from '@libp2p/interface'
 import type { Duplex, Source } from 'it-stream-types'
 import type { PeerConnection } from 'node-datachannel'
 
-const browser = detect()
-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> => {}

package/dist/typedoc-urls.json

@@ -1,14 +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",
-  "TransportCertificate": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.TransportCertificate.html",
-  ".:TransportCertificate": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.TransportCertificate.html",
-  "WebRTCDirectTransportComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.WebRTCDirectTransportComponents.html",
-  "WebRTCTransportComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.WebRTCTransportComponents.html",
-  "WebRTCTransportDirectInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.WebRTCTransportDirectInit.html",
-  "WebRTCTransportInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.WebRTCTransportInit.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"
-}