p2party 0.6.15

package/README.md

@@ -0,0 +1,417 @@
+# p2party-js
+
+<!-- [![codecov][codecov-image]][codecov-url] -->
+
+[![Known Vulnerabilities](https://snyk.io/test/github/p2party/p2party-js/badge.svg?targetFile=package.json)](https://snyk.io/test/github/p2party/p2party-js?targetFile=package.json)
+<br>
+![NPM Version](https://img.shields.io/npm/v/p2party)
+![NPM License](https://img.shields.io/npm/l/p2party)
+[![code-style-prettier][code-style-prettier-image]][code-style-prettier-url]
+<br>
+![NPM Downloads](https://img.shields.io/npm/dw/p2party)
+
+<!-- [![](https://data.jsdelivr.com/v1/package/npm/@deliberative/crypto/badge)](https://www.jsdelivr.com/package/npm/@deliberative/crypto) -->
+
+<!-- [codecov-image]: https://codecov.io/gh/deliberative/crypto/branch/master/graph/badge.svg -->
+<!-- [codecov-url]: https://codecov.io/gh/deliberative/crypto -->
+
+[code-style-prettier-image]: https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square
+[code-style-prettier-url]: https://github.com/prettier/prettier
+
+> Peer-to-peer WebRTC mesh communication with offensive cryptographic encoding.
+
+**p2party** connects peers visiting the same URL into a WebRTC mesh network and enables secure, chunked message exchange over ephemeral data channels. Unlike traditional privacy libraries, `p2party` actively obfuscates traffic using randomized padding and byte-level noise, making message signatures indistinguishable and message intent opaque. Of course it also adds a layer of ChaChaPoly1305 end-to-end encryption.
+
+---
+
+## Disclaimer
+
+The API is not completely stable and the code has not undergone external security audits. Use at your own risk.
+
+## Features
+
+- 📡 Auto-connect peers based on shared URLs
+- 🔀 WebRTC mesh topology (no central servers except for signaling and STUN/TURN)
+- 🔐 Offensive cryptography: every message can be split in multiple 64KB chunks so the attacker needs to store a lot of useless info
+- 🧩 Supports `File` and `string` messages via chunked encoding
+- 🧠 Built-in address book, blacklist, and room memory, all stored in the browser's IndexedDB
+- 🛠 Easy API and integration with React via custom hooks
+
+---
+
+## Dependencies
+
+This library relies heavily on [libsodium](https://github.com/jedisct1/libsodium) for cryptographic operations, which is a battle-tested project, compiled to WebAssembly for speed.
+
+The library offers mnemonic generation, validation and Ed25519 key pair from mnemonic functionality that was inspired by [bip39](https://github.com/bitcoinjs/bip39) but instead of Blake2b we use Argon2 and instead of SHA256 we use SHA512, both of which can be found in libsodium.
+
+On the js side, the library depends on [Redux](https://githun.com/redux) for state management,
+
+## Install
+
+```bash
+npm install p2party
+```
+
+## Usage
+
+The official website [p2party.com](https://p2party.com), which is an SPA written in React, consumes the library with a hook in the following way:
+
+```tsx
+import p2party from "p2party";
+
+import { useState } from "react";
+import { useNavigate } from "react-router";
+import { useSelector } from "react-redux";
+
+import type { Message } from "p2party";
+
+export interface MessageWithData extends Message {
+  data: string | File;
+}
+
+export const useRoom = () => {
+  const navigate = useNavigate();
+
+  const [roomIndex, setRoomIndex] = useState(-1);
+  const keyPair = useSelector(p2party.keyPairSelector);
+  const rooms = useSelector(p2party.roomSelector);
+  const signalingServerConnection = useSelector(
+    p2party.signalingServerSelector,
+  );
+
+  const goToRandomRoom = async (replace = false) => {
+    const random = await p2party.generateRandomRoomUrl();
+    navigate("/rooms/" + random, { replace });
+  };
+
+  const openChannel = async (name: string) => {
+    if (roomIndex === -1) throw new Error("No room was selected");
+
+    await p2party.openChannel(
+      rooms[roomIndex].id,
+      name,
+      rooms[roomIndex].peers,
+    );
+  };
+
+  const sendMessage = (message: string | File, channel: string) => {
+    if (roomIndex === -1) throw new Error("No room was selected");
+
+    p2party.sendMessage(
+      message,
+      channel,
+      rooms[roomIndex].id,
+      percentageFilledChunk / 100,
+      chunks,
+    );
+  };
+
+  return {
+    keyPair,
+    peerId: keyPair.peerId,
+    signalingServerURL: signalingServerConnection.serverUrl,
+    signalingServerConnectionState: signalingServerConnection,
+    peers: roomIndex > -1 ? rooms[roomIndex].peers : [],
+    channels: roomIndex > -1 ? rooms[roomIndex].channels : [],
+    messages: roomIndex > -1 ? rooms[roomIndex].messages : [],
+    goToRandomRoom,
+    connect: p2party.connect,
+    connectToSignalingServer: p2party.connectToSignalingServer,
+    disconnect: p2party.disconnectFromRoom,
+    disconnectFromSignalingServer: p2party.disconnectFromSignalingServer,
+    disconnectFromRoom: p2party.disconnectFromRoom,
+    disconnectFromAllRooms: p2party.disconnectFromAllRooms,
+    disconnectFromPeer: p2party.disconnectFromPeer,
+    openChannel,
+    selectChannel: setSelectedChannel,
+    sendMessage,
+    readMessage: p2party.readMessage,
+    cancelMessage: p2party.cancelMessage,
+    deleteMessage: p2party.deleteMessage,
+    purge: p2party.purge,
+    purgeRoom: p2party.purgeRoom,
+    purgeIdentity: p2party.purgeIdentity,
+  };
+};
+```
+
+For a complete reference of the API you can check the library output file [index.ts](src/index.ts).
+
+The most important functions with their types, which can be called as p2party.fn are:
+
+```typescript
+
+/**
+ * Connects peer to a room.
+ * A room URL is 64 chars long. We use the sha256 of the sha512 of random data.
+ */
+const connect = (
+  roomUrl: string,
+  signalingServerUrl = "wss://signaling.p2party.com/ws",
+  rtcConfig: RTCConfiguration = {
+    iceServers: [
+      {
+        urls: [
+          "stun:stun.p2party.com:3478",
+        ],
+      },
+    ],
+    iceTransportPolicy: "all",
+  },
+) => void;
+
+const connectToSignalingServer = (
+  roomUrl: string,
+  signalingServerUrl = "wss://signaling.p2party.com/ws",
+) => void;
+
+/**
+ * If no toChannel then broadcast the message everywhere to everyone.
+ * If toChannel then broadcast to all peers with that channel.
+ */
+const sendMessage = (
+  data: string | File,
+  toChannel: string,
+  roomId: string,
+  percentageFilledChunk = 0.9,
+  minChunks = 3,
+  chunkSize = CHUNK_LEN,
+  metadataSchemaVersion = 1,
+) => void;
+
+const readMessage = async (
+  merkleRootHex?: string,
+  hashHex?: string,
+) => Promise<{
+  message: string | Blob;
+  percentage: number;
+  size: number;
+  filename: string;
+  mimeType: MimeType;
+  extension: FileExtension;
+  category: string;
+}>;
+
+const cancelMessage = async (
+  channelLabel: string,
+  merkleRoot?: string | Uint8Array,
+  hash?: string | Uint8Array,
+) => void;
+
+```
+
+To load all the past room data you call
+
+```typescript
+const rooms = await p2party.getAllExistingRooms();
+```
+
+To load the contents of a private message you can do the following from the react hook:
+
+```tsx
+// {{ message }} comes from const { messages } = useRoom();
+const MessageItem: FC<MessageItemProps> = ({ message }) => {
+  const [state, setState] = useState<{
+    msg: string;
+    msgSize: number;
+    msgFilename: string;
+    msgCategory: string;
+    msgPercentage: number;
+    msgLoadingText: string;
+    msgExtension: FileExtension;
+  }>({
+    msg: "",
+    msgSize: 0,
+    msgFilename: "",
+    msgCategory: p2party.MessageCategory.Text,
+    msgLoadingText: "",
+    msgPercentage: 0,
+    msgExtension: "",
+  });
+
+  useEffect(() => {
+    const controller = new AbortController();
+
+    const setMessage = async () => {
+      const m = await readMessage(message.merkleRootHex, message.sha512Hex);
+
+      if (
+        message.fromPeerId === peerId &&
+        message.totalChunks > 0 &&
+        message.chunksCreated < message.totalChunks
+      ) {
+        setState((prevState) => ({
+          ...prevState,
+          msg:
+            typeof m.message === "string"
+              ? m.message
+              : m.message
+                ? URL.createObjectURL(m.message)
+                : "",
+          msgLoadingText:
+            "Split " +
+            message.chunksCreated +
+            " chunks of " +
+            message.totalChunks,
+          msgFilename: m.filename,
+          msgCategory: m.category,
+          msgExtension: m.extension,
+          msgPercentage: Math.floor(
+            (message.chunksCreated / message.totalChunks) * 100,
+          ),
+        }));
+      } else {
+        if (m.percentage === 100) {
+          setState((prevState) => ({
+            ...prevState,
+            msg:
+              typeof m.message === "string"
+                ? m.message
+                : m.message
+                  ? URL.createObjectURL(m.message)
+                  : "",
+            msgSize: m.size,
+            msgLoadingText: "",
+            msgFilename: m.filename,
+            msgCategory: m.category,
+            msgExtension: m.extension,
+            msgPercentage: m.percentage, // 100,
+          }));
+        } else {
+          setState((prevState) => ({
+            ...prevState,
+            msgSize: m.size,
+            msgLoadingText:
+              "Received " +
+              formatBytes(message.savedSize) +
+              " of " +
+              formatBytes(message.totalSize),
+            msgFilename: m.filename,
+            msgCategory: m.category,
+            msgExtension: m.extension,
+            msgPercentage: m.percentage,
+          }));
+        }
+      }
+    };
+
+    setMessage();
+
+    return () => {
+      controller.abort();
+
+      if (msg.length > 0 && msgCategory !== p2party.MessageCategory.Text)
+        URL.revokeObjectURL(msg);
+    };
+  }, [
+    message.merkleRootHex,
+    message.sha512Hex,
+    message.savedSize,
+    message.chunksCreated,
+  ]);
+
+  const {
+    msg,
+    msgSize,
+    msgCategory,
+    msgPercentage,
+    msgExtension,
+    msgLoadingText,
+    msgFilename,
+  } = state;
+
+  return (
+    <div>
+      {msgCategory === p2party.MessageCategory.Text && url.length === 0 && (
+        <Text
+          className={`text-left tracking-wide break-words whitespace-pre-line ${message.fromPeerId === peerId ? "font-medium text-black dark:font-semibold dark:text-black" : "font-normal text-white dark:text-white"} text-pretty break-words text-clip hyphens-auto antialiased select-text`}
+        >
+          {msg as string}
+        </Text>
+      )}
+
+      {msgCategory === p2party.MessageCategory.Text && url.length > 0 && (
+        <Text
+          className={`text-left font-semibold tracking-wide text-pretty break-words break-all text-clip hyphens-auto whitespace-normal text-sky-700 underline decoration-sky-400 antialiased select-text dark:font-normal dark:text-sky-400`}
+        >
+          {msg as string}
+        </Text>
+      )}
+
+      {msgCategory !== p2party.MessageCategory.Text && (
+        <Text
+          className={`text-left tracking-wide break-words whitespace-pre-wrap ${message.fromPeerId === peerId ? "font-medium text-black dark:font-semibold dark:text-black" : "font-normal text-white dark:text-white"} antialiased`}
+        >
+          {msgFilename}
+        </Text>
+      )}
+    </div>
+  );
+};
+```
+
+For privacy features like whitelist, blacklist and room purging we have the following APIs:
+
+```typescript
+
+const purgeIdentity = () => void;
+const purgeRoom = (roomUrl: string) => void;
+const purge = async () => void;
+
+const deleteMessage = async (
+  merkleRoot?: string | Uint8Array,
+  hash?: string | Uint8Array,
+) => void;
+
+const addPeerToAddressBook = async (
+  username: string,
+  peerId: string,
+  peerPublicKey: string,
+) => void;
+const onlyAllowConnectionsFromAddressBook = async (
+  roomUrl: string,
+  onlyAllow: boolean,
+) => void;
+const deletePeerFromAddressBook = async (
+  username?: string,
+  peerId?: string,
+  peerPublicKey?: string,
+) => void;
+const blacklistPeer = async (peerId: string, peerPublicKey: string) => void;
+
+```
+
+## Development
+
+If you want to bundle the library yourselves, you need to have [Emscripten](https://github.com/emscripten-core/emscripten)
+installed on your machine in order to compile the C code into WebAssembly.
+We have the `-s SINGLE_FILE=1` option for the `emcc` compiler, which converts the `wasm` file to a `base64` string
+that will be compiled by the glue js code into a WebAssembly module. This was done for the purpose of interoperability
+and modularity.
+
+Clone the repo, download the libsodium submodule and install packages:
+
+```
+git clone https://github.com/p2party/p2party-js.git
+cd p2party-js
+git submodule init
+git submodule update
+npm i
+```
+
+Once you have all the dependencies installed, you can run
+
+```
+npm run dist
+```
+
+and [Rollup](https://github.com/rollup/rollup) will generate the UMD, ESM and CJS bundles.
+
+## License
+
+The source code is licensed under the terms of the Affero General Public License version 3.0 (see [LICENSE](LICENSE)).
+
+## Copyright
+
+Copyright (C) 2025 Deliberative Technologies P.C.

package/lib/api/signalingServerApi.d.ts

@@ -0,0 +1,19 @@
+import type { BaseQueryFn } from "@reduxjs/toolkit/query";
+import type { WebSocketMessageCandidateSend, WebSocketMessageDescriptionSend, WebSocketMessageChallengeResponse, WebSocketMessageRoomIdRequest, WebSocketMessagePeersRequest, WebSocketMessageConnectionResponse, WebSocketMessagePongResponse, WebSocketMessageMessageSendRequest, WebSocketPeerConnectionParams } from "../utils/interfaces";
+export interface WebSocketParams {
+    signalingServerUrl: string;
+}
+export interface WebSocketMessage {
+    content: WebSocketMessagePongResponse | WebSocketMessageCandidateSend | WebSocketMessageDescriptionSend | WebSocketMessageChallengeResponse | WebSocketMessageRoomIdRequest | WebSocketMessagePeersRequest | WebSocketMessageConnectionResponse | WebSocketMessageMessageSendRequest;
+}
+export declare const rtcDataChannelMessageLimit: number;
+export declare const messageLen: number;
+export declare const encryptedLen: number;
+declare const signalingServerApi: import("@reduxjs/toolkit/query").Api<BaseQueryFn<WebSocketParams, undefined>, {
+    connectWebSocket: import("@reduxjs/toolkit/query").MutationDefinition<string, BaseQueryFn<WebSocketParams, undefined>, never, void, "signalingServerApi", undefined>;
+    disconnectWebSocket: import("@reduxjs/toolkit/query").MutationDefinition<void, BaseQueryFn<WebSocketParams, undefined>, never, void, "signalingServerApi", undefined>;
+    sendMessage: import("@reduxjs/toolkit/query").MutationDefinition<WebSocketMessage, BaseQueryFn<WebSocketParams, undefined>, never, void, "signalingServerApi", undefined>;
+    connectWithPeer: import("@reduxjs/toolkit/query").MutationDefinition<WebSocketPeerConnectionParams, BaseQueryFn<WebSocketParams, undefined>, never, void, "signalingServerApi", undefined>;
+}, "signalingServerApi", never, typeof import("@reduxjs/toolkit/query").coreModuleName>;
+export default signalingServerApi;
+//# sourceMappingURL=signalingServerApi.d.ts.map

package/lib/api/webrtc/baseQuery.d.ts

@@ -0,0 +1,11 @@
+import type { BaseQueryFn } from "@reduxjs/toolkit/query";
+import type { RTCPeerConnectionParams, IRTCPeerConnection, IRTCDataChannel } from "./interfaces";
+export interface RTCPeerConnectionParamsExtend extends RTCPeerConnectionParams {
+    peerConnections: IRTCPeerConnection[];
+    dataChannels: IRTCDataChannel[];
+    decryptionWasmMemory: WebAssembly.Memory;
+    merkleWasmMemory: WebAssembly.Memory;
+}
+declare const webrtcBaseQuery: BaseQueryFn<RTCPeerConnectionParamsExtend, void, unknown>;
+export default webrtcBaseQuery;
+//# sourceMappingURL=baseQuery.d.ts.map

package/lib/api/webrtc/baseQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseQuery.d.ts","sourceRoot":"","sources":["../../../src/api/webrtc/baseQuery.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EACV,uBAAuB,EACvB,kBAAkB,EAClB,eAAe,EAChB,MAAM,cAAc,CAAC;AAGtB,MAAM,WAAW,6BAA8B,SAAQ,uBAAuB;IAC5E,eAAe,EAAE,kBAAkB,EAAE,CAAC;IACtC,YAAY,EAAE,eAAe,EAAE,CAAC;IAChC,oBAAoB,EAAE,WAAW,CAAC,MAAM,CAAC;IACzC,gBAAgB,EAAE,WAAW,CAAC,MAAM,CAAC;CACtC;AAED,QAAA,MAAM,eAAe,EAAE,WAAW,CAChC,6BAA6B,EAC7B,IAAI,EACJ,OAAO,CA0GR,CAAC;AAEF,eAAe,eAAe,CAAC"}

package/lib/api/webrtc/disconnectFromAllRoomsQuery.d.ts

@@ -0,0 +1,9 @@
+import type { BaseQueryFn } from "@reduxjs/toolkit/query";
+import type { IRTCDataChannel, IRTCPeerConnection, RTCDisconnectFromAllRoomsParams } from "./interfaces";
+export interface RTCDisconnectFromAllRoomsParamsExtension extends RTCDisconnectFromAllRoomsParams {
+    peerConnections: IRTCPeerConnection[];
+    dataChannels: IRTCDataChannel[];
+}
+declare const webrtcDisconnectAllRoomsQuery: BaseQueryFn<RTCDisconnectFromAllRoomsParamsExtension, void, unknown>;
+export default webrtcDisconnectAllRoomsQuery;
+//# sourceMappingURL=disconnectFromAllRoomsQuery.d.ts.map

package/lib/api/webrtc/disconnectFromAllRoomsQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disconnectFromAllRoomsQuery.d.ts","sourceRoot":"","sources":["../../../src/api/webrtc/disconnectFromAllRoomsQuery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,+BAA+B,EAChC,MAAM,cAAc,CAAC;AAKtB,MAAM,WAAW,wCACf,SAAQ,+BAA+B;IACvC,eAAe,EAAE,kBAAkB,EAAE,CAAC;IACtC,YAAY,EAAE,eAAe,EAAE,CAAC;CACjC;AAED,QAAA,MAAM,6BAA6B,EAAE,WAAW,CAC9C,wCAAwC,EACxC,IAAI,EACJ,OAAO,CAiHR,CAAC;AAEF,eAAe,6BAA6B,CAAC"}

package/lib/api/webrtc/disconnectFromChannelLabelQuery.d.ts

@@ -0,0 +1,8 @@
+import type { BaseQueryFn } from "@reduxjs/toolkit/query";
+import type { IRTCDataChannel, RTCDisconnectFromChannelLabelParams } from "./interfaces";
+export interface RTCDisconnectFromChannelLabelParamsExtension extends RTCDisconnectFromChannelLabelParams {
+    dataChannels: IRTCDataChannel[];
+}
+declare const webrtcDisconnectFromChannelLabelQuery: BaseQueryFn<RTCDisconnectFromChannelLabelParamsExtension, void, unknown>;
+export default webrtcDisconnectFromChannelLabelQuery;
+//# sourceMappingURL=disconnectFromChannelLabelQuery.d.ts.map

package/lib/api/webrtc/disconnectFromChannelLabelQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disconnectFromChannelLabelQuery.d.ts","sourceRoot":"","sources":["../../../src/api/webrtc/disconnectFromChannelLabelQuery.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EACV,eAAe,EACf,mCAAmC,EACpC,MAAM,cAAc,CAAC;AAEtB,MAAM,WAAW,4CACf,SAAQ,mCAAmC;IAC3C,YAAY,EAAE,eAAe,EAAE,CAAC;CACjC;AAED,QAAA,MAAM,qCAAqC,EAAE,WAAW,CACtD,4CAA4C,EAC5C,IAAI,EACJ,OAAO,CA6BR,CAAC;AAEF,eAAe,qCAAqC,CAAC"}

package/lib/api/webrtc/disconnectFromPeerChannelLabelQuery.d.ts

@@ -0,0 +1,9 @@
+import type { BaseQueryFn } from "@reduxjs/toolkit/query";
+import type { IRTCDataChannel, IRTCPeerConnection, RTCDisconnectFromPeerChannelLabelParams } from "./interfaces";
+export interface RTCDisconnectFromPeerChannelLabelParamsExtension extends RTCDisconnectFromPeerChannelLabelParams {
+    peerConnections: IRTCPeerConnection[];
+    dataChannels: IRTCDataChannel[];
+}
+declare const webrtcDisconnectFromPeerChannelLabelQuery: BaseQueryFn<RTCDisconnectFromPeerChannelLabelParamsExtension, void, unknown>;
+export default webrtcDisconnectFromPeerChannelLabelQuery;
+//# sourceMappingURL=disconnectFromPeerChannelLabelQuery.d.ts.map

package/lib/api/webrtc/disconnectFromPeerChannelLabelQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disconnectFromPeerChannelLabelQuery.d.ts","sourceRoot":"","sources":["../../../src/api/webrtc/disconnectFromPeerChannelLabelQuery.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE1D,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,uCAAuC,EACxC,MAAM,cAAc,CAAC;AAGtB,MAAM,WAAW,gDACf,SAAQ,uCAAuC;IAC/C,eAAe,EAAE,kBAAkB,EAAE,CAAC;IACtC,YAAY,EAAE,eAAe,EAAE,CAAC;CACjC;AAED,QAAA,MAAM,yCAAyC,EAAE,WAAW,CAC1D,gDAAgD,EAChD,IAAI,EACJ,OAAO,CAqIR,CAAC;AAEF,eAAe,yCAAyC,CAAC"}

package/lib/api/webrtc/disconnectFromPeerQuery.d.ts

@@ -0,0 +1,9 @@
+import type { BaseQueryFn } from "@reduxjs/toolkit/query";
+import type { IRTCDataChannel, IRTCPeerConnection, RTCDisconnectFromPeerParams } from "./interfaces";
+export interface RTCDisconnectFromPeerParamsExtension extends RTCDisconnectFromPeerParams {
+    peerConnections: IRTCPeerConnection[];
+    dataChannels: IRTCDataChannel[];
+}
+declare const webrtcDisconnectPeerQuery: BaseQueryFn<RTCDisconnectFromPeerParamsExtension, void, unknown>;
+export default webrtcDisconnectPeerQuery;
+//# sourceMappingURL=disconnectFromPeerQuery.d.ts.map

package/lib/api/webrtc/disconnectFromPeerQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disconnectFromPeerQuery.d.ts","sourceRoot":"","sources":["../../../src/api/webrtc/disconnectFromPeerQuery.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,2BAA2B,EAC5B,MAAM,cAAc,CAAC;AAGtB,MAAM,WAAW,oCACf,SAAQ,2BAA2B;IACnC,eAAe,EAAE,kBAAkB,EAAE,CAAC;IACtC,YAAY,EAAE,eAAe,EAAE,CAAC;CACjC;AAED,QAAA,MAAM,yBAAyB,EAAE,WAAW,CAC1C,oCAAoC,EACpC,IAAI,EACJ,OAAO,CAwDR,CAAC;AAEF,eAAe,yBAAyB,CAAC"}

package/lib/api/webrtc/disconnectFromRoomQuery.d.ts

@@ -0,0 +1,9 @@
+import type { BaseQueryFn } from "@reduxjs/toolkit/query";
+import type { IRTCDataChannel, IRTCPeerConnection, RTCDisconnectFromRoomParams } from "./interfaces";
+export interface RTCDisconnectFromRoomParamsExtension extends RTCDisconnectFromRoomParams {
+    peerConnections: IRTCPeerConnection[];
+    dataChannels: IRTCDataChannel[];
+}
+declare const webrtcDisconnectRoomQuery: BaseQueryFn<RTCDisconnectFromRoomParamsExtension, void, unknown>;
+export default webrtcDisconnectRoomQuery;
+//# sourceMappingURL=disconnectFromRoomQuery.d.ts.map

package/lib/api/webrtc/disconnectFromRoomQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disconnectFromRoomQuery.d.ts","sourceRoot":"","sources":["../../../src/api/webrtc/disconnectFromRoomQuery.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,2BAA2B,EAC5B,MAAM,cAAc,CAAC;AAEtB,MAAM,WAAW,oCACf,SAAQ,2BAA2B;IACnC,eAAe,EAAE,kBAAkB,EAAE,CAAC;IACtC,YAAY,EAAE,eAAe,EAAE,CAAC;CACjC;AAED,QAAA,MAAM,yBAAyB,EAAE,WAAW,CAC1C,oCAAoC,EACpC,IAAI,EACJ,OAAO,CA6ER,CAAC;AAEF,eAAe,yBAAyB,CAAC"}

package/lib/api/webrtc/disconnectQuery.d.ts

@@ -0,0 +1,9 @@
+import type { BaseQueryFn } from "@reduxjs/toolkit/query";
+import type { IRTCDataChannel, IRTCPeerConnection, RTCDisconnectParams } from "./interfaces";
+export interface RTCDisconnectParamsExtension extends RTCDisconnectParams {
+    peerConnections: IRTCPeerConnection[];
+    dataChannels: IRTCDataChannel[];
+}
+declare const webrtcDisconnectQuery: BaseQueryFn<RTCDisconnectParamsExtension, void, unknown>;
+export default webrtcDisconnectQuery;
+//# sourceMappingURL=disconnectQuery.d.ts.map

package/lib/api/webrtc/disconnectQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disconnectQuery.d.ts","sourceRoot":"","sources":["../../../src/api/webrtc/disconnectQuery.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,cAAc,CAAC;AAGtB,MAAM,WAAW,4BAA6B,SAAQ,mBAAmB;IACvE,eAAe,EAAE,kBAAkB,EAAE,CAAC;IACtC,YAAY,EAAE,eAAe,EAAE,CAAC;CACjC;AAED,QAAA,MAAM,qBAAqB,EAAE,WAAW,CACtC,4BAA4B,EAC5B,IAAI,EACJ,OAAO,CA+CR,CAAC;AAEF,eAAe,qBAAqB,CAAC"}

package/lib/api/webrtc/index.d.ts

@@ -0,0 +1,19 @@
+import type { RTCPeerConnectionParams, RTCSendMessageParams, RTCSetDescriptionParams, RTCSetCandidateParams, RTCOpenChannelParams, RTCDisconnectFromRoomParams, RTCDisconnectFromAllRoomsParams, RTCDisconnectFromPeerParams, RTCDisconnectFromChannelLabelParams, RTCDisconnectFromPeerChannelLabelParams, RTCDisconnectParams } from "./interfaces";
+export declare const rtcDataChannelMessageLimit: number;
+export declare const messageLen: number;
+export declare const encryptedLen: number;
+declare const webrtcApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, void, unknown>, {
+    connectWithPeer: import("@reduxjs/toolkit/query").MutationDefinition<RTCPeerConnectionParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, void, unknown>, never, void, "webrtcApi", void>;
+    setDescription: import("@reduxjs/toolkit/query").MutationDefinition<RTCSetDescriptionParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, void, unknown>, never, void, "webrtcApi", void>;
+    setCandidate: import("@reduxjs/toolkit/query").MutationDefinition<RTCSetCandidateParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, void, unknown>, never, void, "webrtcApi", void>;
+    openChannel: import("@reduxjs/toolkit/query").MutationDefinition<RTCOpenChannelParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, void, unknown>, never, void, "webrtcApi", void>;
+    sendMessage: import("@reduxjs/toolkit/query").MutationDefinition<RTCSendMessageParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, void, unknown>, never, void, "webrtcApi", void>;
+    disconnect: import("@reduxjs/toolkit/query").MutationDefinition<RTCDisconnectParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, void, unknown>, never, void, "webrtcApi", void>;
+    disconnectFromRoom: import("@reduxjs/toolkit/query").MutationDefinition<RTCDisconnectFromRoomParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, void, unknown>, never, void, "webrtcApi", void>;
+    disconnectFromAllRooms: import("@reduxjs/toolkit/query").MutationDefinition<RTCDisconnectFromAllRoomsParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, void, unknown>, never, void, "webrtcApi", void>;
+    disconnectFromPeer: import("@reduxjs/toolkit/query").MutationDefinition<RTCDisconnectFromPeerParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, void, unknown>, never, void, "webrtcApi", void>;
+    disconnectFromChannelLabel: import("@reduxjs/toolkit/query").MutationDefinition<RTCDisconnectFromChannelLabelParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, void, unknown>, never, void, "webrtcApi", void>;
+    disconnectFromPeerChannelLabel: import("@reduxjs/toolkit/query").MutationDefinition<RTCDisconnectFromPeerChannelLabelParams, import("@reduxjs/toolkit/query").BaseQueryFn<import("./baseQuery").RTCPeerConnectionParamsExtend, void, unknown>, never, void, "webrtcApi", void>;
+}, "webrtcApi", never, typeof import("@reduxjs/toolkit/query").coreModuleName>;
+export default webrtcApi;
+//# sourceMappingURL=index.d.ts.map

package/lib/api/webrtc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/webrtc/index.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAIV,uBAAuB,EACvB,oBAAoB,EACpB,uBAAuB,EACvB,qBAAqB,EACrB,oBAAoB,EACpB,2BAA2B,EAC3B,+BAA+B,EAC/B,2BAA2B,EAC3B,mCAAmC,EACnC,uCAAuC,EACvC,mBAAmB,EACpB,MAAM,cAAc,CAAC;AAMtB,eAAO,MAAM,0BAA0B,QAAY,CAAC;AACpD,eAAO,MAAM,UAAU,QAIW,CAAC;AACnC,eAAO,MAAM,YAAY,QAC8B,CAAC;AAexD,QAAA,MAAM,SAAS;;;;;;;;;;;;8EA0Jb,CAAC;AAEH,eAAe,SAAS,CAAC"}

package/lib/api/webrtc/interfaces.d.ts

@@ -0,0 +1,101 @@
+export interface IRTCPeerConnection extends RTCPeerConnection {
+    withPeerId: string;
+    withPeerPublicKey: string;
+    roomIds: string[];
+    iceCandidates: RTCIceCandidate[];
+}
+export interface IRTCDataChannel extends RTCDataChannel {
+    withPeerId: string;
+    roomIds: string[];
+}
+export interface IRTCMessage {
+    id: string;
+    message: string;
+    fromPeerId: string;
+    toPeerId: string;
+    channelLabel: string;
+    timestamp: Date;
+}
+export interface IRTCIceCandidate extends RTCIceCandidate {
+    withPeerId: string;
+}
+export interface RTCPeerConnectionParams {
+    peerId: string;
+    peerPublicKey: string;
+    roomId: string;
+    initiator?: boolean;
+    rtcConfig?: RTCConfiguration;
+}
+export interface RTCSetDescriptionParams {
+    peerId: string;
+    peerPublicKey: string;
+    roomId: string;
+    description: RTCSessionDescription;
+    rtcConfig?: RTCConfiguration;
+}
+export interface RTCSetCandidateParams {
+    peerId: string;
+    candidate: RTCIceCandidate;
+}
+export interface RTCOpenChannelParams {
+    roomId: string;
+    channel: string | RTCDataChannel;
+    withPeers?: {
+        peerId: string;
+        peerPublicKey: string;
+    }[];
+}
+export interface RTCSendMessageParams {
+    data: string | File;
+    label: string;
+    roomId: string;
+    minChunks?: number;
+    chunkSize?: number;
+    percentageFilledChunk?: number;
+    metadataSchemaVersion?: number;
+}
+export interface RTCRoomInfoParams {
+    roomId: string;
+}
+export interface ChannelData {
+    label: string;
+    peerId: string;
+}
+export interface PeerData {
+    peerId: string;
+    peerPublicKey: string;
+}
+export interface MessageData extends IRTCMessage {
+    channel: string;
+}
+export interface RoomData {
+    roomId: string;
+    peers: PeerData[];
+    channels: ChannelData[];
+    messages: MessageData[];
+}
+export interface RTCDisconnectParams {
+    alsoDeleteDB: boolean;
+}
+export interface RTCDisconnectFromRoomParams {
+    roomId: string;
+    deleteMessages?: boolean;
+}
+export interface RTCDisconnectFromAllRoomsParams {
+    deleteMessages?: boolean;
+    exceptionRoomIds?: string[];
+}
+export interface RTCDisconnectFromPeerParams {
+    peerId: string;
+    alsoDeleteData?: boolean;
+}
+export interface RTCDisconnectFromChannelLabelParams {
+    label: string;
+    alsoDeleteData?: boolean;
+    alsoSendFinishedMessage?: boolean;
+}
+export interface RTCDisconnectFromPeerChannelLabelParams {
+    peerId: string;
+    label: string;
+}
+//# sourceMappingURL=interfaces.d.ts.map