@livekit/rtc-node 0.0.2 → 0.0.4

package/dist/video_stream.d.ts

@@ -0,0 +1,24 @@
+import { FfiHandle } from './ffi_client';
+import { Track } from './track';
+import TypedEmitter from 'typed-emitter';
+import { VideoFrame } from './video_frame';
+import { VideoStreamInfo } from './proto/video_frame_pb';
+export type VideoStreamCallbacks = {
+    frameReceived: (frame: VideoFrame) => void;
+};
+export declare enum VideoStreamEvent {
+    FrameReceived = "frameReceived"
+}
+declare const VideoStream_base: new () => TypedEmitter<VideoStreamCallbacks>;
+export declare class VideoStream extends VideoStream_base {
+    /** @internal */
+    info: VideoStreamInfo;
+    /** @internal */
+    ffiHandle: FfiHandle;
+    track: Track;
+    constructor(track: Track);
+    private onEvent;
+    close(): void;
+}
+export {};
+//# sourceMappingURL=video_stream.d.ts.map

package/dist/video_stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"video_stream.d.ts","sourceRoot":"","sources":["../src/video_stream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuC,SAAS,EAAc,MAAM,cAAc,CAAC;AAC1F,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,OAAO,YAAY,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,UAAU,EAAoB,MAAM,eAAe,CAAC;AAC7D,OAAO,EAGL,eAAe,EAEhB,MAAM,wBAAwB,CAAC;AAEhC,MAAM,MAAM,oBAAoB,GAAG;IACjC,aAAa,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;CAC5C,CAAC;AAEF,oBAAY,gBAAgB;IAC1B,aAAa,kBAAkB;CAChC;0CAE2D,aAAa,oBAAoB,CAAC;AAA9F,qBAAa,WAAY,SAAQ,gBAA8D;IAC7F,gBAAgB;IAChB,IAAI,EAAE,eAAe,CAAC;IACtB,gBAAgB;IAChB,SAAS,EAAE,SAAS,CAAC;IAErB,KAAK,EAAE,KAAK,CAAC;gBAED,KAAK,EAAE,KAAK;IAsBxB,OAAO,CAAC,OAAO;IAsBf,KAAK;CAGN"}

package/dist/video_stream.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VideoStream = exports.VideoStreamEvent = void 0;
+const ffi_client_1 = require("./ffi_client");
+const events_1 = __importDefault(require("events"));
+const video_frame_1 = require("./video_frame");
+const video_frame_pb_1 = require("./proto/video_frame_pb");
+var VideoStreamEvent;
+(function (VideoStreamEvent) {
+    VideoStreamEvent["FrameReceived"] = "frameReceived";
+})(VideoStreamEvent || (exports.VideoStreamEvent = VideoStreamEvent = {}));
+class VideoStream extends events_1.default {
+    constructor(track) {
+        super();
+        this.track = track;
+        let req = new video_frame_pb_1.NewVideoStreamRequest({
+            type: video_frame_pb_1.VideoStreamType.VIDEO_STREAM_NATIVE,
+            trackHandle: track.ffi_handle.handle,
+        });
+        let res = ffi_client_1.FfiClient.instance.request({
+            message: {
+                case: 'newVideoStream',
+                value: req,
+            },
+        });
+        this.info = res.stream.info;
+        this.ffiHandle = new ffi_client_1.FfiHandle(res.stream.handle.id);
+        ffi_client_1.FfiClient.instance.on(ffi_client_1.FfiClientEvent.FfiEvent, this.onEvent);
+    }
+    onEvent(ev) {
+        if (ev.message.case != 'videoStreamEvent' ||
+            ev.message.value.streamHandle != this.ffiHandle.handle) {
+            return;
+        }
+        let streamEvent = ev.message.value.message;
+        switch (streamEvent.case) {
+            case 'frameReceived':
+                let frameInfo = streamEvent.value.frame;
+                let buffer = video_frame_1.VideoFrameBuffer.fromOwnedInfo(streamEvent.value.buffer);
+                let frame = new video_frame_1.VideoFrame(Number(frameInfo.timestampUs), frameInfo.rotation, buffer);
+                this.emit(VideoStreamEvent.FrameReceived, frame);
+                break;
+            case 'eos':
+                ffi_client_1.FfiClient.instance.off(ffi_client_1.FfiClientEvent.FfiEvent, this.onEvent);
+                break;
+        }
+    }
+    close() {
+        this.ffiHandle.dispose();
+    }
+}
+exports.VideoStream = VideoStream;
+//# sourceMappingURL=video_stream.js.map

package/dist/video_stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"video_stream.js","sourceRoot":"","sources":["../src/video_stream.ts"],"names":[],"mappings":";;;;;;AAAA,6CAA0F;AAE1F,oDAAkC;AAElC,+CAA6D;AAC7D,2DAKgC;AAMhC,IAAY,gBAEX;AAFD,WAAY,gBAAgB;IAC1B,mDAA+B,CAAA;AACjC,CAAC,EAFW,gBAAgB,gCAAhB,gBAAgB,QAE3B;AAED,MAAa,WAAY,SAAS,gBAA6D;IAQ7F,YAAY,KAAY;QACtB,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QAEnB,IAAI,GAAG,GAAG,IAAI,sCAAqB,CAAC;YAClC,IAAI,EAAE,gCAAe,CAAC,mBAAmB;YACzC,WAAW,EAAE,KAAK,CAAC,UAAU,CAAC,MAAM;SACrC,CAAC,CAAC;QAEH,IAAI,GAAG,GAAG,sBAAS,CAAC,QAAQ,CAAC,OAAO,CAAyB;YAC3D,OAAO,EAAE;gBACP,IAAI,EAAE,gBAAgB;gBACtB,KAAK,EAAE,GAAG;aACX;SACF,CAAC,CAAC;QAEH,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC;QAC5B,IAAI,CAAC,SAAS,GAAG,IAAI,sBAAS,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QAErD,sBAAS,CAAC,QAAQ,CAAC,EAAE,CAAC,2BAAc,CAAC,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IAC/D,CAAC;IAEO,OAAO,CAAC,EAAY;QAC1B,IACE,EAAE,CAAC,OAAO,CAAC,IAAI,IAAI,kBAAkB;YACrC,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,YAAY,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,EACtD,CAAC;YACD,OAAO;QACT,CAAC;QAED,IAAI,WAAW,GAAG,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC;QAC3C,QAAQ,WAAW,CAAC,IAAI,EAAE,CAAC;YACzB,KAAK,eAAe;gBAClB,IAAI,SAAS,GAAG,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC;gBACxC,IAAI,MAAM,GAAG,8BAAgB,CAAC,aAAa,CAAC,WAAW,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;gBACtE,IAAI,KAAK,GAAG,IAAI,wBAAU,CAAC,MAAM,CAAC,SAAS,CAAC,WAAW,CAAC,EAAE,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;gBACtF,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;gBACjD,MAAM;YACR,KAAK,KAAK;gBACR,sBAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,2BAAc,CAAC,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;gBAC9D,MAAM;QACV,CAAC;IACH,CAAC;IAED,KAAK;QACH,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;CACF;AAvDD,kCAuDC"}

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "@livekit/rtc-node",
   "description": "LiveKit RTC Node",
-  "version": "0.0.2",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
+  "license": "Apache-2.0",
+  "version": "0.0.4",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "files": [
-    "lib/**/*"
+    "dist",
+    "src",
+    "build.rs",
+    "Cargo.toml",
+    "Cargo.lock"
   ],
   "napi": {
     "name": "rtc-node",
@@ -20,14 +25,13 @@
       ]
     }
   },
-  "license": "Apache-2.0",
   "dependencies": {
-    "@bufbuild/protobuf": "^1.4.2"
+    "@bufbuild/protobuf": "^1.4.2",
+    "typed-emitter": "^2.1.0"
   },
   "devDependencies": {
     "@napi-rs/cli": "^2.16.5",
     "@types/node": "^20.9.2",
-    "typed-emitter": "^2.1.0",
     "typescript": "^5.2.2",
     "prettier": "^3.0.3"
   },
@@ -35,18 +39,19 @@
     "node": ">= 10"
   },
   "scripts": {
-    "artifacts": "napi artifacts",
-    "build": "tsc && napi build --platform --release --dts src/native.d.ts --js src/native.js --pipe \"prettier -w\"",
+    "build:tsc": "tsc && cp src/native.d.ts dist/native.d.ts",
+    "build": "yarn build:tsc && napi build --platform --release --dts src/native.d.ts --js src/native.js --pipe \"prettier -w\"",
+    "artifacts": "yarn build:tsc && napi artifacts",
     "build:debug": "napi build --platform",
     "prepublishOnly": "napi prepublish -t npm",
     "universal": "napi universal",
     "version": "napi version"
   },
   "optionalDependencies": {
-    "@livekit/rtc-node-darwin-arm64": "0.0.2",
-    "@livekit/rtc-node-darwin-x64": "0.0.2",
-    "@livekit/rtc-node-linux-arm64-gnu": "0.0.2",
-    "@livekit/rtc-node-linux-x64-gnu": "0.0.2",
-    "@livekit/rtc-node-win32-x64-msvc": "0.0.2"
+    "@livekit/rtc-node-darwin-arm64": "0.0.4",
+    "@livekit/rtc-node-darwin-x64": "0.0.4",
+    "@livekit/rtc-node-linux-arm64-gnu": "0.0.4",
+    "@livekit/rtc-node-linux-x64-gnu": "0.0.4",
+    "@livekit/rtc-node-win32-x64-msvc": "0.0.4"
   }
 }

package/src/audio_frame.ts

@@ -0,0 +1,45 @@
+import { FfiClient, FfiHandle } from './ffi_client';
+import { AudioFrameBufferInfo, OwnedAudioFrameBuffer } from './proto/audio_frame_pb';
+
+export class AudioFrame {
+  data: Uint16Array;
+  sampleRate: number;
+  channels: number;
+  samplesPerChannel: number;
+
+  constructor(data: Uint16Array, sampleRate: number, channels: number, samplesPerChannel: number) {
+    this.data = data;
+    this.sampleRate = sampleRate;
+    this.channels = channels;
+    this.samplesPerChannel = samplesPerChannel;
+  }
+
+  static create(sampleRate: number, channels: number, samplesPerChannel: number): AudioFrame {
+    const data = new Uint16Array(channels * samplesPerChannel);
+    return new AudioFrame(data, sampleRate, channels, samplesPerChannel);
+  }
+
+  /** @internal */
+  static fromOwnedInfo(owned: OwnedAudioFrameBuffer): AudioFrame {
+    let info = owned.info;
+    let len = info.numChannels * info.samplesPerChannel * 2; // c_int16
+    let data = FfiClient.instance.copyBuffer(info.dataPtr, len);
+    new FfiHandle(owned.handle.id).dispose();
+    return new AudioFrame(
+      new Uint16Array(data.buffer),
+      info.sampleRate,
+      info.numChannels,
+      info.samplesPerChannel,
+    );
+  }
+
+  /** @internal */
+  protoInfo(): AudioFrameBufferInfo {
+    return new AudioFrameBufferInfo({
+      dataPtr: FfiClient.instance.retrievePtr(new Uint8Array(this.data.buffer)),
+      sampleRate: this.sampleRate,
+      numChannels: this.channels,
+      samplesPerChannel: this.samplesPerChannel,
+    });
+  }
+}

package/src/audio_source.ts

@@ -0,0 +1,64 @@
+import EventEmitter from 'events';
+import TypedEmitter from 'typed-emitter';
+import { FfiHandle } from './native';
+import { AudioFrame } from './audio_frame';
+import {
+  AudioSourceInfo,
+  AudioSourceType,
+  CaptureAudioFrameCallback,
+  CaptureAudioFrameRequest,
+  CaptureAudioFrameResponse,
+  NewAudioSourceRequest,
+  NewAudioSourceResponse,
+} from './proto/audio_frame_pb';
+import { FfiClient, FfiRequest } from './ffi_client';
+
+export class AudioSource {
+  /** @internal */
+  info: AudioSourceInfo;
+  /** @internal */
+  ffiHandle: FfiHandle;
+
+  sampleRate: number;
+  numChannels: number;
+
+  constructor(sampleRate: number, numChannels: number) {
+    this.sampleRate = sampleRate;
+    this.numChannels = numChannels;
+
+    let req = new NewAudioSourceRequest({
+      type: AudioSourceType.AUDIO_SOURCE_NATIVE,
+      sampleRate: sampleRate,
+      numChannels: numChannels,
+    });
+
+    let res = FfiClient.instance.request<NewAudioSourceResponse>({
+      message: {
+        case: 'newAudioSource',
+        value: req,
+      },
+    });
+
+    this.info = res.source.info;
+    this.ffiHandle = new FfiHandle(res.source.handle.id);
+  }
+
+  async captureFrame(frame: AudioFrame) {
+    let req = new CaptureAudioFrameRequest({
+      sourceHandle: this.ffiHandle.handle,
+      buffer: frame.protoInfo(),
+    });
+
+    let res = FfiClient.instance.request<CaptureAudioFrameResponse>({
+      message: { case: 'captureAudioFrame', value: req },
+    });
+
+    let cb = await FfiClient.instance.waitFor<CaptureAudioFrameCallback>((ev) => {
+      return ev.message.case == 'captureAudioFrame' && ev.message.value.asyncId == res.asyncId;
+    });
+
+    if (cb.error) {
+      throw new Error(cb.error);
+    }
+  }
+}

package/src/audio_stream.ts

@@ -0,0 +1,74 @@
+import { AudioFrame } from './audio_frame';
+import { FfiClient, FfiClientEvent, FfiEvent, FfiHandle, FfiRequest } from './ffi_client';
+import {
+  AudioStreamInfo,
+  AudioStreamType,
+  NewAudioStreamRequest,
+  NewAudioStreamResponse,
+} from './proto/audio_frame_pb';
+import { Track } from './track';
+import EventEmitter from 'events';
+import TypedEmitter from 'typed-emitter';
+
+export type AudioStreamCallbacks = {
+  frameReceived: (frame: AudioFrame) => void;
+};
+
+export enum AudioStreamEvent {
+  FrameReceived = 'frameReceived',
+}
+
+export class AudioStream extends (EventEmitter as new () => TypedEmitter<AudioStreamCallbacks>) {
+  /** @internal */
+  info: AudioStreamInfo;
+  /** @internal */
+  ffiHandle: FfiHandle;
+
+  track: Track;
+
+  constructor(track: Track) {
+    super();
+    this.track = track;
+
+    let req = new NewAudioStreamRequest({
+      type: AudioStreamType.AUDIO_STREAM_NATIVE,
+      trackHandle: track.ffi_handle.handle,
+    });
+
+    let res = FfiClient.instance.request<NewAudioStreamResponse>({
+      message: {
+        case: 'newAudioStream',
+        value: req,
+      },
+    });
+
+    this.info = res.stream.info;
+    this.ffiHandle = new FfiHandle(res.stream.handle.id);
+
+    FfiClient.instance.on(FfiClientEvent.FfiEvent, this.onEvent);
+  }
+
+  private onEvent(ev: FfiEvent) {
+    if (
+      ev.message.case != 'audioStreamEvent' ||
+      ev.message.value.streamHandle != this.ffiHandle.handle
+    ) {
+      return;
+    }
+
+    let streamEvent = ev.message.value.message;
+    switch (streamEvent.case) {
+      case 'frameReceived':
+        let frame = AudioFrame.fromOwnedInfo(streamEvent.value.frame);
+        this.emit(AudioStreamEvent.FrameReceived, frame);
+        break;
+      case 'eos':
+        FfiClient.instance.off(FfiClientEvent.FfiEvent, this.onEvent);
+        break;
+    }
+  }
+
+  close() {
+    this.ffiHandle.dispose();
+  }
+}

package/src/e2ee.ts

@@ -0,0 +1,311 @@
+import { FfiClient, FfiRequest } from './ffi_client';
+import {
+  E2eeManagerGetFrameCryptorsResponse,
+  E2eeManagerSetEnabledRequest,
+  E2eeRequest,
+  E2eeResponse,
+  EncryptionType,
+  FrameCryptorSetEnabledRequest,
+  FrameCryptorSetKeyIndexRequest,
+  GetKeyRequest,
+  GetKeyResponse,
+  GetSharedKeyRequest,
+  GetSharedKeyResponse,
+  RatchetKeyRequest,
+  RatchetKeyResponse,
+  RatchetSharedKeyRequest,
+  RatchetSharedKeyResponse,
+  SetKeyRequest,
+  SetSharedKeyRequest,
+} from './proto/e2ee_pb';
+
+const DEFAULT_RATCHET_SALT = new TextEncoder().encode('LKFrameEncryptionKey');
+const DEFAULT_RATCHET_WINDOW_SIZE = 16;
+const DEFAULT_FAILURE_TOLERANCE = -1;
+
+export interface KeyProviderOptions {
+  sharedKey?: Uint8Array;
+  ratchetSalt: Uint8Array;
+  ratchetWindowSize: number;
+  failureTolerance: number;
+}
+
+export const defaultKeyProviderOptions: KeyProviderOptions = {
+  ratchetSalt: DEFAULT_RATCHET_SALT,
+  ratchetWindowSize: DEFAULT_RATCHET_WINDOW_SIZE,
+  failureTolerance: DEFAULT_FAILURE_TOLERANCE,
+};
+
+export interface E2EEOptions {
+  keyProviderOptions: KeyProviderOptions;
+  encryptionType: EncryptionType;
+}
+
+export const defaultE2EEOptions: E2EEOptions = {
+  keyProviderOptions: defaultKeyProviderOptions,
+  encryptionType: EncryptionType.GCM,
+};
+
+export class KeyProvider {
+  private roomHandle: bigint;
+  options: KeyProviderOptions;
+
+  /** internal */
+  constructor(roomHandle: bigint, opts: KeyProviderOptions) {
+    this.roomHandle = roomHandle;
+    this.options = opts;
+  }
+
+  setSharedKey(sharedKey: Uint8Array, keyIndex: number) {
+    let req = new E2eeRequest({
+      roomHandle: this.roomHandle,
+      message: {
+        case: 'setSharedKey',
+        value: new SetSharedKeyRequest({
+          keyIndex: keyIndex,
+          sharedKey: sharedKey,
+        }),
+      },
+    });
+
+    FfiClient.instance.request({
+      message: {
+        case: 'e2ee',
+        value: req,
+      },
+    });
+  }
+
+  exportSharedKey(keyIndex: number): Uint8Array {
+    let req = new E2eeRequest({
+      roomHandle: this.roomHandle,
+      message: {
+        case: 'getSharedKey',
+        value: new GetSharedKeyRequest({
+          keyIndex: keyIndex,
+        }),
+      },
+    });
+
+    let res = FfiClient.instance.request<E2eeResponse>({
+      message: {
+        case: 'e2ee',
+        value: req,
+      },
+    });
+
+    return (res.message.value as GetSharedKeyResponse).key;
+  }
+
+  ratchetSharedKey(keyIndex: number): Uint8Array {
+    let req = new E2eeRequest({
+      roomHandle: this.roomHandle,
+      message: {
+        case: 'ratchetSharedKey',
+        value: new RatchetSharedKeyRequest({
+          keyIndex: keyIndex,
+        }),
+      },
+    });
+
+    let res = FfiClient.instance.request<E2eeResponse>({
+      message: {
+        case: 'e2ee',
+        value: req,
+      },
+    });
+
+    return (res.message.value as RatchetSharedKeyResponse).newKey;
+  }
+
+  setKey(participantIdentity: string, keyIndex: number) {
+    let req = new E2eeRequest({
+      roomHandle: this.roomHandle,
+      message: {
+        case: 'setKey',
+        value: new SetKeyRequest({
+          keyIndex: keyIndex,
+          participantIdentity: participantIdentity,
+        }),
+      },
+    });
+
+    FfiClient.instance.request({
+      message: {
+        case: 'e2ee',
+        value: req,
+      },
+    });
+  }
+
+  exportKey(participantIdentity: string, keyIndex: number): Uint8Array {
+    let req = new E2eeRequest({
+      roomHandle: this.roomHandle,
+      message: {
+        case: 'getKey',
+        value: new GetKeyRequest({
+          keyIndex: keyIndex,
+          participantIdentity: participantIdentity,
+        }),
+      },
+    });
+
+    let res = FfiClient.instance.request<E2eeResponse>({
+      message: {
+        case: 'e2ee',
+        value: req,
+      },
+    });
+
+    return (res.message.value as GetKeyResponse).key;
+  }
+
+  ratchetKey(participantIdentity: string, keyIndex: number): Uint8Array {
+    let req = new E2eeRequest({
+      roomHandle: this.roomHandle,
+      message: {
+        case: 'ratchetKey',
+        value: new RatchetKeyRequest({
+          keyIndex: keyIndex,
+          participantIdentity: participantIdentity,
+        }),
+      },
+    });
+
+    let res = FfiClient.instance.request<E2eeResponse>({
+      message: {
+        case: 'e2ee',
+        value: req,
+      },
+    });
+
+    return (res.message.value as RatchetKeyResponse).newKey;
+  }
+}
+
+export class FrameCryptor {
+  private roomHandle = 0n;
+  participantIdentity: string;
+  keyIndex: number;
+  enabled: boolean;
+
+  constructor(roomHandle: bigint, participantIdentity: string, keyIndex: number, enabled: boolean) {
+    this.roomHandle = roomHandle;
+    this.participantIdentity = participantIdentity;
+    this.keyIndex = keyIndex;
+    this.enabled = enabled;
+  }
+
+  setEnabled(enabled: boolean) {
+    this.enabled = enabled;
+    let req = new E2eeRequest({
+      roomHandle: this.roomHandle,
+      message: {
+        case: 'cryptorSetEnabled',
+        value: new FrameCryptorSetEnabledRequest({
+          participantIdentity: this.participantIdentity,
+          enabled: this.enabled,
+        }),
+      },
+    });
+
+    FfiClient.instance.request({
+      message: {
+        case: 'e2ee',
+        value: req,
+      },
+    });
+  }
+
+  setKeyIndex(keyIndex: number) {
+    this.keyIndex = keyIndex;
+    let req = new E2eeRequest({
+      roomHandle: this.roomHandle,
+      message: {
+        case: 'cryptorSetKeyIndex',
+        value: new FrameCryptorSetKeyIndexRequest({
+          participantIdentity: this.participantIdentity,
+          keyIndex: this.keyIndex,
+        }),
+      },
+    });
+
+    FfiClient.instance.request({
+      message: {
+        case: 'e2ee',
+        value: req,
+      },
+    });
+  }
+}
+
+export class E2EEManager {
+  private roomHandle = 0n;
+  private options: E2EEOptions;
+  private keyProvider?: KeyProvider;
+
+  enabled: boolean;
+
+  constructor(roomHandle: bigint, opts?: E2EEOptions) {
+    this.roomHandle = roomHandle;
+    this.enabled = opts !== undefined;
+
+    if (opts !== undefined) {
+      const options = { ...defaultE2EEOptions, ...opts };
+
+      this.options = options;
+      this.keyProvider = new KeyProvider(roomHandle, options.keyProviderOptions);
+    }
+  }
+
+  setEnabled(enabled: boolean) {
+    this.enabled = enabled;
+    let req = new E2eeRequest({
+      roomHandle: this.roomHandle,
+      message: {
+        case: 'managerSetEnabled',
+        value: new E2eeManagerSetEnabledRequest({
+          enabled: this.enabled,
+        }),
+      },
+    });
+
+    FfiClient.instance.request({
+      message: {
+        case: 'e2ee',
+        value: req,
+      },
+    });
+  }
+
+  frameCryptors(): FrameCryptor[] {
+    let req = new E2eeRequest({
+      roomHandle: this.roomHandle,
+      message: {
+        case: 'managerGetFrameCryptors',
+        value: {},
+      },
+    });
+
+    let res = FfiClient.instance.request<E2eeResponse>({
+      message: {
+        case: 'e2ee',
+        value: req,
+      },
+    });
+
+    let frameCryptors = (
+      res.message.value as E2eeManagerGetFrameCryptorsResponse
+    ).frameCryptors.map(
+      (cryptor) =>
+        new FrameCryptor(
+          this.roomHandle,
+          cryptor.participantIdentity,
+          cryptor.keyIndex,
+          cryptor.enabled,
+        ),
+    );
+
+    return frameCryptors;
+  }
+}