web-dc-api 0.0.57 → 0.0.59

package/dist/cjs/node_modules/@libp2p/webrtc/dist/src/error.js

@@ -0,0 +1,39 @@
+'use strict';
+
+class WebRTCTransportError extends Error {
+  constructor(msg) {
+    super(`WebRTC transport error: ${msg}`);
+    this.name = 'WebRTCTransportError';
+  }
+}
+class SDPHandshakeFailedError extends WebRTCTransportError {
+  constructor() {
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'SDP handshake failed';
+    super(message);
+    this.name = 'SDPHandshakeFailedError';
+  }
+}
+class InvalidFingerprintError extends WebRTCTransportError {
+  constructor(fingerprint, source) {
+    super(`Invalid fingerprint "${fingerprint}" within ${source}`);
+    this.name = 'WebRTC/InvalidFingerprintError';
+  }
+}
+class UnimplementedError extends WebRTCTransportError {
+  constructor(methodName) {
+    super(`A method (${methodName}) was called though it has been intentionally left unimplemented.`);
+    this.name = 'WebRTC/UnimplementedError';
+  }
+}
+class UnsupportedHashAlgorithmError extends WebRTCTransportError {
+  constructor(algo) {
+    super(`unsupported hash algorithm code: ${algo} please see the codes at https://github.com/multiformats/multicodec/blob/master/table.csv `);
+    this.name = 'WebRTC/UnsupportedHashAlgorithmError';
+  }
+}
+
+exports.InvalidFingerprintError = InvalidFingerprintError;
+exports.SDPHandshakeFailedError = SDPHandshakeFailedError;
+exports.UnimplementedError = UnimplementedError;
+exports.UnsupportedHashAlgorithmError = UnsupportedHashAlgorithmError;
+exports.WebRTCTransportError = WebRTCTransportError;

package/dist/cjs/node_modules/@libp2p/webrtc/dist/src/index.js

@@ -0,0 +1,277 @@
+'use strict';
+
+var transport$1 = require('./private-to-private/transport.js');
+var transport = require('./private-to-public/transport.js');
+
+/**
+ * @packageDocumentation
+ *
+ * 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.
+ *
+ * There are two transports exposed by this module, [webRTC](https://github.com/libp2p/specs/blob/master/webrtc/webrtc.md) and [webRTCDirect](https://github.com/libp2p/specs/blob/master/webrtc/webrtc-direct.md).
+ *
+ * ## WebRTC vs WebRTC Direct
+ *
+ * The connection establishment phase of WebRTC involves a handshake using [SDP](https://en.wikipedia.org/wiki/Session_Description_Protocol) during which two peers will exchange information such as open ports, network addresses and required capabilities.
+ *
+ * A third party is usually necessary to carry out this handshake, forwarding messages between the two peers until they can make a direct connection between themselves.
+ *
+ * The WebRTC transport uses libp2p [Circuit Relay](https://docs.libp2p.io/concepts/nat/circuit-relay/)s to forward SDP messages. Once a direct connection is formed the relay plays no further part in the exchange.
+ *
+ * WebRTC Direct uses a technique known as [SDP munging](https://webrtchacks.com/not-a-guide-to-sdp-munging/) to skip the handshake step, instead encoding enough information in the connection request that the responder can derive what would have been in the handshake messages and so requires no third parties to establish a connection.
+ *
+ * A WebRTC Direct multiaddr also includes a certhash of the target peer - this is used to allow opening a connection to the remote, which would otherwise be denied due to use of a self-signed certificate.
+ *
+ * In both cases, once the connection is established a [Noise handshake](https://noiseprotocol.org/noise.html) is carried out to ensure that the remote peer has the private key that corresponds to the public key that makes up their PeerId, giving you both encryption and authentication.
+ *
+ * @example WebRTC
+ *
+ * WebRTC requires use of a relay to connect two nodes. The listener first discovers a relay server and makes a reservation, then the dialer can connect via the relayed address.
+ *
+ * ```TypeScript
+ * import { noise } from '@chainsafe/libp2p-noise'
+ * import { yamux } from '@chainsafe/libp2p-yamux'
+ * import { echo } from '@libp2p/echo'
+ * import { circuitRelayTransport, circuitRelayServer } from '@libp2p/circuit-relay-v2'
+ * import { identify } from '@libp2p/identify'
+ * import { webRTC } from '@libp2p/webrtc'
+ * import { webSockets } from '@libp2p/websockets'
+ * import { WebRTC } from '@multiformats/multiaddr-matcher'
+ * import delay from 'delay'
+ * import { pipe } from 'it-pipe'
+ * import { createLibp2p } from 'libp2p'
+ * import type { Multiaddr } from '@multiformats/multiaddr'
+ *
+ * // the relay server listens on a transport dialable by the listener and the
+ * // dialer, and has a relay service configured
+ * const relay = await createLibp2p({
+ *   addresses: {
+ *   listen: ['/ip4/127.0.0.1/tcp/0/ws']
+ *   },
+ *   transports: [
+ *     webSockets()
+ *   ],
+ *   connectionEncrypters: [noise()],
+ *   streamMuxers: [yamux()],
+ *   connectionGater: {
+ *     denyDialMultiaddr: () => false
+ *   },
+ *   services: {
+ *     identify: identify(),
+ *     relay: circuitRelayServer()
+ *   }
+ * })
+ *
+ * // the listener has a WebSocket transport to dial the relay, a Circuit Relay
+ * // transport to make a reservation, and a WebRTC transport to accept incoming
+ * // WebRTC connections
+ * const listener = await createLibp2p({
+ *   addresses: {
+ *     listen: [
+ *       '/p2p-circuit',
+ *       '/webrtc'
+ *     ]
+ *   },
+ *   transports: [
+ *     webSockets(),
+ *     webRTC(),
+ *     circuitRelayTransport()
+ *   ],
+ *   connectionEncrypters: [noise()],
+ *   streamMuxers: [yamux()],
+ *   connectionGater: {
+ *     denyDialMultiaddr: () => false
+ *   },
+ *   services: {
+ *     identify: identify(),
+ *     echo: echo()
+ *   }
+ * })
+ *
+ * // the listener dials the relay (or discovers a public relay via some other
+ * // method)
+ * await listener.dial(relay.getMultiaddrs(), {
+ *   signal: AbortSignal.timeout(5000)
+ * })
+ *
+ * let webRTCMultiaddr: Multiaddr | undefined
+ *
+ * // wait for the listener to make a reservation on the relay
+ * while (true) {
+ *   webRTCMultiaddr = listener.getMultiaddrs().find(ma => WebRTC.matches(ma))
+ *
+ *   if (webRTCMultiaddr != null) {
+ *     break
+ *   }
+ *
+ *   // try again later
+ *   await delay(1000)
+ * }
+ *
+ * // the dialer has Circuit Relay, WebSocket and WebRTC transports to dial
+ * // the listener via the relay, complete the SDP handshake and establish a
+ * // direct WebRTC connection
+ * const dialer = await createLibp2p({
+ *   transports: [
+ *     webSockets(),
+ *     webRTC(),
+ *     circuitRelayTransport()
+ *   ],
+ *   connectionEncrypters: [noise()],
+ *   streamMuxers: [yamux()],
+ *   connectionGater: {
+ *     denyDialMultiaddr: () => false
+ *   },
+ *   services: {
+ *     identify: identify(),
+ *     echo: echo()
+ *   }
+ * })
+ *
+ * // dial the listener and open an echo protocol stream
+ * const stream = await dialer.dialProtocol(webRTCMultiaddr, dialer.services.echo.protocol, {
+ *   signal: AbortSignal.timeout(5000)
+ * })
+ *
+ * // we can now stop the relay
+ * await relay.stop()
+ *
+ * // send/receive some data from the remote peer via a direct connection
+ * await pipe(
+ *   [new TextEncoder().encode('hello world')],
+ *   stream,
+ *   async source => {
+ *     for await (const buf of source) {
+ *       console.info(new TextDecoder().decode(buf.subarray()))
+ *     }
+ *   }
+ * )
+ * ```
+ *
+ * @example WebRTC Direct
+ *
+ * WebRTC Direct allows a client to establish a WebRTC connection to a server
+ * without using a relay to first exchange SDP messages.
+ *
+ * Instead the server listens on a public UDP port and embeds its certificate
+ * hash in the published multiaddr. It derives the client's SDP offer based on
+ * the incoming IP/port of STUN messages sent to this public port.
+ *
+ * The client derives the server's SDP answer based on the information in the
+ * multiaddr so no SDP handshake via a third party is required.
+ *
+ * Full details of the connection protocol can be found in the [WebRTC Direct spec](https://github.com/libp2p/specs/blob/master/webrtc/webrtc-direct.md).
+ *
+ * Browsers cannot listen on WebRTC Direct addresses since they cannot open
+ * ports, but they can dial all spec-compliant servers.
+ *
+ * Node.js/go and rust-libp2p can listen on and dial WebRTC Direct addresses.
+ *
+ * ```TypeScript
+ * import { createLibp2p } from 'libp2p'
+ * import { multiaddr } from '@multiformats/multiaddr'
+ * import { pipe } from 'it-pipe'
+ * import { fromString, toString } from 'uint8arrays'
+ * import { webRTCDirect } from '@libp2p/webrtc'
+ *
+ * const listener = await createLibp2p({
+ *   addresses: {
+ *     listen: [
+ *       '/ip4/0.0.0.0/udp/0/webrtc-direct'
+ *     ]
+ *   },
+ *   transports: [
+ *     webRTCDirect()
+ *   ]
+ * })
+ *
+ * await listener.start()
+ *
+ * const dialer = await createLibp2p({
+ *   transports: [
+ *     webRTCDirect()
+ *   ]
+ * })
+ *
+ * await dialer.start()
+ *
+ * const stream = await dialer.dialProtocol(listener.getMultiaddrs(), '/my-protocol/1.0.0', {
+ *   signal: AbortSignal.timeout(10_000)
+ * })
+ *
+ * await pipe(
+ *   [fromString(`Hello js-libp2p-webrtc\n`)],
+ *   stream,
+ *   async function (source) {
+ *     for await (const buf of source) {
+ *       console.info(toString(buf.subarray()))
+ *     }
+ *   }
+ * )
+ * ```
+ *
+ * ## WebRTC Direct certificate hashes
+ *
+ * WebRTC Direct listeners publish the hash of their TLS certificate as part of
+ * the listening multiaddr.
+ *
+ * By default these certificates are generated at start up using an ephemeral
+ * keypair that only exists while the node is running.
+ *
+ * This means that the certificate hashes change when the node is restarted,
+ * which can be undesirable if multiaddrs are intended to be long lived (e.g.
+ * if the node is used as a network bootstrapper).
+ *
+ * To reuse the same certificate and keypair, configure a persistent datastore
+ * and the [@libp2p/keychain](https://www.npmjs.com/package/@libp2p/keychain)
+ * service as part of your service map:
+ *
+ * @example Reuse TLS certificates after restart
+ *
+ * ```ts
+ * import { LevelDatastore } from 'datastore-level'
+ * import { webRTCDirect } from '@libp2p/webrtc'
+ * import { keychain } from '@libp2p/keychain'
+ * import { createLibp2p } from 'libp2p'
+ *
+ * // store data on disk between restarts
+ * const datastore = new LevelDatastore('/path/to/store')
+ *
+ * const listener = await createLibp2p({
+ *   addresses: {
+ *     listen: [
+ *       '/ip4/0.0.0.0/udp/0/webrtc-direct'
+ *     ]
+ *   },
+ *   datastore,
+ *   transports: [
+ *     webRTCDirect()
+ *   ],
+ *   services: {
+ *     keychain: keychain()
+ *   }
+ * })
+ *
+ * await listener.start()
+ *
+ * console.info(listener.getMultiaddrs())
+ * // /ip4/...../udp/../webrtc-direct/certhash/foo
+ *
+ * await listener.stop()
+ * await listener.start()
+ *
+ * console.info(listener.getMultiaddrs())
+ * // /ip4/...../udp/../webrtc-direct/certhash/foo
+ * ```
+ */
+function webRTCDirect(init) {
+  return components => new transport.WebRTCDirectTransport(components, init);
+}
+function webRTC(init) {
+  return components => new transport$1.WebRTCTransport(components, init);
+}
+
+exports.webRTC = webRTC;
+exports.webRTCDirect = webRTCDirect;

package/dist/cjs/node_modules/@libp2p/webrtc/dist/src/maconn.js

@@ -0,0 +1,64 @@
+'use strict';
+
+var util = require('./util.js');
+
+class WebRTCMultiaddrConnection {
+  log;
+  /**
+   * WebRTC Peer Connection
+   */
+  peerConnection;
+  /**
+   * The multiaddr address used to communicate with the remote peer
+   */
+  remoteAddr;
+  /**
+   * Holds the life cycle times of the connection
+   */
+  timeline;
+  /**
+   * Optional metrics counter group for this connection
+   */
+  metrics;
+  /**
+   * The stream source, a no-op as the transport natively supports multiplexing
+   */
+  source = (() => util.nopSource())();
+  /**
+   * The stream destination, a no-op as the transport natively supports multiplexing
+   */
+  sink = (() => util.nopSink)();
+  constructor(components, init) {
+    this.log = components.logger.forComponent('libp2p:webrtc:maconn');
+    this.remoteAddr = init.remoteAddr;
+    this.timeline = init.timeline;
+    this.peerConnection = init.peerConnection;
+    const peerConnection = this.peerConnection;
+    const initialState = peerConnection.connectionState;
+    this.peerConnection.onconnectionstatechange = () => {
+      this.log.trace('peer connection state change', peerConnection.connectionState, 'initial state', initialState);
+      if (peerConnection.connectionState === 'disconnected' || peerConnection.connectionState === 'failed' || peerConnection.connectionState === 'closed') {
+        // nothing else to do but close the connection
+        this.timeline.close = Date.now();
+      }
+    };
+  }
+  async close(options) {
+    this.log.trace('closing connection');
+    this.peerConnection.close();
+    this.timeline.close = Date.now();
+    this.metrics?.increment({
+      close: true
+    });
+  }
+  abort(err) {
+    this.log.error('closing connection due to error', err);
+    this.peerConnection.close();
+    this.timeline.close = Date.now();
+    this.metrics?.increment({
+      abort: true
+    });
+  }
+}
+
+exports.WebRTCMultiaddrConnection = WebRTCMultiaddrConnection;

package/dist/cjs/node_modules/@libp2p/webrtc/dist/src/muxer.js

@@ -0,0 +1,211 @@
+'use strict';
+
+var constants = require('./constants.js');
+var stream = require('./stream.js');
+var util = require('./util.js');
+
+class DataChannelMuxerFactory {
+  protocol;
+  /**
+   * WebRTC Peer Connection
+   */
+  peerConnection;
+  bufferedStreams = [];
+  metrics;
+  dataChannelOptions;
+  components;
+  log;
+  constructor(components, init) {
+    this.components = components;
+    this.peerConnection = init.peerConnection;
+    this.metrics = init.metrics;
+    this.protocol = init.protocol ?? constants.MUXER_PROTOCOL;
+    this.dataChannelOptions = init.dataChannelOptions ?? {};
+    this.log = components.logger.forComponent('libp2p:webrtc:muxerfactory');
+    // store any data channels opened before upgrade has been completed
+    this.peerConnection.ondatachannel = _ref => {
+      let {
+        channel
+      } = _ref;
+      this.log.trace('incoming early datachannel with channel id %d and label "%s"', channel.id);
+      // 'init' channel is only used during connection establishment
+      if (channel.label === 'init') {
+        this.log.trace('closing early init channel');
+        channel.close();
+        return;
+      }
+      // @ts-expect-error fields are set below
+      const bufferedStream = {};
+      const stream$1 = stream.createStream({
+        channel,
+        direction: 'inbound',
+        onEnd: err => {
+          bufferedStream.onEnd(err);
+        },
+        logger: components.logger,
+        ...this.dataChannelOptions
+      });
+      bufferedStream.stream = stream$1;
+      bufferedStream.channel = channel;
+      bufferedStream.onEnd = () => {
+        this.bufferedStreams = this.bufferedStreams.filter(s => s.stream.id !== stream$1.id);
+      };
+      this.bufferedStreams.push(bufferedStream);
+    };
+  }
+  createStreamMuxer(init) {
+    return new DataChannelMuxer(this.components, {
+      ...init,
+      peerConnection: this.peerConnection,
+      dataChannelOptions: this.dataChannelOptions,
+      metrics: this.metrics,
+      streams: this.bufferedStreams,
+      protocol: this.protocol
+    });
+  }
+}
+/**
+ * A libp2p data channel stream muxer
+ */
+class DataChannelMuxer {
+  init;
+  /**
+   * Array of streams in the data channel
+   */
+  streams;
+  protocol;
+  log;
+  peerConnection;
+  dataChannelOptions;
+  metrics;
+  logger;
+  constructor(components, init) {
+    this.init = init;
+    this.log = components.logger.forComponent('libp2p:webrtc:muxer');
+    this.logger = components.logger;
+    this.streams = init.streams.map(s => s.stream);
+    this.peerConnection = init.peerConnection;
+    this.protocol = init.protocol ?? constants.MUXER_PROTOCOL;
+    this.metrics = init.metrics;
+    this.dataChannelOptions = init.dataChannelOptions ?? {};
+    /**
+     * Fired when a data channel has been added to the connection has been
+     * added by the remote peer.
+     *
+     * {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/datachannel_event}
+     */
+    this.peerConnection.ondatachannel = _ref2 => {
+      let {
+        channel
+      } = _ref2;
+      this.log.trace('incoming datachannel with channel id %d', channel.id);
+      // 'init' channel is only used during connection establishment
+      if (channel.label === 'init') {
+        this.log.trace('closing init channel');
+        channel.close();
+        return;
+      }
+      // lib-datachannel throws if `.getId` is called on a closed channel so
+      // memoize it
+      const id = channel.id;
+      const stream$1 = stream.createStream({
+        channel,
+        direction: 'inbound',
+        onEnd: () => {
+          this.#onStreamEnd(stream$1, channel);
+          this.log('incoming channel %s ended', id);
+        },
+        logger: this.logger,
+        ...this.dataChannelOptions
+      });
+      this.streams.push(stream$1);
+      this.metrics?.increment({
+        incoming_stream: true
+      });
+      init?.onIncomingStream?.(stream$1);
+    };
+    // the DataChannelMuxer constructor is called during set up of the
+    // connection by the upgrader.
+    //
+    // If we invoke `init.onIncomingStream` immediately, the connection object
+    // will not be set up yet so add a tiny delay before letting the
+    // connection know about early streams
+    if (this.init.streams.length > 0) {
+      queueMicrotask(() => {
+        this.init.streams.forEach(bufferedStream => {
+          bufferedStream.onEnd = () => {
+            this.log('incoming early channel %s ended with state %s', bufferedStream.channel.id, bufferedStream.channel.readyState);
+            this.#onStreamEnd(bufferedStream.stream, bufferedStream.channel);
+          };
+          this.metrics?.increment({
+            incoming_stream: true
+          });
+          this.init?.onIncomingStream?.(bufferedStream.stream);
+        });
+      });
+    }
+  }
+  #onStreamEnd(stream, channel) {
+    this.log.trace('stream %s %s %s onEnd', stream.direction, stream.id, stream.protocol);
+    util.drainAndClose(channel, `${stream.direction} ${stream.id} ${stream.protocol}`, this.dataChannelOptions.drainTimeout, {
+      log: this.log
+    });
+    this.streams = this.streams.filter(s => s.id !== stream.id);
+    this.metrics?.increment({
+      stream_end: true
+    });
+    this.init?.onStreamEnd?.(stream);
+  }
+  /**
+   * Gracefully close all tracked streams and stop the muxer
+   */
+  async close(options) {
+    try {
+      await Promise.all(this.streams.map(async stream => stream.close(options)));
+    } catch (err) {
+      this.abort(err);
+    }
+  }
+  /**
+   * Abort all tracked streams and stop the muxer
+   */
+  abort(err) {
+    for (const stream of this.streams) {
+      stream.abort(err);
+    }
+  }
+  /**
+   * The stream source, a no-op as the transport natively supports multiplexing
+   */
+  source = (() => util.nopSource())();
+  /**
+   * The stream destination, a no-op as the transport natively supports multiplexing
+   */
+  sink = (() => util.nopSink)();
+  newStream() {
+    // The spec says the label MUST be an empty string: https://github.com/libp2p/specs/blob/master/webrtc/README.md#rtcdatachannel-label
+    const channel = this.peerConnection.createDataChannel('');
+    // lib-datachannel throws if `.getId` is called on a closed channel so
+    // memoize it
+    const id = channel.id;
+    this.log.trace('opened outgoing datachannel with channel id %s', id);
+    const stream$1 = stream.createStream({
+      channel,
+      direction: 'outbound',
+      onEnd: () => {
+        this.#onStreamEnd(stream$1, channel);
+        this.log('outgoing channel %s ended', id);
+      },
+      logger: this.logger,
+      ...this.dataChannelOptions
+    });
+    this.streams.push(stream$1);
+    this.metrics?.increment({
+      outgoing_stream: true
+    });
+    return stream$1;
+  }
+}
+
+exports.DataChannelMuxer = DataChannelMuxer;
+exports.DataChannelMuxerFactory = DataChannelMuxerFactory;