@signalapp/libsignal-client 0.22.1 → 0.23.0

package/Native.d.ts

@@ -54,21 +54,41 @@ export function Aes256GcmSiv_Decrypt(aesGcmSiv: Wrapper<Aes256GcmSiv>, ctext: Bu
 export function Aes256GcmSiv_Encrypt(aesGcmSivObj: Wrapper<Aes256GcmSiv>, ptext: Buffer, nonce: Buffer, associatedData: Buffer): Buffer;
 export function Aes256GcmSiv_New(key: Buffer): Aes256GcmSiv;
 export function AuthCredentialPresentation_CheckValidContents(presentationBytes: Buffer): void;
-export function AuthCredentialPresentation_GetPniCiphertext(presentationBytes: Buffer): Buffer;
+export function AuthCredentialPresentation_GetPniCiphertext(presentationBytes: Buffer): Buffer | null;
 export function AuthCredentialPresentation_GetRedemptionTime(presentationBytes: Buffer): Timestamp;
 export function AuthCredentialPresentation_GetUuidCiphertext(presentationBytes: Buffer): Serialized<UuidCiphertext>;
 export function AuthCredentialResponse_CheckValidContents(buffer: Buffer): void;
 export function AuthCredentialWithPniResponse_CheckValidContents(buffer: Buffer): void;
 export function AuthCredentialWithPni_CheckValidContents(buffer: Buffer): void;
 export function AuthCredential_CheckValidContents(buffer: Buffer): void;
-export function Cds2ClientState_CompleteHandshake(cli: Wrapper<Cds2ClientState>, handshakeReceived: Buffer): void;
-export function Cds2ClientState_EstablishedRecv(cli: Wrapper<Cds2ClientState>, receivedCiphertext: Buffer): Buffer;
-export function Cds2ClientState_EstablishedSend(cli: Wrapper<Cds2ClientState>, plaintextToSend: Buffer): Buffer;
-export function Cds2ClientState_InitialRequest(obj: Wrapper<Cds2ClientState>): Buffer;
-export function Cds2ClientState_New(mrenclave: Buffer, attestationMsg: Buffer, currentTimestamp: Timestamp): Cds2ClientState;
+export function CallLinkAuthCredentialPresentation_CheckValidContents(presentationBytes: Buffer): void;
+export function CallLinkAuthCredentialPresentation_GetUserId(presentationBytes: Buffer): Serialized<UuidCiphertext>;
+export function CallLinkAuthCredentialPresentation_Verify(presentationBytes: Buffer, now: Timestamp, serverParamsBytes: Buffer, callLinkParamsBytes: Buffer): void;
+export function CallLinkAuthCredentialResponse_CheckValidContents(responseBytes: Buffer): void;
+export function CallLinkAuthCredentialResponse_IssueDeterministic(userId: Uuid, redemptionTime: Timestamp, paramsBytes: Buffer, randomness: Buffer): Buffer;
+export function CallLinkAuthCredentialResponse_Receive(responseBytes: Buffer, userId: Uuid, redemptionTime: Timestamp, paramsBytes: Buffer): Buffer;
+export function CallLinkAuthCredential_CheckValidContents(credentialBytes: Buffer): void;
+export function CallLinkAuthCredential_PresentDeterministic(credentialBytes: Buffer, userId: Uuid, redemptionTime: Timestamp, serverParamsBytes: Buffer, callLinkParamsBytes: Buffer, randomness: Buffer): Buffer;
+export function CallLinkPublicParams_CheckValidContents(paramsBytes: Buffer): void;
+export function CallLinkSecretParams_CheckValidContents(paramsBytes: Buffer): void;
+export function CallLinkSecretParams_DecryptUserId(paramsBytes: Buffer, userId: Serialized<UuidCiphertext>): Uuid;
+export function CallLinkSecretParams_DeriveFromRootKey(rootKey: Buffer): Buffer;
+export function CallLinkSecretParams_GetPublicParams(paramsBytes: Buffer): Buffer;
+export function Cds2ClientState_New(mrenclave: Buffer, attestationMsg: Buffer, currentTimestamp: Timestamp): SgxClientState;
 export function CiphertextMessage_FromPlaintextContent(m: Wrapper<PlaintextContent>): CiphertextMessage;
 export function CiphertextMessage_Serialize(obj: Wrapper<CiphertextMessage>): Buffer;
 export function CiphertextMessage_Type(msg: Wrapper<CiphertextMessage>): number;
+export function CreateCallLinkCredentialPresentation_CheckValidContents(presentationBytes: Buffer): void;
+export function CreateCallLinkCredentialPresentation_Verify(presentationBytes: Buffer, roomId: Buffer, now: Timestamp, serverParamsBytes: Buffer, callLinkParamsBytes: Buffer): void;
+export function CreateCallLinkCredentialRequestContext_CheckValidContents(contextBytes: Buffer): void;
+export function CreateCallLinkCredentialRequestContext_GetRequest(contextBytes: Buffer): Buffer;
+export function CreateCallLinkCredentialRequestContext_NewDeterministic(roomId: Buffer, randomness: Buffer): Buffer;
+export function CreateCallLinkCredentialRequestContext_ReceiveResponse(contextBytes: Buffer, responseBytes: Buffer, userId: Uuid, paramsBytes: Buffer): Buffer;
+export function CreateCallLinkCredentialRequest_CheckValidContents(requestBytes: Buffer): void;
+export function CreateCallLinkCredentialRequest_IssueDeterministic(requestBytes: Buffer, userId: Uuid, timestamp: Timestamp, paramsBytes: Buffer, randomness: Buffer): Buffer;
+export function CreateCallLinkCredentialResponse_CheckValidContents(responseBytes: Buffer): void;
+export function CreateCallLinkCredential_CheckValidContents(paramsBytes: Buffer): void;
+export function CreateCallLinkCredential_PresentDeterministic(credentialBytes: Buffer, roomId: Buffer, userId: Uuid, serverParamsBytes: Buffer, callLinkParamsBytes: Buffer, randomness: Buffer): Buffer;
 export function DecryptionErrorMessage_Deserialize(data: Buffer): DecryptionErrorMessage;
 export function DecryptionErrorMessage_ExtractFromSerializedContent(bytes: Buffer): DecryptionErrorMessage;
 export function DecryptionErrorMessage_ForOriginalMessage(originalBytes: Buffer, originalType: number, originalTimestamp: Timestamp, originalSenderDeviceId: number): DecryptionErrorMessage;
@@ -82,6 +102,10 @@ export function ExpiringProfileKeyCredential_GetExpirationTime(credential: Seria
 export function Fingerprint_DisplayString(obj: Wrapper<Fingerprint>): string;
 export function Fingerprint_New(iterations: number, version: number, localIdentifier: Buffer, localKey: Wrapper<PublicKey>, remoteIdentifier: Buffer, remoteKey: Wrapper<PublicKey>): Fingerprint;
 export function Fingerprint_ScannableEncoding(obj: Wrapper<Fingerprint>): Buffer;
+export function GenericServerPublicParams_CheckValidContents(paramsBytes: Buffer): void;
+export function GenericServerSecretParams_CheckValidContents(paramsBytes: Buffer): void;
+export function GenericServerSecretParams_GenerateDeterministic(randomness: Buffer): Buffer;
+export function GenericServerSecretParams_GetPublicParams(paramsBytes: Buffer): Buffer;
 export function GroupCipher_DecryptMessage(sender: Wrapper<ProtocolAddress>, message: Buffer, store: SenderKeyStore, ctx: null): Promise<Buffer>;
 export function GroupCipher_EncryptMessage(sender: Wrapper<ProtocolAddress>, distributionId: Uuid, message: Buffer, store: SenderKeyStore, ctx: null): Promise<CiphertextMessage>;
 export function GroupMasterKey_CheckValidContents(buffer: Buffer): void;
@@ -112,14 +136,6 @@ export function PlaintextContent_Deserialize(data: Buffer): PlaintextContent;
 export function PlaintextContent_FromDecryptionErrorMessage(m: Wrapper<DecryptionErrorMessage>): PlaintextContent;
 export function PlaintextContent_GetBody(obj: Wrapper<PlaintextContent>): Buffer;
 export function PlaintextContent_Serialize(obj: Wrapper<PlaintextContent>): Buffer;
-export function PniCredentialPresentation_CheckValidContents(presentationBytes: Buffer): void;
-export function PniCredentialPresentation_GetAciCiphertext(presentationBytes: Buffer): Serialized<UuidCiphertext>;
-export function PniCredentialPresentation_GetPniCiphertext(presentationBytes: Buffer): Serialized<UuidCiphertext>;
-export function PniCredentialPresentation_GetProfileKeyCiphertext(presentationBytes: Buffer): Serialized<ProfileKeyCiphertext>;
-export function PniCredentialRequestContext_CheckValidContents(buffer: Buffer): void;
-export function PniCredentialRequestContext_GetRequest(context: Serialized<PniCredentialRequestContext>): Serialized<ProfileKeyCredentialRequest>;
-export function PniCredentialResponse_CheckValidContents(buffer: Buffer): void;
-export function PniCredential_CheckValidContents(buffer: Buffer): void;
 export function PreKeyBundle_GetDeviceId(obj: Wrapper<PreKeyBundle>): number;
 export function PreKeyBundle_GetIdentityKey(p: Wrapper<PreKeyBundle>): PublicKey;
 export function PreKeyBundle_GetPreKeyId(obj: Wrapper<PreKeyBundle>): number | null;
@@ -156,9 +172,8 @@ export function ProfileKeyCredentialPresentation_GetUuidCiphertext(presentationB
 export function ProfileKeyCredentialRequestContext_CheckValidContents(buffer: Buffer): void;
 export function ProfileKeyCredentialRequestContext_GetRequest(context: Serialized<ProfileKeyCredentialRequestContext>): Serialized<ProfileKeyCredentialRequest>;
 export function ProfileKeyCredentialRequest_CheckValidContents(buffer: Buffer): void;
-export function ProfileKeyCredentialResponse_CheckValidContents(buffer: Buffer): void;
-export function ProfileKeyCredential_CheckValidContents(buffer: Buffer): void;
 export function ProfileKey_CheckValidContents(buffer: Buffer): void;
+export function ProfileKey_DeriveAccessKey(profileKey: Serialized<ProfileKey>): Buffer;
 export function ProfileKey_GetCommitment(profileKey: Serialized<ProfileKey>, uuid: Uuid): Serialized<ProfileKeyCommitment>;
 export function ProfileKey_GetProfileKeyVersion(profileKey: Serialized<ProfileKey>, uuid: Uuid): Buffer;
 export function ProtocolAddress_DeviceId(obj: Wrapper<ProtocolAddress>): number;
@@ -232,17 +247,12 @@ export function ServerPublicParams_CheckValidContents(buffer: Buffer): void;
 export function ServerPublicParams_CreateAuthCredentialPresentationDeterministic(serverPublicParams: Serialized<ServerPublicParams>, randomness: Buffer, groupSecretParams: Serialized<GroupSecretParams>, authCredential: Serialized<AuthCredential>): Buffer;
 export function ServerPublicParams_CreateAuthCredentialWithPniPresentationDeterministic(serverPublicParams: Serialized<ServerPublicParams>, randomness: Buffer, groupSecretParams: Serialized<GroupSecretParams>, authCredential: Serialized<AuthCredentialWithPni>): Buffer;
 export function ServerPublicParams_CreateExpiringProfileKeyCredentialPresentationDeterministic(serverPublicParams: Serialized<ServerPublicParams>, randomness: Buffer, groupSecretParams: Serialized<GroupSecretParams>, profileKeyCredential: Serialized<ExpiringProfileKeyCredential>): Buffer;
-export function ServerPublicParams_CreatePniCredentialPresentationDeterministic(serverPublicParams: Serialized<ServerPublicParams>, randomness: Buffer, groupSecretParams: Serialized<GroupSecretParams>, pniCredential: Serialized<PniCredential>): Buffer;
-export function ServerPublicParams_CreatePniCredentialRequestContextDeterministic(serverPublicParams: Serialized<ServerPublicParams>, randomness: Buffer, aci: Uuid, pni: Uuid, profileKey: Serialized<ProfileKey>): Serialized<PniCredentialRequestContext>;
-export function ServerPublicParams_CreateProfileKeyCredentialPresentationDeterministic(serverPublicParams: Serialized<ServerPublicParams>, randomness: Buffer, groupSecretParams: Serialized<GroupSecretParams>, profileKeyCredential: Serialized<ProfileKeyCredential>): Buffer;
 export function ServerPublicParams_CreateProfileKeyCredentialRequestContextDeterministic(serverPublicParams: Serialized<ServerPublicParams>, randomness: Buffer, uuid: Uuid, profileKey: Serialized<ProfileKey>): Serialized<ProfileKeyCredentialRequestContext>;
 export function ServerPublicParams_CreateReceiptCredentialPresentationDeterministic(serverPublicParams: Serialized<ServerPublicParams>, randomness: Buffer, receiptCredential: Serialized<ReceiptCredential>): Serialized<ReceiptCredentialPresentation>;
 export function ServerPublicParams_CreateReceiptCredentialRequestContextDeterministic(serverPublicParams: Serialized<ServerPublicParams>, randomness: Buffer, receiptSerial: Buffer): Serialized<ReceiptCredentialRequestContext>;
 export function ServerPublicParams_ReceiveAuthCredential(params: Serialized<ServerPublicParams>, uuid: Uuid, redemptionTime: number, response: Serialized<AuthCredentialResponse>): Serialized<AuthCredential>;
 export function ServerPublicParams_ReceiveAuthCredentialWithPni(params: Serialized<ServerPublicParams>, aci: Uuid, pni: Uuid, redemptionTime: Timestamp, response: Serialized<AuthCredentialWithPniResponse>): Serialized<AuthCredentialWithPni>;
 export function ServerPublicParams_ReceiveExpiringProfileKeyCredential(serverPublicParams: Serialized<ServerPublicParams>, requestContext: Serialized<ProfileKeyCredentialRequestContext>, response: Serialized<ExpiringProfileKeyCredentialResponse>, currentTimeInSeconds: Timestamp): Serialized<ExpiringProfileKeyCredential>;
-export function ServerPublicParams_ReceivePniCredential(serverPublicParams: Serialized<ServerPublicParams>, requestContext: Serialized<PniCredentialRequestContext>, response: Serialized<PniCredentialResponse>): Serialized<PniCredential>;
-export function ServerPublicParams_ReceiveProfileKeyCredential(serverPublicParams: Serialized<ServerPublicParams>, requestContext: Serialized<ProfileKeyCredentialRequestContext>, response: Serialized<ProfileKeyCredentialResponse>): Serialized<ProfileKeyCredential>;
 export function ServerPublicParams_ReceiveReceiptCredential(serverPublicParams: Serialized<ServerPublicParams>, requestContext: Serialized<ReceiptCredentialRequestContext>, response: Serialized<ReceiptCredentialResponse>): Serialized<ReceiptCredential>;
 export function ServerPublicParams_VerifySignature(serverPublicParams: Serialized<ServerPublicParams>, message: Buffer, notarySignature: Buffer): void;
 export function ServerSecretParams_CheckValidContents(buffer: Buffer): void;
@@ -251,12 +261,9 @@ export function ServerSecretParams_GetPublicParams(params: Serialized<ServerSecr
 export function ServerSecretParams_IssueAuthCredentialDeterministic(serverSecretParams: Serialized<ServerSecretParams>, randomness: Buffer, uuid: Uuid, redemptionTime: number): Serialized<AuthCredentialResponse>;
 export function ServerSecretParams_IssueAuthCredentialWithPniDeterministic(serverSecretParams: Serialized<ServerSecretParams>, randomness: Buffer, aci: Uuid, pni: Uuid, redemptionTime: Timestamp): Serialized<AuthCredentialWithPniResponse>;
 export function ServerSecretParams_IssueExpiringProfileKeyCredentialDeterministic(serverSecretParams: Serialized<ServerSecretParams>, randomness: Buffer, request: Serialized<ProfileKeyCredentialRequest>, uuid: Uuid, commitment: Serialized<ProfileKeyCommitment>, expirationInSeconds: Timestamp): Serialized<ExpiringProfileKeyCredentialResponse>;
-export function ServerSecretParams_IssuePniCredentialDeterministic(serverSecretParams: Serialized<ServerSecretParams>, randomness: Buffer, request: Serialized<ProfileKeyCredentialRequest>, aci: Uuid, pni: Uuid, commitment: Serialized<ProfileKeyCommitment>): Serialized<PniCredentialResponse>;
-export function ServerSecretParams_IssueProfileKeyCredentialDeterministic(serverSecretParams: Serialized<ServerSecretParams>, randomness: Buffer, request: Serialized<ProfileKeyCredentialRequest>, uuid: Uuid, commitment: Serialized<ProfileKeyCommitment>): Serialized<ProfileKeyCredentialResponse>;
 export function ServerSecretParams_IssueReceiptCredentialDeterministic(serverSecretParams: Serialized<ServerSecretParams>, randomness: Buffer, request: Serialized<ReceiptCredentialRequest>, receiptExpirationTime: Timestamp, receiptLevel: Buffer): Serialized<ReceiptCredentialResponse>;
 export function ServerSecretParams_SignDeterministic(params: Serialized<ServerSecretParams>, randomness: Buffer, message: Buffer): Buffer;
 export function ServerSecretParams_VerifyAuthCredentialPresentation(serverSecretParams: Serialized<ServerSecretParams>, groupPublicParams: Serialized<GroupPublicParams>, presentationBytes: Buffer, currentTimeInSeconds: Timestamp): void;
-export function ServerSecretParams_VerifyPniCredentialPresentation(serverSecretParams: Serialized<ServerSecretParams>, groupPublicParams: Serialized<GroupPublicParams>, presentationBytes: Buffer): void;
 export function ServerSecretParams_VerifyProfileKeyCredentialPresentation(serverSecretParams: Serialized<ServerSecretParams>, groupPublicParams: Serialized<GroupPublicParams>, presentationBytes: Buffer, currentTimeInSeconds: Timestamp): void;
 export function ServerSecretParams_VerifyReceiptCredentialPresentation(serverSecretParams: Serialized<ServerSecretParams>, presentation: Serialized<ReceiptCredentialPresentation>): void;
 export function SessionBuilder_ProcessPreKeyBundle(bundle: Wrapper<PreKeyBundle>, protocolAddress: Wrapper<ProtocolAddress>, sessionStore: SessionStore, identityKeyStore: IdentityKeyStore, ctx: null): Promise<void>;
@@ -270,6 +277,10 @@ export function SessionRecord_GetLocalRegistrationId(obj: Wrapper<SessionRecord>
 export function SessionRecord_GetRemoteRegistrationId(obj: Wrapper<SessionRecord>): number;
 export function SessionRecord_HasCurrentState(obj: Wrapper<SessionRecord>): boolean;
 export function SessionRecord_Serialize(obj: Wrapper<SessionRecord>): Buffer;
+export function SgxClientState_CompleteHandshake(cli: Wrapper<SgxClientState>, handshakeReceived: Buffer): void;
+export function SgxClientState_EstablishedRecv(cli: Wrapper<SgxClientState>, receivedCiphertext: Buffer): Buffer;
+export function SgxClientState_EstablishedSend(cli: Wrapper<SgxClientState>, plaintextToSend: Buffer): Buffer;
+export function SgxClientState_InitialRequest(obj: Wrapper<SgxClientState>): Buffer;
 export function SignalMessage_Deserialize(data: Buffer): SignalMessage;
 export function SignalMessage_GetBody(obj: Wrapper<SignalMessage>): Buffer;
 export function SignalMessage_GetCounter(obj: Wrapper<SignalMessage>): number;
@@ -288,7 +299,7 @@ export function SignedPreKeyRecord_Serialize(obj: Wrapper<SignedPreKeyRecord>):
 export function UnidentifiedSenderMessageContent_Deserialize(data: Buffer): UnidentifiedSenderMessageContent;
 export function UnidentifiedSenderMessageContent_GetContentHint(m: Wrapper<UnidentifiedSenderMessageContent>): number;
 export function UnidentifiedSenderMessageContent_GetContents(obj: Wrapper<UnidentifiedSenderMessageContent>): Buffer;
-export function UnidentifiedSenderMessageContent_GetGroupId(obj: Wrapper<UnidentifiedSenderMessageContent>): Buffer;
+export function UnidentifiedSenderMessageContent_GetGroupId(obj: Wrapper<UnidentifiedSenderMessageContent>): Buffer | null;
 export function UnidentifiedSenderMessageContent_GetMsgType(m: Wrapper<UnidentifiedSenderMessageContent>): number;
 export function UnidentifiedSenderMessageContent_GetSenderCert(m: Wrapper<UnidentifiedSenderMessageContent>): SenderCertificate;
 export function UnidentifiedSenderMessageContent_New(message: Wrapper<CiphertextMessage>, sender: Wrapper<SenderCertificate>, contentHint: number, groupId: Buffer | null): UnidentifiedSenderMessageContent;
@@ -304,7 +315,6 @@ interface AuthCredential { readonly __type: unique symbol; }
 interface AuthCredentialResponse { readonly __type: unique symbol; }
 interface AuthCredentialWithPni { readonly __type: unique symbol; }
 interface AuthCredentialWithPniResponse { readonly __type: unique symbol; }
-interface Cds2ClientState { readonly __type: unique symbol; }
 interface CiphertextMessage { readonly __type: unique symbol; }
 interface DecryptionErrorMessage { readonly __type: unique symbol; }
 interface ExpiringProfileKeyCredential { readonly __type: unique symbol; }
@@ -315,9 +325,6 @@ interface GroupPublicParams { readonly __type: unique symbol; }
 interface GroupSecretParams { readonly __type: unique symbol; }
 interface HsmEnclaveClient { readonly __type: unique symbol; }
 interface PlaintextContent { readonly __type: unique symbol; }
-interface PniCredential { readonly __type: unique symbol; }
-interface PniCredentialRequestContext { readonly __type: unique symbol; }
-interface PniCredentialResponse { readonly __type: unique symbol; }
 interface PreKeyBundle { readonly __type: unique symbol; }
 interface PreKeyRecord { readonly __type: unique symbol; }
 interface PreKeySignalMessage { readonly __type: unique symbol; }
@@ -325,10 +332,8 @@ interface PrivateKey { readonly __type: unique symbol; }
 interface ProfileKey { readonly __type: unique symbol; }
 interface ProfileKeyCiphertext { readonly __type: unique symbol; }
 interface ProfileKeyCommitment { readonly __type: unique symbol; }
-interface ProfileKeyCredential { readonly __type: unique symbol; }
 interface ProfileKeyCredentialRequest { readonly __type: unique symbol; }
 interface ProfileKeyCredentialRequestContext { readonly __type: unique symbol; }
-interface ProfileKeyCredentialResponse { readonly __type: unique symbol; }
 interface ProtocolAddress { readonly __type: unique symbol; }
 interface PublicKey { readonly __type: unique symbol; }
 interface ReceiptCredential { readonly __type: unique symbol; }
@@ -345,6 +350,7 @@ interface ServerCertificate { readonly __type: unique symbol; }
 interface ServerPublicParams { readonly __type: unique symbol; }
 interface ServerSecretParams { readonly __type: unique symbol; }
 interface SessionRecord { readonly __type: unique symbol; }
+interface SgxClientState { readonly __type: unique symbol; }
 interface SignalMessage { readonly __type: unique symbol; }
 interface SignedPreKeyRecord { readonly __type: unique symbol; }
 interface UnidentifiedSenderMessageContent { readonly __type: unique symbol; }

package/dist/index.d.ts

@@ -324,7 +324,7 @@ export declare function sealedSenderMultiRecipientMessageForSingleRecipient(mess
 export declare function sealedSenderDecryptMessage(message: Buffer, trustRoot: PublicKey, timestamp: number, localE164: string | null, localUuid: string, localDeviceId: number, sessionStore: SessionStore, identityStore: IdentityKeyStore, prekeyStore: PreKeyStore, signedPrekeyStore: SignedPreKeyStore): Promise<SealedSenderDecryptionResult>;
 export declare function sealedSenderDecryptToUsmc(message: Buffer, identityStore: IdentityKeyStore): Promise<UnidentifiedSenderMessageContent>;
 export declare class Cds2Client {
-    readonly _nativeHandle: Native.Cds2ClientState;
+    readonly _nativeHandle: Native.SgxClientState;
     private constructor();
     static new(mrenclave: Buffer, attestationMsg: Buffer, currentTimestamp: Date): Cds2Client;
     initialRequest(): Buffer;

package/dist/index.js

@@ -865,16 +865,16 @@ class Cds2Client {
         return new Cds2Client(Native.Cds2ClientState_New(mrenclave, attestationMsg, currentTimestamp.getTime()));
     }
     initialRequest() {
-        return Native.Cds2ClientState_InitialRequest(this);
+        return Native.SgxClientState_InitialRequest(this);
     }
     completeHandshake(buffer) {
-        return Native.Cds2ClientState_CompleteHandshake(this, buffer);
+        return Native.SgxClientState_CompleteHandshake(this, buffer);
     }
     establishedSend(buffer) {
-        return Native.Cds2ClientState_EstablishedSend(this, buffer);
+        return Native.SgxClientState_EstablishedSend(this, buffer);
     }
     establishedRecv(buffer) {
-        return Native.Cds2ClientState_EstablishedRecv(this, buffer);
+        return Native.SgxClientState_EstablishedRecv(this, buffer);
     }
 }
 exports.Cds2Client = Cds2Client;
@@ -951,7 +951,7 @@ function initLogger(maxLevel, callback) {
                 level = LogLevel.Trace;
                 break;
             default:
-                callback(LogLevel.Warn, 'signal-client', 'index.ts', 0, 'unknown log level ' + nativeLevel + '; treating as error');
+                callback(LogLevel.Warn, 'signal-client', 'index.ts', 0, `unknown log level ${nativeLevel}; treating as error`);
                 level = LogLevel.Error;
                 break;
         }

package/dist/usernames.js

@@ -5,6 +5,7 @@
 //
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyProof = exports.generateProofWithRandom = exports.generateProof = exports.hash = exports.generateCandidates = void 0;
+/* eslint @typescript-eslint/no-shadow: ["error", { "allow": ["hash"] }] */
 const crypto_1 = require("crypto");
 const Constants_1 = require("./zkgroup/internal/Constants");
 const Native = require("../Native");

package/dist/zkgroup/GenericServerPublicParams.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import ByteArray from './internal/ByteArray';
+export default class GenericServerPublicParams extends ByteArray {
+    private readonly __type?;
+    constructor(contents: Buffer);
+}

package/dist/zkgroup/GenericServerPublicParams.js

@@ -0,0 +1,15 @@
+"use strict";
+//
+// Copyright 2020-2021 Signal Messenger, LLC.
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+const ByteArray_1 = require("./internal/ByteArray");
+const Native = require("../../Native");
+class GenericServerPublicParams extends ByteArray_1.default {
+    constructor(contents) {
+        super(contents, Native.GenericServerPublicParams_CheckValidContents);
+    }
+}
+exports.default = GenericServerPublicParams;
+//# sourceMappingURL=GenericServerPublicParams.js.map

package/dist/zkgroup/GenericServerSecretParams.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import ByteArray from './internal/ByteArray';
+import GenericServerPublicParams from './GenericServerPublicParams';
+export default class GenericServerSecretParams extends ByteArray {
+    private readonly __type?;
+    static generate(): GenericServerSecretParams;
+    static generateWithRandom(random: Buffer): GenericServerSecretParams;
+    constructor(contents: Buffer);
+    getPublicParams(): GenericServerPublicParams;
+}

package/dist/zkgroup/GenericServerSecretParams.js

@@ -0,0 +1,28 @@
+"use strict";
+//
+// Copyright 2023 Signal Messenger, LLC.
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+const Native = require("../../Native");
+const ByteArray_1 = require("./internal/ByteArray");
+const Constants_1 = require("./internal/Constants");
+const GenericServerPublicParams_1 = require("./GenericServerPublicParams");
+class GenericServerSecretParams extends ByteArray_1.default {
+    static generate() {
+        const random = (0, crypto_1.randomBytes)(Constants_1.RANDOM_LENGTH);
+        return GenericServerSecretParams.generateWithRandom(random);
+    }
+    static generateWithRandom(random) {
+        return new GenericServerSecretParams(Native.GenericServerSecretParams_GenerateDeterministic(random));
+    }
+    constructor(contents) {
+        super(contents, Native.GenericServerSecretParams_CheckValidContents);
+    }
+    getPublicParams() {
+        return new GenericServerPublicParams_1.default(Native.GenericServerSecretParams_GetPublicParams(this.contents));
+    }
+}
+exports.default = GenericServerSecretParams;
+//# sourceMappingURL=GenericServerSecretParams.js.map

package/dist/zkgroup/calllinks/CallLinkAuthCredential.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import ByteArray from '../internal/ByteArray';
+import CallLinkSecretParams from './CallLinkSecretParams';
+import CallLinkAuthCredentialPresentation from './CallLinkAuthCredentialPresentation';
+import GenericServerPublicParams from '../GenericServerPublicParams';
+import { UUIDType } from '../internal/UUIDUtil';
+export default class CallLinkAuthCredential extends ByteArray {
+    private readonly __type?;
+    constructor(contents: Buffer);
+    present(userId: UUIDType, redemptionTime: number, serverParams: GenericServerPublicParams, callLinkParams: CallLinkSecretParams): CallLinkAuthCredentialPresentation;
+    presentWithRandom(userId: UUIDType, redemptionTime: number, serverParams: GenericServerPublicParams, callLinkParams: CallLinkSecretParams, random: Buffer): CallLinkAuthCredentialPresentation;
+}

package/dist/zkgroup/calllinks/CallLinkAuthCredential.js

@@ -0,0 +1,26 @@
+"use strict";
+//
+// Copyright 2023 Signal Messenger, LLC.
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+const ByteArray_1 = require("../internal/ByteArray");
+const Constants_1 = require("../internal/Constants");
+const Native = require("../../../Native");
+const CallLinkAuthCredentialPresentation_1 = require("./CallLinkAuthCredentialPresentation");
+const UUIDUtil_1 = require("../internal/UUIDUtil");
+class CallLinkAuthCredential extends ByteArray_1.default {
+    constructor(contents) {
+        super(contents, Native.CallLinkAuthCredential_CheckValidContents);
+    }
+    present(userId, redemptionTime, serverParams, callLinkParams) {
+        const random = (0, crypto_1.randomBytes)(Constants_1.RANDOM_LENGTH);
+        return this.presentWithRandom(userId, redemptionTime, serverParams, callLinkParams, random);
+    }
+    presentWithRandom(userId, redemptionTime, serverParams, callLinkParams, random) {
+        return new CallLinkAuthCredentialPresentation_1.default(Native.CallLinkAuthCredential_PresentDeterministic(this.contents, (0, UUIDUtil_1.fromUUID)(userId), redemptionTime, serverParams.contents, callLinkParams.contents, random));
+    }
+}
+exports.default = CallLinkAuthCredential;
+//# sourceMappingURL=CallLinkAuthCredential.js.map

package/dist/zkgroup/calllinks/CallLinkAuthCredentialPresentation.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import ByteArray from '../internal/ByteArray';
+import CallLinkPublicParams from './CallLinkPublicParams';
+import GenericServerSecretParams from '../GenericServerSecretParams';
+import UuidCiphertext from '../groups/UuidCiphertext';
+export default class CallLinkAuthCredentialPresentation extends ByteArray {
+    private readonly __type?;
+    constructor(contents: Buffer);
+    verify(serverParams: GenericServerSecretParams, callLinkParams: CallLinkPublicParams, now?: Date): void;
+    getUserId(): UuidCiphertext;
+}

package/dist/zkgroup/calllinks/CallLinkAuthCredentialPresentation.js

@@ -0,0 +1,22 @@
+"use strict";
+//
+// Copyright 2023 Signal Messenger, LLC.
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+const ByteArray_1 = require("../internal/ByteArray");
+const Native = require("../../../Native");
+const UuidCiphertext_1 = require("../groups/UuidCiphertext");
+class CallLinkAuthCredentialPresentation extends ByteArray_1.default {
+    constructor(contents) {
+        super(contents, Native.CallLinkAuthCredentialPresentation_CheckValidContents);
+    }
+    verify(serverParams, callLinkParams, now = new Date()) {
+        Native.CallLinkAuthCredentialPresentation_Verify(this.contents, Math.floor(now.getTime() / 1000), serverParams.contents, callLinkParams.contents);
+    }
+    getUserId() {
+        return new UuidCiphertext_1.default(Native.CallLinkAuthCredentialPresentation_GetUserId(this.contents));
+    }
+}
+exports.default = CallLinkAuthCredentialPresentation;
+//# sourceMappingURL=CallLinkAuthCredentialPresentation.js.map

package/dist/zkgroup/calllinks/CallLinkAuthCredentialResponse.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import ByteArray from '../internal/ByteArray';
+import { UUIDType } from '../internal/UUIDUtil';
+import GenericServerSecretParams from '../GenericServerSecretParams';
+import GenericServerPublicParams from '../GenericServerPublicParams';
+import CallLinkAuthCredential from './CallLinkAuthCredential';
+export default class CallLinkAuthCredentialResponse extends ByteArray {
+    private readonly __type?;
+    constructor(contents: Buffer);
+    static issueCredential(userId: UUIDType, redemptionTime: number, params: GenericServerSecretParams): CallLinkAuthCredentialResponse;
+    static issueCredentialWithRandom(userId: UUIDType, redemptionTime: number, params: GenericServerSecretParams, random: Buffer): CallLinkAuthCredentialResponse;
+    receive(userId: UUIDType, redemptionTime: number, params: GenericServerPublicParams): CallLinkAuthCredential;
+}

package/dist/zkgroup/calllinks/CallLinkAuthCredentialResponse.js

@@ -0,0 +1,29 @@
+"use strict";
+//
+// Copyright 2023 Signal Messenger, LLC.
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+const ByteArray_1 = require("../internal/ByteArray");
+const Native = require("../../../Native");
+const Constants_1 = require("../internal/Constants");
+const UUIDUtil_1 = require("../internal/UUIDUtil");
+const CallLinkAuthCredential_1 = require("./CallLinkAuthCredential");
+class CallLinkAuthCredentialResponse extends ByteArray_1.default {
+    constructor(contents) {
+        super(contents, Native.CallLinkAuthCredentialResponse_CheckValidContents);
+    }
+    static issueCredential(userId, redemptionTime, params) {
+        const random = (0, crypto_1.randomBytes)(Constants_1.RANDOM_LENGTH);
+        return this.issueCredentialWithRandom(userId, redemptionTime, params, random);
+    }
+    static issueCredentialWithRandom(userId, redemptionTime, params, random) {
+        return new CallLinkAuthCredentialResponse(Native.CallLinkAuthCredentialResponse_IssueDeterministic((0, UUIDUtil_1.fromUUID)(userId), redemptionTime, params.contents, random));
+    }
+    receive(userId, redemptionTime, params) {
+        return new CallLinkAuthCredential_1.default(Native.CallLinkAuthCredentialResponse_Receive(this.contents, (0, UUIDUtil_1.fromUUID)(userId), redemptionTime, params.contents));
+    }
+}
+exports.default = CallLinkAuthCredentialResponse;
+//# sourceMappingURL=CallLinkAuthCredentialResponse.js.map

package/dist/zkgroup/{profiles/PniCredential.d.ts → calllinks/CallLinkPublicParams.d.ts}

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import ByteArray from '../internal/ByteArray';
-export default class PniCredential extends ByteArray {
+export default class CallLinkPublicParams extends ByteArray {
     private readonly __type?;
     constructor(contents: Buffer);
 }

package/dist/zkgroup/{profiles/ProfileKeyCredential.js → calllinks/CallLinkPublicParams.js}

@@ -1,15 +1,15 @@
 "use strict";
 //
-// Copyright 2020-2021 Signal Messenger, LLC.
+// Copyright 2023 Signal Messenger, LLC.
 // SPDX-License-Identifier: AGPL-3.0-only
 //
 Object.defineProperty(exports, "__esModule", { value: true });
 const ByteArray_1 = require("../internal/ByteArray");
 const Native = require("../../../Native");
-class ProfileKeyCredential extends ByteArray_1.default {
+class CallLinkPublicParams extends ByteArray_1.default {
     constructor(contents) {
-        super(contents, Native.ProfileKeyCredential_CheckValidContents);
+        super(contents, Native.CallLinkPublicParams_CheckValidContents);
     }
 }
-exports.default = ProfileKeyCredential;
-//# sourceMappingURL=ProfileKeyCredential.js.map
+exports.default = CallLinkPublicParams;
+//# sourceMappingURL=CallLinkPublicParams.js.map

package/dist/zkgroup/calllinks/CallLinkSecretParams.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import ByteArray from '../internal/ByteArray';
+import CallLinkPublicParams from './CallLinkPublicParams';
+import UuidCiphertext from '../groups/UuidCiphertext';
+import { UUIDType } from '../internal/UUIDUtil';
+export default class CallLinkSecretParams extends ByteArray {
+    private readonly __type?;
+    static deriveFromRootKey(callLinkRootKey: Buffer): CallLinkSecretParams;
+    constructor(contents: Buffer);
+    getPublicParams(): CallLinkPublicParams;
+    decryptUserId(userId: UuidCiphertext): UUIDType;
+}

package/dist/zkgroup/calllinks/CallLinkSecretParams.js

@@ -0,0 +1,26 @@
+"use strict";
+//
+// Copyright 2023 Signal Messenger, LLC.
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+const ByteArray_1 = require("../internal/ByteArray");
+const Native = require("../../../Native");
+const CallLinkPublicParams_1 = require("./CallLinkPublicParams");
+const UUIDUtil_1 = require("../internal/UUIDUtil");
+class CallLinkSecretParams extends ByteArray_1.default {
+    static deriveFromRootKey(callLinkRootKey) {
+        return new CallLinkSecretParams(Native.CallLinkSecretParams_DeriveFromRootKey(callLinkRootKey));
+    }
+    constructor(contents) {
+        super(contents, Native.CallLinkSecretParams_CheckValidContents);
+    }
+    getPublicParams() {
+        return new CallLinkPublicParams_1.default(Native.CallLinkSecretParams_GetPublicParams(this.contents));
+    }
+    decryptUserId(userId) {
+        return (0, UUIDUtil_1.toUUID)(Native.CallLinkSecretParams_DecryptUserId(this.contents, userId.contents));
+    }
+}
+exports.default = CallLinkSecretParams;
+//# sourceMappingURL=CallLinkSecretParams.js.map

package/dist/zkgroup/calllinks/CreateCallLinkCredential.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import ByteArray from '../internal/ByteArray';
+import CallLinkSecretParams from './CallLinkSecretParams';
+import CreateCallLinkCredentialPresentation from './CreateCallLinkCredentialPresentation';
+import GenericServerPublicParams from '../GenericServerPublicParams';
+import { UUIDType } from '../internal/UUIDUtil';
+export default class CreateCallLinkCredential extends ByteArray {
+    private readonly __type?;
+    constructor(contents: Buffer);
+    present(roomId: Buffer, userId: UUIDType, serverParams: GenericServerPublicParams, callLinkParams: CallLinkSecretParams): CreateCallLinkCredentialPresentation;
+    presentWithRandom(roomId: Buffer, userId: UUIDType, serverParams: GenericServerPublicParams, callLinkParams: CallLinkSecretParams, random: Buffer): CreateCallLinkCredentialPresentation;
+}

package/dist/zkgroup/calllinks/CreateCallLinkCredential.js

@@ -0,0 +1,26 @@
+"use strict";
+//
+// Copyright 2023 Signal Messenger, LLC.
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+const ByteArray_1 = require("../internal/ByteArray");
+const Constants_1 = require("../internal/Constants");
+const Native = require("../../../Native");
+const CreateCallLinkCredentialPresentation_1 = require("./CreateCallLinkCredentialPresentation");
+const UUIDUtil_1 = require("../internal/UUIDUtil");
+class CreateCallLinkCredential extends ByteArray_1.default {
+    constructor(contents) {
+        super(contents, Native.CreateCallLinkCredential_CheckValidContents);
+    }
+    present(roomId, userId, serverParams, callLinkParams) {
+        const random = (0, crypto_1.randomBytes)(Constants_1.RANDOM_LENGTH);
+        return this.presentWithRandom(roomId, userId, serverParams, callLinkParams, random);
+    }
+    presentWithRandom(roomId, userId, serverParams, callLinkParams, random) {
+        return new CreateCallLinkCredentialPresentation_1.default(Native.CreateCallLinkCredential_PresentDeterministic(this.contents, roomId, (0, UUIDUtil_1.fromUUID)(userId), serverParams.contents, callLinkParams.contents, random));
+    }
+}
+exports.default = CreateCallLinkCredential;
+//# sourceMappingURL=CreateCallLinkCredential.js.map

package/dist/zkgroup/calllinks/CreateCallLinkCredentialPresentation.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import ByteArray from '../internal/ByteArray';
+import CallLinkPublicParams from './CallLinkPublicParams';
+import GenericServerSecretParams from '../GenericServerSecretParams';
+export default class CreateCallLinkCredentialPresentation extends ByteArray {
+    private readonly __type?;
+    constructor(contents: Buffer);
+    verify(roomId: Buffer, serverParams: GenericServerSecretParams, callLinkParams: CallLinkPublicParams, now?: Date): void;
+}

package/dist/zkgroup/calllinks/CreateCallLinkCredentialPresentation.js

@@ -0,0 +1,18 @@
+"use strict";
+//
+// Copyright 2023 Signal Messenger, LLC.
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+const ByteArray_1 = require("../internal/ByteArray");
+const Native = require("../../../Native");
+class CreateCallLinkCredentialPresentation extends ByteArray_1.default {
+    constructor(contents) {
+        super(contents, Native.CreateCallLinkCredentialPresentation_CheckValidContents);
+    }
+    verify(roomId, serverParams, callLinkParams, now = new Date()) {
+        Native.CreateCallLinkCredentialPresentation_Verify(this.contents, roomId, Math.floor(now.getTime() / 1000), serverParams.contents, callLinkParams.contents);
+    }
+}
+exports.default = CreateCallLinkCredentialPresentation;
+//# sourceMappingURL=CreateCallLinkCredentialPresentation.js.map

package/dist/zkgroup/calllinks/CreateCallLinkCredentialRequest.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import ByteArray from '../internal/ByteArray';
+import CreateCallLinkCredentialResponse from './CreateCallLinkCredentialResponse';
+import GenericServerSecretParams from '../GenericServerSecretParams';
+import { UUIDType } from '../internal/UUIDUtil';
+export default class CreateCallLinkCredentialRequest extends ByteArray {
+    private readonly __type?;
+    constructor(contents: Buffer);
+    issueCredential(userId: UUIDType, timestamp: number, params: GenericServerSecretParams): CreateCallLinkCredentialResponse;
+    issueCredentialWithRandom(userId: UUIDType, timestamp: number, params: GenericServerSecretParams, random: Buffer): CreateCallLinkCredentialResponse;
+}

package/dist/zkgroup/calllinks/CreateCallLinkCredentialRequest.js

@@ -0,0 +1,26 @@
+"use strict";
+//
+// Copyright 2023 Signal Messenger, LLC.
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+const ByteArray_1 = require("../internal/ByteArray");
+const Constants_1 = require("../internal/Constants");
+const Native = require("../../../Native");
+const CreateCallLinkCredentialResponse_1 = require("./CreateCallLinkCredentialResponse");
+const UUIDUtil_1 = require("../internal/UUIDUtil");
+class CreateCallLinkCredentialRequest extends ByteArray_1.default {
+    constructor(contents) {
+        super(contents, Native.CreateCallLinkCredentialRequest_CheckValidContents);
+    }
+    issueCredential(userId, timestamp, params) {
+        const random = (0, crypto_1.randomBytes)(Constants_1.RANDOM_LENGTH);
+        return this.issueCredentialWithRandom(userId, timestamp, params, random);
+    }
+    issueCredentialWithRandom(userId, timestamp, params, random) {
+        return new CreateCallLinkCredentialResponse_1.default(Native.CreateCallLinkCredentialRequest_IssueDeterministic(this.contents, (0, UUIDUtil_1.fromUUID)(userId), timestamp, params.contents, random));
+    }
+}
+exports.default = CreateCallLinkCredentialRequest;
+//# sourceMappingURL=CreateCallLinkCredentialRequest.js.map

package/dist/zkgroup/calllinks/CreateCallLinkCredentialRequestContext.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import ByteArray from '../internal/ByteArray';
+import CreateCallLinkCredentialRequest from './CreateCallLinkCredentialRequest';
+import CreateCallLinkCredentialResponse from './CreateCallLinkCredentialResponse';
+import CreateCallLinkCredential from './CreateCallLinkCredential';
+import GenericServerPublicParams from '../GenericServerPublicParams';
+import { UUIDType } from '../internal/UUIDUtil';
+export default class CreateCallLinkCredentialRequestContext extends ByteArray {
+    private readonly __type?;
+    constructor(contents: Buffer);
+    static forRoomId(roomId: Buffer): CreateCallLinkCredentialRequestContext;
+    static forRoomIdWithRandom(roomId: Buffer, random: Buffer): CreateCallLinkCredentialRequestContext;
+    getRequest(): CreateCallLinkCredentialRequest;
+    receive(response: CreateCallLinkCredentialResponse, userId: UUIDType, params: GenericServerPublicParams): CreateCallLinkCredential;
+}