@libp2p/webrtc 1.0.5 → 1.1.0

package/src/peer_transport/handler.ts

@@ -0,0 +1,139 @@
+import type { IncomingStreamData } from '@libp2p/interface-registrar'
+import { pbStream } from 'it-pb-stream'
+import pDefer, { type DeferredPromise } from 'p-defer'
+import { TimeoutController } from 'timeout-abort-controller'
+import { readCandidatesUntilConnected, resolveOnConnected } from './util.js'
+import * as pb from './pb/index.js'
+import { abortableDuplex } from 'abortable-iterator'
+import { logger } from '@libp2p/logger'
+import type { Stream } from '@libp2p/interface-connection'
+import type { StreamMuxerFactory } from '@libp2p/interface-stream-muxer'
+import { DataChannelMuxerFactory } from '../muxer.js'
+
+const DEFAULT_TIMEOUT = 30 * 1000
+
+const log = logger('libp2p:webrtc:peer')
+
+export type IncomingStreamOpts = { rtcConfiguration?: RTCConfiguration } & IncomingStreamData
+
+export async function handleIncomingStream ({ rtcConfiguration, stream: rawStream }: IncomingStreamOpts): Promise<[RTCPeerConnection, StreamMuxerFactory]> {
+  const timeoutController = new TimeoutController(DEFAULT_TIMEOUT)
+  const signal = timeoutController.signal
+  const stream = pbStream(abortableDuplex(rawStream, timeoutController.signal)).pb(pb.Message)
+  const pc = new RTCPeerConnection(rtcConfiguration)
+  const muxerFactory = new DataChannelMuxerFactory(pc)
+
+  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: pb.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)
+
+  // read an SDP offer
+  const pbOffer = await stream.read()
+  if (pbOffer.type !== pb.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
+  stream.write({ type: pb.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)
+  return [pc, muxerFactory]
+}
+
+export interface ConnectOptions {
+  stream: Stream
+  signal: AbortSignal
+  rtcConfiguration?: RTCConfiguration
+}
+
+export async function initiateConnection ({ rtcConfiguration, signal, stream: rawStream }: ConnectOptions): Promise<[RTCPeerConnection, StreamMuxerFactory]> {
+  const stream = pbStream(abortableDuplex(rawStream, signal)).pb(pb.Message)
+
+  // setup peer connection
+  const pc = new RTCPeerConnection(rtcConfiguration)
+  const muxerFactory = new DataChannelMuxerFactory(pc)
+
+  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: pb.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 })
+  // 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 !== pb.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()
+  return [pc, muxerFactory]
+}

package/src/peer_transport/listener.ts

@@ -0,0 +1,44 @@
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { ListenerEvents, TransportManager, Upgrader, Listener } from '@libp2p/interface-transport'
+import { EventEmitter } from '@libp2p/interfaces/events'
+import { multiaddr, Multiaddr } from '@multiformats/multiaddr'
+import { inappropriateMultiaddr } from '../error.js'
+import { TRANSPORT } from './transport.js'
+
+export interface ListenerOptions {
+  peerId: PeerId
+  upgrader: Upgrader
+  transportManager: TransportManager
+}
+
+export class WebRTCPeerListener extends EventEmitter<ListenerEvents> implements Listener {
+  constructor (
+    private readonly opts: ListenerOptions
+  ) {
+    super()
+  }
+
+  private getBaseAddress (ma: Multiaddr): Multiaddr {
+    const addrs = ma.toString().split(TRANSPORT)
+    if (addrs.length < 2) {
+      throw inappropriateMultiaddr('base address not found')
+    }
+    return multiaddr(addrs[0])
+  }
+
+  private listeningAddrs: Multiaddr[] = []
+  async listen (ma: Multiaddr): Promise<void> {
+    const baseAddr = this.getBaseAddress(ma)
+    const tpt = this.opts.transportManager.transportForMultiaddr(baseAddr)
+    const listener = tpt?.createListener({ ...this.opts })
+    await listener?.listen(baseAddr)
+    const listeningAddr = ma.encapsulate(`/p2p/${this.opts.peerId.toString()}`)
+    this.listeningAddrs.push(listeningAddr)
+    listener?.addEventListener('close', () => {
+      this.listeningAddrs = this.listeningAddrs.filter(a => a !== listeningAddr)
+    })
+  }
+
+  getAddrs (): Multiaddr[] { return this.listeningAddrs }
+  async close (): Promise<void> { }
+}

package/src/peer_transport/pb/index.proto

@@ -0,0 +1,16 @@
+syntax = "proto3";
+
+message Message {
+    // Specifies type in `data` field.
+    enum Type {
+        // String of `RTCSessionDescription.sdp`
+        SDP_OFFER = 0;
+        // String of `RTCSessionDescription.sdp`
+        SDP_ANSWER = 1;
+        // String of `RTCIceCandidate.toJSON()`
+        ICE_CANDIDATE = 2;
+    }
+
+    optional Type type = 1;
+    optional string data = 2;
+}

package/src/peer_transport/pb/index.ts

@@ -0,0 +1,92 @@
+/* eslint-disable import/export */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+
+import { enumeration, encodeMessage, decodeMessage, message } from 'protons-runtime'
+import type { Uint8ArrayList } from 'uint8arraylist'
+import type { Codec } from 'protons-runtime'
+
+export interface Message {
+  type?: Message.Type
+  data?: string
+}
+
+export namespace Message {
+  export enum Type {
+    SDP_OFFER = 'SDP_OFFER',
+    SDP_ANSWER = 'SDP_ANSWER',
+    ICE_CANDIDATE = 'ICE_CANDIDATE'
+  }
+
+  enum __TypeValues {
+    SDP_OFFER = 0,
+    SDP_ANSWER = 1,
+    ICE_CANDIDATE = 2
+  }
+
+  export namespace Type {
+    export const codec = (): Codec<Type> => {
+      return enumeration<Type>(__TypeValues)
+    }
+  }
+
+  let _codec: Codec<Message>
+
+  export const codec = (): Codec<Message> => {
+    if (_codec == null) {
+      _codec = message<Message>((obj, w, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          w.fork()
+        }
+
+        if (obj.type != null) {
+          w.uint32(8)
+          Message.Type.codec().encode(obj.type, w)
+        }
+
+        if (obj.data != null) {
+          w.uint32(18)
+          w.string(obj.data)
+        }
+
+        if (opts.lengthDelimited !== false) {
+          w.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {}
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.type = Message.Type.codec().decode(reader)
+              break
+            case 2:
+              obj.data = reader.string()
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
+  }
+
+  export const encode = (obj: Message): Uint8Array => {
+    return encodeMessage(obj, Message.codec())
+  }
+
+  export const decode = (buf: Uint8Array | Uint8ArrayList): Message => {
+    return decodeMessage(buf, Message.codec())
+  }
+}

package/src/peer_transport/transport.ts

@@ -0,0 +1,167 @@
+import type { Connection } from '@libp2p/interface-connection'
+import { CreateListenerOptions, DialOptions, Listener, symbol, Transport } from '@libp2p/interface-transport'
+import type { TransportManager, Upgrader } from '@libp2p/interface-transport'
+import { multiaddr, Multiaddr, protocols } from '@multiformats/multiaddr'
+import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import { WebRTCMultiaddrConnection } from '../maconn.js'
+import type { Startable } from '@libp2p/interfaces/startable'
+import { WebRTCPeerListener } from './listener.js'
+import type { PeerStore } from '@libp2p/interface-peer-store'
+import { logger } from '@libp2p/logger'
+import { initiateConnection, handleIncomingStream } from './handler.js'
+import { CodeError } from '@libp2p/interfaces/errors'
+import { codes } from '../error.js'
+
+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
+
+export interface WebRTCTransportInit {
+  rtcConfiguration?: RTCConfiguration
+}
+
+export interface WebRTCTransportComponents {
+  peerId: PeerId
+  registrar: Registrar
+  upgrader: Upgrader
+  transportManager: TransportManager
+  peerStore: PeerStore
+}
+
+export class WebRTCTransport implements Transport, Startable {
+  private _started = false
+
+  constructor (
+    private readonly components: WebRTCTransportComponents,
+    private readonly init: WebRTCTransportInit
+  ) {
+  }
+
+  isStarted (): boolean {
+    return this._started
+  }
+
+  async start (): Promise<void> {
+    await this.components.registrar.handle(SIGNALING_PROTO_ID, (data) => {
+      this._onProtocol(data).catch(err => { log.error('failed to handle incoming connect from %p', data.connection.remotePeer, err) })
+    })
+    this._started = true
+  }
+
+  async stop (): Promise<void> {
+    await this.components.registrar.unhandle(SIGNALING_PROTO_ID)
+    this._started = false
+  }
+
+  createListener (options: CreateListenerOptions): Listener {
+    return new WebRTCPeerListener(this.components)
+  }
+
+  get [Symbol.toStringTag] (): string {
+    return '@libp2p/webrtc'
+  }
+
+  get [symbol] (): true {
+    return true
+  }
+
+  filter (multiaddrs: Multiaddr[]): Multiaddr[] {
+    return multiaddrs.filter((ma) => {
+      const codes = ma.protoCodes()
+      return codes.includes(CODE)
+    })
+  }
+
+  /*
+   * dial connects to a remote via the circuit relay or any other protocol
+   * and proceeds to upgrade to a webrtc connection.
+   * multiaddr of the form: <multiaddr>/webrtc/p2p/<destination-peer>
+   * For a circuit relay, this will be of the form
+   * <relay address>/p2p/<relay-peer>/p2p-circuit/webrtc/p2p/<destination-peer>
+  */
+  async dial (ma: Multiaddr, options: DialOptions): Promise<Connection> {
+    log.trace('dialing address: ', ma)
+    const addrs = ma.toString().split(`${TRANSPORT}/`)
+    if (addrs.length !== 2) {
+      throw new CodeError('invalid multiaddr', codes.ERR_INVALID_MULTIADDR)
+    }
+    // look for remote peerId
+    let remoteAddr = multiaddr(addrs[0])
+    const destination = multiaddr('/' + addrs[1])
+
+    const destinationIdString = destination.getPeerId()
+    if (destinationIdString == null) {
+      throw new CodeError('bad destination', codes.ERR_INVALID_MULTIADDR)
+    }
+
+    if (options.signal == null) {
+      const controller = new AbortController()
+      options.signal = controller.signal
+    }
+
+    const lastProtoInRemote = remoteAddr.protos().pop()
+    if (lastProtoInRemote === undefined) {
+      throw new CodeError('invalid multiaddr', codes.ERR_INVALID_MULTIADDR)
+    }
+    if (lastProtoInRemote.name !== 'p2p') {
+      remoteAddr = remoteAddr.encapsulate(`/p2p/${destinationIdString}`)
+    }
+
+    const connection = await this.components.transportManager.dial(remoteAddr)
+
+    const rawStream = await connection.newStream([SIGNALING_PROTO_ID], options)
+
+    try {
+      const [pc, muxerFactory] = await initiateConnection({
+        stream: rawStream,
+        rtcConfiguration: this.init.rtcConfiguration,
+        signal: options.signal
+      })
+      const result = await options.upgrader.upgradeOutbound(
+        new WebRTCMultiaddrConnection({
+          peerConnection: pc,
+          timeline: { open: (new Date()).getTime() },
+          remoteAddr: connection.remoteAddr
+        }),
+        {
+          skipProtection: true,
+          skipEncryption: true,
+          muxerFactory
+        }
+      )
+
+      // close the stream if SDP has been exchanged successfully
+      rawStream.close()
+      return result
+    } catch (err) {
+      // reset the stream in case of any error
+      rawStream.reset()
+      throw err
+    }
+  }
+
+  async _onProtocol ({ connection, stream }: IncomingStreamData): Promise<void> {
+    try {
+      const [pc, muxerFactory] = await handleIncomingStream({
+        rtcConfiguration: this.init.rtcConfiguration,
+        connection,
+        stream
+      })
+      await this.components.upgrader.upgradeInbound(new WebRTCMultiaddrConnection({
+        peerConnection: pc,
+        timeline: { open: (new Date()).getTime() },
+        remoteAddr: connection.remoteAddr
+      }), {
+        skipEncryption: true,
+        skipProtection: true,
+        muxerFactory
+      })
+    } catch (err) {
+      stream.reset()
+      throw err
+    }
+  }
+}

package/src/peer_transport/util.ts

@@ -0,0 +1,62 @@
+import { logger } from '@libp2p/logger'
+import type { DeferredPromise } from 'p-defer'
+import * as pb from './pb/index.js'
+import { detect } from 'detect-browser'
+
+const browser = detect()
+const isFirefox = ((browser != null) && browser.name === 'firefox')
+
+interface MessageStream {
+  read: () => Promise<pb.Message>
+  write: (d: pb.Message) => void | Promise<void>
+}
+
+const log = logger('libp2p:webrtc:peer:util')
+
+export const readCandidatesUntilConnected = async (connectedPromise: DeferredPromise<void>, pc: RTCPeerConnection, stream: MessageStream): Promise<void> => {
+  while (true) {
+    const readResult = await Promise.race([connectedPromise.promise, stream.read()])
+    // check if readResult is a message
+    if (readResult instanceof Object) {
+      const message = readResult
+      if (message.type !== pb.Message.Type.ICE_CANDIDATE) {
+        throw new Error('expected only ice candidates')
+      }
+      // end of candidates has been signalled
+      if (message.data == null || message.data === '') {
+        log.trace('end-of-candidates received')
+        break
+      }
+
+      log.trace('received new ICE candidate: %s', message.data)
+      try {
+        await pc.addIceCandidate(new RTCIceCandidate(JSON.parse(message.data)))
+      } catch (err) {
+        log.error('bad candidate received: ', err)
+        throw new Error('bad candidate received')
+      }
+    } else {
+      // connected promise resolved
+      break
+    }
+  }
+  await connectedPromise.promise
+}
+
+export function resolveOnConnected (pc: RTCPeerConnection, promise: DeferredPromise<void>): void {
+  pc[isFirefox ? 'oniceconnectionstatechange' : 'onconnectionstatechange'] = (_) => {
+    log.trace('receiver peerConnectionState state: ', pc.connectionState)
+    switch (isFirefox ? pc.iceConnectionState : pc.connectionState) {
+      case 'connected':
+        promise.resolve()
+        break
+      case 'failed':
+      case 'disconnected':
+      case 'closed':
+        promise.reject()
+        break
+      default:
+        break
+    }
+  }
+}

package/src/stream.ts

@@ -421,8 +421,6 @@ export class WebRTCStream implements Stream {
    * @see this.closeWrite
    */
   reset (): void {
-    // TODO Why are you resetting the stat here?
-    this.stat = defaultStat(this.stat.direction)
     const [currentState, nextState] = this.streamState.transition({ direction: 'outbound', flag: pb.Message_Flag.RESET })
     if (currentState === nextState) {
       // No change, no op
@@ -454,4 +452,11 @@ export class WebRTCStream implements Stream {
       }
     }
   }
+
+  eq (stream: Stream): boolean {
+    if (stream instanceof WebRTCStream) {
+      return stream.channel.id === this.channel.id
+    }
+    return false
+  }
 }

package/src/transport.ts

@@ -15,6 +15,7 @@ import type { WebRTCDialOptions } from './options.js'
 import * as sdp from './sdp.js'
 import { WebRTCStream } from './stream.js'
 import { genUfrag } from './util.js'
+import { protocols } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:webrtc:transport')
 
@@ -28,30 +29,30 @@ const HANDSHAKE_TIMEOUT_MS = 10_000
  *
  * {@link https://github.com/multiformats/multiaddr/blob/master/protocols.csv}
  */
-export const WEBRTC_CODE: number = 280
+export const WEBRTC_CODE: number = protocols('webrtc-direct').code
 
 /**
  * Created by converting the hexadecimal protocol code to an integer.
  *
  * {@link https://github.com/multiformats/multiaddr/blob/master/protocols.csv}
  */
-export const CERTHASH_CODE: number = 466
+export const CERTHASH_CODE: number = protocols('certhash').code
 
 /**
  * The peer for this transport
  */
 // @TODO(ddimaria): seems like an unnessary abstraction, consider removing
-export interface WebRTCTransportComponents {
+export interface WebRTCDirectTransportComponents {
   peerId: PeerId
 }
 
-export class WebRTCTransport implements Transport {
+export class WebRTCDirectTransport implements Transport {
   /**
    * The peer for this transport
    */
-  private readonly components: WebRTCTransportComponents
+  private readonly components: WebRTCDirectTransportComponents
 
-  constructor (components: WebRTCTransportComponents) {
+  constructor (components: WebRTCDirectTransportComponents) {
     this.components = components
   }
 
@@ -82,7 +83,7 @@ export class WebRTCTransport implements Transport {
    * Implement toString() for WebRTCTransport
    */
   get [Symbol.toStringTag] (): string {
-    return '@libp2p/webrtc'
+    return '@libp2p/webrtc-direct'
   }
 
   /**
@@ -238,5 +239,5 @@ export class WebRTCTransport implements Transport {
  */
 function validMa (ma: Multiaddr): boolean {
   const codes = ma.protoCodes()
-  return codes.includes(WEBRTC_CODE) && codes.includes(CERTHASH_CODE) && ma.getPeerId() != null
+  return codes.includes(WEBRTC_CODE) && codes.includes(CERTHASH_CODE) && ma.getPeerId() != null && !codes.includes(protocols('p2p-circuit').code)
 }