@libp2p/webrtc 2.0.11 → 3.0.0-e66f4891

package/dist/src/webrtc/rtc-session-description.js

@@ -0,0 +1,18 @@
+/**
+ * @see https://developer.mozilla.org/docs/Web/API/RTCSessionDescription
+ */
+export class SessionDescription {
+    sdp;
+    type;
+    constructor(init) {
+        this.sdp = init.sdp ?? '';
+        this.type = init.type;
+    }
+    toJSON() {
+        return {
+            sdp: this.sdp,
+            type: this.type
+        };
+    }
+}
+//# sourceMappingURL=rtc-session-description.js.map

package/dist/src/webrtc/rtc-session-description.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rtc-session-description.js","sourceRoot":"","sources":["../../../src/webrtc/rtc-session-description.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,OAAO,kBAAkB;IACpB,GAAG,CAAQ;IACX,IAAI,CAAY;IAEzB,YAAa,IAA+B;QAC1C,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,IAAI,EAAE,CAAA;QACzB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAA;IACvB,CAAC;IAED,MAAM;QACJ,OAAO;YACL,GAAG,EAAE,IAAI,CAAC,GAAG;YACb,IAAI,EAAE,IAAI,CAAC,IAAI;SAChB,CAAA;IACH,CAAC;CACF"}

package/package.json

@@ -1,20 +1,16 @@
 {
   "name": "@libp2p/webrtc",
-  "version": "2.0.11",
+  "version": "3.0.0-e66f4891",
   "description": "A libp2p transport using WebRTC connections",
   "author": "",
   "license": "Apache-2.0 OR MIT",
-  "homepage": "https://github.com/libp2p/js-libp2p-webrtc#readme",
+  "homepage": "https://github.com/libp2p/js-libp2p/tree/master/packages/transport-webrtc#readme",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/libp2p/js-libp2p-webrtc.git"
+    "url": "git+https://github.com/libp2p/js-libp2p.git"
   },
   "bugs": {
-    "url": "https://github.com/libp2p/js-libp2p-webrtc/issues"
-  },
-  "engines": {
-    "node": ">=18.0.0",
-    "npm": ">=8.6.0"
+    "url": "https://github.com/libp2p/js-libp2p/issues"
   },
   "type": "module",
   "types": "./dist/src/index.d.ts",
@@ -22,8 +18,7 @@
     "src",
     "dist",
     "!dist/test",
-    "!**/*.tsbuildinfo",
-    "proto_ts"
+    "!**/*.tsbuildinfo"
   ],
   "exports": {
     ".": {
@@ -37,147 +32,60 @@
       "sourceType": "module"
     }
   },
-  "release": {
-    "branches": [
-      "main"
-    ],
-    "plugins": [
-      [
-        "@semantic-release/commit-analyzer",
-        {
-          "preset": "conventionalcommits",
-          "releaseRules": [
-            {
-              "breaking": true,
-              "release": "major"
-            },
-            {
-              "revert": true,
-              "release": "patch"
-            },
-            {
-              "type": "feat",
-              "release": "minor"
-            },
-            {
-              "type": "fix",
-              "release": "patch"
-            },
-            {
-              "type": "docs",
-              "release": "patch"
-            },
-            {
-              "type": "test",
-              "release": "patch"
-            },
-            {
-              "type": "deps",
-              "release": "patch"
-            },
-            {
-              "scope": "no-release",
-              "release": false
-            }
-          ]
-        }
-      ],
-      [
-        "@semantic-release/release-notes-generator",
-        {
-          "preset": "conventionalcommits",
-          "presetConfig": {
-            "types": [
-              {
-                "type": "feat",
-                "section": "Features"
-              },
-              {
-                "type": "fix",
-                "section": "Bug Fixes"
-              },
-              {
-                "type": "chore",
-                "section": "Trivial Changes"
-              },
-              {
-                "type": "docs",
-                "section": "Documentation"
-              },
-              {
-                "type": "deps",
-                "section": "Dependencies"
-              },
-              {
-                "type": "test",
-                "section": "Tests"
-              }
-            ]
-          }
-        }
-      ],
-      "@semantic-release/changelog",
-      "@semantic-release/npm",
-      "@semantic-release/github",
-      "@semantic-release/git"
-    ]
-  },
   "scripts": {
     "generate": "protons src/private-to-private/pb/message.proto src/pb/message.proto",
     "build": "aegir build",
-    "test": "aegir test -t browser",
+    "test": "aegir test -t node -t browser -t electron-main",
+    "test:node": "aegir test -t node --cov",
     "test:chrome": "aegir test -t browser --cov",
     "test:firefox": "aegir test -t browser -- --browser firefox",
     "lint": "aegir lint",
     "lint:fix": "aegir lint --fix",
     "clean": "aegir clean",
-    "dep-check": "aegir dep-check -i protons",
-    "release": "aegir release"
+    "dep-check": "aegir dep-check"
   },
   "dependencies": {
     "@chainsafe/libp2p-noise": "^12.0.0",
-    "@libp2p/interface-connection": "^5.0.2",
-    "@libp2p/interface-metrics": "^4.0.8",
-    "@libp2p/interface-peer-id": "^2.0.2",
-    "@libp2p/interface-registrar": "^2.0.12",
-    "@libp2p/interface-stream-muxer": "^4.1.2",
-    "@libp2p/interface-transport": "^4.0.3",
-    "@libp2p/interfaces": "^3.3.2",
-    "@libp2p/logger": "^2.0.7",
-    "@libp2p/peer-id": "^2.0.3",
+    "@libp2p/interface": "0.1.0-e66f4891",
+    "@libp2p/interface-internal": "0.1.0-e66f4891",
+    "@libp2p/logger": "3.0.0-e66f4891",
+    "@libp2p/peer-id": "3.0.0-e66f4891",
     "@multiformats/mafmt": "^12.1.2",
-    "@multiformats/multiaddr": "^12.1.2",
+    "@multiformats/multiaddr": "^12.1.3",
     "abortable-iterator": "^5.0.1",
     "detect-browser": "^5.3.0",
     "it-length-prefixed": "^9.0.1",
-    "it-pb-stream": "^4.0.1",
     "it-pipe": "^3.0.1",
-    "it-pushable": "^3.1.3",
+    "it-protobuf-stream": "^1.0.0",
+    "it-pushable": "^3.2.0",
     "it-stream-types": "^2.0.1",
     "it-to-buffer": "^4.0.2",
-    "multiformats": "^11.0.2",
+    "multiformats": "^12.0.1",
     "multihashes": "^4.0.3",
+    "node-datachannel": "^0.4.3",
     "p-defer": "^4.0.0",
     "p-event": "^6.0.0",
     "protons-runtime": "^5.0.0",
     "uint8arraylist": "^2.4.3",
-    "uint8arrays": "^4.0.3"
+    "uint8arrays": "^4.0.4"
   },
   "devDependencies": {
-    "@chainsafe/libp2p-yamux": "^4.0.1",
-    "@libp2p/interface-libp2p": "^3.1.0",
-    "@libp2p/interface-mocks": "^12.0.1",
-    "@libp2p/peer-id-factory": "^2.0.3",
-    "@libp2p/websockets": "^6.0.1",
-    "@types/sinon": "^10.0.14",
-    "aegir": "^39.0.7",
+    "@chainsafe/libp2p-yamux": "^4.0.0",
+    "@libp2p/interface-compliance-tests": "4.0.0-e66f4891",
+    "@libp2p/peer-id-factory": "3.0.0-e66f4891",
+    "@libp2p/websockets": "7.0.0-e66f4891",
+    "@types/sinon": "^10.0.15",
+    "aegir": "^40.0.1",
     "delay": "^6.0.0",
     "it-length": "^3.0.2",
     "it-map": "^3.0.3",
     "it-pair": "^2.0.6",
-    "libp2p": "^0.45.0",
+    "libp2p": "0.46.0-e66f4891",
     "protons": "^7.0.2",
-    "sinon": "^15.0.4",
+    "sinon": "^15.1.2",
     "sinon-ts": "^1.0.0"
+  },
+  "browser": {
+    "./dist/src/webrtc/index.js": "./dist/src/webrtc/index.browser.js"
   }
 }

package/src/error.ts

@@ -1,5 +1,5 @@
-import { CodeError } from '@libp2p/interfaces/errors'
-import type { Direction } from '@libp2p/interface-connection'
+import { CodeError } from '@libp2p/interface/errors'
+import type { Direction } from '@libp2p/interface/connection'
 
 export enum codes {
   ERR_ALREADY_ABORTED = 'ERR_ALREADY_ABORTED',

package/src/index.ts

@@ -1,7 +1,7 @@
 import { WebRTCTransport } from './private-to-private/transport.js'
 import { WebRTCDirectTransport, type WebRTCTransportDirectInit, type WebRTCDirectTransportComponents } from './private-to-public/transport.js'
 import type { WebRTCTransportComponents, WebRTCTransportInit } from './private-to-private/transport.js'
-import type { Transport } from '@libp2p/interface-transport'
+import type { Transport } from '@libp2p/interface/transport'
 
 /**
  * @param {WebRTCTransportDirectInit} init - WebRTC direct transport configuration

package/src/maconn.ts

@@ -1,8 +1,8 @@
 import { logger } from '@libp2p/logger'
 import { nopSink, nopSource } from './util.js'
-import type { MultiaddrConnection, MultiaddrConnectionTimeline } from '@libp2p/interface-connection'
-import type { CounterGroup } from '@libp2p/interface-metrics'
-import type { Multiaddr } from '@multiformats/multiaddr'
+import type { MultiaddrConnection, MultiaddrConnectionTimeline } from '@libp2p/interface/connection'
+import type { CounterGroup } from '@libp2p/interface/metrics'
+import type { AbortOptions, Multiaddr } from '@multiformats/multiaddr'
 import type { Source, Sink } from 'it-stream-types'
 
 const log = logger('libp2p:webrtc:connection')
@@ -72,14 +72,19 @@ export class WebRTCMultiaddrConnection implements MultiaddrConnection {
     }
   }
 
-  async close (err?: Error | undefined): Promise<void> {
-    if (err !== undefined) {
-      log.error('error closing connection', err)
-    }
+  async close (options?: AbortOptions): Promise<void> {
     log.trace('closing connection')
 
-    this.timeline.close = Date.now()
     this.peerConnection.close()
+    this.timeline.close = Date.now()
     this.metrics?.increment({ close: true })
   }
+
+  abort (err: Error): void {
+    log.error('closing connection due to error', err)
+
+    this.peerConnection.close()
+    this.timeline.close = Date.now()
+    this.metrics?.increment({ abort: true })
+  }
 }

package/src/muxer.ts

@@ -1,9 +1,10 @@
 import { createStream } from './stream.js'
 import { nopSink, nopSource } from './util.js'
 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 { 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,14 +1,16 @@
+import { CodeError } from '@libp2p/interface/errors'
 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 { RTCPeerConnection, RTCSessionDescription } from '../webrtc/index.js'
 import { Message } from './pb/message.js'
 import { readCandidatesUntilConnected, resolveOnConnected } from './util.js'
 import type { DataChannelOpts } from '../stream.js'
-import type { Stream } from '@libp2p/interface-connection'
-import type { IncomingStreamData } from '@libp2p/interface-registrar'
-import type { StreamMuxerFactory } from '@libp2p/interface-stream-muxer'
+import type { Stream } from '@libp2p/interface/connection'
+import type { StreamMuxerFactory } from '@libp2p/interface/stream-muxer'
+import type { IncomingStreamData } from '@libp2p/interface-internal/registrar'
 
 const DEFAULT_TIMEOUT = 30 * 1000
 
@@ -20,66 +22,75 @@ export async function handleIncomingStream ({ rtcConfiguration, dataChannelOptio
   const signal = AbortSignal.timeout(DEFAULT_TIMEOUT)
   const stream = pbStream(abortableDuplex(rawStream, signal)).pb(Message)
   const pc = new RTCPeerConnection(rtcConfiguration)
-  const muxerFactory = new DataChannelMuxerFactory({ peerConnection: pc, dataChannelOptions })
-  const connectedPromise: DeferredPromise<void> = pDefer()
-  const answerSentPromise: DeferredPromise<void> = pDefer()
-
-  signal.onabort = () => { connectedPromise.reject() }
-  // candidate callbacks
-  pc.onicecandidate = ({ candidate }) => {
-    answerSentPromise.promise.then(
-      () => {
-        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)
-      }
-    )
-  }
 
-  resolveOnConnected(pc, connectedPromise)
+  try {
+    const muxerFactory = new DataChannelMuxerFactory({ peerConnection: pc, dataChannelOptions })
+    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
+    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()
 
-  // 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'} `)
+    // 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
   }
-  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
-  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 }
 }
 
 export interface ConnectOptions {
@@ -93,53 +104,63 @@ export async function initiateConnection ({ rtcConfiguration, dataChannelOptions
   const stream = pbStream(abortableDuplex(rawStream, signal)).pb(Message)
   // setup peer connection
   const pc = new RTCPeerConnection(rtcConfiguration)
-  const muxerFactory = new DataChannelMuxerFactory({ peerConnection: pc, dataChannelOptions })
-
-  const connectedPromise: DeferredPromise<void> = 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 }) => {
-    stream.write({
-      type: Message.Type.ICE_CANDIDATE,
-      data: (candidate != null) ? JSON.stringify(candidate.toJSON()) : ''
+
+  try {
+    const muxerFactory = new DataChannelMuxerFactory({ peerConnection: pc, dataChannelOptions })
+
+    const connectedPromise: DeferredPromise<void> = 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')
     })
-  }
-  // create an offer
-  const offerSdp = await pc.createOffer()
-  // write the offer to the stream
-  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')
-  })
+    // 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()
+    await readCandidatesUntilConnected(connectedPromise, pc, stream)
+    channel.close()
 
-  const remoteAddress = parseRemoteAddress(pc.currentRemoteDescription?.sdp ?? '')
+    const remoteAddress = parseRemoteAddress(pc.currentRemoteDescription?.sdp ?? '')
 
-  return { pc, muxerFactory, remoteAddress }
+    return { pc, muxerFactory, remoteAddress }
+  } catch (err) {
+    pc.close()
+    throw err
+  }
 }
 
 function parseRemoteAddress (sdp: string): string {

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

@@ -1,7 +1,8 @@
-import { EventEmitter } from '@libp2p/interfaces/events'
+import { EventEmitter } from '@libp2p/interface/events'
 import { Circuit } from '@multiformats/mafmt'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { ListenerEvents, Listener, TransportManager } from '@libp2p/interface-transport'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { ListenerEvents, Listener } from '@libp2p/interface/transport'
+import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 export interface ListenerOptions {