@libp2p/webrtc 5.2.24-6059227cb → 5.2.24-87bc8d4fb

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

@@ -1,10 +1,10 @@
+import { PeerConnection } from '@ipshipyard/node-datachannel'
+import { RTCPeerConnection } from '@ipshipyard/node-datachannel/polyfill'
 import { Crypto } from '@peculiar/webcrypto'
-import { PeerConnection } from 'node-datachannel'
-import { RTCPeerConnection } from 'node-datachannel/polyfill'
 import { DEFAULT_ICE_SERVERS, MAX_MESSAGE_SIZE } from '../../constants.js'
 import { generateTransportCertificate } from './generate-certificates.js'
 import type { TransportCertificate } from '../../index.js'
-import type { CertificateFingerprint } from 'node-datachannel'
+import type { CertificateFingerprint } from '@ipshipyard/node-datachannel'
 
 const crypto = new Crypto()
 
@@ -14,7 +14,7 @@ interface DirectRTCPeerConnectionInit extends RTCConfiguration {
 }
 
 export class DirectRTCPeerConnection extends RTCPeerConnection {
-  private peerConnection: PeerConnection
+  private readonly peerConnection: PeerConnection
   private readonly ufrag: string
 
   constructor (init: DirectRTCPeerConnectionInit) {
@@ -22,18 +22,6 @@ export class DirectRTCPeerConnection extends RTCPeerConnection {
 
     this.peerConnection = init.peerConnection
     this.ufrag = init.ufrag
-
-    // make sure C++ peer connection is garbage collected
-    // https://github.com/murat-dogan/node-datachannel/issues/366#issuecomment-3228453155
-    this.addEventListener('connectionstatechange', () => {
-      switch (this.connectionState) {
-        case 'closed':
-          this.peerConnection.close()
-          break
-        default:
-          break
-      }
-    })
   }
 
   async createOffer (): Promise<globalThis.RTCSessionDescriptionInit | any> {

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

@@ -1,11 +1,10 @@
 import { InvalidParametersError } from '@libp2p/interface'
-import { getNetConfig } from '@libp2p/utils'
-import { CODE_CERTHASH, multiaddr } from '@multiformats/multiaddr'
+import { multiaddr } from '@multiformats/multiaddr'
 import { base64url } from 'multiformats/bases/base64'
 import { bases, digest } from 'multiformats/basics'
 import * as Digest from 'multiformats/hashes/digest'
 import { sha256 } from 'multiformats/hashes/sha2'
-import { MAX_MESSAGE_SIZE } from '../../constants.js'
+import { CODEC_CERTHASH, MAX_MESSAGE_SIZE } from '../../constants.js'
 import { InvalidFingerprintError, UnsupportedHashAlgorithmError } from '../../error.js'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { MultihashDigest } from 'multiformats/hashes/interface'
@@ -28,8 +27,8 @@ export function getFingerprintFromSdp (sdp: string | undefined): string | undefi
 
 // Extract the certhash from a multiaddr
 export function certhash (ma: Multiaddr): string {
-  const components = ma.getComponents()
-  const certhash = components.find(c => c.code === CODE_CERTHASH)?.value
+  const tups = ma.stringTuples()
+  const certhash = tups.filter((tup) => tup[0] === CODEC_CERTHASH).map((tup) => tup[1])[0]
 
   if (certhash === undefined || certhash === '') {
     throw new InvalidParametersError(`Couldn't find a certhash component of multiaddr: ${ma.toString()}`)
@@ -101,20 +100,15 @@ export function toSupportedHashFunction (code: number): 'sha-1' | 'sha-256' | 's
  * ice-lite mode and DTLS active mode.
  */
 export function serverAnswerFromMultiaddr (ma: Multiaddr, ufrag: string): RTCSessionDescriptionInit {
-  const { host, port, type } = getNetConfig(ma)
-
-  if (type !== 'ip4' && type !== 'ip6') {
-    throw new InvalidParametersError(`Multiaddr ${ma} was not an IPv4 or IPv6 address`)
-  }
-
+  const { host, port, family } = ma.toOptions()
   const fingerprint = ma2Fingerprint(ma)
   const sdp = `v=0
-o=- 0 0 IN IP${type === 'ip4' ? 4 : 6} ${host}
+o=- 0 0 IN IP${family} ${host}
 s=-
 t=0 0
 a=ice-lite
 m=application ${port} UDP/DTLS/SCTP webrtc-datachannel
-c=IN IP${type === 'ip4' ? 4 : 6} ${host}
+c=IN IP${family} ${host}
 a=mid:0
 a=ice-options:ice2
 a=ice-ufrag:${ufrag}
@@ -137,16 +131,11 @@ a=end-of-candidates
  * Create an offer SDP message from a multiaddr
  */
 export function clientOfferFromMultiAddr (ma: Multiaddr, ufrag: string): RTCSessionDescriptionInit {
-  const { host, port, type } = getNetConfig(ma)
-
-  if (type !== 'ip4' && type !== 'ip6') {
-    throw new InvalidParametersError(`Multiaddr ${ma} was not an IPv4 or IPv6 address`)
-  }
-
+  const { host, port, family } = ma.toOptions()
   const sdp = `v=0
-o=- 0 0 IN IP${type === 'ip4' ? 4 : 6} ${host}
+o=- 0 0 IN IP${family} ${host}
 s=-
-c=IN IP${type === 'ip4' ? 4 : 6} ${host}
+c=IN IP${family} ${host}
 t=0 0
 a=ice-options:ice2,trickle
 m=application ${port} UDP/DTLS/SCTP webrtc-datachannel
@@ -177,13 +166,8 @@ export function munge (desc: RTCSessionDescriptionInit, ufrag: string): RTCSessi
 
   const lineBreak = desc.sdp.includes('\r\n') ? '\r\n' : '\n'
 
-  try {
-    desc.sdp = desc.sdp
-      .replace(/\na=ice-ufrag:[^\n]*\n/, '\na=ice-ufrag:' + ufrag + lineBreak)
-      .replace(/\na=ice-pwd:[^\n]*\n/, '\na=ice-pwd:' + ufrag + lineBreak)
-  } catch {
-    // fails under Node.js
-  }
-
+  desc.sdp = desc.sdp
+    .replace(/\na=ice-ufrag:[^\n]*\n/, '\na=ice-ufrag:' + ufrag + lineBreak)
+    .replace(/\na=ice-pwd:[^\n]*\n/, '\na=ice-pwd:' + ufrag + lineBreak)
   return desc
 }

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

@@ -1,5 +1,5 @@
 import { isIPv4 } from '@chainsafe/is-ip'
-import { IceUdpMuxListener } from 'node-datachannel'
+import { IceUdpMuxListener } from '@ipshipyard/node-datachannel'
 import type { Logger } from '@libp2p/interface'
 import type { AddressInfo } from 'node:net'
 

package/src/stream.ts

@@ -1,17 +1,20 @@
-import { StreamResetError, StreamStateError } from '@libp2p/interface'
-import { AbstractStream } from '@libp2p/utils'
+import { StreamStateError, TimeoutError } from '@libp2p/interface'
+import { AbstractStream } from '@libp2p/utils/abstract-stream'
+import { anySignal } from 'any-signal'
 import * as lengthPrefixed from 'it-length-prefixed'
 import { pushable } from 'it-pushable'
-import { pEvent } from 'p-event'
+import pDefer from 'p-defer'
+import pTimeout from 'p-timeout'
+import { raceEvent } from 'race-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 { BUFFERED_AMOUNT_LOW_TIMEOUT, FIN_ACK_TIMEOUT, MAX_BUFFERED_AMOUNT, MAX_MESSAGE_SIZE, OPEN_TIMEOUT, 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 type { AbortOptions, MessageStreamDirection, Logger } from '@libp2p/interface'
-import type { AbstractStreamInit, SendResult } from '@libp2p/utils'
+import type { AbortOptions, Direction, Logger } from '@libp2p/interface'
+import type { AbstractStreamInit } from '@libp2p/utils/abstract-stream'
 import type { Pushable } from 'it-pushable'
+import type { DeferredPromise } from 'p-defer'
 
 export interface WebRTCStreamInit extends AbstractStreamInit, DataChannelOptions {
   /**
@@ -36,40 +39,124 @@ export class WebRTCStream extends AbstractStream {
    * and then the protobuf decoder.
    */
   private readonly incomingData: Pushable<Uint8Array>
+
   private readonly maxBufferedAmount: number
-  private receivedFinAck?: PromiseWithResolvers<void>
-  private finAckTimeout: number
+
+  private readonly bufferedAmountLowEventTimeout: number
+
+  /**
+   * The maximum size of a message in bytes
+   */
+  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 readonly openTimeout: number
+  private readonly closeController: AbortController
 
   constructor (init: WebRTCStreamInit) {
-    super({
-      ...init,
-      maxMessageSize: (init.maxMessageSize ?? MAX_MESSAGE_SIZE) - PROTOBUF_OVERHEAD
-    })
+    // 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 with status "%s"', 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)
+        })
+        .finally(() => {
+          this.channel.close()
+        })
+    }
+
+    super(init)
 
     this.channel = init.channel
     this.channel.binaryType = 'arraybuffer'
     this.incomingData = pushable<Uint8Array>()
+    this.bufferedAmountLowEventTimeout = init.bufferedAmountLowEventTimeout ?? BUFFERED_AMOUNT_LOW_TIMEOUT
     this.maxBufferedAmount = init.maxBufferedAmount ?? MAX_BUFFERED_AMOUNT
-    this.finAckTimeout = init.finAckTimeout ?? DEFAULT_FIN_ACK_TIMEOUT
+    this.maxMessageSize = (init.maxMessageSize ?? MAX_MESSAGE_SIZE) - PROTOBUF_OVERHEAD
+    this.receiveFinAck = pDefer()
+    this.finAckTimeout = init.closeTimeout ?? FIN_ACK_TIMEOUT
+    this.openTimeout = init.openTimeout ?? OPEN_TIMEOUT
+    this.closeController = new AbortController()
+
+    // set up initial state
+    switch (this.channel.readyState) {
+      case 'open':
+        this.timeline.open = new Date().getTime()
+        break
+
+      case 'closed':
+      case 'closing':
+        if (this.timeline.close === undefined || this.timeline.close === 0) {
+          this.timeline.close = Date.now()
+        }
+        break
+      case 'connecting':
+        // noop
+        break
+
+      default:
+        this.log.error('unknown datachannel state %s', this.channel.readyState)
+        throw new StreamStateError('Unknown datachannel state')
+    }
 
     // handle RTCDataChannel events
-    this.channel.onclose = () => {
-      this.log.trace('received datachannel close event')
+    this.channel.onopen = (_evt) => {
+      this.timeline.open = new Date().getTime()
+    }
+
+    this.channel.onclose = (_evt) => {
+      this.log.trace('received onclose event')
 
-      this.onRemoteCloseWrite()
-      this.onTransportClosed()
+      // stop any in-progress writes
+      this.closeController.abort()
+
+      // 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)
+      })
     }
 
     this.channel.onerror = (evt) => {
-      const err = (evt as RTCErrorEvent).error
+      this.log.trace('received onerror event')
 
-      this.log.trace('received datachannel error event - %e', err)
+      // stop any in-progress writes
+      this.closeController.abort()
 
+      const err = (evt as RTCErrorEvent).error
       this.abort(err)
     }
 
     this.channel.onmessage = async (event: MessageEvent<ArrayBuffer>) => {
-      this.log('incoming message %d bytes', event.data.byteLength)
       const { data } = event
 
       if (data === null || data.byteLength === 0) {
@@ -79,186 +166,187 @@ export class WebRTCStream extends AbstractStream {
       this.incomingData.push(new Uint8Array(data, 0, data.byteLength))
     }
 
-    // dispatch drain event when the buffered amount drops to zero
-    this.channel.bufferedAmountLowThreshold = 0
-
-    this.channel.onbufferedamountlow = () => {
-      if (this.writableNeedsDrain) {
-        this.safeDispatchEvent('drain')
-      }
-    }
-
-    if (this.channel.readyState !== 'open') {
-      this.log('channel ready state is "%s" and not "open", waiting for "open" event before sending data', this.channel.readyState)
-      pEvent(this.channel, 'open', {
-        rejectionEvents: [
-          'close',
-          'error'
-        ]
-      })
-        .then(() => {
-          this.log('channel ready state is now "%s", dispatching drain', this.channel.readyState)
-          this.safeDispatchEvent('drain')
-        })
-        .catch(err => {
-          this.abort(err.error ?? err)
-        })
-    }
+    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)) {
-        this.processIncomingProtobuf(buf)
+        const message = self.processIncomingProtobuf(buf)
+
+        if (message != null) {
+          self.sourcePush(new Uint8ArrayList(message))
+        }
       }
     })
       .catch(err => {
         this.log.error('error processing incoming data channel messages', err)
       })
-
-    // close when both writable ends are closed or an error occurs
-    const cleanUpDatachannelOnClose = (): void => {
-      if (this.channel.readyState === 'open') {
-        this.log.trace('stream closed, closing underlying datachannel')
-        this.channel.close()
-      }
-    }
-    this.addEventListener('close', cleanUpDatachannelOnClose)
   }
 
   sendNewStream (): void {
     // opening new streams is handled by WebRTC so this is a noop
   }
 
-  _sendMessage (data: Uint8ArrayList): void {
-    if (this.channel.readyState !== 'open') {
+  async _sendMessage (data: Uint8ArrayList, checkBuffer: boolean = true): Promise<void> {
+    if (this.channel.readyState === 'closed' || this.channel.readyState === 'closing') {
       throw new StreamStateError(`Invalid datachannel state - ${this.channel.readyState}`)
     }
 
-    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
-    }
+    if (this.channel.readyState !== 'open') {
+      const timeout = AbortSignal.timeout(this.openTimeout)
+      const signal = anySignal([
+        this.closeController.signal,
+        timeout
+      ])
+
+      try {
+        this.log('channel state is "%s" and not "open", waiting for "open" event before sending data', this.channel.readyState)
+        await raceEvent(this.channel, 'open', signal)
+      } finally {
+        signal.clear()
+      }
 
-    // send message without copying data
-    for (const buf of data) {
-      this.channel.send(buf)
+      this.log('channel state is now "%s", sending data', this.channel.readyState)
     }
-  }
 
-  sendData (data: Uint8ArrayList): SendResult {
-    if (this.channel.readyState !== 'open') {
-      return {
-        sentBytes: 0,
-        canSendMore: false
+    if (checkBuffer && this.channel.bufferedAmount > this.maxBufferedAmount) {
+      const timeout = AbortSignal.timeout(this.bufferedAmountLowEventTimeout)
+      const signal = anySignal([
+        this.closeController.signal,
+        timeout
+      ])
+
+      try {
+        this.log('channel buffer is %d, wait for "bufferedamountlow" event', this.channel.bufferedAmount)
+        await raceEvent(this.channel, 'bufferedamountlow', signal)
+      } catch (err: any) {
+        if (timeout.aborted) {
+          throw new TimeoutError(`Timed out waiting for DataChannel buffer to clear after ${this.bufferedAmountLowEventTimeout}ms`)
+        }
+
+        throw err
+      } finally {
+        signal.clear()
       }
     }
 
-    // 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 is also necessary to work with rust-libp2p 0.54 though 0.53 seems ok
-    this._sendMessage(
-      lengthPrefixed.encode.single(Message.encode({
-        message: data.subarray()
-      }))
-    )
-
-    /*
-    // TODO: enable this when FF and rust-libp2p are not broken
-    // send message without copying data
-      for (const message of data) {
-        this._sendMessage(
-          lengthPrefixed.encode.single(Message.encode({
-            message
-          }))
-        )
-      }
+    try {
+      this.log.trace('sending message, channel state "%s"', this.channel.readyState)
+      // send message without copying data
+      this.channel.send(data.subarray())
+    } catch (err: any) {
+      this.log.error('error while sending message', err)
     }
-    */
+  }
 
-    return {
-      sentBytes: data.byteLength,
-      canSendMore: this.channel.bufferedAmount < this.maxBufferedAmount
+  async sendData (data: Uint8ArrayList): Promise<void> {
+    const bytesTotal = data.byteLength
+    // 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.maxMessageSize)
+      const buf = data.subarray(0, toSend)
+      const messageBuf = Message.encode({ message: buf })
+      const sendBuf = lengthPrefixed.encode.single(messageBuf)
+      this.log.trace('sending %d/%d bytes on channel', buf.byteLength, bytesTotal)
+      await this._sendMessage(sendBuf)
+
+      data.consume(toSend)
     }
+
+    this.log.trace('finished sending data, channel state "%s"', this.channel.readyState)
   }
 
-  sendReset (err: Error): void {
+  async sendReset (): Promise<void> {
     try {
-      this.log.error('sending reset - %e', err)
-      this._sendFlag(Message.Flag.RESET)
-      this.receivedFinAck?.reject(err)
+      await this._sendFlag(Message.Flag.RESET)
     } catch (err) {
       this.log.error('failed to send reset - %e', err)
+    } finally {
+      this.channel.close()
     }
   }
 
-  async sendCloseWrite (options?: AbortOptions): Promise<void> {
-    this._sendFlag(Message.Flag.FIN)
-    options?.signal?.throwIfAborted()
-    this.receivedFinAck = Promise.withResolvers<void>()
-
-    await Promise.any([
-      raceSignal(this.receivedFinAck.promise, options?.signal),
-      new Promise<void>(resolve => {
-        AbortSignal.timeout(this.finAckTimeout)
-          .addEventListener('abort', () => {
-            resolve()
-          })
-      })
-    ])
+  async sendCloseWrite (options: AbortOptions): Promise<void> {
+    if (this.channel.readyState !== 'open') {
+      this.receiveFinAck.resolve()
+      return
+    }
+
+    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',
+          errorName: 'FinAckNotReceivedError'
+        })
+      } 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 (options?: AbortOptions): Promise<void> {
-    this._sendFlag(Message.Flag.STOP_SENDING)
-    options?.signal?.throwIfAborted()
+  async sendCloseRead (): Promise<void> {
+    if (this.channel.readyState !== 'open') {
+      return
+    }
+
+    await this._sendFlag(Message.Flag.STOP_SENDING)
   }
 
   /**
    * Handle incoming
    */
-  private processIncomingProtobuf (buffer: Uint8ArrayList): void {
+  private processIncomingProtobuf (buffer: Uint8ArrayList): Uint8Array | undefined {
     const message = Message.decode(buffer)
 
-    // ignore data messages if we've closed the readable end already
-    if (message.message != null && (this.readStatus === 'readable' || this.readStatus === 'paused')) {
-      this.onData(new Uint8ArrayList(message.message))
-    }
-
     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._sendFlag(Message.Flag.FIN_ACK)
-        this.onRemoteCloseWrite()
+        // We should expect no more data from the remote, stop reading
+        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) {
-        // stop reading and writing to the stream immediately
-        this.receivedFinAck?.reject(new StreamResetError('The stream was reset'))
-        this.onRemoteReset()
+        // Stop reading and writing to the stream immediately
+        this.reset()
       }
 
       if (message.flag === Message.Flag.STOP_SENDING) {
-        // the remote has stopped reading
-        this.onRemoteCloseRead()
+        // The remote has stopped reading
+        this.remoteCloseRead()
       }
 
       if (message.flag === Message.Flag.FIN_ACK) {
-        // remote received our FIN
-        this.receivedFinAck?.resolve()
+        this.log.trace('received FIN_ACK')
+        this.receiveFinAck.resolve()
       }
     }
+
+    // ignore data messages if we've closed the readable end already
+    if (this.readStatus === 'ready') {
+      return message.message
+    }
   }
 
-  private _sendFlag (flag: Message.Flag): boolean {
+  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
@@ -272,7 +360,7 @@ export class WebRTCStream extends AbstractStream {
     const prefixedBuf = lengthPrefixed.encode.single(messageBuf)
 
     try {
-      this._sendMessage(prefixedBuf)
+      await this._sendMessage(prefixedBuf, false)
 
       return true
     } catch (err: any) {
@@ -281,14 +369,6 @@ export class WebRTCStream extends AbstractStream {
 
     return false
   }
-
-  sendPause (): void {
-    // TODO: read backpressure?
-  }
-
-  sendResume (): void {
-    // TODO: read backpressure?
-  }
 }
 
 export interface WebRTCStreamOptions extends DataChannelOptions {
@@ -303,7 +383,12 @@ export interface WebRTCStreamOptions extends DataChannelOptions {
   /**
    * The stream direction
    */
-  direction: MessageStreamDirection
+  direction: Direction
+
+  /**
+   * A callback invoked when the channel ends
+   */
+  onEnd?(err?: Error | undefined): void
 
   /**
    * The logger to create a scope from
@@ -314,16 +399,15 @@ export interface WebRTCStreamOptions extends DataChannelOptions {
    * If true the underlying datachannel is being used to perform the noise
    * handshake during connection establishment
    */
-  isHandshake?: boolean
+  handshake?: boolean
 }
 
 export function createStream (options: WebRTCStreamOptions): WebRTCStream {
-  const { channel, direction, isHandshake } = options
+  const { channel, direction, handshake } = options
 
   return new WebRTCStream({
     ...options,
     id: `${channel.id}`,
-    log: options.log.newScope(`${isHandshake === true ? 'handshake' : direction}:${channel.id}`),
-    protocol: ''
+    log: options.log.newScope(`${handshake === true ? 'handshake' : direction}:${channel.id}`)
   })
 }