@libp2p/webrtc 5.2.2 → 5.2.3-f465c5473

package/src/constants.ts

@@ -16,3 +16,10 @@ export const DEFAULT_ICE_SERVERS = [
 export const UFRAG_ALPHABET = Array.from('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')
 
 export const UFRAG_PREFIX = 'libp2p+webrtc+v1/'
+
+/**
+ * The time to wait, in milliseconds, for the data channel handshake to complete
+ */
+export const HANDSHAKE_TIMEOUT_MS = 10_000
+export const CODEC_WEBRTC_DIRECT = 0x0118
+export const CODEC_CERTHASH = 0x01d2

package/src/index.ts

@@ -1,7 +1,7 @@
 /**
  * @packageDocumentation
  *
- * A [libp2p transport](https://docs.libp2p.io/concepts/transports/overview/) based on [WebRTC datachannels](https://webrtc.org/).
+ * A [libp2p transport](https://docs.libp2p.io/concepts/transports/overview/) based on [WebRTC data channels](https://webrtc.org/).
  *
  * [WebRTC](https://www.w3.org/TR/webrtc/) is a specification that allows real-time communication between nodes - it's commonly used in browser video conferencing applications but it also provides a reliable data transport mechanism called [data channels](https://www.w3.org/TR/webrtc/#peer-to-peer-data-api) which libp2p uses to facilitate [protocol streams](https://docs.libp2p.io/concepts/multiplex/overview/) between peers.
  *

package/src/maconn.ts

@@ -45,7 +45,7 @@ export class WebRTCMultiaddrConnection implements MultiaddrConnection {
   remoteAddr: Multiaddr
 
   /**
-   * Holds the lifecycle times of the connection
+   * Holds the life cycle times of the connection
    */
   timeline: MultiaddrConnectionTimeline
 

package/src/muxer.ts

@@ -59,7 +59,7 @@ export class DataChannelMuxerFactory implements StreamMuxerFactory {
     this.dataChannelOptions = init.dataChannelOptions ?? {}
     this.log = components.logger.forComponent('libp2p:webrtc:muxerfactory')
 
-    // store any datachannels opened before upgrade has been completed
+    // store any data channels opened before upgrade has been completed
     this.peerConnection.ondatachannel = ({ channel }) => {
       this.log.trace('incoming early datachannel with channel id %d and label "%s"', channel.id)
 

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

@@ -6,6 +6,7 @@ import { IP4, WebRTCDirect } from '@multiformats/multiaddr-matcher'
 import { Crypto } from '@peculiar/webcrypto'
 import getPort from 'get-port'
 import pWaitFor from 'p-wait-for'
+import { CODEC_CERTHASH, CODEC_WEBRTC_DIRECT, HANDSHAKE_TIMEOUT_MS } from '../constants.js'
 import { connect } from './utils/connect.js'
 import { generateTransportCertificate } from './utils/generate-certificates.js'
 import { createDialerRTCPeerConnection } from './utils/get-rtcpeerconnection.js'
@@ -18,13 +19,6 @@ import type { Multiaddr } from '@multiformats/multiaddr'
 
 const crypto = new Crypto()
 
-/**
- * The time to wait, in milliseconds, for the data channel handshake to complete
- */
-const HANDSHAKE_TIMEOUT_MS = 10_000
-const CODEC_WEBRTC_DIRECT = 0x0118
-const CODEC_CERTHASH = 0x01d2
-
 export interface WebRTCDirectListenerComponents {
   peerId: PeerId
   privateKey: PrivateKey
@@ -99,14 +93,14 @@ export class WebRTCDirectListener extends TypedEventEmitter<ListenerEvents> impl
       .pop()?.[1]
 
     if (host == null) {
-      throw new Error('IP4/6 host must be specified in webrtc-direct mulitaddr')
+      throw new Error('IP4/6 host must be specified in webrtc-direct multiaddr')
     }
     const port = parseInt(parts
       .filter(([code, value]) => code === UDP_PROTOCOL.code)
       .pop()?.[1] ?? '')
 
     if (isNaN(port)) {
-      throw new Error('UDP port must be specified in webrtc-direct mulitaddr')
+      throw new Error('UDP port must be specified in webrtc-direct multiaddr')
     }
 
     // have to do this before any async work happens so starting two listeners

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

@@ -1,8 +1,8 @@
 import { serviceCapabilities, transportSymbol } from '@libp2p/interface'
 import { peerIdFromString } from '@libp2p/peer-id'
-import { protocols } from '@multiformats/multiaddr'
 import { WebRTCDirect } from '@multiformats/multiaddr-matcher'
 import { raceSignal } from 'race-signal'
+import { HANDSHAKE_TIMEOUT_MS } from '../constants.js'
 import { genUfrag } from '../util.js'
 import { WebRTCDirectListener } from './listener.js'
 import { connect } from './utils/connect.js'
@@ -13,25 +13,6 @@ import type { CreateListenerOptions, Transport, Listener, ComponentLogger, Logge
 import type { TransportManager } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
-/**
- * The time to wait, in milliseconds, for the data channel handshake to complete
- */
-const HANDSHAKE_TIMEOUT_MS = 10_000
-
-/**
- * Created by converting the hexadecimal protocol code to an integer.
- *
- * {@link https://github.com/multiformats/multiaddr/blob/master/protocols.csv}
- */
-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 = protocols('certhash').code
-
 /**
  * The peer for this transport
  */

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

@@ -146,6 +146,7 @@ export async function connect (peerConnection: DirectRTCPeerConnection, ufrag: s
       case 'closed':
         maConn.close().catch((err) => {
           options.log.error('error closing connection', err)
+          maConn.abort(err)
         })
         break
       default:
@@ -167,18 +168,25 @@ export async function connect (peerConnection: DirectRTCPeerConnection, ufrag: s
     // Therefore, we need to secure an inbound noise connection from the remote.
     options.log.trace('%s secure inbound', options.role)
     await connectionEncrypter.secureInbound(wrappedDuplex, {
-      remotePeer: options.remotePeerId
+      remotePeer: options.remotePeerId,
+      signal: options.signal
     })
 
     options.log.trace('%s upgrade outbound', options.role)
-    return options.upgrader.upgradeOutbound(maConn, { skipProtection: true, skipEncryption: true, muxerFactory })
+    return options.upgrader.upgradeOutbound(maConn, {
+      skipProtection: true,
+      skipEncryption: true,
+      muxerFactory,
+      signal: options.signal
+    })
   }
 
   // For inbound connections, we are expected to start the noise handshake.
   // Therefore, we need to secure an outbound noise connection from the remote.
   options.log.trace('%s secure outbound', options.role)
   const result = await connectionEncrypter.secureOutbound(wrappedDuplex, {
-    remotePeer: options.remotePeerId
+    remotePeer: options.remotePeerId,
+    signal: options.signal
   })
   maConn.remoteAddr = maConn.remoteAddr.encapsulate(`/p2p/${result.remotePeer}`)
 
@@ -187,6 +195,7 @@ export async function connect (peerConnection: DirectRTCPeerConnection, ufrag: s
   await options.upgrader.upgradeInbound(maConn, {
     skipProtection: true,
     skipEncryption: true,
-    muxerFactory
+    muxerFactory,
+    signal: options.signal
   })
 }

package/src/private-to-public/utils/generate-noise-prologue.ts

@@ -15,7 +15,7 @@ export function generateNoisePrologue (localFingerprint: string, remoteAddr: Mul
   const localFpString = localFingerprint.trim().toLowerCase().replaceAll(':', '')
   const localFpArray = uint8arrayFromString(localFpString, 'hex')
   const local = Digest.create(sha256.code, localFpArray)
-  const remote: Uint8Array = sdp.mbdecoder.decode(sdp.certhash(remoteAddr))
+  const remote: Uint8Array = sdp.multibaseDecoder.decode(sdp.certhash(remoteAddr))
   const byteLength = PREFIX.byteLength + local.bytes.byteLength + remote.byteLength
 
   if (role === 'server') {

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

@@ -4,9 +4,9 @@ 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 { CODEC_CERTHASH } from '../../constants.js'
 import { InvalidFingerprintError, UnsupportedHashAlgorithmError } from '../../error.js'
 import { MAX_MESSAGE_SIZE } from '../../stream.js'
-import { CERTHASH_CODE } from '../transport.js'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { MultihashDigest } from 'multiformats/hashes/interface'
 
@@ -14,7 +14,7 @@ import type { MultihashDigest } from 'multiformats/hashes/interface'
  * Get base2 | identity decoders
  */
 // @ts-expect-error - Not easy to combine these types.
-export const mbdecoder: any = Object.values(bases).map(b => b.decoder).reduce((d, b) => d.or(b))
+export const multibaseDecoder: any = Object.values(bases).map(b => b.decoder).reduce((d, b) => d.or(b))
 
 const fingerprintRegex = /^a=fingerprint:(?:\w+-[0-9]+)\s(?<fingerprint>(:?[0-9a-fA-F]{2})+)$/m
 export function getFingerprintFromSdp (sdp: string | undefined): string | undefined {
@@ -29,7 +29,7 @@ export function getFingerprintFromSdp (sdp: string | undefined): string | undefi
 // Extract the certhash from a multiaddr
 export function certhash (ma: Multiaddr): string {
   const tups = ma.stringTuples()
-  const certhash = tups.filter((tup) => tup[0] === CERTHASH_CODE).map((tup) => tup[1])[0]
+  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()}`)
@@ -42,16 +42,16 @@ export function certhash (ma: Multiaddr): string {
  * Convert a certhash into a multihash
  */
 export function decodeCerthash (certhash: string): MultihashDigest {
-  return digest.decode(mbdecoder.decode(certhash))
+  return digest.decode(multibaseDecoder.decode(certhash))
 }
 
 export function certhashToFingerprint (certhash: string): string {
-  const mbdecoded = decodeCerthash(certhash)
+  const multibaseDecoded = decodeCerthash(certhash)
 
-  return new Array(mbdecoded.bytes.length)
+  return new Array(multibaseDecoded.bytes.length)
     .fill(0)
     .map((val, index) => {
-      return mbdecoded.digest[index].toString(16).padStart(2, '0').toUpperCase()
+      return multibaseDecoded.digest[index].toString(16).padStart(2, '0').toUpperCase()
     })
     .join(':')
 }
@@ -60,9 +60,9 @@ export function certhashToFingerprint (certhash: string): string {
  * Extract the fingerprint from a multiaddr
  */
 export function ma2Fingerprint (ma: Multiaddr): string {
-  const mhdecoded = decodeCerthash(certhash(ma))
-  const prefix = toSupportedHashFunction(mhdecoded.code)
-  const fingerprint = mhdecoded.digest.reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '')
+  const multihashDecoded = decodeCerthash(certhash(ma))
+  const prefix = toSupportedHashFunction(multihashDecoded.code)
+  const fingerprint = multihashDecoded.digest.reduce((str, byte) => str + byte.toString(16).padStart(2, '0'), '')
   const sdp = fingerprint.match(/.{1,2}/g)
 
   if (sdp == null) {

package/src/stream.ts

@@ -305,10 +305,10 @@ export class WebRTCStream extends AbstractStream {
     while (data.byteLength > 0) {
       const toSend = Math.min(data.byteLength, this.maxMessageSize)
       const buf = data.subarray(0, toSend)
-      const msgbuf = Message.encode({ message: buf })
-      const sendbuf = lengthPrefixed.encode.single(msgbuf)
+      const messageBuf = Message.encode({ message: buf })
+      const sendBuf = lengthPrefixed.encode.single(messageBuf)
       this.log.trace('-> sending message %s', this.channel.readyState)
-      await this._sendMessage(sendbuf)
+      await this._sendMessage(sendBuf)
       this.log.trace('-> sent message %s', this.channel.readyState)
 
       data.consume(toSend)
@@ -411,8 +411,8 @@ export class WebRTCStream extends AbstractStream {
     }
 
     this.log.trace('sending flag %s', flag.toString())
-    const msgbuf = Message.encode({ flag })
-    const prefixedBuf = lengthPrefixed.encode.single(msgbuf)
+    const messageBuf = Message.encode({ flag })
+    const prefixedBuf = lengthPrefixed.encode.single(messageBuf)
 
     try {
       await this._sendMessage(prefixedBuf, false)

package/dist/typedoc-urls.json

@@ -1,14 +0,0 @@
-{
-  "DataChannelOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.DataChannelOptions.html",
-  ".:DataChannelOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.DataChannelOptions.html",
-  "TransportCertificate": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.TransportCertificate.html",
-  ".:TransportCertificate": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.TransportCertificate.html",
-  "WebRTCDirectTransportComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.WebRTCDirectTransportComponents.html",
-  "WebRTCTransportComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.WebRTCTransportComponents.html",
-  "WebRTCTransportDirectInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.WebRTCTransportDirectInit.html",
-  "WebRTCTransportInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_webrtc.WebRTCTransportInit.html",
-  "webRTC": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTC.html",
-  ".:webRTC": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTC.html",
-  "webRTCDirect": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTCDirect.html",
-  ".:webRTCDirect": "https://libp2p.github.io/js-libp2p/functions/_libp2p_webrtc.webRTCDirect.html"
-}