@libp2p/webrtc 0.0.0

package/package.json

@@ -0,0 +1,170 @@
+{
+  "name": "@libp2p/webrtc",
+  "version": "0.0.0",
+  "description": "A libp2p transport using WebRTC connections",
+  "author": "",
+  "license": "Apache-2.0 OR MIT",
+  "homepage": "https://github.com/libp2p/js-libp2p-webrtc#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/libp2p/js-libp2p-webrtc.git"
+  },
+  "bugs": {
+    "url": "https://github.com/libp2p/js-libp2p-webrtc/issues"
+  },
+  "engines": {
+    "node": ">=16.0.0",
+    "npm": ">=7.0.0"
+  },
+  "type": "module",
+  "types": "./dist/src/index.d.ts",
+  "files": [
+    "src",
+    "dist",
+    "!dist/test",
+    "!**/*.tsbuildinfo",
+    "proto_ts"
+  ],
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./dist/src/index.js"
+    }
+  },
+  "eslintConfig": {
+    "extends": "ipfs",
+    "parserOptions": {
+      "sourceType": "module"
+    }
+  },
+  "release": {
+    "branches": [
+      "main"
+    ],
+    "plugins": [
+      [
+        "@semantic-release/commit-analyzer",
+        {
+          "preset": "conventionalcommits",
+          "releaseRules": [
+            {
+              "breaking": true,
+              "release": "major"
+            },
+            {
+              "revert": true,
+              "release": "patch"
+            },
+            {
+              "type": "feat",
+              "release": "minor"
+            },
+            {
+              "type": "fix",
+              "release": "patch"
+            },
+            {
+              "type": "docs",
+              "release": "patch"
+            },
+            {
+              "type": "test",
+              "release": "patch"
+            },
+            {
+              "type": "deps",
+              "release": "patch"
+            },
+            {
+              "scope": "no-release",
+              "release": false
+            }
+          ]
+        }
+      ],
+      [
+        "@semantic-release/release-notes-generator",
+        {
+          "preset": "conventionalcommits",
+          "presetConfig": {
+            "types": [
+              {
+                "type": "feat",
+                "section": "Features"
+              },
+              {
+                "type": "fix",
+                "section": "Bug Fixes"
+              },
+              {
+                "type": "chore",
+                "section": "Trivial Changes"
+              },
+              {
+                "type": "docs",
+                "section": "Documentation"
+              },
+              {
+                "type": "deps",
+                "section": "Dependencies"
+              },
+              {
+                "type": "test",
+                "section": "Tests"
+              }
+            ]
+          }
+        }
+      ],
+      "@semantic-release/changelog",
+      "@semantic-release/npm",
+      "@semantic-release/github",
+      "@semantic-release/git"
+    ]
+  },
+  "scripts": {
+    "generate:proto": "npx protoc --ts_out proto_ts --proto_path src src/*.proto",
+    "build": "aegir build",
+    "test": "aegir test -t browser",
+    "test:chrome": "aegir test -t browser -f \"./dist/test/**/*.spec.js\" --cov",
+    "test:firefox": "aegir test -t browser -f \"./dist/test/**/*.spec.js\" -- --browser firefox",
+    "lint": "aegir lint",
+    "lint:fix": "aegir lint --fix",
+    "clean": "aegir clean",
+    "dep-check": "aegir dep-check",
+    "release": "aegir release"
+  },
+  "dependencies": {
+    "@chainsafe/libp2p-noise": "^10.0.0",
+    "@libp2p/interface-connection": "^3.0.2",
+    "@libp2p/interface-peer-id": "^1.0.5",
+    "@libp2p/interface-stream-muxer": "^3.0.0",
+    "@libp2p/interface-transport": "^2.0.0",
+    "@libp2p/logger": "^2.0.0",
+    "@libp2p/peer-id": "^1.1.15",
+    "@multiformats/multiaddr": "^11.0.3",
+    "@protobuf-ts/runtime": "^2.8.0",
+    "err-code": "^3.0.1",
+    "it-length-prefixed": "^8.0.3",
+    "it-merge": "^2.0.0",
+    "it-pipe": "^2.0.4",
+    "it-pushable": "^3.1.0",
+    "it-stream-types": "^1.0.4",
+    "multiformats": "^10.0.0",
+    "multihashes": "^4.0.3",
+    "p-defer": "^4.0.0",
+    "uint8arraylist": "^2.3.3",
+    "uint8arrays": "^4.0.2",
+    "uuid": "^9.0.0"
+  },
+  "devDependencies": {
+    "@libp2p/interface-mocks": "^8.0.1",
+    "@libp2p/peer-id-factory": "^1.0.19",
+    "@protobuf-ts/plugin": "^2.8.0",
+    "@protobuf-ts/protoc": "^2.8.0",
+    "@types/uuid": "^8.3.4",
+    "aegir": "^37.4.6",
+    "it-first": "^2.0.0",
+    "libp2p": "^0.40.0"
+  }
+}

package/proto_ts/message.ts

@@ -0,0 +1,105 @@
+// @generated by protobuf-ts 2.8.1
+// @generated from protobuf file "message.proto" (package "webrtc.pb", syntax proto2)
+// tslint:disable
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import { WireType } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MESSAGE_TYPE } 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 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
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class Message$Type extends MessageType<Message> {
+    constructor() {
+        super("webrtc.pb.Message", [
+            { no: 1, name: "flag", kind: "enum", opt: true, T: () => ["webrtc.pb.Message.Flag", Message_Flag] },
+            { no: 2, name: "message", kind: "scalar", opt: true, T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+    create(value?: PartialMessage<Message>): Message {
+        const message = {};
+        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        if (value !== undefined)
+            reflectionMergePartial<Message>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Message): Message {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* optional webrtc.pb.Message.Flag flag */ 1:
+                    message.flag = reader.int32();
+                    break;
+                case /* optional bytes message */ 2:
+                    message.message = reader.bytes();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: Message, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* optional webrtc.pb.Message.Flag flag = 1; */
+        if (message.flag !== undefined)
+            writer.tag(1, WireType.Varint).int32(message.flag);
+        /* optional bytes message = 2; */
+        if (message.message !== undefined)
+            writer.tag(2, WireType.LengthDelimited).bytes(message.message);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message webrtc.pb.Message
+ */
+export const Message = new Message$Type();

package/src/error.ts

@@ -0,0 +1,123 @@
+import errCode from 'err-code'
+import { Direction } from '@libp2p/interface-connection'
+
+export enum codes {
+  ERR_ALREADY_ABORTED = 'ERR_ALREADY_ABORTED',
+  ERR_DATA_CHANNEL = 'ERR_DATA_CHANNEL',
+  ERR_CONNECTION_CLOSED = 'ERR_CONNECTION_CLOSED',
+  ERR_HASH_NOT_SUPPORTED = 'ERR_HASH_NOT_SUPPORTED',
+  ERR_INVALID_MULTIADDR = 'ERR_INVALID_MULTIADDR',
+  ERR_INVALID_FINGERPRINT = 'ERR_INVALID_FINGERPRINT',
+  ERR_INVALID_PARAMETERS = 'ERR_INVALID_PARAMETERS',
+  ERR_NOT_IMPLEMENTED = 'ERR_NOT_IMPLEMENTED',
+  ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS = 'ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS',
+  ERR_TOO_MANY_OUTBOUND_PROTOCOL_STREAMS = 'ERR_TOO_MANY_OUTBOUND_PROTOCOL_STREAMS',
+}
+
+export class WebRTCTransportError extends Error {
+  constructor (msg: string) {
+    super(`WebRTC transport error: ${msg}`)
+    this.name = 'WebRTCTransportError'
+  }
+}
+
+export class ConnectionClosedError extends WebRTCTransportError {
+  constructor (state: RTCPeerConnectionState, msg: string) {
+    super(`peerconnection moved to state: ${state}: ${msg}`)
+    this.name = 'WebRTC/ConnectionClosed'
+  }
+}
+
+export function connectionClosedError (state: RTCPeerConnectionState, msg: string) {
+  return errCode(new ConnectionClosedError(state, msg), codes.ERR_CONNECTION_CLOSED)
+}
+
+export class DataChannelError extends WebRTCTransportError {
+  constructor (streamLabel: string, msg: string) {
+    super(`[stream: ${streamLabel}] data channel error: ${msg}`)
+    this.name = 'WebRTC/DataChannelError'
+  }
+}
+
+export function dataChannelError (streamLabel: string, msg: string) {
+  return errCode(new DataChannelError(streamLabel, msg), codes.ERR_DATA_CHANNEL)
+}
+
+export class InappropriateMultiaddrError extends WebRTCTransportError {
+  constructor (msg: string) {
+    super(`There was a problem with the Multiaddr which was passed in: ${msg}`)
+    this.name = 'WebRTC/InappropriateMultiaddrError'
+  }
+}
+
+export function inappropriateMultiaddr (msg: string) {
+  return errCode(new InappropriateMultiaddrError(msg), codes.ERR_INVALID_MULTIADDR)
+}
+
+export class InvalidArgumentError extends WebRTCTransportError {
+  constructor (msg: string) {
+    super(`There was a problem with a provided argument: ${msg}`)
+    this.name = 'WebRTC/InvalidArgumentError'
+  }
+}
+
+export function invalidArgument (msg: string) {
+  return errCode(new InvalidArgumentError(msg), codes.ERR_INVALID_PARAMETERS)
+}
+
+export class InvalidFingerprintError extends WebRTCTransportError {
+  constructor (fingerprint: string, source: string) {
+    super(`Invalid fingerprint "${fingerprint}" within ${source}`)
+    this.name = 'WebRTC/InvalidFingerprintError'
+  }
+}
+
+export function invalidFingerprint (fingerprint: string, source: string) {
+  return errCode(new InvalidFingerprintError(fingerprint, source), codes.ERR_INVALID_FINGERPRINT)
+}
+
+export class OperationAbortedError extends WebRTCTransportError {
+  constructor (context: string, abortReason: string) {
+    super(`Signalled to abort because (${abortReason}}) ${context}`)
+    this.name = 'WebRTC/OperationAbortedError'
+  }
+}
+
+export function operationAborted (context: string, reason: string) {
+  return errCode(new OperationAbortedError(context, reason), codes.ERR_ALREADY_ABORTED)
+}
+
+export class OverStreamLimitError extends WebRTCTransportError {
+  constructor (msg: string) {
+    super(msg)
+    this.name = 'WebRTC/OverStreamLimitError'
+  }
+}
+
+export function overStreamLimit (dir: Direction, proto: string) {
+  const code = dir === 'inbound' ? codes.ERR_TOO_MANY_INBOUND_PROTOCOL_STREAMS : codes.ERR_TOO_MANY_OUTBOUND_PROTOCOL_STREAMS
+  return errCode(new OverStreamLimitError(`${dir} stream limit reached for protocol - ${proto}`), code)
+}
+
+export class UnimplementedError extends WebRTCTransportError {
+  constructor (methodName: string) {
+    super(`A method (${methodName}) was called though it has been intentionally left unimplemented.`)
+    this.name = 'WebRTC/UnimplementedError'
+  }
+}
+
+export function unimplemented (methodName: string) {
+  return errCode(new UnimplementedError(methodName), codes.ERR_NOT_IMPLEMENTED)
+}
+
+export class UnsupportedHashAlgorithmError extends WebRTCTransportError {
+  constructor (algo: string) {
+    const msg = `unsupported hash algorithm: ${algo}`
+    super(msg)
+    this.name = 'WebRTC/UnsupportedHashAlgorithmError'
+  }
+}
+
+export function unsupportedHashAlgorithm (algorithm: string) {
+  return errCode(new UnsupportedHashAlgorithmError(algorithm), codes.ERR_HASH_NOT_SUPPORTED)
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+import { Transport } from '@libp2p/interface-transport'
+import { WebRTCTransport, WebRTCTransportComponents } from './transport.js'
+
+export function webRTC (): (components: WebRTCTransportComponents) => Transport {
+  return (components: WebRTCTransportComponents) => new WebRTCTransport(components)
+}

package/src/maconn.ts

@@ -0,0 +1,67 @@
+import { MultiaddrConnection, MultiaddrConnectionTimeline } from '@libp2p/interface-connection'
+import { logger } from '@libp2p/logger'
+import { Multiaddr } from '@multiformats/multiaddr'
+import { Source, Sink } from 'it-stream-types'
+
+import { nopSink, nopSource } from './util.js'
+
+const log = logger('libp2p:webrtc:connection')
+
+interface WebRTCMultiaddrConnectionInit {
+  /**
+   * WebRTC Peer Connection
+   */
+  peerConnection: RTCPeerConnection
+
+  /**
+   * The multiaddr address used to communicate with the remote peer
+   */
+  remoteAddr: Multiaddr
+
+  /**
+   * Holds the relevant events timestamps of the connection
+   */
+  timeline: MultiaddrConnectionTimeline
+}
+
+export class WebRTCMultiaddrConnection implements MultiaddrConnection {
+  /**
+   * WebRTC Peer Connection
+   */
+  readonly peerConnection: RTCPeerConnection;
+
+  /**
+   * The multiaddr address used to communicate with the remote peer
+   */
+  remoteAddr: Multiaddr;
+
+  /**
+   * Holds the lifecycle times of the connection
+   */
+  timeline: MultiaddrConnectionTimeline;
+
+  /**
+   * The stream source, a no-op as the transport natively supports multiplexing
+   */
+  source: Source<Uint8Array> = nopSource
+
+  /**
+   * The stream destination, a no-op as the transport natively supports multiplexing
+   */
+  sink: Sink<Uint8Array, Promise<void>> = nopSink;
+
+  constructor (init: WebRTCMultiaddrConnectionInit) {
+    this.remoteAddr = init.remoteAddr
+    this.timeline = init.timeline
+    this.peerConnection = init.peerConnection
+  }
+
+  async close (err?: Error | undefined): Promise<void> {
+    if (err !== undefined) {
+      log.error('error closing connection', err)
+    }
+
+    this.timeline.close = new Date().getTime()
+    this.peerConnection.close()
+  }
+}

package/src/message.proto

@@ -0,0 +1,22 @@
+syntax = "proto2";
+
+package webrtc.pb;
+
+message Message {
+  enum Flag {
+    // The sender will no longer send messages on the stream.
+    FIN = 0;
+
+    // The sender will no longer read messages on the stream. Incoming data is
+    // being discarded on receipt.
+    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.
+    RESET = 2;
+  }
+
+  optional Flag flag = 1;
+
+  optional bytes message = 2;
+}

package/src/muxer.ts

@@ -0,0 +1,120 @@
+import { Stream } from '@libp2p/interface-connection'
+import { StreamMuxer, StreamMuxerFactory, StreamMuxerInit } from '@libp2p/interface-stream-muxer'
+import { Source, Sink } from 'it-stream-types'
+
+import { WebRTCStream } from './stream.js'
+import { nopSink, nopSource } from './util.js'
+
+export class DataChannelMuxerFactory implements StreamMuxerFactory {
+  /**
+   * WebRTC Peer Connection
+   */
+  private readonly peerConnection: RTCPeerConnection
+
+  /**
+   * The string representation of the protocol, required by `StreamMuxerFactory`
+   */
+  protocol: string = '/webrtc'
+
+  constructor (peerConnection: RTCPeerConnection) {
+    this.peerConnection = peerConnection
+  }
+
+  createStreamMuxer (init?: StreamMuxerInit | undefined): StreamMuxer {
+    return new DataChannelMuxer(this.peerConnection, init)
+  }
+}
+
+/**
+ * A libp2p data channel stream muxer
+ */
+export class DataChannelMuxer implements StreamMuxer {
+  /**
+   * WebRTC Peer Connection
+   */
+  private readonly peerConnection: RTCPeerConnection
+  /**
+   * The protocol as represented in the multiaddress
+   */
+  readonly protocol: string = '/webrtc'
+
+  /**
+   * Array of streams in the data channel
+   */
+  streams: Stream[] = []
+
+  /**
+   * Initialized stream muxer
+   */
+  init?: StreamMuxerInit
+
+  /**
+   * Close or abort all tracked streams and stop the muxer
+   */
+  close: (err?: Error | undefined) => void = () => {}
+
+  /**
+   * The stream source, a no-op as the transport natively supports multiplexing
+   */
+  source: Source<Uint8Array> = nopSource;
+
+  /**
+   * The stream destination, a no-op as the transport natively supports multiplexing
+   */
+  sink: Sink<Uint8Array, Promise<void>> = nopSink;
+
+  constructor (peerConnection: RTCPeerConnection, init?: StreamMuxerInit) {
+    /**
+     * Initialized stream muxer
+     */
+    this.init = init
+
+    /**
+     * WebRTC Peer Connection
+     */
+    this.peerConnection = peerConnection
+
+    /**
+     * 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 = ({ channel }) => {
+      const stream = new WebRTCStream({
+        channel,
+        stat: {
+          direction: 'inbound',
+          timeline: {
+            open: 0
+          }
+        },
+        closeCb: init?.onStreamEnd
+      })
+
+      if ((init?.onIncomingStream) != null) {
+        init.onIncomingStream(stream)
+      }
+    }
+  }
+
+  /**
+   * Initiate a new stream with the given name. If no name is
+   * provided, the id of the stream will be used.
+   */
+  newStream (name: string = ''): Stream {
+    const channel = this.peerConnection.createDataChannel(name)
+    const stream = new WebRTCStream({
+      channel,
+      stat: {
+        direction: 'outbound',
+        timeline: {
+          open: 0
+        }
+      },
+      closeCb: this.init?.onStreamEnd
+    })
+
+    return stream
+  }
+}

package/src/options.ts

@@ -0,0 +1,4 @@
+import { CreateListenerOptions, DialOptions } from '@libp2p/interface-transport'
+
+export interface WebRTCListenerOptions extends CreateListenerOptions {}
+export interface WebRTCDialOptions extends DialOptions {}