@libp2p/webrtc 2.0.11 → 3.0.0-72e81dc1

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

@@ -1,17 +1,19 @@
-import { type CreateListenerOptions, type DialOptions, type Listener, symbol, type Transport, type Upgrader, type TransportManager } from '@libp2p/interface-transport'
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
+import { type CreateListenerOptions, type DialOptions, symbol, type Transport, type Listener, type Upgrader } from '@libp2p/interface/transport'
 import { logger } from '@libp2p/logger'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { multiaddr, type Multiaddr, protocols } from '@multiformats/multiaddr'
 import { codes } from '../error.js'
 import { WebRTCMultiaddrConnection } from '../maconn.js'
+import { cleanup } from '../webrtc/index.js'
 import { initiateConnection, handleIncomingStream } from './handler.js'
 import { WebRTCPeerListener } from './listener.js'
 import type { DataChannelOpts } from '../stream.js'
-import type { Connection } from '@libp2p/interface-connection'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
-import type { Startable } from '@libp2p/interfaces/startable'
+import type { Connection } from '@libp2p/interface/connection'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { Startable } from '@libp2p/interface/startable'
+import type { IncomingStreamData, Registrar } from '@libp2p/interface-internal/registrar'
+import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
 
 const log = logger('libp2p:webrtc:peer')
 
@@ -48,12 +50,15 @@ 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
   }
 
   async stop (): Promise<void> {
     await this.components.registrar.unhandle(SIGNALING_PROTO_ID)
+    cleanup()
     this._started = false
   }
 
@@ -89,7 +94,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({
@@ -113,11 +121,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
@@ -143,8 +151,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-private/util.ts

@@ -1,5 +1,6 @@
 import { logger } from '@libp2p/logger'
 import { isFirefox } from '../util.js'
+import { RTCIceCandidate } from '../webrtc/index.js'
 import { Message } from './pb/message.js'
 import type { DeferredPromise } from 'p-defer'
 

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

@@ -1,4 +1,4 @@
-import type { CreateListenerOptions, DialOptions } from '@libp2p/interface-transport'
+import type { CreateListenerOptions, DialOptions } from '@libp2p/interface/transport'
 
 export interface WebRTCListenerOptions extends CreateListenerOptions {}
 export interface WebRTCDialOptions extends DialOptions {}

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

@@ -133,7 +133,7 @@ a=ice-ufrag:${ufrag}
 a=ice-pwd:${ufrag}
 a=fingerprint:${CERTFP}
 a=sctp-port:5000
-a=max-message-size:100000
+a=max-message-size:16384
 a=candidate:1467250027 1 UDP 1467250027 ${host} ${port} typ host\r\n`
 }
 

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

@@ -1,5 +1,5 @@
 import { noise as Noise } from '@chainsafe/libp2p-noise'
-import { type CreateListenerOptions, type Listener, symbol, type Transport } from '@libp2p/interface-transport'
+import { type CreateListenerOptions, symbol, type Transport, type Listener } from '@libp2p/interface/transport'
 import { logger } from '@libp2p/logger'
 import * as p from '@libp2p/peer-id'
 import { protocols } from '@multiformats/multiaddr'
@@ -11,13 +11,14 @@ import { WebRTCMultiaddrConnection } from '../maconn.js'
 import { DataChannelMuxerFactory } from '../muxer.js'
 import { createStream } from '../stream.js'
 import { isFirefox } from '../util.js'
+import { RTCPeerConnection } from '../webrtc/index.js'
 import * as sdp from './sdp.js'
 import { genUfrag } from './util.js'
 import type { WebRTCDialOptions } from './options.js'
 import type { DataChannelOpts } from '../stream.js'
-import type { Connection } from '@libp2p/interface-connection'
-import type { CounterGroup, Metrics } from '@libp2p/interface-metrics'
-import type { PeerId } from '@libp2p/interface-peer-id'
+import type { Connection } from '@libp2p/interface/connection'
+import type { CounterGroup, Metrics } from '@libp2p/interface/metrics'
+import type { PeerId } from '@libp2p/interface/peer-id'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:webrtc:transport')
@@ -134,116 +135,121 @@ export class WebRTCDirectTransport implements Transport {
 
     const peerConnection = new RTCPeerConnection({ certificates: [certificate] })
 
-    // create data channel for running the noise handshake. Once the data channel is opened,
-    // the remote will initiate the noise handshake. This is used to confirm the identity of
-    // the peer.
-    const dataChannelOpenPromise = new Promise<RTCDataChannel>((resolve, reject) => {
-      const handshakeDataChannel = peerConnection.createDataChannel('', { negotiated: true, id: 0 })
-      const handshakeTimeout = setTimeout(() => {
-        const error = `Data channel was never opened: state: ${handshakeDataChannel.readyState}`
-        log.error(error)
-        this.metrics?.dialerEvents.increment({ open_error: true })
-        reject(dataChannelError('data', error))
-      }, HANDSHAKE_TIMEOUT_MS)
-
-      handshakeDataChannel.onopen = (_) => {
-        clearTimeout(handshakeTimeout)
-        resolve(handshakeDataChannel)
-      }
-
-      // ref: https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel/error_event
-      handshakeDataChannel.onerror = (event: Event) => {
-        clearTimeout(handshakeTimeout)
-        const errorTarget = event.target?.toString() ?? 'not specified'
-        const error = `Error opening a data channel for handshaking: ${errorTarget}`
-        log.error(error)
-        // NOTE: We use unknown error here but this could potentially be considered a reset by some standards.
-        this.metrics?.dialerEvents.increment({ unknown_error: true })
-        reject(dataChannelError('data', error))
-      }
-    })
-
-    const ufrag = 'libp2p+webrtc+v1/' + genUfrag(32)
-
-    // Create offer and munge sdp with ufrag == pwd. This allows the remote to
-    // respond to STUN messages without performing an actual SDP exchange.
-    // This is because it can infer the passwd field by reading the USERNAME
-    // attribute of the STUN message.
-    const offerSdp = await peerConnection.createOffer()
-    const mungedOfferSdp = sdp.munge(offerSdp, ufrag)
-    await peerConnection.setLocalDescription(mungedOfferSdp)
-
-    // construct answer sdp from multiaddr and ufrag
-    const answerSdp = sdp.fromMultiAddr(ma, ufrag)
-    await peerConnection.setRemoteDescription(answerSdp)
-
-    // wait for peerconnection.onopen to fire, or for the datachannel to open
-    const handshakeDataChannel = await dataChannelOpenPromise
-
-    const myPeerId = this.components.peerId
-
-    // Do noise handshake.
-    // Set the Noise Prologue to libp2p-webrtc-noise:<FINGERPRINTS> before starting the actual Noise handshake.
-    // <FINGERPRINTS> is the concatenation of the of the two TLS fingerprints of A and B in their multihash byte representation, sorted in ascending order.
-    const fingerprintsPrologue = this.generateNoisePrologue(peerConnection, remoteCerthash.code, ma)
-
-    // Since we use the default crypto interface and do not use a static key or early data,
-    // we pass in undefined for these parameters.
-    const noise = Noise({ prologueBytes: fingerprintsPrologue })()
-
-    const wrappedChannel = createStream({ channel: handshakeDataChannel, direction: 'inbound', dataChannelOptions: this.init.dataChannel })
-    const wrappedDuplex = {
-      ...wrappedChannel,
-      sink: wrappedChannel.sink.bind(wrappedChannel),
-      source: (async function * () {
-        for await (const list of wrappedChannel.source) {
-          for (const buf of list) {
-            yield buf
-          }
+    try {
+      // create data channel for running the noise handshake. Once the data channel is opened,
+      // the remote will initiate the noise handshake. This is used to confirm the identity of
+      // the peer.
+      const dataChannelOpenPromise = new Promise<RTCDataChannel>((resolve, reject) => {
+        const handshakeDataChannel = peerConnection.createDataChannel('', { negotiated: true, id: 0 })
+        const handshakeTimeout = setTimeout(() => {
+          const error = `Data channel was never opened: state: ${handshakeDataChannel.readyState}`
+          log.error(error)
+          this.metrics?.dialerEvents.increment({ open_error: true })
+          reject(dataChannelError('data', error))
+        }, HANDSHAKE_TIMEOUT_MS)
+
+        handshakeDataChannel.onopen = (_) => {
+          clearTimeout(handshakeTimeout)
+          resolve(handshakeDataChannel)
         }
-      }())
-    }
 
-    // Creating the connection before completion of the noise
-    // handshake ensures that the stream opening callback is set up
-    const maConn = new WebRTCMultiaddrConnection({
-      peerConnection,
-      remoteAddr: ma,
-      timeline: {
-        open: Date.now()
-      },
-      metrics: this.metrics?.dialerEvents
-    })
-
-    const eventListeningName = isFirefox ? 'iceconnectionstatechange' : 'connectionstatechange'
-
-    peerConnection.addEventListener(eventListeningName, () => {
-      switch (peerConnection.connectionState) {
-        case 'failed':
-        case 'disconnected':
-        case 'closed':
-          maConn.close().catch((err) => {
-            log.error('error closing connection', err)
-          }).finally(() => {
-            // Remove the event listener once the connection is closed
-            controller.abort()
-          })
-          break
-        default:
-          break
+        // ref: https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel/error_event
+        handshakeDataChannel.onerror = (event: Event) => {
+          clearTimeout(handshakeTimeout)
+          const errorTarget = event.target?.toString() ?? 'not specified'
+          const error = `Error opening a data channel for handshaking: ${errorTarget}`
+          log.error(error)
+          // NOTE: We use unknown error here but this could potentially be considered a reset by some standards.
+          this.metrics?.dialerEvents.increment({ unknown_error: true })
+          reject(dataChannelError('data', error))
+        }
+      })
+
+      const ufrag = 'libp2p+webrtc+v1/' + genUfrag(32)
+
+      // Create offer and munge sdp with ufrag == pwd. This allows the remote to
+      // respond to STUN messages without performing an actual SDP exchange.
+      // This is because it can infer the passwd field by reading the USERNAME
+      // attribute of the STUN message.
+      const offerSdp = await peerConnection.createOffer()
+      const mungedOfferSdp = sdp.munge(offerSdp, ufrag)
+      await peerConnection.setLocalDescription(mungedOfferSdp)
+
+      // construct answer sdp from multiaddr and ufrag
+      const answerSdp = sdp.fromMultiAddr(ma, ufrag)
+      await peerConnection.setRemoteDescription(answerSdp)
+
+      // wait for peerconnection.onopen to fire, or for the datachannel to open
+      const handshakeDataChannel = await dataChannelOpenPromise
+
+      const myPeerId = this.components.peerId
+
+      // Do noise handshake.
+      // Set the Noise Prologue to libp2p-webrtc-noise:<FINGERPRINTS> before starting the actual Noise handshake.
+      // <FINGERPRINTS> is the concatenation of the of the two TLS fingerprints of A and B in their multihash byte representation, sorted in ascending order.
+      const fingerprintsPrologue = this.generateNoisePrologue(peerConnection, remoteCerthash.code, ma)
+
+      // Since we use the default crypto interface and do not use a static key or early data,
+      // we pass in undefined for these parameters.
+      const noise = Noise({ prologueBytes: fingerprintsPrologue })()
+
+      const wrappedChannel = createStream({ channel: handshakeDataChannel, direction: 'inbound', dataChannelOptions: this.init.dataChannel })
+      const wrappedDuplex = {
+        ...wrappedChannel,
+        sink: wrappedChannel.sink.bind(wrappedChannel),
+        source: (async function * () {
+          for await (const list of wrappedChannel.source) {
+            for (const buf of list) {
+              yield buf
+            }
+          }
+        }())
       }
-    }, { signal })
 
-    // Track opened peer connection
-    this.metrics?.dialerEvents.increment({ peer_connection: true })
+      // Creating the connection before completion of the noise
+      // handshake ensures that the stream opening callback is set up
+      const maConn = new WebRTCMultiaddrConnection({
+        peerConnection,
+        remoteAddr: ma,
+        timeline: {
+          open: Date.now()
+        },
+        metrics: this.metrics?.dialerEvents
+      })
+
+      const eventListeningName = isFirefox ? 'iceconnectionstatechange' : 'connectionstatechange'
+
+      peerConnection.addEventListener(eventListeningName, () => {
+        switch (peerConnection.connectionState) {
+          case 'failed':
+          case 'disconnected':
+          case 'closed':
+            maConn.close().catch((err) => {
+              log.error('error closing connection', err)
+            }).finally(() => {
+              // Remove the event listener once the connection is closed
+              controller.abort()
+            })
+            break
+          default:
+            break
+        }
+      }, { signal })
 
-    const muxerFactory = new DataChannelMuxerFactory({ peerConnection, metrics: this.metrics?.dialerEvents, dataChannelOptions: this.init.dataChannel })
+      // Track opened peer connection
+      this.metrics?.dialerEvents.increment({ peer_connection: true })
 
-    // For outbound connections, the remote is expected to start the noise handshake.
-    // Therefore, we need to secure an inbound noise connection from the remote.
-    await noise.secureInbound(myPeerId, wrappedDuplex, theirPeerId)
+      const muxerFactory = new DataChannelMuxerFactory({ peerConnection, metrics: this.metrics?.dialerEvents, dataChannelOptions: this.init.dataChannel })
 
-    return options.upgrader.upgradeOutbound(maConn, { skipProtection: true, skipEncryption: true, muxerFactory })
+      // For outbound connections, the remote is expected to start the noise handshake.
+      // Therefore, we need to secure an inbound noise connection from the remote.
+      await noise.secureInbound(myPeerId, wrappedDuplex, theirPeerId)
+
+      return await options.upgrader.upgradeOutbound(maConn, { skipProtection: true, skipEncryption: true, muxerFactory })
+    } catch (err) {
+      peerConnection.close()
+      throw err
+    }
   }
 
   /**

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

@@ -1,12 +1,12 @@
-import { AbstractStream, type AbstractStreamInit } from '@libp2p/interface-stream-muxer/stream'
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
+import { AbstractStream, type AbstractStreamInit } from '@libp2p/interface/stream-muxer/stream'
 import { logger } from '@libp2p/logger'
 import * as lengthPrefixed from 'it-length-prefixed'
 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}`)
   })
 }

package/src/webrtc/index.browser.ts

@@ -0,0 +1,4 @@
+export const RTCPeerConnection = globalThis.RTCPeerConnection
+export const RTCSessionDescription = globalThis.RTCSessionDescription
+export const RTCIceCandidate = globalThis.RTCIceCandidate
+export function cleanup (): void {}

package/src/webrtc/index.ts

@@ -0,0 +1,12 @@
+import node from 'node-datachannel'
+import { IceCandidate } from './rtc-ice-candidate.js'
+import { PeerConnection } from './rtc-peer-connection.js'
+import { SessionDescription } from './rtc-session-description.js'
+
+export { SessionDescription as RTCSessionDescription }
+export { IceCandidate as RTCIceCandidate }
+export { PeerConnection as RTCPeerConnection }
+
+export function cleanup (): void {
+  node.cleanup()
+}

package/src/webrtc/rtc-data-channel.ts

@@ -0,0 +1,140 @@
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import type node from 'node-datachannel'
+
+export class DataChannel extends EventTarget implements RTCDataChannel {
+  binaryType: BinaryType
+
+  readonly maxPacketLifeTime: number | null
+  readonly maxRetransmits: number | null
+  readonly negotiated: boolean
+  readonly ordered: boolean
+
+  onbufferedamountlow: ((this: RTCDataChannel, ev: Event) => any) | null
+  onclose: ((this: RTCDataChannel, ev: Event) => any) | null
+  onclosing: ((this: RTCDataChannel, ev: Event) => any) | null
+  onerror: ((this: RTCDataChannel, ev: Event) => any) | null
+  onmessage: ((this: RTCDataChannel, ev: MessageEvent) => any) | null
+  onopen: ((this: RTCDataChannel, ev: Event) => any) | null
+
+  #dataChannel: node.DataChannel
+  #bufferedAmountLowThreshold: number
+  #readyState: RTCDataChannelState
+
+  constructor (dataChannel: node.DataChannel, dataChannelDict: RTCDataChannelInit = {}) {
+    super()
+
+    this.#dataChannel = dataChannel
+    this.#readyState = 'connecting'
+    this.#bufferedAmountLowThreshold = 0
+
+    this.binaryType = 'arraybuffer'
+
+    this.#dataChannel.onOpen(() => {
+      this.#readyState = 'open'
+      this.dispatchEvent(new Event('open'))
+    })
+    this.#dataChannel.onClosed(() => {
+      this.#readyState = 'closed'
+      this.dispatchEvent(new Event('close'))
+    })
+    this.#dataChannel.onError((msg) => {
+      this.#readyState = 'closed'
+      this.dispatchEvent(new RTCErrorEvent('error', {
+        error: new RTCError({
+          errorDetail: 'data-channel-failure'
+        }, msg)
+      }))
+    })
+    this.#dataChannel.onBufferedAmountLow(() => {
+      this.dispatchEvent(new Event('bufferedamountlow'))
+    })
+    this.#dataChannel.onMessage((data: string | Uint8Array) => {
+      if (typeof data === 'string') {
+        data = uint8ArrayFromString(data)
+      }
+
+      this.dispatchEvent(new MessageEvent('message', { data }))
+    })
+
+    // forward events to properties
+    this.addEventListener('message', event => {
+      this.onmessage?.(event as MessageEvent<ArrayBuffer>)
+    })
+    this.addEventListener('bufferedamountlow', event => {
+      this.onbufferedamountlow?.(event)
+    })
+    this.addEventListener('error', event => {
+      this.onerror?.(event)
+    })
+    this.addEventListener('close', event => {
+      this.onclose?.(event)
+    })
+    this.addEventListener('closing', event => {
+      this.onclosing?.(event)
+    })
+    this.addEventListener('open', event => {
+      this.onopen?.(event)
+    })
+
+    this.onbufferedamountlow = null
+    this.onclose = null
+    this.onclosing = null
+    this.onerror = null
+    this.onmessage = null
+    this.onopen = null
+
+    this.maxPacketLifeTime = dataChannelDict.maxPacketLifeTime ?? null
+    this.maxRetransmits = dataChannelDict.maxRetransmits ?? null
+    this.negotiated = dataChannelDict.negotiated ?? false
+    this.ordered = dataChannelDict.ordered ?? true
+  }
+
+  get id (): number {
+    return this.#dataChannel.getId()
+  }
+
+  get label (): string {
+    return this.#dataChannel.getLabel()
+  }
+
+  get protocol (): string {
+    return this.#dataChannel.getProtocol()
+  }
+
+  get bufferedAmount (): number {
+    return this.#dataChannel.bufferedAmount()
+  }
+
+  set bufferedAmountLowThreshold (threshold: number) {
+    this.#bufferedAmountLowThreshold = threshold
+    this.#dataChannel.setBufferedAmountLowThreshold(threshold)
+  }
+
+  get bufferedAmountLowThreshold (): number {
+    return this.#bufferedAmountLowThreshold
+  }
+
+  get readyState (): RTCDataChannelState {
+    return this.#readyState
+  }
+
+  close (): void {
+    this.#readyState = 'closing'
+    this.dispatchEvent(new Event('closing'))
+
+    this.#dataChannel.close()
+  }
+
+  send (data: string): void
+  send (data: Blob): void
+  send (data: ArrayBuffer): void
+  send (data: ArrayBufferView): void
+  send (data: any): void {
+    // TODO: sending Blobs
+    if (typeof data === 'string') {
+      this.#dataChannel.sendMessage(data)
+    } else {
+      this.#dataChannel.sendMessageBinary(data)
+    }
+  }
+}