@libp2p/webrtc 5.2.4 → 5.2.5-0555339ba

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

@@ -2,6 +2,7 @@ import { InvalidParametersError, serviceCapabilities, serviceDependencies, setMa
 import { peerIdFromString } from '@libp2p/peer-id'
 import { multiaddr, type Multiaddr } from '@multiformats/multiaddr'
 import { WebRTC } from '@multiformats/multiaddr-matcher'
+import { SIGNALING_PROTOCOL } from '../constants.js'
 import { WebRTCMultiaddrConnection } from '../maconn.js'
 import { DataChannelMuxerFactory } from '../muxer.js'
 import { getRtcConfiguration } from '../util.js'
@@ -10,22 +11,28 @@ import { initiateConnection } from './initiate-connection.js'
 import { WebRTCPeerListener } from './listener.js'
 import { handleIncomingStream } from './signaling-stream-handler.js'
 import type { DataChannelOptions } from '../index.js'
-import type { OutboundConnectionUpgradeEvents, CreateListenerOptions, DialTransportOptions, Transport, Listener, Upgrader, ComponentLogger, Logger, Connection, PeerId, CounterGroup, Metrics, Startable, OpenConnectionProgressEvents, IncomingStreamData } from '@libp2p/interface'
+import type { OutboundConnectionUpgradeEvents, CreateListenerOptions, DialTransportOptions, Transport, Listener, Upgrader, ComponentLogger, Logger, Connection, PeerId, CounterGroup, Metrics, Startable, OpenConnectionProgressEvents, IncomingStreamData, Libp2pEvents, TypedEventTarget } from '@libp2p/interface'
 import type { Registrar, ConnectionManager, TransportManager } from '@libp2p/interface-internal'
 import type { ProgressEvent } from 'progress-events'
 
-const WEBRTC_TRANSPORT = '/webrtc'
-const CIRCUIT_RELAY_TRANSPORT = '/p2p-circuit'
-export const SIGNALING_PROTO_ID = '/webrtc-signaling/0.0.1'
-
 export interface WebRTCTransportInit {
+  /**
+   * Add additional configuration to any RTCPeerConnections that are created.
+   *
+   * This could be extra STUN/TURN servers, certificate, etc.
+   */
   rtcConfiguration?: RTCConfiguration | (() => RTCConfiguration | Promise<RTCConfiguration>)
+
+  /**
+   * Any options here will be applied to any RTCDataChannels that are opened.
+   */
   dataChannel?: DataChannelOptions
 
   /**
    * Inbound connections must complete the upgrade within this many ms
    *
-   * @default 30000
+   * @default 30_000
+   * @deprecated configure `connectionManager.inboundUpgradeTimeout` instead
    */
   inboundConnectionTimeout?: number
 }
@@ -38,6 +45,7 @@ export interface WebRTCTransportComponents {
   connectionManager: ConnectionManager
   metrics?: Metrics
   logger: ComponentLogger
+  events: TypedEventTarget<Libp2pEvents>
 }
 
 export interface WebRTCTransportMetrics {
@@ -104,7 +112,7 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
   }
 
   async start (): Promise<void> {
-    await this.components.registrar.handle(SIGNALING_PROTO_ID, (data: IncomingStreamData) => {
+    await this.components.registrar.handle(SIGNALING_PROTOCOL, (data: IncomingStreamData) => {
       // ensure we don't try to upgrade forever
       const signal = this.components.upgrader.createInboundAbortSignal(this.shutdownController.signal)
 
@@ -122,7 +130,7 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
   }
 
   async stop (): Promise<void> {
-    await this.components.registrar.unhandle(SIGNALING_PROTO_ID)
+    await this.components.registrar.unhandle(SIGNALING_PROTOCOL)
     this._started = false
   }
 
@@ -254,12 +262,12 @@ export class WebRTCTransport implements Transport<WebRTCDialEvents>, Startable {
 }
 
 export function splitAddr (ma: Multiaddr): { baseAddr: Multiaddr, peerId: PeerId } {
-  const addrs = ma.toString().split(WEBRTC_TRANSPORT + '/')
+  const addrs = ma.toString().split('/webrtc/')
   if (addrs.length !== 2) {
     throw new InvalidParametersError('webrtc protocol was not present in multiaddr')
   }
 
-  if (!addrs[0].includes(CIRCUIT_RELAY_TRANSPORT)) {
+  if (!addrs[0].includes('/p2p-circuit')) {
     throw new InvalidParametersError('p2p-circuit protocol was not present in multiaddr')
   }
 

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

@@ -1,8 +1,7 @@
 import { PeerConnection } from '@ipshipyard/node-datachannel'
 import { RTCPeerConnection } from '@ipshipyard/node-datachannel/polyfill'
 import { Crypto } from '@peculiar/webcrypto'
-import { DEFAULT_ICE_SERVERS } from '../../constants.js'
-import { MAX_MESSAGE_SIZE } from '../../stream.js'
+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 '@ipshipyard/node-datachannel'

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

@@ -4,9 +4,8 @@ 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 { CODEC_CERTHASH, MAX_MESSAGE_SIZE } from '../../constants.js'
 import { InvalidFingerprintError, UnsupportedHashAlgorithmError } from '../../error.js'
-import { MAX_MESSAGE_SIZE } from '../../stream.js'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { MultihashDigest } from 'multiformats/hashes/interface'
 

package/src/stream.ts

@@ -7,8 +7,8 @@ import pDefer from 'p-defer'
 import pTimeout from 'p-timeout'
 import { raceEvent } from 'race-event'
 import { raceSignal } from 'race-signal'
-import { encodingLength } from 'uint8-varint'
 import { Uint8ArrayList } from 'uint8arraylist'
+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 type { DataChannelOptions } from './index.js'
 import type { RTCDataChannel } from './webrtc/index.js'
@@ -27,65 +27,6 @@ export interface WebRTCStreamInit extends AbstractStreamInit, DataChannelOptions
   logger: ComponentLogger
 }
 
-/**
- * How much can be buffered to the DataChannel at once
- */
-export const MAX_BUFFERED_AMOUNT = 2 * 1024 * 1024
-
-/**
- * How long time we wait for the 'bufferedamountlow' event to be emitted
- */
-export const BUFFERED_AMOUNT_LOW_TIMEOUT = 30 * 1000
-
-/**
- * Max message size that can be sent to the DataChannel. In browsers this is
- * 256KiB but go-libp2p and rust-libp2p only support 16KiB at the time of
- * writing.
- *
- * @see https://blog.mozilla.org/webrtc/large-data-channel-messages/
- * @see https://issues.webrtc.org/issues/40644524
- */
-export const MAX_MESSAGE_SIZE = 16 * 1024
-
-/**
- * max protobuf overhead:
- *
- * ```
- * [message-length][flag-field-id+type][flag-field-length][flag-field][message-field-id+type][message-field-length][message-field]
- * ```
- */
-function calculateProtobufOverhead (maxMessageSize = MAX_MESSAGE_SIZE): number {
-  // these have a fixed size
-  const messageLength = encodingLength(maxMessageSize - encodingLength(maxMessageSize))
-  const flagField = 1 + encodingLength(Object.keys(Message.Flag).length - 1) // id+type/value
-  const messageFieldIdType = 1 // id+type
-  const available = maxMessageSize - messageLength - flagField - messageFieldIdType
-
-  // let message-length/message-data fill the rest of the message
-  const messageFieldLengthLength = encodingLength(available)
-
-  return messageLength + flagField + messageFieldIdType + messageFieldLengthLength
-}
-
-/**
- * The protobuf message overhead includes the maximum amount of all bytes in the
- * protobuf that aren't message field bytes
- */
-export const PROTOBUF_OVERHEAD = calculateProtobufOverhead()
-
-/**
- * When closing streams we send a FIN then wait for the remote to
- * reply with a FIN_ACK. If that does not happen within this timeout
- * we close the stream anyway.
- */
-export const FIN_ACK_TIMEOUT = 5000
-
-/**
- * When sending data messages, if the channel is not in the "open" state, wait
- * this long for the "open" event to fire.
- */
-export const OPEN_TIMEOUT = 5000
-
 export class WebRTCStream extends AbstractStream {
   /**
    * The data channel used to send and receive data

package/src/util.ts

@@ -1,7 +1,7 @@
 import { detect } from 'detect-browser'
 import pDefer from 'p-defer'
 import pTimeout from 'p-timeout'
-import { DEFAULT_ICE_SERVERS, UFRAG_ALPHABET, UFRAG_PREFIX } from './constants.js'
+import { DATA_CHANNEL_DRAIN_TIMEOUT, DEFAULT_ICE_SERVERS, UFRAG_ALPHABET, UFRAG_PREFIX } from './constants.js'
 import type { RTCDataChannel } from './webrtc/index.js'
 import type { PeerConnection } from '@ipshipyard/node-datachannel'
 import type { LoggerOptions } from '@libp2p/interface'
@@ -13,8 +13,6 @@ export const nopSource = async function * nop (): AsyncGenerator<Uint8Array, any
 
 export const nopSink = async (_: any): Promise<void> => {}
 
-export const DATA_CHANNEL_DRAIN_TIMEOUT = 30 * 1000
-
 export function drainAndClose (channel: RTCDataChannel, direction: string, drainTimeout: number = DATA_CHANNEL_DRAIN_TIMEOUT, options: LoggerOptions): void {
   if (channel.readyState !== 'open') {
     return

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"
-}