@m7mdxzx1/discord-video-strem 0.0.1

package/README.md

@@ -0,0 +1,294 @@
+# Discord self-bot video
+
+Fork: [Discord-video-experiment](https://github.com/mrjvs/Discord-video-experiment)
+
+> [!CAUTION]
+> Using any kind of automation programs on your account can result in your account getting permanently banned by Discord. Use at your own risk
+
+This project implements the custom Discord UDP protocol for sending media. Since Discord is likely change their custom protocol, this library is subject to break at any point. An effort will be made to keep this library up to date with the latest Discord protocol, but it is not guranteed.
+
+For better stability it is recommended to use WebRTC protocol instead since Discord is forced to adhere to spec, which means that the non-signaling portion of the code is guaranteed to work.
+
+## Features
+
+- Playing video & audio in a voice channel (`Go Live`, or webcam video)
+
+## Implementation
+
+What I implemented and what I did not.
+
+### Video codecs
+
+- [X] VP8
+- [ ] VP9
+- [X] H.264
+- [X] H.265
+- [ ] AV1
+
+### Packet types
+
+- [X] RTP (sending of realtime data)
+- [ ] RTX (retransmission)
+
+### Connection types
+
+- [X] Regular Voice Connection
+- [X] Go live
+
+### Encryption
+
+- [X] Transport Encryption
+- [ ] [End-to-end Encryption](https://github.com/dank074/Discord-video-stream/issues/102)
+
+### Extras
+
+- [X] Figure out rtp header extensions (discord specific) (discord seems to use one-byte RTP header extension https://www.rfc-editor.org/rfc/rfc8285.html#section-4.2)
+
+Extensions supported by Discord (taken from the webrtc sdp exchange)
+
+```
+"a=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level"
+"a=extmap:2 http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time"
+"a=extmap:3 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01"
+"a=extmap:4 urn:ietf:params:rtp-hdrext:sdes:mid"
+"a=extmap:5 http://www.webrtc.org/experiments/rtp-hdrext/playout-delay"
+"a=extmap:6 http://www.webrtc.org/experiments/rtp-hdrext/video-content-type"
+"a=extmap:7 http://www.webrtc.org/experiments/rtp-hdrext/video-timing"
+"a=extmap:8 http://www.webrtc.org/experiments/rtp-hdrext/color-space"
+"a=extmap:10 urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id"
+"a=extmap:11 urn:ietf:params:rtp-hdrext:sdes:repaired-rtp-stream-id"
+"a=extmap:13 urn:3gpp:video-orientation"
+"a=extmap:14 urn:ietf:params:rtp-hdrext:toffset"
+```
+
+## Requirements
+
+For full functionality, this library requires an FFmpeg build with `libzmq` enabled. Here is our recommendation:
+- Windows & Linux: [BtbN's FFmpeg Builds](https://github.com/BtbN/FFmpeg-Builds)
+- macOS (Intel): [evermeet.cx](https://evermeet.cx/ffmpeg/)
+- macOS (Apple Silicon): Install from Homebrew
+
+## Usage
+
+Install the package, alongside its peer-dependency discord.js-selfbot-v13:
+
+```
+npm install @dank074/discord-video-stream@latest
+npm install discord.js-selfbot-v13@latest
+```
+
+Create a new Streamer, and pass it a selfbot Client
+
+```typescript
+import { Client } from "discord.js-selfbot-v13";
+import { Streamer } from '@dank074/discord-video-stream';
+
+const streamer = new Streamer(new Client());
+await streamer.client.login('TOKEN HERE');
+
+```
+
+Make client join a voice channel
+
+```typescript
+await streamer.joinVoice("GUILD ID HERE", "CHANNEL ID HERE");
+```
+
+Start sending media
+
+```typescript
+import { prepareStream, playStream, Utils } from "@dank074/discord-video-stream"
+try {
+    const { command, output } = prepareStream("DIRECT VIDEO URL OR READABLE STREAM HERE", {
+        // Specify either width or height for aspect ratio aware scaling
+        // Specify both for stretched output
+        height: 1080,
+
+        // Force frame rate, or leave blank to use source frame rate
+        frameRate: 30,
+        bitrateVideo: 5000,
+        bitrateVideoMax: 7500,
+        videoCodec: Utils.normalizeVideoCodec("H264" /* or H265, VP9 */),
+        h26xPreset: "veryfast" // or superfast, ultrafast, ...
+    });
+    command.on("error", (err, stdout, stderr) => {
+        // Handle ffmpeg errors here
+    });
+
+    await playStream(output, streamer, {
+        type: "go-live" // use "camera" for camera stream
+    });
+
+    console.log("Finished playing video");
+} catch (e) {
+    console.log(e);
+}
+```
+
+## Encoder options available
+
+```typescript
+/**
+ * Disable transcoding of the video stream. If specified, all video related
+ * options have no effects
+ * 
+ * Only use this if your video stream is Discord streaming friendly, otherwise
+ * you'll get a glitchy output
+ */
+noTranscoding?: boolean;
+/**
+ * Video output width
+ */
+width?: number;
+/**
+ * Video output height
+ */
+height?: number;
+/**
+ * Video output frames per second
+ */
+fps?: number;
+/**
+ * Video average bitrate in kbps
+ */
+bitrateVideo?: number;
+/**
+ * Video max bitrate in kbps
+ */
+bitrateVideoMax?: number;
+/**
+ * Audio bitrate in kbps
+ */
+bitrateAudio?: number;
+/**
+ * Enable audio output
+ */
+includeAudio?: boolean;
+/**
+ * Enables hardware accelerated video decoding. Enabling this option might result in an exception
+ * being thrown by Ffmpeg process if your system does not support hardware acceleration
+ */
+hardwareAcceleratedDecoding?: boolean;
+/**
+ * Output video codec. **Only** supports H264, H265, and VP8 currently
+ */
+videoCodec?: SupportedVideoCodec;
+/**
+ * Encoding preset for H264 or H265. The faster it is, the lower the quality
+ */
+h26xPreset?: 'ultrafast' | 'superfast' | 'veryfast' | 'faster' | 'fast' | 'medium' | 'slow' | 'slower' | 'veryslow';
+/**
+ * Adds ffmpeg params to minimize latency and start outputting video as fast as possible.
+ * Might create lag in video output in some rare cases
+ */
+minimizeLatency?: boolean;
+/**
+ * Custom headers for HTTP requests
+ */
+customHeaders?: Record<string, string>;
+/**
+ * Custom ffmpeg flags/options to pass directly to ffmpeg
+ * These will be added to the command after other options
+ */
+customFfmpegFlags?: string[];
+```
+
+## `playStream` options available
+
+```typescript
+/**
+ * Set stream type as "Go Live" or camera stream
+ */
+type?: "go-live" | "camera",
+
+/**
+ * Override video width sent to Discord.
+ * 
+ * DO NOT SPECIFY UNLESS YOU KNOW WHAT YOU'RE DOING!
+ */
+width?: number,
+
+/**
+ * Override video height sent to Discord.
+ * 
+ * DO NOT SPECIFY UNLESS YOU KNOW WHAT YOU'RE DOING!
+ */
+height?: number,
+
+/**
+ * Override video frame rate sent to Discord.
+ * 
+ * DO NOT SPECIFY UNLESS YOU KNOW WHAT YOU'RE DOING!
+ */
+frameRate?: number,
+
+/**
+ * Same as ffmpeg's `readrate_initial_burst` command line flag
+ * 
+ * See https://ffmpeg.org/ffmpeg.html#:~:text=%2Dreadrate_initial_burst
+ */
+readrateInitialBurst?: number,
+```
+
+## Streamer options available
+
+These control internal operations of the library, and can be changed through the `opts` property on the `Streamer` class. You probably shouldn't change it without a good reason
+
+```typescript
+/**
+ * Enables sending RTCP sender reports. Helps the receiver synchronize the
+ * audio/video frames, except in some weird cases which is why you can disable it
+ */
+rtcpSenderReportEnabled?: boolean;
+/**
+ * ChaCha20-Poly1305 Encryption is faster than AES-256-GCM, except when using AES-NI
+ */
+forceChacha20Encryption?: boolean;
+```
+
+## Performance tips
+
+See [this page](./PERFORMANCE.md) for some tips on improving performance
+
+## Running example
+
+`examples/basic/src/config.json`:
+
+```json
+"token": "SELF TOKEN HERE",
+"acceptedAuthors": ["USER_ID_HERE"],
+```
+
+1. Configure your `config.json` with your accepted authors ids, and your self token
+2. Generate js files with ```npm run build```
+3. Start program with: ```npm run start```
+4. Join a voice channel
+5. Start streaming with commands:
+
+for go-live
+
+```
+$play-live <Direct video link>
+```
+
+or for cam
+
+```
+$play-cam <Direct video link>
+```
+
+for example:
+
+```
+$play-live http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4
+```
+
+## FAQS
+
+- Can I stream on existing voice connection (CAM) and in a go-live connection simultaneously?
+
+Yes, just send the media packets over both udp connections. The voice gateway expects you to signal when a user turns on their camera, so make sure you signal using `client.signalVideo(guildId, channelId, true)` before you start sending cam media packets.
+
+- Does this library work with bot tokens?
+
+No, Discord blocks video from bots which is why this library uses a selfbot library as peer dependency. You must use a user token

package/dist/client/GatewayEvents.d.ts

@@ -0,0 +1,27 @@
+type GatewayEventGeneric<Type extends string = string, Data = unknown> = {
+    t: Type;
+    d: Data;
+};
+export declare namespace GatewayEvent {
+    type VoiceStateUpdate = GatewayEventGeneric<"VOICE_STATE_UPDATE", {
+        user_id: string;
+        session_id: string;
+    }>;
+    type VoiceServerUpdate = GatewayEventGeneric<"VOICE_SERVER_UPDATE", {
+        guild_id: string;
+        channel_id?: string;
+        endpoint: string;
+        token: string;
+    }>;
+    type StreamCreate = GatewayEventGeneric<"STREAM_CREATE", {
+        stream_key: string;
+        rtc_server_id: string;
+    }>;
+    type StreamServerUpdate = GatewayEventGeneric<"STREAM_SERVER_UPDATE", {
+        stream_key: string;
+        endpoint: string;
+        token: string;
+    }>;
+}
+export type GatewayEvent = GatewayEvent.VoiceStateUpdate | GatewayEvent.VoiceServerUpdate | GatewayEvent.StreamCreate | GatewayEvent.StreamServerUpdate;
+export {};

package/dist/client/GatewayEvents.js

@@ -0,0 +1 @@
+export {};

package/dist/client/GatewayOpCodes.d.ts

@@ -0,0 +1,40 @@
+export declare enum GatewayOpCodes {
+    DISPATCH = 0,
+    HEARTBEAT = 1,
+    IDENTIFY = 2,
+    PRESENCE_UPDATE = 3,
+    VOICE_STATE_UPDATE = 4,
+    VOICE_SERVER_PING = 5,
+    RESUME = 6,
+    RECONNECT = 7,
+    REQUEST_GUILD_MEMBERS = 8,
+    INVALID_SESSION = 9,
+    HELLO = 10,
+    HEARTBEAT_ACK = 11,
+    CALL_CONNECT = 13,
+    GUILD_SUBSCRIPTIONS = 14,
+    LOBBY_CONNECT = 15,
+    LOBBY_DISCONNECT = 16,
+    LOBBY_VOICE_STATES_UPDATE = 17,
+    STREAM_CREATE = 18,
+    STREAM_DELETE = 19,
+    STREAM_WATCH = 20,
+    STREAM_PING = 21,
+    STREAM_SET_PAUSED = 22,
+    REQUEST_GUILD_APPLICATION_COMMANDS = 24,
+    EMBEDDED_ACTIVITY_LAUNCH = 25,
+    EMBEDDED_ACTIVITY_CLOSE = 26,
+    EMBEDDED_ACTIVITY_UPDATE = 27,
+    REQUEST_FORUM_UNREADS = 28,
+    REMOTE_COMMAND = 29,
+    GET_DELETED_ENTITY_IDS_NOT_MATCHING_HASH = 30,
+    REQUEST_SOUNDBOARD_SOUNDS = 31,
+    SPEED_TEST_CREATE = 32,
+    SPEED_TEST_DELETE = 33,
+    REQUEST_LAST_MESSAGES = 34,
+    SEARCH_RECENT_MEMBERS = 35,
+    REQUEST_CHANNEL_STATUSES = 36,
+    GUILD_SUBSCRIPTIONS_BULK = 37,
+    GUILD_CHANNELS_RESYNC = 38,
+    REQUEST_CHANNEL_MEMBER_COUNT = 39
+}

package/dist/client/GatewayOpCodes.js

@@ -0,0 +1,41 @@
+export var GatewayOpCodes;
+(function (GatewayOpCodes) {
+    GatewayOpCodes[GatewayOpCodes["DISPATCH"] = 0] = "DISPATCH";
+    GatewayOpCodes[GatewayOpCodes["HEARTBEAT"] = 1] = "HEARTBEAT";
+    GatewayOpCodes[GatewayOpCodes["IDENTIFY"] = 2] = "IDENTIFY";
+    GatewayOpCodes[GatewayOpCodes["PRESENCE_UPDATE"] = 3] = "PRESENCE_UPDATE";
+    GatewayOpCodes[GatewayOpCodes["VOICE_STATE_UPDATE"] = 4] = "VOICE_STATE_UPDATE";
+    GatewayOpCodes[GatewayOpCodes["VOICE_SERVER_PING"] = 5] = "VOICE_SERVER_PING";
+    GatewayOpCodes[GatewayOpCodes["RESUME"] = 6] = "RESUME";
+    GatewayOpCodes[GatewayOpCodes["RECONNECT"] = 7] = "RECONNECT";
+    GatewayOpCodes[GatewayOpCodes["REQUEST_GUILD_MEMBERS"] = 8] = "REQUEST_GUILD_MEMBERS";
+    GatewayOpCodes[GatewayOpCodes["INVALID_SESSION"] = 9] = "INVALID_SESSION";
+    GatewayOpCodes[GatewayOpCodes["HELLO"] = 10] = "HELLO";
+    GatewayOpCodes[GatewayOpCodes["HEARTBEAT_ACK"] = 11] = "HEARTBEAT_ACK";
+    GatewayOpCodes[GatewayOpCodes["CALL_CONNECT"] = 13] = "CALL_CONNECT";
+    GatewayOpCodes[GatewayOpCodes["GUILD_SUBSCRIPTIONS"] = 14] = "GUILD_SUBSCRIPTIONS";
+    GatewayOpCodes[GatewayOpCodes["LOBBY_CONNECT"] = 15] = "LOBBY_CONNECT";
+    GatewayOpCodes[GatewayOpCodes["LOBBY_DISCONNECT"] = 16] = "LOBBY_DISCONNECT";
+    GatewayOpCodes[GatewayOpCodes["LOBBY_VOICE_STATES_UPDATE"] = 17] = "LOBBY_VOICE_STATES_UPDATE";
+    GatewayOpCodes[GatewayOpCodes["STREAM_CREATE"] = 18] = "STREAM_CREATE";
+    GatewayOpCodes[GatewayOpCodes["STREAM_DELETE"] = 19] = "STREAM_DELETE";
+    GatewayOpCodes[GatewayOpCodes["STREAM_WATCH"] = 20] = "STREAM_WATCH";
+    GatewayOpCodes[GatewayOpCodes["STREAM_PING"] = 21] = "STREAM_PING";
+    GatewayOpCodes[GatewayOpCodes["STREAM_SET_PAUSED"] = 22] = "STREAM_SET_PAUSED";
+    GatewayOpCodes[GatewayOpCodes["REQUEST_GUILD_APPLICATION_COMMANDS"] = 24] = "REQUEST_GUILD_APPLICATION_COMMANDS";
+    GatewayOpCodes[GatewayOpCodes["EMBEDDED_ACTIVITY_LAUNCH"] = 25] = "EMBEDDED_ACTIVITY_LAUNCH";
+    GatewayOpCodes[GatewayOpCodes["EMBEDDED_ACTIVITY_CLOSE"] = 26] = "EMBEDDED_ACTIVITY_CLOSE";
+    GatewayOpCodes[GatewayOpCodes["EMBEDDED_ACTIVITY_UPDATE"] = 27] = "EMBEDDED_ACTIVITY_UPDATE";
+    GatewayOpCodes[GatewayOpCodes["REQUEST_FORUM_UNREADS"] = 28] = "REQUEST_FORUM_UNREADS";
+    GatewayOpCodes[GatewayOpCodes["REMOTE_COMMAND"] = 29] = "REMOTE_COMMAND";
+    GatewayOpCodes[GatewayOpCodes["GET_DELETED_ENTITY_IDS_NOT_MATCHING_HASH"] = 30] = "GET_DELETED_ENTITY_IDS_NOT_MATCHING_HASH";
+    GatewayOpCodes[GatewayOpCodes["REQUEST_SOUNDBOARD_SOUNDS"] = 31] = "REQUEST_SOUNDBOARD_SOUNDS";
+    GatewayOpCodes[GatewayOpCodes["SPEED_TEST_CREATE"] = 32] = "SPEED_TEST_CREATE";
+    GatewayOpCodes[GatewayOpCodes["SPEED_TEST_DELETE"] = 33] = "SPEED_TEST_DELETE";
+    GatewayOpCodes[GatewayOpCodes["REQUEST_LAST_MESSAGES"] = 34] = "REQUEST_LAST_MESSAGES";
+    GatewayOpCodes[GatewayOpCodes["SEARCH_RECENT_MEMBERS"] = 35] = "SEARCH_RECENT_MEMBERS";
+    GatewayOpCodes[GatewayOpCodes["REQUEST_CHANNEL_STATUSES"] = 36] = "REQUEST_CHANNEL_STATUSES";
+    GatewayOpCodes[GatewayOpCodes["GUILD_SUBSCRIPTIONS_BULK"] = 37] = "GUILD_SUBSCRIPTIONS_BULK";
+    GatewayOpCodes[GatewayOpCodes["GUILD_CHANNELS_RESYNC"] = 38] = "GUILD_CHANNELS_RESYNC";
+    GatewayOpCodes[GatewayOpCodes["REQUEST_CHANNEL_MEMBER_COUNT"] = 39] = "REQUEST_CHANNEL_MEMBER_COUNT";
+})(GatewayOpCodes || (GatewayOpCodes = {}));

package/dist/client/Streamer.d.ts

@@ -0,0 +1,41 @@
+import { VoiceConnection } from "./voice/VoiceConnection.js";
+import type { Client, DMChannel, GroupDMChannel, VoiceBasedChannel } from 'discord.js-selfbot-v13';
+import type { MediaUdp } from "./voice/MediaUdp.js";
+export type StreamerOptions = {
+    /**
+     * Force the use of ChaCha20 encryption. Faster on CPUs without AES-NI
+     */
+    forceChacha20Encryption: boolean;
+    /**
+     * Enable RTCP Sender Report for synchronization
+     */
+    rtcpSenderReportEnabled: boolean;
+};
+export declare class Streamer {
+    private _voiceConnection?;
+    private _client;
+    private _opts;
+    private _gatewayEmitter;
+    constructor(client: Client, opts?: Partial<StreamerOptions>);
+    get client(): Client;
+    get opts(): StreamerOptions;
+    get voiceConnection(): VoiceConnection | undefined;
+    sendOpcode(code: number, data: unknown): void;
+    joinVoiceChannel(channel: DMChannel | GroupDMChannel | VoiceBasedChannel): Promise<MediaUdp>;
+    /**
+     * Joins a voice channel and returns a MediaUdp object.
+     * @param guild_id the guild id of the voice channel. If null, it will join a DM voice channel.
+     * @param channel_id the channel id of the voice channel
+     * @returns the MediaUdp object
+     * @throws Error if the client is not logged in
+     */
+    joinVoice(guild_id: string | null, channel_id: string): Promise<MediaUdp>;
+    createStream(): Promise<MediaUdp>;
+    setStreamPreview(image: Buffer): Promise<void>;
+    stopStream(): void;
+    leaveVoice(): void;
+    signalVideo(video_enabled: boolean): void;
+    signalStream(): void;
+    signalStopStream(): void;
+    signalLeaveVoice(): void;
+}

package/dist/client/Streamer.js

@@ -0,0 +1,189 @@
+import { EventEmitter } from "node:events";
+import { VoiceConnection } from "./voice/VoiceConnection.js";
+import { StreamConnection } from "./voice/StreamConnection.js";
+import { GatewayOpCodes } from "./GatewayOpCodes.js";
+import { generateStreamKey, parseStreamKey } from "../utils.js";
+export class Streamer {
+    constructor(client, opts) {
+        this._gatewayEmitter = new EventEmitter();
+        this._client = client;
+        this._opts = {
+            forceChacha20Encryption: false,
+            rtcpSenderReportEnabled: true,
+            ...opts
+        };
+        //listen for messages
+        this.client.on('raw', (packet) => {
+            // @ts-expect-error I don't know how to make this work with TypeScript, so whatever
+            this._gatewayEmitter.emit(packet.t, packet.d);
+        });
+    }
+    get client() {
+        return this._client;
+    }
+    get opts() {
+        return this._opts;
+    }
+    get voiceConnection() {
+        return this._voiceConnection;
+    }
+    sendOpcode(code, data) {
+        this.client.ws.broadcast({
+            op: code,
+            d: data,
+        });
+    }
+    joinVoiceChannel(channel) {
+        let guildId = null;
+        if (channel.type === "GUILD_STAGE_VOICE" || channel.type === "GUILD_VOICE") {
+            guildId = channel.guildId;
+        }
+        return this.joinVoice(guildId, channel.id);
+    }
+    /**
+     * Joins a voice channel and returns a MediaUdp object.
+     * @param guild_id the guild id of the voice channel. If null, it will join a DM voice channel.
+     * @param channel_id the channel id of the voice channel
+     * @returns the MediaUdp object
+     * @throws Error if the client is not logged in
+     */
+    joinVoice(guild_id, channel_id) {
+        return new Promise((resolve, reject) => {
+            if (!this.client.user) {
+                reject("Client not logged in");
+                return;
+            }
+            const user_id = this.client.user.id;
+            const voiceConn = new VoiceConnection(this, guild_id, user_id, channel_id, (udp) => {
+                resolve(udp);
+            });
+            this._voiceConnection = voiceConn;
+            this._gatewayEmitter.on("VOICE_STATE_UPDATE", (d) => {
+                if (user_id !== d.user_id)
+                    return;
+                voiceConn.setSession(d.session_id);
+            });
+            this._gatewayEmitter.on("VOICE_SERVER_UPDATE", (d) => {
+                if (guild_id !== d.guild_id)
+                    return;
+                // channel_id is not set for guild voice calls
+                if (d.channel_id && (channel_id !== d.channel_id))
+                    return;
+                voiceConn.setTokens(d.endpoint, d.token);
+            });
+            this.signalVideo(false);
+        });
+    }
+    createStream() {
+        return new Promise((resolve, reject) => {
+            if (!this.client.user) {
+                reject("Client not logged in");
+                return;
+            }
+            if (!this.voiceConnection) {
+                reject("cannot start stream without first joining voice channel");
+                return;
+            }
+            this.signalStream();
+            const { guildId: clientGuildId, channelId: clientChannelId, session_id } = this.voiceConnection;
+            const { id: clientUserId } = this.client.user;
+            if (!session_id)
+                throw new Error("Session doesn't exist yet");
+            const streamConn = new StreamConnection(this, clientGuildId, clientUserId, clientChannelId, (udp) => {
+                resolve(udp);
+            });
+            this.voiceConnection.streamConnection = streamConn;
+            this._gatewayEmitter.on("STREAM_CREATE", (d) => {
+                const { type, channelId, guildId, userId } = parseStreamKey(d.stream_key);
+                if (clientGuildId !== guildId ||
+                    clientChannelId !== channelId ||
+                    clientUserId !== userId)
+                    return;
+                streamConn.serverId = d.rtc_server_id;
+                streamConn.streamKey = d.stream_key;
+                streamConn.setSession(session_id);
+            });
+            this._gatewayEmitter.on("STREAM_SERVER_UPDATE", (d) => {
+                const { type, channelId, guildId, userId } = parseStreamKey(d.stream_key);
+                if (clientGuildId !== guildId ||
+                    clientChannelId !== channelId ||
+                    clientUserId !== userId)
+                    return;
+                streamConn.setTokens(d.endpoint, d.token);
+            });
+        });
+    }
+    async setStreamPreview(image) {
+        if (!this.client.token)
+            throw new Error("Please login :)");
+        if (!this.voiceConnection?.streamConnection?.guildId)
+            return;
+        const data = `data:image/jpeg;base64,${image.toString("base64")}`;
+        const { guildId } = this.voiceConnection.streamConnection;
+        const server = await this.client.guilds.fetch(guildId);
+        await server.members.me?.voice.postPreview(data);
+    }
+    stopStream() {
+        const stream = this.voiceConnection?.streamConnection;
+        if (!stream)
+            return;
+        stream.stop();
+        this.signalStopStream();
+        this.voiceConnection.streamConnection = undefined;
+        this._gatewayEmitter.removeAllListeners("STREAM_CREATE");
+        this._gatewayEmitter.removeAllListeners("STREAM_SERVER_UPDATE");
+    }
+    leaveVoice() {
+        this.voiceConnection?.stop();
+        this.signalLeaveVoice();
+        this._voiceConnection = undefined;
+        this._gatewayEmitter.removeAllListeners("VOICE_STATE_UPDATE");
+        this._gatewayEmitter.removeAllListeners("VOICE_SERVER_UPDATE");
+    }
+    signalVideo(video_enabled) {
+        if (!this.voiceConnection)
+            return;
+        const { guildId: guild_id, channelId: channel_id, } = this.voiceConnection;
+        this.sendOpcode(GatewayOpCodes.VOICE_STATE_UPDATE, {
+            guild_id: guild_id,
+            channel_id,
+            self_mute: false,
+            self_deaf: true,
+            self_video: video_enabled,
+        });
+    }
+    signalStream() {
+        if (!this.voiceConnection)
+            return;
+        const { type, guildId: guild_id, channelId: channel_id, botId: user_id } = this.voiceConnection;
+        const streamKey = generateStreamKey(type, guild_id, channel_id, user_id);
+        this.sendOpcode(GatewayOpCodes.STREAM_CREATE, {
+            type,
+            guild_id,
+            channel_id,
+            preferred_region: null,
+        });
+        this.sendOpcode(GatewayOpCodes.STREAM_SET_PAUSED, {
+            stream_key: streamKey,
+            paused: false,
+        });
+    }
+    signalStopStream() {
+        if (!this.voiceConnection)
+            return;
+        const { type, guildId: guild_id, channelId: channel_id, botId: user_id } = this.voiceConnection;
+        const streamKey = generateStreamKey(type, guild_id, channel_id, user_id);
+        this.sendOpcode(GatewayOpCodes.STREAM_DELETE, {
+            stream_key: streamKey
+        });
+    }
+    signalLeaveVoice() {
+        this.sendOpcode(GatewayOpCodes.VOICE_STATE_UPDATE, {
+            guild_id: null,
+            channel_id: null,
+            self_mute: true,
+            self_deaf: false,
+            self_video: false,
+        });
+    }
+}

package/dist/client/encryptor/TransportEncryptor.d.ts

@@ -0,0 +1,16 @@
+export interface TransportEncryptor {
+    encrypt(plaintext: Buffer, additionalData: Buffer): Promise<[Buffer, Buffer]>;
+}
+export declare class AES256TransportEncryptor implements TransportEncryptor {
+    private _nonce;
+    private _secretKey;
+    constructor(secretKey: Buffer);
+    encrypt(plaintext: Buffer, additionalData: Buffer): Promise<[Buffer, Buffer]>;
+}
+export declare class Chacha20TransportEncryptor implements TransportEncryptor {
+    private static sodium;
+    private _nonce;
+    private _secretKey;
+    constructor(secretKey: Buffer);
+    encrypt(plaintext: Buffer, additionalData: Buffer): Promise<[Buffer, Buffer]>;
+}

package/dist/client/encryptor/TransportEncryptor.js

@@ -0,0 +1,38 @@
+import sp from "sodium-plus";
+import { max_int32bit } from "../../utils.js";
+const { SodiumPlus } = sp;
+export class AES256TransportEncryptor {
+    constructor(secretKey) {
+        this._nonce = 0;
+        this._secretKey = crypto.subtle.importKey("raw", secretKey, {
+            name: "AES-GCM",
+            length: 32
+        }, false, ["encrypt"]);
+    }
+    async encrypt(plaintext, additionalData) {
+        const nonceBuffer = Buffer.alloc(12);
+        nonceBuffer.writeUInt32BE(this._nonce);
+        this._nonce = (this._nonce + 1) % max_int32bit;
+        const ciphertext = Buffer.from(await crypto.subtle.encrypt({
+            name: "AES-GCM",
+            iv: nonceBuffer,
+            additionalData,
+        }, await this._secretKey, plaintext));
+        return [ciphertext, nonceBuffer];
+    }
+}
+export class Chacha20TransportEncryptor {
+    constructor(secretKey) {
+        this._nonce = 0;
+        this._secretKey = new sp.CryptographyKey(secretKey);
+    }
+    async encrypt(plaintext, additionalData) {
+        const nonceBuffer = Buffer.alloc(24);
+        nonceBuffer.writeUInt32BE(this._nonce);
+        this._nonce = (this._nonce + 1) % max_int32bit;
+        const ciphertext = await Chacha20TransportEncryptor.sodium
+            .then(s => s.crypto_aead_xchacha20poly1305_ietf_encrypt(plaintext, nonceBuffer, this._secretKey, additionalData));
+        return [ciphertext, nonceBuffer];
+    }
+}
+Chacha20TransportEncryptor.sodium = SodiumPlus.auto();