@libp2p/webrtc 1.2.0 → 2.0.1

package/src/{peer_transport → private-to-private}/handler.ts

@@ -3,7 +3,7 @@ import { abortableDuplex } from 'abortable-iterator'
 import { pbStream } from 'it-pb-stream'
 import pDefer, { type DeferredPromise } from 'p-defer'
 import { DataChannelMuxerFactory } from '../muxer.js'
-import * as pb from './pb/index.js'
+import { Message } from './pb/message.js'
 import { readCandidatesUntilConnected, resolveOnConnected } from './util.js'
 import type { Stream } from '@libp2p/interface-connection'
 import type { IncomingStreamData } from '@libp2p/interface-registrar'
@@ -15,9 +15,9 @@ const log = logger('libp2p:webrtc:peer')
 
 export type IncomingStreamOpts = { rtcConfiguration?: RTCConfiguration } & IncomingStreamData
 
-export async function handleIncomingStream ({ rtcConfiguration, stream: rawStream }: IncomingStreamOpts): Promise<[RTCPeerConnection, StreamMuxerFactory]> {
+export async function handleIncomingStream ({ rtcConfiguration, stream: rawStream }: IncomingStreamOpts): Promise<{ pc: RTCPeerConnection, muxerFactory: StreamMuxerFactory, remoteAddress: string }> {
   const signal = AbortSignal.timeout(DEFAULT_TIMEOUT)
-  const stream = pbStream(abortableDuplex(rawStream, signal)).pb(pb.Message)
+  const stream = pbStream(abortableDuplex(rawStream, signal)).pb(Message)
   const pc = new RTCPeerConnection(rtcConfiguration)
   const muxerFactory = new DataChannelMuxerFactory(pc)
 
@@ -30,7 +30,7 @@ export async function handleIncomingStream ({ rtcConfiguration, stream: rawStrea
     answerSentPromise.promise.then(
       () => {
         stream.write({
-          type: pb.Message.Type.ICE_CANDIDATE,
+          type: Message.Type.ICE_CANDIDATE,
           data: (candidate != null) ? JSON.stringify(candidate.toJSON()) : ''
         })
       },
@@ -44,7 +44,7 @@ export async function handleIncomingStream ({ rtcConfiguration, stream: rawStrea
 
   // read an SDP offer
   const pbOffer = await stream.read()
-  if (pbOffer.type !== pb.Message.Type.SDP_OFFER) {
+  if (pbOffer.type !== Message.Type.SDP_OFFER) {
     throw new Error(`expected message type SDP_OFFER, received: ${pbOffer.type ?? 'undefined'} `)
   }
   const offer = new RTCSessionDescription({
@@ -64,7 +64,7 @@ export async function handleIncomingStream ({ rtcConfiguration, stream: rawStrea
     throw new Error('Failed to create answer')
   })
   // write the answer to the remote
-  stream.write({ type: pb.Message.Type.SDP_ANSWER, data: answer.sdp })
+  stream.write({ type: Message.Type.SDP_ANSWER, data: answer.sdp })
 
   await pc.setLocalDescription(answer).catch(err => {
     log.error('could not execute setLocalDescription', err)
@@ -76,7 +76,10 @@ export async function handleIncomingStream ({ rtcConfiguration, stream: rawStrea
 
   // wait until candidates are connected
   await readCandidatesUntilConnected(connectedPromise, pc, stream)
-  return [pc, muxerFactory]
+
+  const remoteAddress = parseRemoteAddress(pc.currentRemoteDescription?.sdp ?? '')
+
+  return { pc, muxerFactory, remoteAddress }
 }
 
 export interface ConnectOptions {
@@ -85,9 +88,8 @@ export interface ConnectOptions {
   rtcConfiguration?: RTCConfiguration
 }
 
-export async function initiateConnection ({ rtcConfiguration, signal, stream: rawStream }: ConnectOptions): Promise<[RTCPeerConnection, StreamMuxerFactory]> {
-  const stream = pbStream(abortableDuplex(rawStream, signal)).pb(pb.Message)
-
+export async function initiateConnection ({ rtcConfiguration, signal, stream: rawStream }: ConnectOptions): Promise<{ pc: RTCPeerConnection, muxerFactory: StreamMuxerFactory, remoteAddress: string }> {
+  const stream = pbStream(abortableDuplex(rawStream, signal)).pb(Message)
   // setup peer connection
   const pc = new RTCPeerConnection(rtcConfiguration)
   const muxerFactory = new DataChannelMuxerFactory(pc)
@@ -105,14 +107,14 @@ export async function initiateConnection ({ rtcConfiguration, signal, stream: ra
   // peer
   pc.onicecandidate = ({ candidate }) => {
     stream.write({
-      type: pb.Message.Type.ICE_CANDIDATE,
+      type: Message.Type.ICE_CANDIDATE,
       data: (candidate != null) ? JSON.stringify(candidate.toJSON()) : ''
     })
   }
   // create an offer
   const offerSdp = await pc.createOffer()
   // write the offer to the stream
-  stream.write({ type: pb.Message.Type.SDP_OFFER, data: offerSdp.sdp })
+  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)
@@ -121,7 +123,7 @@ export async function initiateConnection ({ rtcConfiguration, signal, stream: ra
 
   // read answer
   const answerMessage = await stream.read()
-  if (answerMessage.type !== pb.Message.Type.SDP_ANSWER) {
+  if (answerMessage.type !== Message.Type.SDP_ANSWER) {
     throw new Error('remote should send an SDP answer')
   }
 
@@ -133,5 +135,21 @@ export async function initiateConnection ({ rtcConfiguration, signal, stream: ra
 
   await readCandidatesUntilConnected(connectedPromise, pc, stream)
   channel.close()
-  return [pc, muxerFactory]
+
+  const remoteAddress = parseRemoteAddress(pc.currentRemoteDescription?.sdp ?? '')
+
+  return { pc, muxerFactory, remoteAddress }
+}
+
+function parseRemoteAddress (sdp: string): string {
+  // 'a=candidate:1746876089 1 udp 2113937151 0614fbad-b...ocal 54882 typ host generation 0 network-cost 999'
+  const candidateLine = sdp.split('\r\n').filter(line => line.startsWith('a=candidate')).pop()
+  const candidateParts = candidateLine?.split(' ')
+
+  if (candidateLine == null || candidateParts == null || candidateParts.length < 5) {
+    log('could not parse remote address from', candidateLine)
+    return '/webrtc'
+  }
+
+  return `/dnsaddr/${candidateParts[4]}/${candidateParts[2]}/${candidateParts[3]}/webrtc`
 }

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

@@ -0,0 +1,55 @@
+import { EventEmitter } from '@libp2p/interfaces/events'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { ListenerEvents, Listener } from '@libp2p/interface-transport'
+import type { Multiaddr } from '@multiformats/multiaddr'
+
+export interface ListenerOptions {
+  peerId: PeerId
+  events: EventEmitter<Libp2pEvents>
+}
+
+export class WebRTCPeerListener extends EventEmitter<ListenerEvents> implements Listener {
+  private readonly peerId: PeerId
+  private listeners: Listener[] = []
+
+  constructor (opts: ListenerOptions) {
+    super()
+
+    this.peerId = opts.peerId
+
+    opts.events.addEventListener('transport:listening', (event) => {
+      const listener = event.detail
+
+      if (listener === this || this.listeners.includes(listener)) {
+        return
+      }
+
+      this.listeners.push(listener)
+    })
+
+    opts.events.addEventListener('transport:close', (event) => {
+      const listener = event.detail
+
+      this.listeners = this.listeners.filter(l => l !== listener)
+    })
+  }
+
+  async listen (ma: Multiaddr): Promise<void> {
+    this.safeDispatchEvent('listening', {})
+  }
+
+  getAddrs (): Multiaddr[] {
+    return this.listeners
+      .map(l => l.getAddrs()
+        .map(ma => {
+          return ma.encapsulate(`/webrtc/p2p/${this.peerId}`)
+        })
+      )
+      .flat()
+  }
+
+  async close (): Promise<void> {
+    this.safeDispatchEvent('close', {})
+  }
+}

package/src/{peer_transport/pb/index.ts → private-to-private/pb/message.ts}

@@ -82,7 +82,7 @@ export namespace Message {
     return _codec
   }
 
-  export const encode = (obj: Message): Uint8Array => {
+  export const encode = (obj: Partial<Message>): Uint8Array => {
     return encodeMessage(obj, Message.codec())
   }
 

package/src/{peer_transport → private-to-private}/transport.ts

@@ -1,4 +1,4 @@
-import { type CreateListenerOptions, type DialOptions, type Listener, symbol, type Transport, type TransportManager, type Upgrader } from '@libp2p/interface-transport'
+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 { logger } from '@libp2p/logger'
 import { peerIdFromString } from '@libp2p/peer-id'
@@ -8,16 +8,18 @@ import { WebRTCMultiaddrConnection } from '../maconn.js'
 import { initiateConnection, handleIncomingStream } from './handler.js'
 import { WebRTCPeerListener } from './listener.js'
 import type { Connection } from '@libp2p/interface-connection'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerStore } from '@libp2p/interface-peer-store'
 import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
+import type { EventEmitter } from '@libp2p/interfaces/events'
 import type { Startable } from '@libp2p/interfaces/startable'
 
 const log = logger('libp2p:webrtc:peer')
 
-export const TRANSPORT = '/webrtc'
-export const SIGNALING_PROTO_ID = '/webrtc-signaling/0.0.1'
-export const CODE = protocols('webrtc').code
+const WEBRTC_TRANSPORT = '/webrtc'
+const CIRCUIT_RELAY_TRANSPORT = '/p2p-circuit'
+const SIGNALING_PROTO_ID = '/webrtc-signaling/0.0.1'
+const WEBRTC_CODE = protocols('webrtc').code
 
 export interface WebRTCTransportInit {
   rtcConfiguration?: RTCConfiguration
@@ -28,7 +30,7 @@ export interface WebRTCTransportComponents {
   registrar: Registrar
   upgrader: Upgrader
   transportManager: TransportManager
-  peerStore: PeerStore
+  events: EventEmitter<Libp2pEvents>
 }
 
 export class WebRTCTransport implements Transport, Startable {
@@ -67,22 +69,27 @@ export class WebRTCTransport implements Transport, Startable {
   filter (multiaddrs: Multiaddr[]): Multiaddr[] {
     return multiaddrs.filter((ma) => {
       const codes = ma.protoCodes()
-      return codes.includes(CODE)
+      return codes.includes(WEBRTC_CODE)
     })
   }
 
   private splitAddr (ma: Multiaddr): { baseAddr: Multiaddr, peerId: PeerId } {
-    const addrs = ma.toString().split(`${TRANSPORT}/`)
+    const addrs = ma.toString().split(WEBRTC_TRANSPORT)
     if (addrs.length !== 2) {
-      throw new CodeError('invalid multiaddr', codes.ERR_INVALID_MULTIADDR)
+      throw new CodeError('webrtc protocol was not present in multiaddr', codes.ERR_INVALID_MULTIADDR)
+    }
+
+    if (!addrs[0].includes(CIRCUIT_RELAY_TRANSPORT)) {
+      throw new CodeError('p2p-circuit protocol was not present in multiaddr', codes.ERR_INVALID_MULTIADDR)
     }
+
     // look for remote peerId
     let remoteAddr = multiaddr(addrs[0])
-    const destination = multiaddr('/' + addrs[1])
+    const destination = multiaddr(addrs[1])
 
     const destinationIdString = destination.getPeerId()
     if (destinationIdString == null) {
-      throw new CodeError('bad destination', codes.ERR_INVALID_MULTIADDR)
+      throw new CodeError('destination peer id was missing', codes.ERR_INVALID_MULTIADDR)
     }
 
     const lastProtoInRemote = remoteAddr.protos().pop()
@@ -112,22 +119,21 @@ export class WebRTCTransport implements Transport, Startable {
       options.signal = controller.signal
     }
 
-    const connection = await this.components.transportManager.dial(baseAddr)
-
-    const rawStream = await connection.newStream([SIGNALING_PROTO_ID], options)
+    const connection = await this.components.transportManager.dial(baseAddr, options)
+    const signalingStream = await connection.newStream([SIGNALING_PROTO_ID], options)
 
     try {
-      const [pc, muxerFactory] = await initiateConnection({
-        stream: rawStream,
+      const { pc, muxerFactory, remoteAddress } = await initiateConnection({
+        stream: signalingStream,
         rtcConfiguration: this.init.rtcConfiguration,
         signal: options.signal
       })
-      const webrtcMultiaddr = baseAddr.encapsulate(`${TRANSPORT}/p2p/${peerId.toString()}`)
+
       const result = await options.upgrader.upgradeOutbound(
         new WebRTCMultiaddrConnection({
           peerConnection: pc,
           timeline: { open: Date.now() },
-          remoteAddr: webrtcMultiaddr
+          remoteAddr: multiaddr(remoteAddress).encapsulate(`/p2p/${peerId.toString()}`)
         }),
         {
           skipProtection: true,
@@ -137,28 +143,27 @@ export class WebRTCTransport implements Transport, Startable {
       )
 
       // close the stream if SDP has been exchanged successfully
-      rawStream.close()
+      signalingStream.close()
       return result
     } catch (err) {
       // reset the stream in case of any error
-      rawStream.reset()
+      signalingStream.reset()
       throw err
     }
   }
 
   async _onProtocol ({ connection, stream }: IncomingStreamData): Promise<void> {
     try {
-      const [pc, muxerFactory] = await handleIncomingStream({
+      const { pc, muxerFactory, remoteAddress } = await handleIncomingStream({
         rtcConfiguration: this.init.rtcConfiguration,
         connection,
         stream
       })
-      const remotePeerId = connection.remoteAddr.getPeerId()
-      const webrtcMultiaddr = connection.remoteAddr.encapsulate(`${TRANSPORT}/p2p/${remotePeerId}`)
+
       await this.components.upgrader.upgradeInbound(new WebRTCMultiaddrConnection({
         peerConnection: pc,
         timeline: { open: (new Date()).getTime() },
-        remoteAddr: webrtcMultiaddr
+        remoteAddr: multiaddr(remoteAddress).encapsulate(`/p2p/${connection.remotePeer.toString()}`)
       }), {
         skipEncryption: true,
         skipProtection: true,

package/src/{peer_transport → private-to-private}/util.ts

@@ -1,14 +1,11 @@
 import { logger } from '@libp2p/logger'
-import { detect } from 'detect-browser'
-import * as pb from './pb/index.js'
+import { isFirefox } from '../util.js'
+import { Message } from './pb/message.js'
 import type { DeferredPromise } from 'p-defer'
 
-const browser = detect()
-export const isFirefox = ((browser != null) && browser.name === 'firefox')
-
 interface MessageStream {
-  read: () => Promise<pb.Message>
-  write: (d: pb.Message) => void | Promise<void>
+  read: () => Promise<Message>
+  write: (d: Message) => void | Promise<void>
 }
 
 const log = logger('libp2p:webrtc:peer:util')
@@ -19,7 +16,7 @@ export const readCandidatesUntilConnected = async (connectedPromise: DeferredPro
     // check if readResult is a message
     if (readResult instanceof Object) {
       const message = readResult
-      if (message.type !== pb.Message.Type.ICE_CANDIDATE) {
+      if (message.type !== Message.Type.ICE_CANDIDATE) {
         throw new Error('expected only ice candidates')
       }
       // end of candidates has been signalled
@@ -53,7 +50,7 @@ export function resolveOnConnected (pc: RTCPeerConnection, promise: DeferredProm
       case 'failed':
       case 'disconnected':
       case 'closed':
-        promise.reject()
+        promise.reject(new Error('RTCPeerConnection was closed'))
         break
       default:
         break

package/src/{sdp.ts → private-to-public/sdp.ts}

@@ -1,7 +1,7 @@
 import { logger } from '@libp2p/logger'
 import { bases } from 'multiformats/basics'
 import * as multihashes from 'multihashes'
-import { inappropriateMultiaddr, invalidArgument, invalidFingerprint, unsupportedHashAlgorithm } from './error.js'
+import { inappropriateMultiaddr, invalidArgument, invalidFingerprint, unsupportedHashAlgorithm } from '../error.js'
 import { CERTHASH_CODE } from './transport.js'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { HashCode, HashName } from 'multihashes'

package/src/{transport.ts → private-to-public/transport.ts}

@@ -6,12 +6,12 @@ import { protocols } from '@multiformats/multiaddr'
 import * as multihashes from 'multihashes'
 import { concat } from 'uint8arrays/concat'
 import { fromString as uint8arrayFromString } from 'uint8arrays/from-string'
-import { dataChannelError, inappropriateMultiaddr, unimplemented, invalidArgument } from './error.js'
-import { WebRTCMultiaddrConnection } from './maconn.js'
-import { DataChannelMuxerFactory } from './muxer.js'
-import { isFirefox } from './peer_transport/util.js'
+import { dataChannelError, inappropriateMultiaddr, unimplemented, invalidArgument } from '../error.js'
+import { WebRTCMultiaddrConnection } from '../maconn.js'
+import { DataChannelMuxerFactory } from '../muxer.js'
+import { WebRTCStream } from '../stream.js'
+import { isFirefox } from '../util.js'
 import * as sdp from './sdp.js'
-import { WebRTCStream } from './stream.js'
 import { genUfrag } from './util.js'
 import type { WebRTCDialOptions } from './options.js'
 import type { Connection } from '@libp2p/interface-connection'
@@ -189,15 +189,13 @@ export class WebRTCDirectTransport implements Transport {
     const wrappedDuplex = {
       ...wrappedChannel,
       sink: wrappedChannel.sink.bind(wrappedChannel),
-      source: {
-        [Symbol.asyncIterator]: async function * () {
-          for await (const list of wrappedChannel.source) {
-            for (const buf of list) {
-              yield buf
-            }
+      source: (async function * () {
+        for await (const list of wrappedChannel.source) {
+          for (const buf of list) {
+            yield buf
           }
         }
-      }
+      }())
     }
 
     // Creating the connection before completion of the noise

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

@@ -0,0 +1,3 @@
+
+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

@@ -5,7 +5,7 @@ import { pipe } from 'it-pipe'
 import { pushable } from 'it-pushable'
 import defer, { type DeferredPromise } from 'p-defer'
 import { Uint8ArrayList } from 'uint8arraylist'
-import * as pb from '../proto_ts/message.js'
+import { Message } from './pb/message.js'
 import type { Stream, StreamStat, Direction } from '@libp2p/interface-connection'
 import type { Source } from 'it-stream-types'
 
@@ -66,7 +66,7 @@ interface StreamStateInput {
    * 1 = STOP_SENDING
    * 2 = RESET
    */
-  flag: pb.Message_Flag
+  flag: Message.Flag
 }
 
 export enum StreamStates {
@@ -99,7 +99,7 @@ class StreamState {
 
     if (direction === 'inbound') {
       switch (flag) {
-        case pb.Message_Flag.FIN:
+        case Message.Flag.FIN:
           if (this.state === StreamStates.OPEN) {
             this.state = StreamStates.READ_CLOSED
           } else if (this.state === StreamStates.WRITE_CLOSED) {
@@ -107,7 +107,7 @@ class StreamState {
           }
           break
 
-        case pb.Message_Flag.STOP_SENDING:
+        case Message.Flag.STOP_SENDING:
           if (this.state === StreamStates.OPEN) {
             this.state = StreamStates.WRITE_CLOSED
           } else if (this.state === StreamStates.READ_CLOSED) {
@@ -115,7 +115,7 @@ class StreamState {
           }
           break
 
-        case pb.Message_Flag.RESET:
+        case Message.Flag.RESET:
           this.state = StreamStates.CLOSED
           break
         default:
@@ -123,7 +123,7 @@ class StreamState {
       }
     } else {
       switch (flag) {
-        case pb.Message_Flag.FIN:
+        case Message.Flag.FIN:
           if (this.state === StreamStates.OPEN) {
             this.state = StreamStates.WRITE_CLOSED
           } else if (this.state === StreamStates.READ_CLOSED) {
@@ -131,7 +131,7 @@ class StreamState {
           }
           break
 
-        case pb.Message_Flag.STOP_SENDING:
+        case Message.Flag.STOP_SENDING:
           if (this.state === StreamStates.OPEN) {
             this.state = StreamStates.READ_CLOSED
           } else if (this.state === StreamStates.WRITE_CLOSED) {
@@ -139,7 +139,7 @@ class StreamState {
           }
           break
 
-        case pb.Message_Flag.RESET:
+        case Message.Flag.RESET:
           this.state = StreamStates.CLOSED
           break
 
@@ -268,7 +268,7 @@ export class WebRTCStream implements Stream {
     // surface data from the `Message.message` field through a source.
     this._src = pipe(
       this._innersrc,
-      lengthPrefixed.decode(),
+      (source) => lengthPrefixed.decode(source),
       (source) => (async function * () {
         for await (const buf of source) {
           const message = self.processIncomingProtobuf(buf.subarray())
@@ -313,7 +313,7 @@ export class WebRTCStream implements Stream {
       if (this.streamState.isWriteClosed()) {
         return
       }
-      const msgbuf = pb.Message.toBinary({ message: buf.subarray() })
+      const msgbuf = Message.encode({ message: buf.subarray() })
       const sendbuf = lengthPrefixed.encode.single(msgbuf)
 
       this.channel.send(sendbuf.subarray())
@@ -324,7 +324,7 @@ export class WebRTCStream implements Stream {
    * Handle incoming
    */
   processIncomingProtobuf (buffer: Uint8Array): Uint8Array | undefined {
-    const message = pb.Message.fromBinary(buffer)
+    const message = Message.decode(buffer)
 
     if (message.flag !== undefined) {
       const [currentState, nextState] = this.streamState.transition({ direction: 'inbound', flag: message.flag })
@@ -371,14 +371,14 @@ export class WebRTCStream implements Stream {
    * Close a stream for reading only
    */
   closeRead (): void {
-    const [currentState, nextState] = this.streamState.transition({ direction: 'outbound', flag: pb.Message_Flag.STOP_SENDING })
+    const [currentState, nextState] = this.streamState.transition({ direction: 'outbound', flag: Message.Flag.STOP_SENDING })
     if (currentState === nextState) {
       // No change, no op
       return
     }
 
     if (currentState === StreamStates.OPEN || currentState === StreamStates.WRITE_CLOSED) {
-      this._sendFlag(pb.Message_Flag.STOP_SENDING)
+      this._sendFlag(Message.Flag.STOP_SENDING)
       this._innersrc.end()
     }
 
@@ -391,14 +391,14 @@ export class WebRTCStream implements Stream {
    * Close a stream for writing only
    */
   closeWrite (): void {
-    const [currentState, nextState] = this.streamState.transition({ direction: 'outbound', flag: pb.Message_Flag.FIN })
+    const [currentState, nextState] = this.streamState.transition({ direction: 'outbound', flag: Message.Flag.FIN })
     if (currentState === nextState) {
       // No change, no op
       return
     }
 
     if (currentState === StreamStates.OPEN || currentState === StreamStates.READ_CLOSED) {
-      this._sendFlag(pb.Message_Flag.FIN)
+      this._sendFlag(Message.Flag.FIN)
       this.closeWritePromise.resolve()
     }
 
@@ -421,20 +421,20 @@ export class WebRTCStream implements Stream {
    * @see this.closeWrite
    */
   reset (): void {
-    const [currentState, nextState] = this.streamState.transition({ direction: 'outbound', flag: pb.Message_Flag.RESET })
+    const [currentState, nextState] = this.streamState.transition({ direction: 'outbound', flag: Message.Flag.RESET })
     if (currentState === nextState) {
       // No change, no op
       return
     }
 
-    this._sendFlag(pb.Message_Flag.RESET)
+    this._sendFlag(Message.Flag.RESET)
     this.close()
   }
 
-  private _sendFlag (flag: pb.Message_Flag): void {
+  private _sendFlag (flag: Message.Flag): void {
     try {
       log.trace('Sending flag: %s', flag.toString())
-      const msgbuf = pb.Message.toBinary({ flag })
+      const msgbuf = Message.encode({ flag })
       this.channel.send(lengthPrefixed.encode.single(msgbuf).subarray())
     } catch (err) {
       if (err instanceof Error) {

package/src/util.ts

@@ -1,6 +1,8 @@
+import { detect } from 'detect-browser'
+
+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> => {}
-
-const charset = Array.from('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/')
-export const genUfrag = (len: number): string => [...Array(len)].map(() => charset.at(Math.floor(Math.random() * charset.length))).join('')

package/dist/proto_ts/message.d.ts

@@ -1,56 +0,0 @@
-import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
-import type { IBinaryWriter } from "@protobuf-ts/runtime";
-import type { BinaryReadOptions } from "@protobuf-ts/runtime";
-import type { IBinaryReader } from "@protobuf-ts/runtime";
-import type { PartialMessage } from "@protobuf-ts/runtime";
-import { MessageType } from "@protobuf-ts/runtime";
-/**
- * @generated from protobuf message webrtc.pb.Message
- */
-export interface Message {
-    /**
-     * @generated from protobuf field: optional webrtc.pb.Message.Flag flag = 1;
-     */
-    flag?: Message_Flag;
-    /**
-     * @generated from protobuf field: optional bytes message = 2;
-     */
-    message?: Uint8Array;
-}
-/**
- * @generated from protobuf enum webrtc.pb.Message.Flag
- */
-export declare enum Message_Flag {
-    /**
-     * The sender will no longer send messages on the stream.
-     *
-     * @generated from protobuf enum value: FIN = 0;
-     */
-    FIN = 0,
-    /**
-     * The sender will no longer read messages on the stream. Incoming data is
-     * being discarded on receipt.
-     *
-     * @generated from protobuf enum value: STOP_SENDING = 1;
-     */
-    STOP_SENDING = 1,
-    /**
-     * The sender abruptly terminates the sending part of the stream. The
-     * receiver can discard any data that it already received on that stream.
-     *
-     * @generated from protobuf enum value: RESET = 2;
-     */
-    RESET = 2
-}
-declare class Message$Type extends MessageType<Message> {
-    constructor();
-    create(value?: PartialMessage<Message>): Message;
-    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Message): Message;
-    internalBinaryWrite(message: Message, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
-}
-/**
- * @generated MessageType for protobuf message webrtc.pb.Message
- */
-export declare const Message: Message$Type;
-export {};
-//# sourceMappingURL=message.d.ts.map

package/dist/proto_ts/message.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../../proto_ts/message.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAG3D,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD;;GAEG;AACH,MAAM,WAAW,OAAO;IACpB;;OAEG;IACH,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB;;OAEG;IACH,OAAO,CAAC,EAAE,UAAU,CAAC;CACxB;AACD;;GAEG;AACH,oBAAY,YAAY;IACpB;;;;OAIG;IACH,GAAG,IAAI;IACP;;;;;OAKG;IACH,YAAY,IAAI;IAChB;;;;;OAKG;IACH,KAAK,IAAI;CACZ;AAED,cAAM,YAAa,SAAQ,WAAW,CAAC,OAAO,CAAC;;IAO3C,MAAM,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC,OAAO,CAAC,GAAG,OAAO;IAOhD,kBAAkB,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO;IAsBhH,mBAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,kBAAkB,GAAG,aAAa;CAY3G;AACD;;GAEG;AACH,eAAO,MAAM,OAAO,cAAqB,CAAC"}