@signalapp/libsignal-client 0.62.0 → 0.63.0

package/Native.d.ts

@@ -11,50 +11,53 @@ type Uuid = Buffer;
 /// what's important is that it's an integer less than Number.MAX_SAFE_INTEGER.
 type Timestamp = number;
 
-interface LookupResponse {
+// Rust code produces or consumes values that conform to these interface
+// definitions. They must be kept in sync to prevent bridging errors.
+
+type LookupResponse = {
   entries: Map<string, LookupResponseEntry>;
   debugPermitsUsed: number;
-}
+};
 
-interface LookupResponseEntry {
+type LookupResponseEntry = {
   readonly aci: string | undefined;
   readonly pni: string | undefined;
-}
+};
 
-interface ChatResponse {
+type ChatResponse = {
   status: number;
   message: string | undefined;
   headers: ReadonlyArray<[string, string]>;
   body: Buffer | undefined;
-}
+};
 
-interface ChatServiceDebugInfo {
+type ChatServiceDebugInfo = {
   ipType: number;
   durationMillis: number;
   connectionInfo: string;
-}
+};
 
-interface ResponseAndDebugInfo {
+type ResponseAndDebugInfo = {
   response: ChatResponse;
   debugInfo: ChatServiceDebugInfo;
-}
+};
 
-interface SealedSenderMultiRecipientMessageRecipient {
+type SealedSenderMultiRecipientMessageRecipient = {
   deviceIds: number[];
   registrationIds: number[];
   rangeOffset: number;
   rangeLen: number;
-}
+};
 
-interface SealedSenderMultiRecipientMessage {
+type SealedSenderMultiRecipientMessage = {
   recipientMap: {
     [serviceId: string]: SealedSenderMultiRecipientMessageRecipient;
   };
   excludedRecipients: string[];
   offsetOfSharedData: number;
-}
+};
 
-export abstract class IdentityKeyStore {
+type IdentityKeyStore = {
   _getIdentityKey(): Promise<PrivateKey>;
   _getLocalRegistrationId(): Promise<number>;
   _saveIdentity(name: ProtocolAddress, key: PublicKey): Promise<boolean>;
@@ -64,37 +67,37 @@ export abstract class IdentityKeyStore {
     sending: boolean
   ): Promise<boolean>;
   _getIdentity(name: ProtocolAddress): Promise<PublicKey | null>;
-}
+};
 
-export abstract class SessionStore {
+type SessionStore = {
   _saveSession(addr: ProtocolAddress, record: SessionRecord): Promise<void>;
   _getSession(addr: ProtocolAddress): Promise<SessionRecord | null>;
-}
+};
 
-export abstract class PreKeyStore {
+type PreKeyStore = {
   _savePreKey(preKeyId: number, record: PreKeyRecord): Promise<void>;
   _getPreKey(preKeyId: number): Promise<PreKeyRecord>;
   _removePreKey(preKeyId: number): Promise<void>;
-}
+};
 
-export abstract class SignedPreKeyStore {
+type SignedPreKeyStore = {
   _saveSignedPreKey(
     signedPreKeyId: number,
     record: SignedPreKeyRecord
   ): Promise<void>;
   _getSignedPreKey(signedPreKeyId: number): Promise<SignedPreKeyRecord>;
-}
+};
 
-export abstract class KyberPreKeyStore {
+type KyberPreKeyStore = {
   _saveKyberPreKey(
     kyberPreKeyId: number,
     record: KyberPreKeyRecord
   ): Promise<void>;
   _getKyberPreKey(kyberPreKeyId: number): Promise<KyberPreKeyRecord>;
   _markKyberPreKeyUsed(kyberPreKeyId: number): Promise<void>;
-}
+};
 
-export abstract class SenderKeyStore {
+type SenderKeyStore = {
   _saveSenderKey(
     sender: ProtocolAddress,
     distributionId: Uuid,
@@ -104,16 +107,16 @@ export abstract class SenderKeyStore {
     sender: ProtocolAddress,
     distributionId: Uuid
   ): Promise<SenderKeyRecord | null>;
-}
+};
 
-export abstract class InputStream {
+type InputStream = {
   _read(amount: number): Promise<Buffer>;
   _skip(amount: number): Promise<void>;
-}
+};
 
-export abstract class SyncInputStream extends Buffer {}
+type SyncInputStream = Buffer;
 
-export abstract class ChatListener {
+type ChatListener = {
   _incoming_message(
     envelope: Buffer,
     timestamp: number,
@@ -124,16 +127,20 @@ export abstract class ChatListener {
     // A LibSignalError or null, but not naming the type to avoid circular import dependencies.
     reason: Error | null
   ): void;
-}
+};
 
 type Wrapper<T> = Readonly<{
   _nativeHandle: T;
 }>;
 
-interface MessageBackupValidationOutcome {
+type MessageBackupValidationOutcome = {
   errorMessage: string | null;
   unknownFieldMessages: Array<string>;
-}
+};
+
+type CancellablePromise<T> = Promise<T> & {
+  _cancellationToken: bigint;
+};
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 type Serialized<T> = Buffer;
@@ -153,6 +160,10 @@ export function AuthCredentialPresentation_GetRedemptionTime(presentationBytes:
 export function AuthCredentialPresentation_GetUuidCiphertext(presentationBytes: Buffer): Serialized<UuidCiphertext>;
 export function AuthCredentialWithPniResponse_CheckValidContents(bytes: Buffer): void;
 export function AuthCredentialWithPni_CheckValidContents(bytes: Buffer): void;
+export function AuthenticatedChatConnection_connect(asyncRuntime: Wrapper<TokioAsyncContext>, connectionManager: Wrapper<ConnectionManager>, username: string, password: string, receiveStories: boolean, listener: ChatListener | null): CancellablePromise<AuthenticatedChatConnection>;
+export function AuthenticatedChatConnection_disconnect(asyncRuntime: Wrapper<TokioAsyncContext>, chat: Wrapper<AuthenticatedChatConnection>): CancellablePromise<void>;
+export function AuthenticatedChatConnection_info(chat: Wrapper<AuthenticatedChatConnection>): ConnectionInfo;
+export function AuthenticatedChatConnection_send(asyncRuntime: Wrapper<TokioAsyncContext>, chat: Wrapper<AuthenticatedChatConnection>, httpRequest: Wrapper<HttpRequest>, timeoutMillis: number): CancellablePromise<ChatResponse>;
 export function BackupAuthCredentialPresentation_CheckValidContents(presentationBytes: Buffer): void;
 export function BackupAuthCredentialPresentation_GetBackupId(presentationBytes: Buffer): Buffer;
 export function BackupAuthCredentialPresentation_GetBackupLevel(presentationBytes: Buffer): number;
@@ -190,27 +201,29 @@ export function CallLinkSecretParams_DecryptUserId(paramsBytes: Buffer, userId:
 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 CdsiLookup_complete(asyncRuntime: Wrapper<TokioAsyncContext>, lookup: Wrapper<CdsiLookup>): Promise<LookupResponse>;
-export function CdsiLookup_new(asyncRuntime: Wrapper<TokioAsyncContext>, connectionManager: Wrapper<ConnectionManager>, username: string, password: string, request: Wrapper<LookupRequest>): Promise<CdsiLookup>;
+export function CdsiLookup_complete(asyncRuntime: Wrapper<TokioAsyncContext>, lookup: Wrapper<CdsiLookup>): CancellablePromise<LookupResponse>;
+export function CdsiLookup_new(asyncRuntime: Wrapper<TokioAsyncContext>, connectionManager: Wrapper<ConnectionManager>, username: string, password: string, request: Wrapper<LookupRequest>): CancellablePromise<CdsiLookup>;
 export function CdsiLookup_token(lookup: Wrapper<CdsiLookup>): Buffer;
 export function ChatService_SetListenerAuth(runtime: Wrapper<TokioAsyncContext>, chat: Wrapper<AuthChat>, listener: ChatListener | null): void;
 export function ChatService_SetListenerUnauth(runtime: Wrapper<TokioAsyncContext>, chat: Wrapper<UnauthChat>, listener: ChatListener | null): void;
-export function ChatService_auth_send(asyncRuntime: Wrapper<TokioAsyncContext>, chat: Wrapper<AuthChat>, httpRequest: Wrapper<HttpRequest>, timeoutMillis: number): Promise<ChatResponse>;
-export function ChatService_auth_send_and_debug(asyncRuntime: Wrapper<TokioAsyncContext>, chat: Wrapper<AuthChat>, httpRequest: Wrapper<HttpRequest>, timeoutMillis: number): Promise<ResponseAndDebugInfo>;
-export function ChatService_connect_auth(asyncRuntime: Wrapper<TokioAsyncContext>, chat: Wrapper<AuthChat>): Promise<ChatServiceDebugInfo>;
-export function ChatService_connect_unauth(asyncRuntime: Wrapper<TokioAsyncContext>, chat: Wrapper<UnauthChat>): Promise<ChatServiceDebugInfo>;
-export function ChatService_disconnect_auth(asyncRuntime: Wrapper<TokioAsyncContext>, chat: Wrapper<AuthChat>): Promise<void>;
-export function ChatService_disconnect_unauth(asyncRuntime: Wrapper<TokioAsyncContext>, chat: Wrapper<UnauthChat>): Promise<void>;
+export function ChatService_auth_send(asyncRuntime: Wrapper<TokioAsyncContext>, chat: Wrapper<AuthChat>, httpRequest: Wrapper<HttpRequest>, timeoutMillis: number): CancellablePromise<ChatResponse>;
+export function ChatService_auth_send_and_debug(asyncRuntime: Wrapper<TokioAsyncContext>, chat: Wrapper<AuthChat>, httpRequest: Wrapper<HttpRequest>, timeoutMillis: number): CancellablePromise<ResponseAndDebugInfo>;
+export function ChatService_connect_auth(asyncRuntime: Wrapper<TokioAsyncContext>, chat: Wrapper<AuthChat>): CancellablePromise<ChatServiceDebugInfo>;
+export function ChatService_connect_unauth(asyncRuntime: Wrapper<TokioAsyncContext>, chat: Wrapper<UnauthChat>): CancellablePromise<ChatServiceDebugInfo>;
+export function ChatService_disconnect_auth(asyncRuntime: Wrapper<TokioAsyncContext>, chat: Wrapper<AuthChat>): CancellablePromise<void>;
+export function ChatService_disconnect_unauth(asyncRuntime: Wrapper<TokioAsyncContext>, chat: Wrapper<UnauthChat>): CancellablePromise<void>;
 export function ChatService_new_auth(connectionManager: Wrapper<ConnectionManager>, username: string, password: string, receiveStories: boolean): AuthChat;
 export function ChatService_new_unauth(connectionManager: Wrapper<ConnectionManager>): UnauthChat;
-export function ChatService_unauth_send(asyncRuntime: Wrapper<TokioAsyncContext>, chat: Wrapper<UnauthChat>, httpRequest: Wrapper<HttpRequest>, timeoutMillis: number): Promise<ChatResponse>;
-export function ChatService_unauth_send_and_debug(asyncRuntime: Wrapper<TokioAsyncContext>, chat: Wrapper<UnauthChat>, httpRequest: Wrapper<HttpRequest>, timeoutMillis: number): Promise<ResponseAndDebugInfo>;
+export function ChatService_unauth_send(asyncRuntime: Wrapper<TokioAsyncContext>, chat: Wrapper<UnauthChat>, httpRequest: Wrapper<HttpRequest>, timeoutMillis: number): CancellablePromise<ChatResponse>;
+export function ChatService_unauth_send_and_debug(asyncRuntime: Wrapper<TokioAsyncContext>, chat: Wrapper<UnauthChat>, httpRequest: Wrapper<HttpRequest>, timeoutMillis: number): CancellablePromise<ResponseAndDebugInfo>;
 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 ComparableBackup_GetComparableString(backup: Wrapper<ComparableBackup>): string;
 export function ComparableBackup_GetUnknownFields(backup: Wrapper<ComparableBackup>): string[];
 export function ComparableBackup_ReadUnencrypted(stream: InputStream, len: bigint, purpose: number): Promise<ComparableBackup>;
+export function ConnectionInfo_ip_version(connectionInfo: Wrapper<ConnectionInfo>): number;
+export function ConnectionInfo_local_port(connectionInfo: Wrapper<ConnectionInfo>): number;
 export function ConnectionManager_clear_proxy(connectionManager: Wrapper<ConnectionManager>): void;
 export function ConnectionManager_new(environment: number, userAgent: string): ConnectionManager;
 export function ConnectionManager_on_network_change(connectionManager: Wrapper<ConnectionManager>): void;
@@ -316,7 +329,6 @@ export function LookupRequest_addAciAndAccessKey(request: Wrapper<LookupRequest>
 export function LookupRequest_addE164(request: Wrapper<LookupRequest>, e164: string): void;
 export function LookupRequest_addPreviousE164(request: Wrapper<LookupRequest>, e164: string): void;
 export function LookupRequest_new(): LookupRequest;
-export function LookupRequest_setReturnAcisWithoutUaks(request: Wrapper<LookupRequest>, returnAcisWithoutUaks: boolean): void;
 export function LookupRequest_setToken(request: Wrapper<LookupRequest>, token: Buffer): void;
 export function MessageBackupKey_FromAccountEntropyPool(accountEntropy: string, aci: Buffer): MessageBackupKey;
 export function MessageBackupKey_FromBackupKeyAndBackupId(backupKey: Buffer, backupId: Buffer): MessageBackupKey;
@@ -326,6 +338,9 @@ export function MessageBackupKey_GetHmacKey(key: Wrapper<MessageBackupKey>): Buf
 export function MessageBackupValidator_Validate(key: Wrapper<MessageBackupKey>, firstStream: InputStream, secondStream: InputStream, len: bigint, purpose: number): Promise<MessageBackupValidationOutcome>;
 export function MinidumpToJSONString(buffer: Buffer): string;
 export function Mp4Sanitizer_Sanitize(input: InputStream, len: bigint): Promise<SanitizedMetadata>;
+export function OnlineBackupValidator_AddFrame(backup: Wrapper<OnlineBackupValidator>, frame: Buffer): void;
+export function OnlineBackupValidator_Finalize(backup: Wrapper<OnlineBackupValidator>): void;
+export function OnlineBackupValidator_New(backupInfoFrame: Buffer, purpose: number): OnlineBackupValidator;
 export function PlaintextContent_Deserialize(data: Buffer): PlaintextContent;
 export function PlaintextContent_FromDecryptionErrorMessage(m: Wrapper<DecryptionErrorMessage>): PlaintextContent;
 export function PlaintextContent_GetBody(obj: Wrapper<PlaintextContent>): Buffer;
@@ -445,7 +460,7 @@ export function ServerCertificate_GetKeyId(obj: Wrapper<ServerCertificate>): num
 export function ServerCertificate_GetSerialized(obj: Wrapper<ServerCertificate>): Buffer;
 export function ServerCertificate_GetSignature(obj: Wrapper<ServerCertificate>): Buffer;
 export function ServerCertificate_New(keyId: number, serverKey: Wrapper<PublicKey>, trustRoot: Wrapper<PrivateKey>): ServerCertificate;
-export function ServerMessageAck_SendStatus(asyncRuntime: Wrapper<TokioAsyncContext>, ack: Wrapper<ServerMessageAck>, status: number): Promise<void>;
+export function ServerMessageAck_SendStatus(asyncRuntime: Wrapper<TokioAsyncContext>, ack: Wrapper<ServerMessageAck>, status: number): CancellablePromise<void>;
 export function ServerPublicParams_CreateAuthCredentialWithPniPresentationDeterministic(serverPublicParams: Wrapper<ServerPublicParams>, randomness: Buffer, groupSecretParams: Serialized<GroupSecretParams>, authCredentialWithPniBytes: Buffer): Buffer;
 export function ServerPublicParams_CreateExpiringProfileKeyCredentialPresentationDeterministic(serverPublicParams: Wrapper<ServerPublicParams>, randomness: Buffer, groupSecretParams: Serialized<GroupSecretParams>, profileKeyCredential: Serialized<ExpiringProfileKeyCredential>): Buffer;
 export function ServerPublicParams_CreateProfileKeyCredentialRequestContextDeterministic(serverPublicParams: Wrapper<ServerPublicParams>, randomness: Buffer, userId: Buffer, profileKey: Serialized<ProfileKey>): Serialized<ProfileKeyCredentialRequestContext>;
@@ -505,11 +520,11 @@ export function SignedPreKeyRecord_GetSignature(obj: Wrapper<SignedPreKeyRecord>
 export function SignedPreKeyRecord_GetTimestamp(obj: Wrapper<SignedPreKeyRecord>): Timestamp;
 export function SignedPreKeyRecord_New(id: number, timestamp: Timestamp, pubKey: Wrapper<PublicKey>, privKey: Wrapper<PrivateKey>, signature: Buffer): SignedPreKeyRecord;
 export function SignedPreKeyRecord_Serialize(obj: Wrapper<SignedPreKeyRecord>): Buffer;
-export function Svr3Backup(asyncRuntime: Wrapper<TokioAsyncContext>, connectionManager: Wrapper<ConnectionManager>, secret: Buffer, password: string, maxTries: number, username: string, enclavePassword: string): Promise<Buffer>;
-export function Svr3Remove(asyncRuntime: Wrapper<TokioAsyncContext>, connectionManager: Wrapper<ConnectionManager>, username: string, enclavePassword: string): Promise<void>;
-export function Svr3Restore(asyncRuntime: Wrapper<TokioAsyncContext>, connectionManager: Wrapper<ConnectionManager>, password: string, shareSet: Buffer, username: string, enclavePassword: string): Promise<Buffer>;
+export function Svr3Backup(asyncRuntime: Wrapper<TokioAsyncContext>, connectionManager: Wrapper<ConnectionManager>, secret: Buffer, password: string, maxTries: number, username: string, enclavePassword: string): CancellablePromise<Buffer>;
+export function Svr3Remove(asyncRuntime: Wrapper<TokioAsyncContext>, connectionManager: Wrapper<ConnectionManager>, username: string, enclavePassword: string): CancellablePromise<void>;
+export function Svr3Restore(asyncRuntime: Wrapper<TokioAsyncContext>, connectionManager: Wrapper<ConnectionManager>, password: string, shareSet: Buffer, username: string, enclavePassword: string): CancellablePromise<Buffer>;
 export function TESTING_CdsiLookupErrorConvert(errorDescription: string): void;
-export function TESTING_CdsiLookupResponseConvert(asyncRuntime: Wrapper<TokioAsyncContext>): Promise<LookupResponse>;
+export function TESTING_CdsiLookupResponseConvert(asyncRuntime: Wrapper<TokioAsyncContext>): CancellablePromise<LookupResponse>;
 export function TESTING_ChatRequestGetBody(request: Wrapper<HttpRequest>): Buffer;
 export function TESTING_ChatRequestGetHeaderValue(request: Wrapper<HttpRequest>, headerName: string): string;
 export function TESTING_ChatRequestGetMethod(request: Wrapper<HttpRequest>): string;
@@ -523,30 +538,30 @@ export function TESTING_ChatService_InjectIntentionalDisconnect(chat: Wrapper<Au
 export function TESTING_ChatService_InjectRawServerRequest(chat: Wrapper<AuthChat>, bytes: Buffer): void;
 export function TESTING_ConnectionManager_newLocalOverride(userAgent: string, chatPort: number, cdsiPort: number, svr2Port: number, svr3SgxPort: number, svr3NitroPort: number, svr3Tpm2SnpPort: number, rootCertificateDer: Buffer): ConnectionManager;
 export function TESTING_ErrorOnBorrowAsync(_input: null): Promise<void>;
-export function TESTING_ErrorOnBorrowIo(asyncRuntime: Wrapper<NonSuspendingBackgroundThreadRuntime>, _input: null): Promise<void>;
+export function TESTING_ErrorOnBorrowIo(asyncRuntime: Wrapper<NonSuspendingBackgroundThreadRuntime>, _input: null): CancellablePromise<void>;
 export function TESTING_ErrorOnBorrowSync(_input: null): void;
 export function TESTING_ErrorOnReturnAsync(_needsCleanup: null): Promise<null>;
-export function TESTING_ErrorOnReturnIo(asyncRuntime: Wrapper<NonSuspendingBackgroundThreadRuntime>, _needsCleanup: null): Promise<null>;
+export function TESTING_ErrorOnReturnIo(asyncRuntime: Wrapper<NonSuspendingBackgroundThreadRuntime>, _needsCleanup: null): CancellablePromise<null>;
 export function TESTING_ErrorOnReturnSync(_needsCleanup: null): null;
-export function TESTING_FutureFailure(asyncRuntime: Wrapper<NonSuspendingBackgroundThreadRuntime>, _input: number): Promise<number>;
-export function TESTING_FutureProducesOtherPointerType(asyncRuntime: Wrapper<NonSuspendingBackgroundThreadRuntime>, input: string): Promise<OtherTestingHandleType>;
-export function TESTING_FutureProducesPointerType(asyncRuntime: Wrapper<NonSuspendingBackgroundThreadRuntime>, input: number): Promise<TestingHandleType>;
-export function TESTING_FutureSuccess(asyncRuntime: Wrapper<NonSuspendingBackgroundThreadRuntime>, input: number): Promise<number>;
+export function TESTING_FutureFailure(asyncRuntime: Wrapper<NonSuspendingBackgroundThreadRuntime>, _input: number): CancellablePromise<number>;
+export function TESTING_FutureProducesOtherPointerType(asyncRuntime: Wrapper<NonSuspendingBackgroundThreadRuntime>, input: string): CancellablePromise<OtherTestingHandleType>;
+export function TESTING_FutureProducesPointerType(asyncRuntime: Wrapper<NonSuspendingBackgroundThreadRuntime>, input: number): CancellablePromise<TestingHandleType>;
+export function TESTING_FutureSuccess(asyncRuntime: Wrapper<NonSuspendingBackgroundThreadRuntime>, input: number): CancellablePromise<number>;
 export function TESTING_InputStreamReadIntoZeroLengthSlice(capsAlphabetInput: InputStream): Promise<Buffer>;
 export function TESTING_NonSuspendingBackgroundThreadRuntime_New(): NonSuspendingBackgroundThreadRuntime;
-export function TESTING_OnlyCompletesByCancellation(asyncRuntime: Wrapper<TokioAsyncContext>): Promise<void>;
+export function TESTING_OnlyCompletesByCancellation(asyncRuntime: Wrapper<TokioAsyncContext>): CancellablePromise<void>;
 export function TESTING_OtherTestingHandleType_getValue(handle: Wrapper<OtherTestingHandleType>): string;
 export function TESTING_PanicInBodyAsync(_input: null): Promise<void>;
-export function TESTING_PanicInBodyIo(asyncRuntime: Wrapper<NonSuspendingBackgroundThreadRuntime>, _input: null): Promise<void>;
+export function TESTING_PanicInBodyIo(asyncRuntime: Wrapper<NonSuspendingBackgroundThreadRuntime>, _input: null): CancellablePromise<void>;
 export function TESTING_PanicInBodySync(_input: null): void;
 export function TESTING_PanicOnBorrowAsync(_input: null): Promise<void>;
-export function TESTING_PanicOnBorrowIo(asyncRuntime: Wrapper<NonSuspendingBackgroundThreadRuntime>, _input: null): Promise<void>;
+export function TESTING_PanicOnBorrowIo(asyncRuntime: Wrapper<NonSuspendingBackgroundThreadRuntime>, _input: null): CancellablePromise<void>;
 export function TESTING_PanicOnBorrowSync(_input: null): void;
 export function TESTING_PanicOnLoadAsync(_needsCleanup: null, _input: null): Promise<void>;
-export function TESTING_PanicOnLoadIo(asyncRuntime: Wrapper<NonSuspendingBackgroundThreadRuntime>, _needsCleanup: null, _input: null): Promise<void>;
+export function TESTING_PanicOnLoadIo(asyncRuntime: Wrapper<NonSuspendingBackgroundThreadRuntime>, _needsCleanup: null, _input: null): CancellablePromise<void>;
 export function TESTING_PanicOnLoadSync(_needsCleanup: null, _input: null): void;
 export function TESTING_PanicOnReturnAsync(_needsCleanup: null): Promise<null>;
-export function TESTING_PanicOnReturnIo(asyncRuntime: Wrapper<NonSuspendingBackgroundThreadRuntime>, _needsCleanup: null): Promise<null>;
+export function TESTING_PanicOnReturnIo(asyncRuntime: Wrapper<NonSuspendingBackgroundThreadRuntime>, _needsCleanup: null): CancellablePromise<null>;
 export function TESTING_PanicOnReturnSync(_needsCleanup: null): null;
 export function TESTING_ProcessBytestringArray(input: Buffer[]): Buffer[];
 export function TESTING_ReturnStringArray(): string[];
@@ -554,6 +569,10 @@ export function TESTING_ServerMessageAck_Create(): ServerMessageAck;
 export function TESTING_TestingHandleType_getValue(handle: Wrapper<TestingHandleType>): number;
 export function TokioAsyncContext_cancel(context: Wrapper<TokioAsyncContext>, rawCancellationId: bigint): void;
 export function TokioAsyncContext_new(): TokioAsyncContext;
+export function UnauthenticatedChatConnection_connect(asyncRuntime: Wrapper<TokioAsyncContext>, connectionManager: Wrapper<ConnectionManager>, listener: ChatListener | null): CancellablePromise<UnauthenticatedChatConnection>;
+export function UnauthenticatedChatConnection_disconnect(asyncRuntime: Wrapper<TokioAsyncContext>, chat: Wrapper<UnauthenticatedChatConnection>): CancellablePromise<void>;
+export function UnauthenticatedChatConnection_info(chat: Wrapper<UnauthenticatedChatConnection>): ConnectionInfo;
+export function UnauthenticatedChatConnection_send(asyncRuntime: Wrapper<TokioAsyncContext>, chat: Wrapper<UnauthenticatedChatConnection>, httpRequest: Wrapper<HttpRequest>, timeoutMillis: number): CancellablePromise<ChatResponse>;
 export function UnidentifiedSenderMessageContent_Deserialize(data: Buffer): UnidentifiedSenderMessageContent;
 export function UnidentifiedSenderMessageContent_GetContentHint(m: Wrapper<UnidentifiedSenderMessageContent>): number;
 export function UnidentifiedSenderMessageContent_GetContents(obj: Wrapper<UnidentifiedSenderMessageContent>): Buffer;
@@ -578,10 +597,12 @@ export function initLogger(maxLevel: LogLevel, callback: (level: LogLevel, targe
 export function test_only_fn_returns_123(): number;
 interface Aes256GcmSiv { readonly __type: unique symbol; }
 interface AuthChat { readonly __type: unique symbol; }
+interface AuthenticatedChatConnection { readonly __type: unique symbol; }
 interface CdsiLookup { readonly __type: unique symbol; }
 interface CiphertextMessage { readonly __type: unique symbol; }
 interface ComparableBackup { readonly __type: unique symbol; }
 interface ComparableBackup { readonly __type: unique symbol; }
+interface ConnectionInfo { readonly __type: unique symbol; }
 interface ConnectionManager { readonly __type: unique symbol; }
 interface DecryptionErrorMessage { readonly __type: unique symbol; }
 interface ExpiringProfileKeyCredential { readonly __type: unique symbol; }
@@ -600,6 +621,7 @@ interface KyberSecretKey { readonly __type: unique symbol; }
 interface LookupRequest { readonly __type: unique symbol; }
 interface MessageBackupKey { readonly __type: unique symbol; }
 interface NonSuspendingBackgroundThreadRuntime { readonly __type: unique symbol; }
+interface OnlineBackupValidator { readonly __type: unique symbol; }
 interface OtherTestingHandleType { readonly __type: unique symbol; }
 interface PlaintextContent { readonly __type: unique symbol; }
 interface PreKeyBundle { readonly __type: unique symbol; }
@@ -635,6 +657,7 @@ interface SignedPreKeyRecord { readonly __type: unique symbol; }
 interface TestingHandleType { readonly __type: unique symbol; }
 interface TokioAsyncContext { readonly __type: unique symbol; }
 interface UnauthChat { readonly __type: unique symbol; }
+interface UnauthenticatedChatConnection { readonly __type: unique symbol; }
 interface UnidentifiedSenderMessageContent { readonly __type: unique symbol; }
 interface UuidCiphertext { readonly __type: unique symbol; }
 interface ValidatingMac { readonly __type: unique symbol; }

package/dist/MessageBackup.d.ts

@@ -81,8 +81,59 @@ export declare enum Purpose {
  * @param length The exact length of the input stream.
  * @returns The outcome of validation, including any errors and warnings.
  * @throws IoError If an IO error on the input occurs.
+ *
+ * @see OnlineBackupValidator
  */
 export declare function validate(backupKey: MessageBackupKey, purpose: Purpose, inputFactory: InputStreamFactory, length: bigint): Promise<ValidationOutcome>;
+/**
+ * An alternative to {@link validate()} that validates a backup frame-by-frame.
+ *
+ * This is much faster than using `validate()` because it bypasses the decryption and decompression
+ * steps, but that also means it's validating less. Don't forget to call `finalize()`!
+ *
+ * Unlike `validate()`, unknown fields are treated as "soft" errors and logged, rather than
+ * collected and returned to the app for processing.
+ *
+ * # Example
+ *
+ * ```
+ * const validator = new OnlineBackupValidator(
+ *     backupInfoProto.serialize(),
+ *     Purpose.deviceTransfer)
+ * repeat {
+ *   // ...generate Frames...
+ *   validator.addFrame(frameProto.serialize())
+ * }
+ * validator.finalize() // don't forget this!
+ * ```
+ */
+export declare class OnlineBackupValidator {
+    readonly _nativeHandle: Native.OnlineBackupValidator;
+    /**
+     * Initializes an OnlineBackupValidator from the given BackupInfo protobuf message.
+     *
+     * "Soft" errors will be logged, including unrecognized fields in the protobuf.
+     *
+     * @throws BackupValidationError on error
+     */
+    constructor(backupInfo: Buffer, purpose: Purpose);
+    /**
+     * Processes a single Frame protobuf message.
+     *
+     * "Soft" errors will be logged, including unrecognized fields in the protobuf.
+     *
+     * @throws BackupValidationError on error
+     */
+    addFrame(frame: Buffer): void;
+    /**
+     * Marks that a backup is complete, and does any final checks that require whole-file knowledge.
+     *
+     * "Soft" errors will be logged.
+     *
+     * @throws BackupValidationError on error
+     */
+    finalize(): void;
+}
 /**
  * An in-memory representation of a backup file used to compare contents.
  *

package/dist/MessageBackup.js

@@ -4,7 +4,7 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 //
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ComparableBackup = exports.validate = exports.Purpose = exports.MessageBackupKey = exports.ValidationOutcome = void 0;
+exports.ComparableBackup = exports.OnlineBackupValidator = exports.validate = exports.Purpose = exports.MessageBackupKey = exports.ValidationOutcome = void 0;
 /**
  * Message backup validation routines.
  *
@@ -81,6 +81,8 @@ var Purpose;
  * @param length The exact length of the input stream.
  * @returns The outcome of validation, including any errors and warnings.
  * @throws IoError If an IO error on the input occurs.
+ *
+ * @see OnlineBackupValidator
  */
 async function validate(backupKey, purpose, inputFactory, length) {
     const firstStream = inputFactory();
@@ -88,6 +90,61 @@ async function validate(backupKey, purpose, inputFactory, length) {
     return new ValidationOutcome(await Native.MessageBackupValidator_Validate(backupKey, firstStream, secondStream, length, purpose));
 }
 exports.validate = validate;
+/**
+ * An alternative to {@link validate()} that validates a backup frame-by-frame.
+ *
+ * This is much faster than using `validate()` because it bypasses the decryption and decompression
+ * steps, but that also means it's validating less. Don't forget to call `finalize()`!
+ *
+ * Unlike `validate()`, unknown fields are treated as "soft" errors and logged, rather than
+ * collected and returned to the app for processing.
+ *
+ * # Example
+ *
+ * ```
+ * const validator = new OnlineBackupValidator(
+ *     backupInfoProto.serialize(),
+ *     Purpose.deviceTransfer)
+ * repeat {
+ *   // ...generate Frames...
+ *   validator.addFrame(frameProto.serialize())
+ * }
+ * validator.finalize() // don't forget this!
+ * ```
+ */
+class OnlineBackupValidator {
+    /**
+     * Initializes an OnlineBackupValidator from the given BackupInfo protobuf message.
+     *
+     * "Soft" errors will be logged, including unrecognized fields in the protobuf.
+     *
+     * @throws BackupValidationError on error
+     */
+    constructor(backupInfo, purpose) {
+        this._nativeHandle = Native.OnlineBackupValidator_New(backupInfo, purpose);
+    }
+    /**
+     * Processes a single Frame protobuf message.
+     *
+     * "Soft" errors will be logged, including unrecognized fields in the protobuf.
+     *
+     * @throws BackupValidationError on error
+     */
+    addFrame(frame) {
+        Native.OnlineBackupValidator_AddFrame(this, frame);
+    }
+    /**
+     * Marks that a backup is complete, and does any final checks that require whole-file knowledge.
+     *
+     * "Soft" errors will be logged.
+     *
+     * @throws BackupValidationError on error
+     */
+    finalize() {
+        Native.OnlineBackupValidator_Finalize(this);
+    }
+}
+exports.OnlineBackupValidator = OnlineBackupValidator;
 /**
  * An in-memory representation of a backup file used to compare contents.
  *

package/dist/acknowledgments.md

@@ -2926,7 +2926,7 @@ DEALINGS IN THE SOFTWARE.
 
 ```
 
-## backtrace 0.3.74, cc 1.1.18, cfg-if 1.0.0, cmake 0.1.48, flate2 1.0.33, jobserver 0.1.32, openssl-probe 0.1.5, rustc-demangle 0.1.24, scoped-tls 1.0.1, socket2 0.5.7
+## backtrace 0.3.74, cc 1.1.18, cfg-if 1.0.0, cmake 0.1.48, flate2 1.0.33, jobserver 0.1.32, openssl-probe 0.1.5, pkg-config 0.3.31, rustc-demangle 0.1.24, scoped-tls 1.0.1, socket2 0.5.7
 
 ```
 Copyright (c) 2014 Alex Crichton
@@ -2989,6 +2989,38 @@ DEALINGS IN THE SOFTWARE.
 
 ```
 
+## libz-sys 1.1.20
+
+```
+Copyright (c) 2014 Alex Crichton
+Copyright (c) 2020 Josh Triplett
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+```
+
 ## mio 1.0.2
 
 ```
@@ -3884,6 +3916,18 @@ DEALINGS IN THE SOFTWARE.
 
 ```
 
+## intmap 2.0.0
+
+```
+Copyright (c) 2016 Jesper Axelsson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+```
+
 ## utf8parse 0.2.2
 
 ```
@@ -4508,6 +4552,38 @@ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+```
+
+## vcpkg 0.2.15
+
+```
+Copyright (c) 2017 Jim McGrath
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+
 ```
 
 ## foreign-types-macros 0.2.3, foreign-types-shared 0.3.1, foreign-types 0.5.0
@@ -6796,6 +6872,33 @@ SOFTWARE.
 
 ```
 
+## visibility 0.1.1
+
+```
+MIT License
+
+Copyright (c) 2024 Daniel Henry-Mantilla
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+```
+
 ## cesu8 1.1.0, half 2.4.1, pqcrypto-internals 0.2.5, pqcrypto-kyber 0.7.9, pqcrypto-kyber 0.8.1, pqcrypto-traits 0.3.5
 
 ```

package/dist/net.d.ts

@@ -18,6 +18,9 @@ export type CDSRequestOptionsType = {
         aci: string;
         accessKey: string;
     }>;
+    /**
+     * @deprecated this option is ignored by the server.
+     */
     returnAcisWithoutUaks: boolean;
     abortSignal?: AbortSignal;
 };
@@ -43,7 +46,7 @@ export declare function newNativeHandle<T>(handle: T): Wrapper<T>;
 export declare class TokioAsyncContext {
     readonly _nativeHandle: Native.TokioAsyncContext;
     constructor(handle: Native.TokioAsyncContext);
-    makeCancellable<T>(abortSignal: AbortSignal | undefined, promise: Promise<T>): Promise<T>;
+    makeCancellable<T>(abortSignal: AbortSignal | undefined, promise: Native.CancellablePromise<T>): Promise<T>;
 }
 export declare class ChatServerMessageAck {
     private readonly asyncContext;
@@ -133,6 +136,61 @@ export type ChatService = {
         abortSignal?: AbortSignal;
     }): Promise<Native.ChatResponse>;
 };
+/**
+ * A connection to the Chat Service.
+ *
+ * Provides API methods to communicate with the remote service. Make sure to
+ * call {@link #disconnect()} when the instance is no longer needed.
+ */
+export type ChatConnection = {
+    /**
+     * Initiates termination of the underlying connection to the Chat Service. After the service is
+     * disconnected, it cannot be used again.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Sends request to the Chat service.
+     */
+    fetch(chatRequest: ChatRequest, options?: {
+        abortSignal?: AbortSignal;
+    }): Promise<Native.ChatResponse>;
+    /**
+     * Information about the connection to the Chat service.
+     */
+    connectionInfo(): ConnectionInfo;
+};
+export interface ConnectionInfo {
+    localPort: number;
+    ipVersion: 'IPv4' | 'IPv6';
+}
+export declare class UnauthenticatedChatConnection implements ChatConnection {
+    private readonly asyncContext;
+    private readonly chatService;
+    private readonly chatListener;
+    static connect(asyncContext: TokioAsyncContext, connectionManager: ConnectionManager, listener: ConnectionEventsListener, options?: {
+        abortSignal?: AbortSignal;
+    }): Promise<UnauthenticatedChatConnection>;
+    private constructor();
+    fetch(chatRequest: ChatRequest, options?: {
+        abortSignal?: AbortSignal;
+    }): Promise<Native.ChatResponse>;
+    disconnect(): Promise<void>;
+    connectionInfo(): ConnectionInfo;
+}
+export declare class AuthenticatedChatConnection implements ChatConnection {
+    private readonly asyncContext;
+    private readonly chatService;
+    private readonly chatListener;
+    static connect(asyncContext: TokioAsyncContext, connectionManager: ConnectionManager, username: string, password: string, receiveStories: boolean, listener: ChatServiceListener, options?: {
+        abortSignal?: AbortSignal;
+    }): Promise<AuthenticatedChatConnection>;
+    private constructor();
+    fetch(chatRequest: ChatRequest, options?: {
+        abortSignal?: AbortSignal;
+    }): Promise<Native.ChatResponse>;
+    disconnect(): Promise<void>;
+    connectionInfo(): ConnectionInfo;
+}
 /**
  * Provides API methods to connect and communicate with the Chat Service over an authenticated channel.
  */
@@ -206,6 +264,23 @@ export declare class Net {
      * Creates a new instance of {@link UnauthenticatedChatService}.
      */
     newUnauthenticatedChatService(listener: ConnectionEventsListener): UnauthenticatedChatService;
+    /**
+     *
+     * Creates a new instance of {@link UnauthenticatedChatConnection}.
+     * @param listener the listener for incoming events.
+     * @param options additional options to pass through.
+     * @param options.abortSignal an {@link AbortSignal} that will cancel the connection attempt.
+     * @returns the connected listener, if the connection succeeds.
+     */
+    connectUnauthenticatedChat(listener: ConnectionEventsListener, options?: {
+        abortSignal?: AbortSignal;
+    }): Promise<UnauthenticatedChatConnection>;
+    /**
+     * Creates a new instance of {@link AuthenticatedChatConnection}.
+     */
+    connectAuthenticatedChat(username: string, password: string, receiveStories: boolean, listener: ChatServiceListener, options?: {
+        abortSignal?: AbortSignal;
+    }): Promise<AuthenticatedChatConnection>;
     /**
      * Enables/disables IPv6 for all new connections (until changed).
      *
@@ -246,7 +321,7 @@ export declare class Net {
      * This will lead to, e.g. caches being cleared and cooldowns being reset.
      */
     onNetworkChange(): void;
-    cdsiLookup({ username, password }: Readonly<ServiceAuth>, { e164s, acisAndAccessKeys, returnAcisWithoutUaks, abortSignal, }: ReadonlyDeep<CDSRequestOptionsType>): Promise<CDSResponseType<string, string>>;
+    cdsiLookup({ username, password }: Readonly<ServiceAuth>, { e164s, acisAndAccessKeys, abortSignal, }: ReadonlyDeep<CDSRequestOptionsType>): Promise<CDSResponseType<string, string>>;
 }
 /**
  * This interface provides functionality for communicating with SVR3

package/dist/net.js

@@ -4,7 +4,7 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 //
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RestoredSecret = exports.Net = exports.buildHttpRequest = exports.UnauthenticatedChatService = exports.AuthenticatedChatService = exports.ChatServerMessageAck = exports.TokioAsyncContext = exports.newNativeHandle = exports.Environment = void 0;
+exports.RestoredSecret = exports.Net = exports.buildHttpRequest = exports.UnauthenticatedChatService = exports.AuthenticatedChatService = exports.AuthenticatedChatConnection = exports.UnauthenticatedChatConnection = exports.ChatServerMessageAck = exports.TokioAsyncContext = exports.newNativeHandle = exports.Environment = void 0;
 const Native = require("../Native");
 const Address_1 = require("./Address");
 const node_buffer_1 = require("node:buffer");
@@ -27,9 +27,7 @@ class TokioAsyncContext {
         this._nativeHandle = handle;
     }
     makeCancellable(abortSignal, promise) {
-        if (abortSignal !== undefined &&
-            '_cancellationToken' in promise &&
-            typeof promise._cancellationToken === 'bigint') {
+        if (abortSignal !== undefined) {
             const cancellationToken = promise._cancellationToken;
             const cancel = () => {
                 Native.TokioAsyncContext_cancel(this, cancellationToken);
@@ -59,6 +57,108 @@ class ChatServerMessageAck {
     }
 }
 exports.ChatServerMessageAck = ChatServerMessageAck;
+class ConnectionInfoImpl {
+    constructor(_nativeHandle) {
+        this._nativeHandle = _nativeHandle;
+    }
+    get localPort() {
+        return Native.ConnectionInfo_local_port(this);
+    }
+    get ipVersion() {
+        const value = Native.ConnectionInfo_ip_version(this);
+        switch (value) {
+            case 1:
+                return 'IPv4';
+            case 2:
+                return 'IPv6';
+            default:
+                throw new TypeError(`ip type was unexpectedly ${value}`);
+        }
+    }
+}
+class UnauthenticatedChatConnection {
+    static async connect(asyncContext, connectionManager, listener, options) {
+        const nativeChatListener = makeNativeChatListener(asyncContext, listener);
+        const connect = Native.UnauthenticatedChatConnection_connect(asyncContext, connectionManager, new WeakListenerWrapper(nativeChatListener));
+        const chat = await asyncContext.makeCancellable(options?.abortSignal, connect);
+        return new UnauthenticatedChatConnection(asyncContext, newNativeHandle(chat), nativeChatListener);
+    }
+    constructor(asyncContext, chatService, 
+    // Unused except to keep the listener alive since the Rust code only holds a
+    // weak reference to the same object.
+    chatListener) {
+        this.asyncContext = asyncContext;
+        this.chatService = chatService;
+        this.chatListener = chatListener;
+    }
+    fetch(chatRequest, options) {
+        return this.asyncContext.makeCancellable(options?.abortSignal, Native.UnauthenticatedChatConnection_send(this.asyncContext, this.chatService, buildHttpRequest(chatRequest), chatRequest.timeoutMillis ?? DEFAULT_CHAT_REQUEST_TIMEOUT_MILLIS));
+    }
+    disconnect() {
+        return Native.UnauthenticatedChatConnection_disconnect(this.asyncContext, this.chatService);
+    }
+    connectionInfo() {
+        return new ConnectionInfoImpl(Native.UnauthenticatedChatConnection_info(this.chatService));
+    }
+}
+exports.UnauthenticatedChatConnection = UnauthenticatedChatConnection;
+class AuthenticatedChatConnection {
+    static async connect(asyncContext, connectionManager, username, password, receiveStories, listener, options) {
+        const nativeChatListener = makeNativeChatListener(asyncContext, listener);
+        const connect = Native.AuthenticatedChatConnection_connect(asyncContext, connectionManager, username, password, receiveStories, new WeakListenerWrapper(nativeChatListener));
+        const chat = await asyncContext.makeCancellable(options?.abortSignal, connect);
+        return new AuthenticatedChatConnection(asyncContext, newNativeHandle(chat), nativeChatListener);
+    }
+    constructor(asyncContext, chatService, 
+    // Unused except to keep the listener alive since the Rust code only holds a
+    // weak reference to the same object.
+    chatListener) {
+        this.asyncContext = asyncContext;
+        this.chatService = chatService;
+        this.chatListener = chatListener;
+    }
+    fetch(chatRequest, options) {
+        return this.asyncContext.makeCancellable(options?.abortSignal, Native.AuthenticatedChatConnection_send(this.asyncContext, this.chatService, buildHttpRequest(chatRequest), chatRequest.timeoutMillis ?? DEFAULT_CHAT_REQUEST_TIMEOUT_MILLIS));
+    }
+    disconnect() {
+        return Native.AuthenticatedChatConnection_disconnect(this.asyncContext, this.chatService);
+    }
+    connectionInfo() {
+        return new ConnectionInfoImpl(Native.AuthenticatedChatConnection_info(this.chatService));
+    }
+}
+exports.AuthenticatedChatConnection = AuthenticatedChatConnection;
+/**
+ * Holds a {@link Native.ChatListener} by {@link WeakRef} and delegates
+ * `ChatListener` calls to it.
+ *
+ * This lets us avoid passing anything across the bridge that has a normal
+ * (strong) reference to the app-side listener. The danger is that the passed-in
+ * listener might gain a reference to the JS connection object; that would
+ * result in a reference cycle that Node can't clean up because one of the
+ * references is through a Rust `Box`.
+ *
+ * When constructing a connection, calling code should wrap an app-side listener
+ * in this type and pass it across the bridge, then hold its own strong
+ * reference to the same listener as a field. This ensures that if there is a
+ * reference cycle between the connection and app-side listener, that cycle is
+ * visible to the Node runtime, while still ensuring the passed-in listener
+ * stays alive as long as the connection does.
+ */
+class WeakListenerWrapper {
+    constructor(listener) {
+        this.listener = new WeakRef(listener);
+    }
+    _connection_interrupted(reason) {
+        this.listener.deref()?._connection_interrupted(reason);
+    }
+    _incoming_message(envelope, timestamp, ack) {
+        this.listener.deref()?._incoming_message(envelope, timestamp, ack);
+    }
+    _queue_empty() {
+        this.listener.deref()?._queue_empty();
+    }
+}
 /**
  * Provides API methods to connect and communicate with the Chat Service over an authenticated channel.
  */
@@ -100,17 +200,7 @@ class UnauthenticatedChatService {
     constructor(asyncContext, connectionManager, listener) {
         this.asyncContext = asyncContext;
         this.chatService = newNativeHandle(Native.ChatService_new_unauth(connectionManager));
-        const nativeChatListener = {
-            _incoming_message(_envelope, _timestamp, _ack) {
-                throw new Error('Event not supported on unauthenticated connection');
-            },
-            _queue_empty() {
-                throw new Error('Event not supported on unauthenticated connection');
-            },
-            _connection_interrupted(cause) {
-                listener.onConnectionInterrupted(cause);
-            },
-        };
+        const nativeChatListener = makeNativeChatListener(asyncContext, listener);
         Native.ChatService_SetListenerUnauth(asyncContext, this.chatService, nativeChatListener);
     }
     disconnect() {
@@ -127,6 +217,32 @@ class UnauthenticatedChatService {
     }
 }
 exports.UnauthenticatedChatService = UnauthenticatedChatService;
+function makeNativeChatListener(asyncContext, listener) {
+    if ('onQueueEmpty' in listener) {
+        return {
+            _incoming_message(envelope, timestamp, ack) {
+                listener.onIncomingMessage(envelope, timestamp, new ChatServerMessageAck(asyncContext, ack));
+            },
+            _queue_empty() {
+                listener.onQueueEmpty();
+            },
+            _connection_interrupted(cause) {
+                listener.onConnectionInterrupted(cause);
+            },
+        };
+    }
+    return {
+        _incoming_message(_envelope, _timestamp, _ack) {
+            throw new Error('Event not supported on unauthenticated connection');
+        },
+        _queue_empty() {
+            throw new Error('Event not supported on unauthenticated connection');
+        },
+        _connection_interrupted(cause) {
+            listener.onConnectionInterrupted(cause);
+        },
+    };
+}
 function buildHttpRequest(chatRequest) {
     const { verb, path, body, headers } = chatRequest;
     const bodyBuffer = body !== undefined ? node_buffer_1.Buffer.from(body) : null;
@@ -168,6 +284,23 @@ class Net {
     newUnauthenticatedChatService(listener) {
         return new UnauthenticatedChatService(this.asyncContext, this.connectionManager, listener);
     }
+    /**
+     *
+     * Creates a new instance of {@link UnauthenticatedChatConnection}.
+     * @param listener the listener for incoming events.
+     * @param options additional options to pass through.
+     * @param options.abortSignal an {@link AbortSignal} that will cancel the connection attempt.
+     * @returns the connected listener, if the connection succeeds.
+     */
+    async connectUnauthenticatedChat(listener, options) {
+        return UnauthenticatedChatConnection.connect(this.asyncContext, this.connectionManager, listener, options);
+    }
+    /**
+     * Creates a new instance of {@link AuthenticatedChatConnection}.
+     */
+    connectAuthenticatedChat(username, password, receiveStories, listener, options) {
+        return AuthenticatedChatConnection.connect(this.asyncContext, this.connectionManager, username, password, receiveStories, listener, options);
+    }
     /**
      * Enables/disables IPv6 for all new connections (until changed).
      *
@@ -218,7 +351,7 @@ class Net {
     onNetworkChange() {
         Native.ConnectionManager_on_network_change(this.connectionManager);
     }
-    async cdsiLookup({ username, password }, { e164s, acisAndAccessKeys, returnAcisWithoutUaks, abortSignal, }) {
+    async cdsiLookup({ username, password }, { e164s, acisAndAccessKeys, abortSignal, }) {
         const request = newNativeHandle(Native.LookupRequest_new());
         e164s.forEach((e164) => {
             Native.LookupRequest_addE164(request, e164);
@@ -226,7 +359,6 @@ class Net {
         acisAndAccessKeys.forEach(({ aci: aciStr, accessKey: accessKeyStr }) => {
             Native.LookupRequest_addAciAndAccessKey(request, Address_1.Aci.parseFromServiceIdString(aciStr).getServiceIdFixedWidthBinary(), node_buffer_1.Buffer.from(accessKeyStr, 'base64'));
         });
-        Native.LookupRequest_setReturnAcisWithoutUaks(request, returnAcisWithoutUaks);
         const lookup = await this.asyncContext.makeCancellable(abortSignal, Native.CdsiLookup_new(this.asyncContext, this.connectionManager, username, password, request));
         return await this.asyncContext.makeCancellable(abortSignal, Native.CdsiLookup_complete(this.asyncContext, newNativeHandle(lookup)));
     }

package/dist/zkgroup/auth/ServerZkAuthOperations.d.ts

@@ -7,7 +7,13 @@ import { Aci, Pni } from '../../Address';
 export default class ServerZkAuthOperations {
     serverSecretParams: ServerSecretParams;
     constructor(serverSecretParams: ServerSecretParams);
+    /**
+     * @deprecated These credentials are no longer supported by the server; use `issueAuthCredentialWithPniZkc` instead.
+     */
     issueAuthCredentialWithPniAsServiceId(aci: Aci, pni: Pni, redemptionTime: number): AuthCredentialWithPniResponse;
+    /**
+     * @deprecated These credentials are no longer supported by the server; use `issueAuthCredentialWithPniZkc` instead.
+     */
     issueAuthCredentialWithPniAsServiceIdWithRandom(random: Buffer, aci: Aci, pni: Pni, redemptionTime: number): AuthCredentialWithPniResponse;
     issueAuthCredentialWithPniZkc(aci: Aci, pni: Pni, redemptionTime: number): AuthCredentialWithPniResponse;
     issueAuthCredentialWithPniZkcWithRandom(random: Buffer, aci: Aci, pni: Pni, redemptionTime: number): AuthCredentialWithPniResponse;

package/dist/zkgroup/auth/ServerZkAuthOperations.js

@@ -12,10 +12,16 @@ class ServerZkAuthOperations {
     constructor(serverSecretParams) {
         this.serverSecretParams = serverSecretParams;
     }
+    /**
+     * @deprecated These credentials are no longer supported by the server; use `issueAuthCredentialWithPniZkc` instead.
+     */
     issueAuthCredentialWithPniAsServiceId(aci, pni, redemptionTime) {
         const random = (0, crypto_1.randomBytes)(Constants_1.RANDOM_LENGTH);
         return this.issueAuthCredentialWithPniAsServiceIdWithRandom(random, aci, pni, redemptionTime);
     }
+    /**
+     * @deprecated These credentials are no longer supported by the server; use `issueAuthCredentialWithPniZkc` instead.
+     */
     issueAuthCredentialWithPniAsServiceIdWithRandom(random, aci, pni, redemptionTime) {
         return new AuthCredentialWithPniResponse_1.default(Native.ServerSecretParams_IssueAuthCredentialWithPniAsServiceIdDeterministic(this.serverSecretParams, random, aci.getServiceIdFixedWidthBinary(), pni.getServiceIdFixedWidthBinary(), redemptionTime));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signalapp/libsignal-client",
-  "version": "0.62.0",
+  "version": "0.63.0",
   "license": "AGPL-3.0-only",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",