@signalapp/ringrtc 2.26.4 → 2.28.0

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { RingRTCType } from './ringrtc/Service';
-export { AnswerMessage, AudioDevice, BandwidthMode, BusyMessage, Call, CallEndedReason, CallId, CallLogLevel, CallMessageUrgency, CallSettings, CallState, CallingMessage, ConnectionState, DeviceId, GroupCall, GroupCallEndReason, GroupCallObserver, GroupMemberInfo, HangupMessage, HangupType, HttpMethod, IceCandidateMessage, JoinState, LocalDeviceState, OfferMessage, OfferType, OpaqueMessage, PeekInfo, RemoteDeviceState, RingCancelReason, RingRTCType, RingUpdate, UserId, VideoCapturer, VideoRenderer, VideoRequest, callIdFromEra, callIdFromRingId, } from './ringrtc/Service';
+export { AnswerMessage, AudioDevice, DataMode, BusyMessage, Call, CallEndedReason, CallId, CallLogLevel, CallMessageUrgency, CallSettings, CallState, CallingMessage, ConnectionState, DeviceId, GroupCall, GroupCallEndReason, GroupCallObserver, GroupMemberInfo, HangupMessage, HangupType, HttpMethod, HttpResult, IceCandidateMessage, JoinState, LocalDeviceState, OfferMessage, OfferType, OpaqueMessage, PeekDeviceInfo, PeekInfo, PeekStatusCodes, RemoteDeviceState, RingCancelReason, RingRTCType, RingUpdate, UserId, VideoCapturer, VideoRenderer, VideoRequest, callIdFromEra, callIdFromRingId, } from './ringrtc/Service';
 export { CanvasVideoRenderer, GumVideoCapturer, VideoFrameSource, MAX_VIDEO_CAPTURE_AREA, MAX_VIDEO_CAPTURE_BUFFER_SIZE, MAX_VIDEO_CAPTURE_HEIGHT, MAX_VIDEO_CAPTURE_WIDTH, } from './ringrtc/VideoSupport';
+export { CallLinkRootKey, CallLinkRestrictions, CallLinkState, } from './ringrtc/CallLinks';
 export declare const RingRTC: RingRTCType;

package/dist/index.js

@@ -4,11 +4,11 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 //
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RingRTC = exports.MAX_VIDEO_CAPTURE_WIDTH = exports.MAX_VIDEO_CAPTURE_HEIGHT = exports.MAX_VIDEO_CAPTURE_BUFFER_SIZE = exports.MAX_VIDEO_CAPTURE_AREA = exports.GumVideoCapturer = exports.CanvasVideoRenderer = exports.callIdFromRingId = exports.callIdFromEra = exports.VideoRequest = exports.RingUpdate = exports.RingRTCType = exports.RingCancelReason = exports.RemoteDeviceState = exports.PeekInfo = exports.OpaqueMessage = exports.OfferType = exports.OfferMessage = exports.LocalDeviceState = exports.JoinState = exports.IceCandidateMessage = exports.HttpMethod = exports.HangupType = exports.HangupMessage = exports.GroupMemberInfo = exports.GroupCallEndReason = exports.GroupCall = exports.ConnectionState = exports.CallingMessage = exports.CallState = exports.CallMessageUrgency = exports.CallLogLevel = exports.CallEndedReason = exports.Call = exports.BusyMessage = exports.BandwidthMode = exports.AnswerMessage = void 0;
+exports.RingRTC = exports.CallLinkState = exports.CallLinkRestrictions = exports.CallLinkRootKey = exports.MAX_VIDEO_CAPTURE_WIDTH = exports.MAX_VIDEO_CAPTURE_HEIGHT = exports.MAX_VIDEO_CAPTURE_BUFFER_SIZE = exports.MAX_VIDEO_CAPTURE_AREA = exports.GumVideoCapturer = exports.CanvasVideoRenderer = exports.callIdFromRingId = exports.callIdFromEra = exports.VideoRequest = exports.RingUpdate = exports.RingRTCType = exports.RingCancelReason = exports.RemoteDeviceState = exports.PeekStatusCodes = exports.OpaqueMessage = exports.OfferType = exports.OfferMessage = exports.LocalDeviceState = exports.JoinState = exports.IceCandidateMessage = exports.HttpMethod = exports.HangupType = exports.HangupMessage = exports.GroupMemberInfo = exports.GroupCallEndReason = exports.GroupCall = exports.ConnectionState = exports.CallingMessage = exports.CallState = exports.CallMessageUrgency = exports.CallLogLevel = exports.CallEndedReason = exports.Call = exports.BusyMessage = exports.DataMode = exports.AnswerMessage = void 0;
 const Service_1 = require("./ringrtc/Service");
 var Service_2 = require("./ringrtc/Service");
 Object.defineProperty(exports, "AnswerMessage", { enumerable: true, get: function () { return Service_2.AnswerMessage; } });
-Object.defineProperty(exports, "BandwidthMode", { enumerable: true, get: function () { return Service_2.BandwidthMode; } });
+Object.defineProperty(exports, "DataMode", { enumerable: true, get: function () { return Service_2.DataMode; } });
 Object.defineProperty(exports, "BusyMessage", { enumerable: true, get: function () { return Service_2.BusyMessage; } });
 Object.defineProperty(exports, "Call", { enumerable: true, get: function () { return Service_2.Call; } });
 Object.defineProperty(exports, "CallEndedReason", { enumerable: true, get: function () { return Service_2.CallEndedReason; } });
@@ -29,7 +29,7 @@ Object.defineProperty(exports, "LocalDeviceState", { enumerable: true, get: func
 Object.defineProperty(exports, "OfferMessage", { enumerable: true, get: function () { return Service_2.OfferMessage; } });
 Object.defineProperty(exports, "OfferType", { enumerable: true, get: function () { return Service_2.OfferType; } });
 Object.defineProperty(exports, "OpaqueMessage", { enumerable: true, get: function () { return Service_2.OpaqueMessage; } });
-Object.defineProperty(exports, "PeekInfo", { enumerable: true, get: function () { return Service_2.PeekInfo; } });
+Object.defineProperty(exports, "PeekStatusCodes", { enumerable: true, get: function () { return Service_2.PeekStatusCodes; } });
 Object.defineProperty(exports, "RemoteDeviceState", { enumerable: true, get: function () { return Service_2.RemoteDeviceState; } });
 Object.defineProperty(exports, "RingCancelReason", { enumerable: true, get: function () { return Service_2.RingCancelReason; } });
 Object.defineProperty(exports, "RingRTCType", { enumerable: true, get: function () { return Service_2.RingRTCType; } });
@@ -44,5 +44,9 @@ Object.defineProperty(exports, "MAX_VIDEO_CAPTURE_AREA", { enumerable: true, get
 Object.defineProperty(exports, "MAX_VIDEO_CAPTURE_BUFFER_SIZE", { enumerable: true, get: function () { return VideoSupport_1.MAX_VIDEO_CAPTURE_BUFFER_SIZE; } });
 Object.defineProperty(exports, "MAX_VIDEO_CAPTURE_HEIGHT", { enumerable: true, get: function () { return VideoSupport_1.MAX_VIDEO_CAPTURE_HEIGHT; } });
 Object.defineProperty(exports, "MAX_VIDEO_CAPTURE_WIDTH", { enumerable: true, get: function () { return VideoSupport_1.MAX_VIDEO_CAPTURE_WIDTH; } });
+var CallLinks_1 = require("./ringrtc/CallLinks");
+Object.defineProperty(exports, "CallLinkRootKey", { enumerable: true, get: function () { return CallLinks_1.CallLinkRootKey; } });
+Object.defineProperty(exports, "CallLinkRestrictions", { enumerable: true, get: function () { return CallLinks_1.CallLinkRestrictions; } });
+Object.defineProperty(exports, "CallLinkState", { enumerable: true, get: function () { return CallLinks_1.CallLinkState; } });
 exports.RingRTC = new Service_1.RingRTCType();
 //# sourceMappingURL=index.js.map

package/dist/ringrtc/CallLinks.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+export declare class CallLinkRootKey {
+    readonly bytes: Buffer;
+    private constructor();
+    static parse(str: string): CallLinkRootKey;
+    static fromBytes(bytes: Buffer): CallLinkRootKey;
+    static generate(): CallLinkRootKey;
+    static generateAdminPassKey(): Buffer;
+    deriveRoomId(): Buffer;
+    toString(): string;
+}
+export declare class CallLinkState {
+    name: string;
+    restrictions: CallLinkRestrictions;
+    revoked: boolean;
+    expiration: Date;
+    constructor(name: string, restrictions: CallLinkRestrictions, revoked: boolean, expiration: Date);
+}
+export declare enum CallLinkRestrictions {
+    None = 0,
+    AdminApproval = 1,
+    Unknown = 2
+}

package/dist/ringrtc/CallLinks.js

@@ -0,0 +1,55 @@
+"use strict";
+//
+// Copyright 2023 Signal Messenger, LLC
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallLinkRestrictions = exports.CallLinkState = exports.CallLinkRootKey = void 0;
+const Native_1 = __importDefault(require("./Native"));
+class CallLinkRootKey {
+    constructor(bytes) {
+        this.bytes = bytes;
+    }
+    static parse(str) {
+        return new CallLinkRootKey(Native_1.default.CallLinkRootKey_parse(str));
+    }
+    static fromBytes(bytes) {
+        Native_1.default.CallLinkRootKey_validate(bytes);
+        return new CallLinkRootKey(bytes);
+    }
+    static generate() {
+        return new CallLinkRootKey(Native_1.default.CallLinkRootKey_generate());
+    }
+    static generateAdminPassKey() {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return Native_1.default.CallLinkRootKey_generateAdminPasskey();
+    }
+    deriveRoomId() {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return Native_1.default.CallLinkRootKey_deriveRoomId(this.bytes);
+    }
+    toString() {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return Native_1.default.CallLinkRootKey_toFormattedString(this.bytes);
+    }
+}
+exports.CallLinkRootKey = CallLinkRootKey;
+class CallLinkState {
+    constructor(name, restrictions, revoked, expiration) {
+        this.name = name;
+        this.restrictions = restrictions;
+        this.revoked = revoked;
+        this.expiration = expiration;
+    }
+}
+exports.CallLinkState = CallLinkState;
+var CallLinkRestrictions;
+(function (CallLinkRestrictions) {
+    CallLinkRestrictions[CallLinkRestrictions["None"] = 0] = "None";
+    CallLinkRestrictions[CallLinkRestrictions["AdminApproval"] = 1] = "AdminApproval";
+    CallLinkRestrictions[CallLinkRestrictions["Unknown"] = 2] = "Unknown";
+})(CallLinkRestrictions = exports.CallLinkRestrictions || (exports.CallLinkRestrictions = {}));
+//# sourceMappingURL=CallLinks.js.map

package/dist/ringrtc/Native.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/ringrtc/Native.js

@@ -0,0 +1,34 @@
+"use strict";
+//
+// Copyright 2023 Signal Messenger, LLC
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const os = __importStar(require("os"));
+const process = __importStar(require("process"));
+// eslint-disable-next-line @typescript-eslint/no-var-requires, import/no-dynamic-require
+exports.default = require(`../../build/${os.platform()}/libringrtc-${process.arch}.node`);
+//# sourceMappingURL=Native.js.map

package/dist/ringrtc/Service.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 import { GumVideoCaptureOptions, VideoPixelFormatEnum } from './VideoSupport';
+import { CallLinkState, CallLinkRestrictions, CallLinkRootKey } from './CallLinks';
 export declare const callIdFromEra: (era: string) => CallId;
 export declare function callIdFromRingId(ringId: bigint): CallId;
 declare class Config {
@@ -8,18 +9,20 @@ declare class Config {
 }
 type GroupId = Buffer;
 type GroupCallUserId = Buffer;
-export declare class PeekDeviceInfo {
+export interface PeekDeviceInfo {
     demuxId: number;
     userId?: GroupCallUserId;
-    constructor(demuxId: number, userId: GroupCallUserId | undefined);
 }
-export declare class PeekInfo {
+export interface PeekInfo {
     devices: Array<PeekDeviceInfo>;
     creator?: GroupCallUserId;
     eraId?: string;
     maxDevices?: number;
     deviceCount: number;
-    constructor();
+}
+export declare enum PeekStatusCodes {
+    EXPIRED_CALL_LINK = 703,
+    INVALID_CALL_LINK = 704
 }
 declare enum NetworkAdapterType {
     Unknown = 0,
@@ -45,11 +48,19 @@ export declare class ReceivedAudioLevel {
     level: RawAudioLevel;
     constructor(demuxId: number, level: RawAudioLevel);
 }
+export type HttpResult<T> = {
+    success: true;
+    value: T;
+} | {
+    success: false;
+    errorStatusCode: number;
+};
 export declare class RingRTCType {
     private readonly callManager;
     private _call;
     private _groupCallByClientId;
     private _peekRequests;
+    private _callLinkRequests;
     private _callInfoByCallId;
     private getCallInfoKey;
     handleOutgoingSignaling: ((remoteUserId: UserId, message: CallingMessage) => Promise<boolean>) | null;
@@ -84,10 +95,107 @@ export declare class RingRTCType {
     onSendHangup(remoteUserId: UserId, remoteDeviceId: DeviceId, callId: CallId, broadcast: boolean, hangupType: HangupType, deviceId: DeviceId | null): void;
     onSendBusy(remoteUserId: UserId, remoteDeviceId: DeviceId, callId: CallId, broadcast: boolean): void;
     private sendSignaling;
+    /**
+     * Asynchronous request to get information about a call link.
+     *
+     * @param sfuUrl - the URL to use when accessing the SFU
+     * @param authCredentialPresentation - a serialized CallLinkAuthCredentialPresentation
+     * @param linkRootKey - the root key for the call link
+     *
+     * Expected failure codes include:
+     * - 404: the room does not exist (or expired so long ago that it has been removed from the server)
+     */
+    readCallLink(sfuUrl: string, authCredentialPresentation: Buffer, linkRootKey: CallLinkRootKey): Promise<HttpResult<CallLinkState>>;
+    /**
+     * Asynchronous request to create a new call link.
+     *
+     * This request is idempotent; if it fails due to a network issue, it is safe to retry.
+     *
+     * @example
+     * const linkKey = CallLinkRootKey.generate();
+     * const adminPasskey = CallLinkRootKey.generateAdminPasskey();
+     * const roomId = linkKey.deriveRoomId();
+     * const credential = requestCreateCredentialFromChatServer(roomId); // using libsignal
+     * const secretParams = CallLinkSecretParams.deriveFromRootKey(linkKey.bytes);
+     * const credentialPresentation = credential.present(roomId, secretParams).serialize();
+     * const serializedPublicParams = secretParams.getPublicParams().serialize();
+     * const result = await RingRTC.createCallLink(sfuUrl, credentialPresentation, linkKey, adminPasskey, serializedPublicParams);
+     * if (result.success) {
+     *   const state = result.value;
+     *   // In actuality you may not want to do this until the user clicks Done.
+     *   saveToDatabase(linkKey.bytes, adminPasskey, state);
+     *   syncToOtherDevices(linkKey.bytes, adminPasskey);
+     * } else {
+     *   switch (result.errorStatusCode) {
+     *   case 409:
+     *     // The room already exists (and isn't yours), i.e. you've hit a 1-in-a-billion conflict.
+     *     // Fall through to kicking the user out to try again later.
+     *   default:
+     *     // Unexpected error, kick the user out for now.
+     *   }
+     * }
+     *
+     * @param sfuUrl - the URL to use when accessing the SFU
+     * @param createCredentialPresentation - a serialized CreateCallLinkCredentialPresentation
+     * @param linkRootKey - the root key for the call link
+     * @param adminPasskey - the arbitrary passkey to use for the new room
+     * @param callLinkPublicParams - the serialized CallLinkPublicParams for the new room
+     */
+    createCallLink(sfuUrl: string, createCredentialPresentation: Buffer, linkRootKey: CallLinkRootKey, adminPasskey: Buffer, callLinkPublicParams: Buffer): Promise<HttpResult<CallLinkState>>;
+    /**
+     * Asynchronous request to update a call link's name.
+     *
+     * Possible failure codes include:
+     * - 401: the room does not exist (and this is the wrong API to create a new room)
+     * - 403: the admin passkey is incorrect
+     *
+     * This request is idempotent; if it fails due to a network issue, it is safe to retry.
+     *
+     * @param sfuUrl - the URL to use when accessing the SFU
+     * @param authCredentialPresentation - a serialized CallLinkAuthCredentialPresentation
+     * @param linkRootKey - the root key for the call link
+     * @param adminPasskey - the passkey specified when the link was created
+     * @param newName - the new name to use
+     */
+    updateCallLinkName(sfuUrl: string, authCredentialPresentation: Buffer, linkRootKey: CallLinkRootKey, adminPasskey: Buffer, newName: string): Promise<HttpResult<CallLinkState>>;
+    /**
+     * Asynchronous request to update a call link's restrictions.
+     *
+     * Possible failure codes include:
+     * - 401: the room does not exist (and this is the wrong API to create a new room)
+     * - 403: the admin passkey is incorrect
+     *
+     * This request is idempotent; if it fails due to a network issue, it is safe to retry.
+     *
+     * @param sfuUrl - the URL to use when accessing the SFU
+     * @param authCredentialPresentation - a serialized CallLinkAuthCredentialPresentation
+     * @param linkRootKey - the root key for the call link
+     * @param adminPasskey - the passkey specified when the link was created
+     * @param restrictions - the new restrictions to use
+     */
+    updateCallLinkRestrictions(sfuUrl: string, authCredentialPresentation: Buffer, linkRootKey: CallLinkRootKey, adminPasskey: Buffer, restrictions: Exclude<CallLinkRestrictions, CallLinkRestrictions.Unknown>): Promise<HttpResult<CallLinkState>>;
+    /**
+     * Asynchronous request to revoke or un-revoke a call link.
+     *
+     * Possible failure codes include:
+     * - 401: the room does not exist (and this is the wrong API to create a new room)
+     * - 403: the admin passkey is incorrect
+     *
+     * This request is idempotent; if it fails due to a network issue, it is safe to retry.
+     *
+     * @param sfuUrl - the URL to use when accessing the SFU
+     * @param authCredentialPresentation - a serialized CallLinkAuthCredentialPresentation
+     * @param linkRootKey - the root key for the call link
+     * @param adminPasskey - the passkey specified when the link was created
+     * @param revoked - whether the link should now be revoked
+     */
+    updateCallLinkRevocation(sfuUrl: string, authCredentialPresentation: Buffer, linkRootKey: CallLinkRootKey, adminPasskey: Buffer, revoked: boolean): Promise<HttpResult<CallLinkState>>;
     receivedHttpResponse(requestId: number, status: number, body: Buffer): void;
     httpRequestFailed(requestId: number, debugInfo: string | undefined): void;
     getGroupCall(groupId: Buffer, sfuUrl: string, hkdfExtraInfo: Buffer, audioLevelsIntervalMillis: number | undefined, observer: GroupCallObserver): GroupCall | undefined;
+    getCallLinkCall(sfuUrl: string, authCredentialPresentation: Buffer, rootKey: CallLinkRootKey, adminPasskey: Buffer | undefined, hkdfExtraInfo: Buffer, audioLevelsIntervalMillis: number | undefined, observer: GroupCallObserver): GroupCall | undefined;
     peekGroupCall(sfuUrl: string, membershipProof: Buffer, groupMembers: Array<GroupMemberInfo>): Promise<PeekInfo>;
+    peekCallLinkCall(sfuUrl: string, authCredentialPresentation: Buffer, rootKey: CallLinkRootKey): Promise<HttpResult<PeekInfo>>;
     requestMembershipProof(clientId: GroupCallClientId): void;
     requestGroupMembers(clientId: GroupCallClientId): void;
     handleConnectionStateChanged(clientId: GroupCallClientId, connectionState: ConnectionState): void;
@@ -96,7 +204,13 @@ export declare class RingRTCType {
     handleAudioLevels(clientId: GroupCallClientId, capturedLevel: RawAudioLevel, receivedLevels: Array<ReceivedAudioLevel>): void;
     handleRemoteDevicesChanged(clientId: GroupCallClientId, remoteDeviceStates: Array<RemoteDeviceState>): void;
     handlePeekChanged(clientId: GroupCallClientId, info: PeekInfo): void;
-    handlePeekResponse(requestId: number, info: PeekInfo): void;
+    handlePeekResponse(requestId: number, statusCode: number, info: PeekInfo | undefined): void;
+    handleCallLinkResponse(requestId: number, statusCode: number, state: {
+        name: string;
+        rawRestrictions: number;
+        revoked: boolean;
+        expiration: Date;
+    } | undefined): void;
     handleEnded(clientId: GroupCallClientId, reason: GroupCallEndReason): void;
     groupCallRingUpdate(groupId: GroupId, ringIdString: string, sender: GroupCallUserId, state: RingUpdate): void;
     onLogMessage(level: number, fileName: string, line: number, message: string): void;
@@ -128,7 +242,7 @@ export declare class RingRTCType {
 export interface CallSettings {
     iceServer: IceServer;
     hideIp: boolean;
-    bandwidthMode: BandwidthMode;
+    dataMode: DataMode;
     audioLevelsIntervalMillis?: number;
 }
 interface IceServer {
@@ -199,7 +313,7 @@ export declare class Call {
     receiveVideoFrame(buffer: Buffer, maxWidth: number, maxHeight: number): [number, number] | undefined;
     private enableOrDisableCapturer;
     private setOutgoingVideoEnabled;
-    updateBandwidthMode(bandwidthMode: BandwidthMode): void;
+    updateDataMode(dataMode: DataMode): void;
     private enableOrDisableRenderer;
 }
 export type GroupCallClientId = number;
@@ -306,7 +420,7 @@ export declare class GroupCall {
     private _localDeviceState;
     private _remoteDeviceStates;
     private _peekInfo;
-    constructor(callManager: CallManager, groupId: Buffer, sfuUrl: string, hkdfExtraInfo: Buffer, audioLevelsIntervalMillis: number | undefined, observer: GroupCallObserver);
+    constructor(callManager: CallManager, observer: GroupCallObserver, clientId: GroupCallClientId);
     connect(): void;
     join(): void;
     leave(): void;
@@ -320,7 +434,7 @@ export declare class GroupCall {
     setOutgoingVideoIsScreenShare(isScreenShare: boolean): void;
     ringAll(): void;
     resendMediaKeys(): void;
-    setBandwidthMode(bandwidthMode: BandwidthMode): void;
+    setDataMode(dataMode: DataMode): void;
     requestVideo(resolutions: Array<VideoRequest>, activeSpeakerHeight: number): void;
     setGroupMembers(members: Array<GroupMemberInfo>): void;
     setMembershipProof(proof: Buffer): void;
@@ -405,7 +519,7 @@ export declare enum HangupType {
     Busy = 3,
     NeedPermission = 4
 }
-export declare enum BandwidthMode {
+export declare enum DataMode {
     Low = 0,
     Normal = 1
 }
@@ -417,7 +531,7 @@ export interface CallManager {
     setConfig(config: Config): void;
     setSelfUuid(uuid: Buffer): void;
     createOutgoingCall(remoteUserId: UserId, isVideoCall: boolean, localDeviceId: DeviceId): CallId;
-    proceed(callId: CallId, iceServerUsername: string, iceServerPassword: string, iceServerUrls: Array<string>, hideIp: boolean, bandwidthMode: BandwidthMode, audioLevelsIntervalMillis: number): void;
+    proceed(callId: CallId, iceServerUsername: string, iceServerPassword: string, iceServerUrls: Array<string>, hideIp: boolean, dataMode: DataMode, audioLevelsIntervalMillis: number): void;
     accept(callId: CallId): void;
     ignore(callId: CallId): void;
     hangup(): void;
@@ -427,7 +541,7 @@ export interface CallManager {
     setOutgoingAudioEnabled(enabled: boolean): void;
     setOutgoingVideoEnabled(enabled: boolean): void;
     setOutgoingVideoIsScreenShare(enabled: boolean): void;
-    updateBandwidthMode(bandwidthMode: BandwidthMode): void;
+    updateDataMode(dataMode: DataMode): void;
     sendVideoFrame(width: number, height: number, format: VideoPixelFormatEnum, buffer: Buffer): void;
     receiveVideoFrame(buffer: Buffer, maxWidth: number, maxHeight: number): [number, number] | undefined;
     receivedOffer(remoteUserId: UserId, remoteDeviceId: DeviceId, localDeviceId: DeviceId, messageAgeSec: number, callId: CallId, offerType: OfferType, opaque: Buffer, senderIdentityKey: Buffer, receiverIdentityKey: Buffer): void;
@@ -439,6 +553,7 @@ export interface CallManager {
     receivedHttpResponse(requestId: number, status: number, body: Buffer): void;
     httpRequestFailed(requestId: number, debugInfo: string | undefined): void;
     createGroupCallClient(groupId: Buffer, sfuUrl: string, hkdfExtraInfo: Buffer, audioLevelsIntervalMillis: number): GroupCallClientId;
+    createCallLinkCallClient(sfuUrl: string, authCredentialPresentation: Buffer, linkRootKey: Buffer, adminPasskey: Buffer | undefined, hkdfExtraInfo: Buffer, audioLevelsIntervalMillis: number): GroupCallClientId;
     deleteGroupCallClient(clientId: GroupCallClientId): void;
     connect(clientId: GroupCallClientId): void;
     join(clientId: GroupCallClientId): void;
@@ -450,12 +565,16 @@ export interface CallManager {
     setOutgoingGroupCallVideoIsScreenShare(clientId: GroupCallClientId, isScreenShare: boolean): void;
     groupRing(clientId: GroupCallClientId, recipient: Buffer | undefined): void;
     resendMediaKeys(clientId: GroupCallClientId): void;
-    setBandwidthMode(clientId: GroupCallClientId, bandwidthMode: BandwidthMode): void;
+    setDataMode(clientId: GroupCallClientId, dataMode: DataMode): void;
     requestVideo(clientId: GroupCallClientId, resolutions: Array<VideoRequest>, activeSpeakerHeight: number): void;
     setGroupMembers(clientId: GroupCallClientId, members: Array<GroupMemberInfo>): void;
     setMembershipProof(clientId: GroupCallClientId, proof: Buffer): void;
     receiveGroupCallVideoFrame(clientId: GroupCallClientId, remoteDemuxId: number, buffer: Buffer, maxWidth: number, maxHeight: number): [number, number] | undefined;
+    readCallLink(requestId: number, sfuUrl: string, authCredentialPresentation: Buffer, linkRootKey: Buffer): void;
+    createCallLink(requestId: number, sfuUrl: string, createCredentialPresentation: Buffer, linkRootKey: Buffer, adminPasskey: Buffer, callLinkPublicParams: Buffer): void;
+    updateCallLink(requestId: number, sfuUrl: string, authCredentialPresentation: Buffer, linkRootKey: Buffer, adminPasskey: Buffer, newName: string | undefined, newRestrictions: number | undefined, newRevoked: boolean | undefined): void;
     peekGroupCall(requestId: number, sfu_url: string, membership_proof: Buffer, group_members: Array<GroupMemberInfo>): void;
+    peekCallLinkCall(requestId: number, sfuUrl: string, authCredentialPresentation: Buffer, linkRootKey: Buffer): void;
     getAudioInputs(): Array<AudioDevice>;
     setAudioInput(index: number): void;
     getAudioOutputs(): Array<AudioDevice>;
@@ -484,7 +603,7 @@ export interface CallManagerCallbacks {
     handleJoinStateChanged(clientId: GroupCallClientId, joinState: JoinState, demuxId: number | undefined): void;
     handleRemoteDevicesChanged(clientId: GroupCallClientId, remoteDeviceStates: Array<RemoteDeviceState>): void;
     handlePeekChanged(clientId: GroupCallClientId, info: PeekInfo): void;
-    handlePeekResponse(requestId: number, info: PeekInfo): void;
+    handlePeekResponse(requestId: number, statusCode: number, info: PeekInfo | undefined): void;
     handleEnded(clientId: GroupCallClientId, reason: GroupCallEndReason): void;
     onLogMessage(level: number, fileName: string, line: number, message: string): void;
 }

package/dist/ringrtc/Service.js

@@ -35,14 +35,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CallLogLevel = exports.CallEndedReason = exports.CallState = exports.RingCancelReason = exports.BandwidthMode = exports.HangupType = exports.OpaqueMessage = exports.HangupMessage = exports.BusyMessage = exports.IceCandidateMessage = exports.AnswerMessage = exports.OfferType = exports.OfferMessage = exports.CallingMessage = exports.GroupCall = exports.VideoRequest = exports.GroupMemberInfo = exports.RemoteDeviceState = exports.LocalDeviceState = exports.HttpMethod = exports.RingUpdate = exports.CallMessageUrgency = exports.GroupCallEndReason = exports.JoinState = exports.ConnectionState = exports.Call = exports.RingRTCType = exports.ReceivedAudioLevel = exports.NetworkRoute = exports.PeekInfo = exports.PeekDeviceInfo = exports.callIdFromRingId = exports.callIdFromEra = void 0;
+exports.CallLogLevel = exports.CallEndedReason = exports.CallState = exports.RingCancelReason = exports.DataMode = exports.HangupType = exports.OpaqueMessage = exports.HangupMessage = exports.BusyMessage = exports.IceCandidateMessage = exports.AnswerMessage = exports.OfferType = exports.OfferMessage = exports.CallingMessage = exports.GroupCall = exports.VideoRequest = exports.GroupMemberInfo = exports.RemoteDeviceState = exports.LocalDeviceState = exports.HttpMethod = exports.RingUpdate = exports.CallMessageUrgency = exports.GroupCallEndReason = exports.JoinState = exports.ConnectionState = exports.Call = exports.RingRTCType = exports.ReceivedAudioLevel = exports.NetworkRoute = exports.PeekStatusCodes = exports.callIdFromRingId = exports.callIdFromEra = void 0;
 /* eslint-disable max-classes-per-file */
-const os = __importStar(require("os"));
 const process = __importStar(require("process"));
-// eslint-disable-next-line @typescript-eslint/no-var-requires, import/no-dynamic-require
-const Native = require(`../../build/${os.platform()}/libringrtc-${process.arch}.node`);
-exports.callIdFromEra = Native.callIdFromEra;
+const CallLinks_1 = require("./CallLinks");
+const Native_1 = __importDefault(require("./Native"));
+exports.callIdFromEra = Native_1.default.callIdFromEra;
 function callIdFromRingId(ringId) {
     return {
         low: Number(BigInt.asIntN(32, ringId)),
@@ -65,22 +67,25 @@ class NativeCallManager {
         this.createCallEndpoint(config);
     }
     createCallEndpoint(config) {
-        const fieldTrials = Object.assign({ 'RingRTC-AnyAddressPortsKillSwitch': 'Enabled' }, config.field_trials);
+        const fieldTrials = Object.assign({
+            'RingRTC-AnyAddressPortsKillSwitch': 'Enabled',
+            'WebRTC-Audio-OpusSetSignalVoiceWithDtx': 'Enabled',
+        }, config.field_trials);
         /* eslint-disable prefer-template */
         const fieldTrialsString = Object.entries(fieldTrials)
             .map(([k, v]) => `${k}/${v}`)
             .join('/') + '/';
         /* eslint-enable prefer-template */
-        Object.defineProperty(this, Native.callEndpointPropertyKey, {
+        Object.defineProperty(this, Native_1.default.callEndpointPropertyKey, {
             configurable: true,
             get() {
-                const callEndpoint = Native.createCallEndpoint(this, config.use_new_audio_device_module, fieldTrialsString);
+                const callEndpoint = Native_1.default.createCallEndpoint(this, config.use_new_audio_device_module, fieldTrialsString);
                 if (process.platform === 'darwin') {
                     // Preload devices to work around
                     // https://bugs.chromium.org/p/chromium/issues/detail?id=1287628
                     void window.navigator.mediaDevices.enumerateDevices();
                 }
-                Object.defineProperty(this, Native.callEndpointPropertyKey, {
+                Object.defineProperty(this, Native_1.default.callEndpointPropertyKey, {
                     configurable: true,
                     value: callEndpoint,
                 });
@@ -92,90 +97,86 @@ class NativeCallManager {
 }
 // Mirror methods onto NativeCallManager.
 // This is done through direct assignment rather than wrapper methods to avoid indirection.
-NativeCallManager.prototype.setSelfUuid = Native.cm_setSelfUuid;
+NativeCallManager.prototype.setSelfUuid = Native_1.default.cm_setSelfUuid;
 NativeCallManager.prototype.createOutgoingCall =
-    Native.cm_createOutgoingCall;
-NativeCallManager.prototype.proceed = Native.cm_proceed;
-NativeCallManager.prototype.accept = Native.cm_accept;
-NativeCallManager.prototype.ignore = Native.cm_ignore;
-NativeCallManager.prototype.hangup = Native.cm_hangup;
+    Native_1.default.cm_createOutgoingCall;
+NativeCallManager.prototype.proceed = Native_1.default.cm_proceed;
+NativeCallManager.prototype.accept = Native_1.default.cm_accept;
+NativeCallManager.prototype.ignore = Native_1.default.cm_ignore;
+NativeCallManager.prototype.hangup = Native_1.default.cm_hangup;
 NativeCallManager.prototype.cancelGroupRing =
-    Native.cm_cancelGroupRing;
+    Native_1.default.cm_cancelGroupRing;
 NativeCallManager.prototype.signalingMessageSent =
-    Native.cm_signalingMessageSent;
+    Native_1.default.cm_signalingMessageSent;
 NativeCallManager.prototype.signalingMessageSendFailed =
-    Native.cm_signalingMessageSendFailed;
-NativeCallManager.prototype.updateBandwidthMode =
-    Native.cm_updateBandwidthMode;
-NativeCallManager.prototype.receivedOffer = Native.cm_receivedOffer;
-NativeCallManager.prototype.receivedAnswer = Native.cm_receivedAnswer;
+    Native_1.default.cm_signalingMessageSendFailed;
+NativeCallManager.prototype.updateDataMode = Native_1.default.cm_updateDataMode;
+NativeCallManager.prototype.receivedOffer = Native_1.default.cm_receivedOffer;
+NativeCallManager.prototype.receivedAnswer = Native_1.default.cm_receivedAnswer;
 NativeCallManager.prototype.receivedIceCandidates =
-    Native.cm_receivedIceCandidates;
-NativeCallManager.prototype.receivedHangup = Native.cm_receivedHangup;
-NativeCallManager.prototype.receivedBusy = Native.cm_receivedBusy;
+    Native_1.default.cm_receivedIceCandidates;
+NativeCallManager.prototype.receivedHangup = Native_1.default.cm_receivedHangup;
+NativeCallManager.prototype.receivedBusy = Native_1.default.cm_receivedBusy;
 NativeCallManager.prototype.receivedCallMessage =
-    Native.cm_receivedCallMessage;
+    Native_1.default.cm_receivedCallMessage;
 NativeCallManager.prototype.receivedHttpResponse =
-    Native.cm_receivedHttpResponse;
+    Native_1.default.cm_receivedHttpResponse;
 NativeCallManager.prototype.httpRequestFailed =
-    Native.cm_httpRequestFailed;
+    Native_1.default.cm_httpRequestFailed;
 NativeCallManager.prototype.setOutgoingAudioEnabled =
-    Native.cm_setOutgoingAudioEnabled;
+    Native_1.default.cm_setOutgoingAudioEnabled;
 NativeCallManager.prototype.setOutgoingVideoEnabled =
-    Native.cm_setOutgoingVideoEnabled;
+    Native_1.default.cm_setOutgoingVideoEnabled;
 NativeCallManager.prototype.setOutgoingVideoIsScreenShare =
-    Native.cm_setOutgoingVideoIsScreenShare;
-NativeCallManager.prototype.sendVideoFrame = Native.cm_sendVideoFrame;
+    Native_1.default.cm_setOutgoingVideoIsScreenShare;
+NativeCallManager.prototype.sendVideoFrame = Native_1.default.cm_sendVideoFrame;
 NativeCallManager.prototype.receiveVideoFrame =
-    Native.cm_receiveVideoFrame;
+    Native_1.default.cm_receiveVideoFrame;
 NativeCallManager.prototype.receiveGroupCallVideoFrame =
-    Native.cm_receiveGroupCallVideoFrame;
+    Native_1.default.cm_receiveGroupCallVideoFrame;
 NativeCallManager.prototype.createGroupCallClient =
-    Native.cm_createGroupCallClient;
+    Native_1.default.cm_createGroupCallClient;
+NativeCallManager.prototype.createCallLinkCallClient =
+    Native_1.default.cm_createCallLinkCallClient;
 NativeCallManager.prototype.deleteGroupCallClient =
-    Native.cm_deleteGroupCallClient;
-NativeCallManager.prototype.connect = Native.cm_connect;
-NativeCallManager.prototype.join = Native.cm_join;
-NativeCallManager.prototype.leave = Native.cm_leave;
-NativeCallManager.prototype.disconnect = Native.cm_disconnect;
-NativeCallManager.prototype.groupRing = Native.cm_groupRing;
+    Native_1.default.cm_deleteGroupCallClient;
+NativeCallManager.prototype.connect = Native_1.default.cm_connect;
+NativeCallManager.prototype.join = Native_1.default.cm_join;
+NativeCallManager.prototype.leave = Native_1.default.cm_leave;
+NativeCallManager.prototype.disconnect = Native_1.default.cm_disconnect;
+NativeCallManager.prototype.groupRing = Native_1.default.cm_groupRing;
 NativeCallManager.prototype.setOutgoingAudioMuted =
-    Native.cm_setOutgoingAudioMuted;
+    Native_1.default.cm_setOutgoingAudioMuted;
 NativeCallManager.prototype.setOutgoingVideoMuted =
-    Native.cm_setOutgoingVideoMuted;
+    Native_1.default.cm_setOutgoingVideoMuted;
 NativeCallManager.prototype.setOutgoingGroupCallVideoIsScreenShare =
-    Native.cm_setOutgoingGroupCallVideoIsScreenShare;
-NativeCallManager.prototype.setPresenting = Native.cm_setPresenting;
+    Native_1.default.cm_setOutgoingGroupCallVideoIsScreenShare;
+NativeCallManager.prototype.setPresenting = Native_1.default.cm_setPresenting;
 NativeCallManager.prototype.resendMediaKeys =
-    Native.cm_resendMediaKeys;
-NativeCallManager.prototype.setBandwidthMode =
-    Native.cm_setBandwidthMode;
-NativeCallManager.prototype.requestVideo = Native.cm_requestVideo;
+    Native_1.default.cm_resendMediaKeys;
+NativeCallManager.prototype.setDataMode = Native_1.default.cm_setDataMode;
+NativeCallManager.prototype.requestVideo = Native_1.default.cm_requestVideo;
 NativeCallManager.prototype.setGroupMembers =
-    Native.cm_setGroupMembers;
+    Native_1.default.cm_setGroupMembers;
 NativeCallManager.prototype.setMembershipProof =
-    Native.cm_setMembershipProof;
-NativeCallManager.prototype.peekGroupCall = Native.cm_peekGroupCall;
-NativeCallManager.prototype.getAudioInputs = Native.cm_getAudioInputs;
-NativeCallManager.prototype.setAudioInput = Native.cm_setAudioInput;
+    Native_1.default.cm_setMembershipProof;
+NativeCallManager.prototype.readCallLink = Native_1.default.cm_readCallLink;
+NativeCallManager.prototype.createCallLink = Native_1.default.cm_createCallLink;
+NativeCallManager.prototype.updateCallLink = Native_1.default.cm_updateCallLink;
+NativeCallManager.prototype.peekGroupCall = Native_1.default.cm_peekGroupCall;
+NativeCallManager.prototype.peekCallLinkCall =
+    Native_1.default.cm_peekCallLinkCall;
+NativeCallManager.prototype.getAudioInputs = Native_1.default.cm_getAudioInputs;
+NativeCallManager.prototype.setAudioInput = Native_1.default.cm_setAudioInput;
 NativeCallManager.prototype.getAudioOutputs =
-    Native.cm_getAudioOutputs;
-NativeCallManager.prototype.setAudioOutput = Native.cm_setAudioOutput;
-NativeCallManager.prototype.processEvents = Native.cm_processEvents;
-class PeekDeviceInfo {
-    constructor(demuxId, userId) {
-        this.demuxId = demuxId;
-        this.userId = userId;
-    }
-}
-exports.PeekDeviceInfo = PeekDeviceInfo;
-class PeekInfo {
-    constructor() {
-        this.devices = [];
-        this.deviceCount = 0;
-    }
-}
-exports.PeekInfo = PeekInfo;
+    Native_1.default.cm_getAudioOutputs;
+NativeCallManager.prototype.setAudioOutput = Native_1.default.cm_setAudioOutput;
+NativeCallManager.prototype.processEvents = Native_1.default.cm_processEvents;
+var PeekStatusCodes;
+(function (PeekStatusCodes) {
+    PeekStatusCodes[PeekStatusCodes["EXPIRED_CALL_LINK"] = 703] = "EXPIRED_CALL_LINK";
+    PeekStatusCodes[PeekStatusCodes["INVALID_CALL_LINK"] = 704] = "INVALID_CALL_LINK";
+})(PeekStatusCodes = exports.PeekStatusCodes || (exports.PeekStatusCodes = {}));
 // In sync with WebRTC's PeerConnection.AdapterType.
 // Despite how it looks, this is not an option set.
 // A network adapter type can only be one of the listed values.
@@ -270,6 +271,7 @@ class RingRTCType {
         this._call = null;
         this._groupCallByClientId = new Map();
         this._peekRequests = new Requests();
+        this._callLinkRequests = new Requests();
         this._callInfoByCallId = new Map();
     }
     setConfig(config) {
@@ -375,7 +377,7 @@ class RingRTCType {
     }
     proceed(callId, settings) {
         sillyDeadlockProtection(() => {
-            this.callManager.proceed(callId, settings.iceServer.username || '', settings.iceServer.password || '', settings.iceServer.urls, settings.hideIp, settings.bandwidthMode, settings.audioLevelsIntervalMillis || 0);
+            this.callManager.proceed(callId, settings.iceServer.username || '', settings.iceServer.password || '', settings.iceServer.urls, settings.hideIp, settings.dataMode, settings.audioLevelsIntervalMillis || 0);
         });
     }
     // Called by Rust
@@ -542,6 +544,138 @@ class RingRTCType {
             }
         }))().catch(e => this.logError(e.toString()));
     }
+    // Call Links
+    /**
+     * Asynchronous request to get information about a call link.
+     *
+     * @param sfuUrl - the URL to use when accessing the SFU
+     * @param authCredentialPresentation - a serialized CallLinkAuthCredentialPresentation
+     * @param linkRootKey - the root key for the call link
+     *
+     * Expected failure codes include:
+     * - 404: the room does not exist (or expired so long ago that it has been removed from the server)
+     */
+    readCallLink(sfuUrl, authCredentialPresentation, linkRootKey) {
+        const [requestId, promise] = this._callLinkRequests.add();
+        // Response comes back via handleCallLinkResponse
+        sillyDeadlockProtection(() => {
+            this.callManager.readCallLink(requestId, sfuUrl, authCredentialPresentation, linkRootKey.bytes);
+        });
+        return promise;
+    }
+    /**
+     * Asynchronous request to create a new call link.
+     *
+     * This request is idempotent; if it fails due to a network issue, it is safe to retry.
+     *
+     * @example
+     * const linkKey = CallLinkRootKey.generate();
+     * const adminPasskey = CallLinkRootKey.generateAdminPasskey();
+     * const roomId = linkKey.deriveRoomId();
+     * const credential = requestCreateCredentialFromChatServer(roomId); // using libsignal
+     * const secretParams = CallLinkSecretParams.deriveFromRootKey(linkKey.bytes);
+     * const credentialPresentation = credential.present(roomId, secretParams).serialize();
+     * const serializedPublicParams = secretParams.getPublicParams().serialize();
+     * const result = await RingRTC.createCallLink(sfuUrl, credentialPresentation, linkKey, adminPasskey, serializedPublicParams);
+     * if (result.success) {
+     *   const state = result.value;
+     *   // In actuality you may not want to do this until the user clicks Done.
+     *   saveToDatabase(linkKey.bytes, adminPasskey, state);
+     *   syncToOtherDevices(linkKey.bytes, adminPasskey);
+     * } else {
+     *   switch (result.errorStatusCode) {
+     *   case 409:
+     *     // The room already exists (and isn't yours), i.e. you've hit a 1-in-a-billion conflict.
+     *     // Fall through to kicking the user out to try again later.
+     *   default:
+     *     // Unexpected error, kick the user out for now.
+     *   }
+     * }
+     *
+     * @param sfuUrl - the URL to use when accessing the SFU
+     * @param createCredentialPresentation - a serialized CreateCallLinkCredentialPresentation
+     * @param linkRootKey - the root key for the call link
+     * @param adminPasskey - the arbitrary passkey to use for the new room
+     * @param callLinkPublicParams - the serialized CallLinkPublicParams for the new room
+     */
+    createCallLink(sfuUrl, createCredentialPresentation, linkRootKey, adminPasskey, callLinkPublicParams) {
+        const [requestId, promise] = this._callLinkRequests.add();
+        // Response comes back via handleCallLinkResponse
+        sillyDeadlockProtection(() => {
+            this.callManager.createCallLink(requestId, sfuUrl, createCredentialPresentation, linkRootKey.bytes, adminPasskey, callLinkPublicParams);
+        });
+        return promise;
+    }
+    /**
+     * Asynchronous request to update a call link's name.
+     *
+     * Possible failure codes include:
+     * - 401: the room does not exist (and this is the wrong API to create a new room)
+     * - 403: the admin passkey is incorrect
+     *
+     * This request is idempotent; if it fails due to a network issue, it is safe to retry.
+     *
+     * @param sfuUrl - the URL to use when accessing the SFU
+     * @param authCredentialPresentation - a serialized CallLinkAuthCredentialPresentation
+     * @param linkRootKey - the root key for the call link
+     * @param adminPasskey - the passkey specified when the link was created
+     * @param newName - the new name to use
+     */
+    updateCallLinkName(sfuUrl, authCredentialPresentation, linkRootKey, adminPasskey, newName) {
+        const [requestId, promise] = this._callLinkRequests.add();
+        // Response comes back via handleCallLinkResponse
+        sillyDeadlockProtection(() => {
+            this.callManager.updateCallLink(requestId, sfuUrl, authCredentialPresentation, linkRootKey.bytes, adminPasskey, newName, undefined, undefined);
+        });
+        return promise;
+    }
+    /**
+     * Asynchronous request to update a call link's restrictions.
+     *
+     * Possible failure codes include:
+     * - 401: the room does not exist (and this is the wrong API to create a new room)
+     * - 403: the admin passkey is incorrect
+     *
+     * This request is idempotent; if it fails due to a network issue, it is safe to retry.
+     *
+     * @param sfuUrl - the URL to use when accessing the SFU
+     * @param authCredentialPresentation - a serialized CallLinkAuthCredentialPresentation
+     * @param linkRootKey - the root key for the call link
+     * @param adminPasskey - the passkey specified when the link was created
+     * @param restrictions - the new restrictions to use
+     */
+    updateCallLinkRestrictions(sfuUrl, authCredentialPresentation, linkRootKey, adminPasskey, restrictions) {
+        const [requestId, promise] = this._callLinkRequests.add();
+        // Response comes back via handleCallLinkResponse
+        sillyDeadlockProtection(() => {
+            this.callManager.updateCallLink(requestId, sfuUrl, authCredentialPresentation, linkRootKey.bytes, adminPasskey, undefined, restrictions, undefined);
+        });
+        return promise;
+    }
+    /**
+     * Asynchronous request to revoke or un-revoke a call link.
+     *
+     * Possible failure codes include:
+     * - 401: the room does not exist (and this is the wrong API to create a new room)
+     * - 403: the admin passkey is incorrect
+     *
+     * This request is idempotent; if it fails due to a network issue, it is safe to retry.
+     *
+     * @param sfuUrl - the URL to use when accessing the SFU
+     * @param authCredentialPresentation - a serialized CallLinkAuthCredentialPresentation
+     * @param linkRootKey - the root key for the call link
+     * @param adminPasskey - the passkey specified when the link was created
+     * @param revoked - whether the link should now be revoked
+     */
+    updateCallLinkRevocation(sfuUrl, authCredentialPresentation, linkRootKey, adminPasskey, revoked) {
+        const [requestId, promise] = this._callLinkRequests.add();
+        // Response comes back via handleCallLinkResponse
+        sillyDeadlockProtection(() => {
+            this.callManager.updateCallLink(requestId, sfuUrl, authCredentialPresentation, linkRootKey.bytes, adminPasskey, undefined, undefined, revoked);
+        });
+        return promise;
+    }
+    // HTTP callbacks
     receivedHttpResponse(requestId, status, body) {
         sillyDeadlockProtection(() => {
             try {
@@ -567,7 +701,15 @@ class RingRTCType {
     // Group Calls
     // Called by UX
     getGroupCall(groupId, sfuUrl, hkdfExtraInfo, audioLevelsIntervalMillis, observer) {
-        const groupCall = new GroupCall(this.callManager, groupId, sfuUrl, hkdfExtraInfo, audioLevelsIntervalMillis, observer);
+        const clientId = this.callManager.createGroupCallClient(groupId, sfuUrl, hkdfExtraInfo, audioLevelsIntervalMillis || 0);
+        const groupCall = new GroupCall(this.callManager, observer, clientId);
+        this._groupCallByClientId.set(groupCall.clientId, groupCall);
+        return groupCall;
+    }
+    // Called by UX
+    getCallLinkCall(sfuUrl, authCredentialPresentation, rootKey, adminPasskey, hkdfExtraInfo, audioLevelsIntervalMillis, observer) {
+        const clientId = this.callManager.createCallLinkCallClient(sfuUrl, authCredentialPresentation, rootKey.bytes, adminPasskey, hkdfExtraInfo, audioLevelsIntervalMillis || 0);
+        const groupCall = new GroupCall(this.callManager, observer, clientId);
         this._groupCallByClientId.set(groupCall.clientId, groupCall);
         return groupCall;
     }
@@ -579,6 +721,22 @@ class RingRTCType {
         sillyDeadlockProtection(() => {
             this.callManager.peekGroupCall(requestId, sfuUrl, membershipProof, groupMembers);
         });
+        return promise.then(result => {
+            if (result.success) {
+                return result.value;
+            }
+            else {
+                return { devices: [], deviceCount: 0 };
+            }
+        });
+    }
+    // Called by UX
+    peekCallLinkCall(sfuUrl, authCredentialPresentation, rootKey) {
+        const [requestId, promise] = this._peekRequests.add();
+        // Response comes back via handlePeekResponse
+        sillyDeadlockProtection(() => {
+            this.callManager.peekCallLinkCall(requestId, sfuUrl, authCredentialPresentation, rootKey.bytes);
+        });
         return promise;
     }
     // Called by Rust
@@ -668,14 +826,52 @@ class RingRTCType {
         });
     }
     // Called by Rust
-    handlePeekResponse(requestId, info) {
+    handlePeekResponse(requestId, statusCode, info) {
         sillyDeadlockProtection(() => {
-            if (!this._peekRequests.resolve(requestId, info)) {
+            let result;
+            if (info) {
+                result = { success: true, value: info };
+            }
+            else {
+                result = { success: false, errorStatusCode: statusCode };
+            }
+            if (!this._peekRequests.resolve(requestId, result)) {
                 this.logWarn(`Invalid request ID for handlePeekResponse: ${requestId}`);
             }
         });
     }
     // Called by Rust
+    handleCallLinkResponse(requestId, statusCode, state) {
+        sillyDeadlockProtection(() => {
+            // Recreate the state so that we have the correct prototype, in case we add more methods to CallLinkState.
+            let result;
+            if (state) {
+                let restrictions;
+                switch (state.rawRestrictions) {
+                    case 0:
+                        restrictions = CallLinks_1.CallLinkRestrictions.None;
+                        break;
+                    case 1:
+                        restrictions = CallLinks_1.CallLinkRestrictions.AdminApproval;
+                        break;
+                    default:
+                        restrictions = CallLinks_1.CallLinkRestrictions.Unknown;
+                        break;
+                }
+                result = {
+                    success: true,
+                    value: new CallLinks_1.CallLinkState(state.name, restrictions, state.revoked, state.expiration),
+                };
+            }
+            else {
+                result = { success: false, errorStatusCode: statusCode };
+            }
+            if (!this._callLinkRequests.resolve(requestId, result)) {
+                this.logWarn(`Invalid request ID for handleCallLinkResponse: ${requestId}`);
+            }
+        });
+    }
+    // Called by Rust
     handleEnded(clientId, reason) {
         sillyDeadlockProtection(() => {
             const groupCall = this._groupCallByClientId.get(clientId);
@@ -1087,10 +1283,10 @@ class Call {
             }
         });
     }
-    updateBandwidthMode(bandwidthMode) {
+    updateDataMode(dataMode) {
         sillyDeadlockProtection(() => {
             try {
-                this._callManager.updateBandwidthMode(bandwidthMode);
+                this._callManager.updateDataMode(dataMode);
             }
             catch (_a) {
                 // We may not have an active connection any more.
@@ -1238,11 +1434,11 @@ class GroupCall {
         return this._clientId;
     }
     // Called by UI via RingRTC object
-    constructor(callManager, groupId, sfuUrl, hkdfExtraInfo, audioLevelsIntervalMillis, observer) {
+    constructor(callManager, observer, clientId) {
         this._callManager = callManager;
         this._observer = observer;
+        this._clientId = clientId;
         this._localDeviceState = new LocalDeviceState();
-        this._clientId = this._callManager.createGroupCallClient(groupId, sfuUrl, hkdfExtraInfo, audioLevelsIntervalMillis || 0);
     }
     // Called by UI
     connect() {
@@ -1305,8 +1501,8 @@ class GroupCall {
         this._callManager.resendMediaKeys(this._clientId);
     }
     // Called by UI
-    setBandwidthMode(bandwidthMode) {
-        this._callManager.setBandwidthMode(this._clientId, bandwidthMode);
+    setDataMode(dataMode) {
+        this._callManager.setDataMode(this._clientId, dataMode);
     }
     // Called by UI
     requestVideo(resolutions, activeSpeakerHeight) {
@@ -1484,11 +1680,11 @@ var HangupType;
     HangupType[HangupType["Busy"] = 3] = "Busy";
     HangupType[HangupType["NeedPermission"] = 4] = "NeedPermission";
 })(HangupType = exports.HangupType || (exports.HangupType = {}));
-var BandwidthMode;
-(function (BandwidthMode) {
-    BandwidthMode[BandwidthMode["Low"] = 0] = "Low";
-    BandwidthMode[BandwidthMode["Normal"] = 1] = "Normal";
-})(BandwidthMode = exports.BandwidthMode || (exports.BandwidthMode = {}));
+var DataMode;
+(function (DataMode) {
+    DataMode[DataMode["Low"] = 0] = "Low";
+    DataMode[DataMode["Normal"] = 1] = "Normal";
+})(DataMode = exports.DataMode || (exports.DataMode = {}));
 /// Describes why a ring was cancelled.
 var RingCancelReason;
 (function (RingCancelReason) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signalapp/ringrtc",
-  "version": "2.26.4",
+  "version": "2.28.0",
   "description": "Signal Messenger voice and video calling library.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -23,7 +23,7 @@
   },
   "config": {
     "prebuildUrl": "https://build-artifacts.signal.org/libraries/ringrtc-desktop-build-v${npm_package_version}.tar.gz",
-    "prebuildChecksum": "6152f6a46abca73e62644fc82e36b2ffa7927cbae1f671a2ba04a7519eb670a1"
+    "prebuildChecksum": "5d4bd3c13ee3373d0e67dacce7e64a422fdc4e0eb8f9c551495fa5b90ec1f322"
   },
   "author": "",
   "license": "AGPL-3.0-only",