@signalapp/libsignal-client 0.67.1 → 0.67.3

package/Native.d.ts

@@ -123,6 +123,7 @@ type ChatListener = {
     ack: ServerMessageAck
   ): void;
   _queue_empty(): void;
+  _received_alerts(alerts: string[]): void;
   _connection_interrupted(
     // A LibSignalError or null, but not naming the type to avoid circular import dependencies.
     reason: Error | null
@@ -463,6 +464,7 @@ export function ServerPublicParams_CreateProfileKeyCredentialRequestContextDeter
 export function ServerPublicParams_CreateReceiptCredentialPresentationDeterministic(serverPublicParams: Wrapper<ServerPublicParams>, randomness: Buffer, receiptCredential: Serialized<ReceiptCredential>): Serialized<ReceiptCredentialPresentation>;
 export function ServerPublicParams_CreateReceiptCredentialRequestContextDeterministic(serverPublicParams: Wrapper<ServerPublicParams>, randomness: Buffer, receiptSerial: Buffer): Serialized<ReceiptCredentialRequestContext>;
 export function ServerPublicParams_Deserialize(buffer: Buffer): ServerPublicParams;
+export function ServerPublicParams_GetEndorsementPublicKey(params: Wrapper<ServerPublicParams>): Buffer;
 export function ServerPublicParams_ReceiveAuthCredentialWithPniAsServiceId(params: Wrapper<ServerPublicParams>, aci: Buffer, pni: Buffer, redemptionTime: Timestamp, authCredentialWithPniResponseBytes: Buffer): Buffer;
 export function ServerPublicParams_ReceiveExpiringProfileKeyCredential(serverPublicParams: Wrapper<ServerPublicParams>, requestContext: Serialized<ProfileKeyCredentialRequestContext>, response: Serialized<ExpiringProfileKeyCredentialResponse>, currentTimeInSeconds: Timestamp): Serialized<ExpiringProfileKeyCredential>;
 export function ServerPublicParams_ReceiveReceiptCredential(serverPublicParams: Wrapper<ServerPublicParams>, requestContext: Serialized<ReceiptCredentialRequestContext>, response: Serialized<ReceiptCredentialResponse>): Serialized<ReceiptCredential>;
@@ -531,7 +533,7 @@ export function TESTING_ErrorOnBorrowSync(_input: null): void;
 export function TESTING_ErrorOnReturnAsync(_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_FakeChatConnection_Create(tokio: Wrapper<TokioAsyncContext>, listener: ChatListener): FakeChatConnection;
+export function TESTING_FakeChatConnection_Create(tokio: Wrapper<TokioAsyncContext>, listener: ChatListener, alertsJoinedByNewlines: string): FakeChatConnection;
 export function TESTING_FakeChatConnection_TakeAuthenticatedChat(chat: Wrapper<FakeChatConnection>): AuthenticatedChatConnection;
 export function TESTING_FakeChatConnection_TakeRemote(chat: Wrapper<FakeChatConnection>): FakeChatRemoteEnd;
 export function TESTING_FakeChatRemoteEnd_InjectConnectionInterrupted(chat: Wrapper<FakeChatRemoteEnd>): void;

package/dist/net/CDSI.d.ts

@@ -0,0 +1,29 @@
+import type { ReadonlyDeep } from 'type-fest';
+import * as Native from '../../Native';
+import { TokioAsyncContext, ServiceAuth } from '../net';
+export type CDSRequestOptionsType = {
+    e164s: Array<string>;
+    acisAndAccessKeys: Array<{
+        aci: string;
+        accessKey: string;
+    }>;
+    /**
+     * @deprecated this option is ignored by the server.
+     */
+    returnAcisWithoutUaks: boolean;
+    abortSignal?: AbortSignal;
+    useNewConnectLogic?: boolean;
+};
+export type CDSResponseEntryType<Aci, Pni> = {
+    aci: Aci | undefined;
+    pni: Pni | undefined;
+};
+export type CDSResponseEntries<Aci, Pni> = Map<string, CDSResponseEntryType<Aci, Pni>>;
+export interface CDSResponseType<Aci, Pni> {
+    entries: CDSResponseEntries<Aci, Pni>;
+    debugPermitsUsed: number;
+}
+export declare function cdsiLookup({ asyncContext, connectionManager, }: Readonly<{
+    asyncContext: TokioAsyncContext;
+    connectionManager: Native.Wrapper<Native.ConnectionManager>;
+}>, { username, password }: Readonly<ServiceAuth>, { e164s, acisAndAccessKeys, abortSignal, useNewConnectLogic, }: ReadonlyDeep<CDSRequestOptionsType>): Promise<CDSResponseType<string, string>>;

package/dist/net/CDSI.js

@@ -0,0 +1,27 @@
+"use strict";
+//
+// Copyright 2025 Signal Messenger, LLC.
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cdsiLookup = void 0;
+const Native = require("../../Native");
+const Address_1 = require("../Address");
+const node_buffer_1 = require("node:buffer");
+const net_1 = require("../net");
+async function cdsiLookup({ asyncContext, connectionManager, }, { username, password }, { e164s, acisAndAccessKeys, abortSignal, useNewConnectLogic, }) {
+    const request = (0, net_1.newNativeHandle)(Native.LookupRequest_new());
+    e164s.forEach((e164) => {
+        Native.LookupRequest_addE164(request, e164);
+    });
+    acisAndAccessKeys.forEach(({ aci: aciStr, accessKey: accessKeyStr }) => {
+        Native.LookupRequest_addAciAndAccessKey(request, Address_1.Aci.parseFromServiceIdString(aciStr).getServiceIdFixedWidthBinary(), node_buffer_1.Buffer.from(accessKeyStr, 'base64'));
+    });
+    const startLookup = useNewConnectLogic
+        ? Native.CdsiLookup_new_routes
+        : Native.CdsiLookup_new;
+    const lookup = await asyncContext.makeCancellable(abortSignal, startLookup(asyncContext, connectionManager, username, password, request));
+    return await asyncContext.makeCancellable(abortSignal, Native.CdsiLookup_complete(asyncContext, (0, net_1.newNativeHandle)(lookup)));
+}
+exports.cdsiLookup = cdsiLookup;
+//# sourceMappingURL=CDSI.js.map

package/dist/net/Chat.d.ts

@@ -0,0 +1,121 @@
+/// <reference types="node" />
+import * as Native from '../../Native';
+import { LibSignalError } from '../Errors';
+import { Wrapper } from '../../Native';
+import { Buffer } from 'node:buffer';
+import { TokioAsyncContext } from '../net';
+export type ChatRequest = Readonly<{
+    verb: string;
+    path: string;
+    headers: ReadonlyArray<[string, string]>;
+    body?: Uint8Array;
+    timeoutMillis?: number;
+}>;
+type ConnectionManager = Wrapper<Native.ConnectionManager>;
+export declare class ChatServerMessageAck {
+    readonly _nativeHandle: Native.ServerMessageAck;
+    constructor(_nativeHandle: Native.ServerMessageAck);
+    send(statusCode: number): void;
+}
+export interface ConnectionEventsListener {
+    /**
+     * Called when the client gets disconnected from the server.
+     *
+     * This includes both deliberate disconnects as well as unexpected socket
+     * closures. If the closure was not due to a deliberate disconnect, the error
+     * will be provided.
+     */
+    onConnectionInterrupted(cause: LibSignalError | null): void;
+}
+export interface ChatServiceListener extends ConnectionEventsListener {
+    /**
+     * Called when the server delivers an incoming message to the client.
+     *
+     * `timestamp` is in milliseconds.
+     *
+     * If `ack`'s `send` method is not called, the server will leave this message in the message
+     * queue and attempt to deliver it again in the future.
+     */
+    onIncomingMessage(envelope: Buffer, timestamp: number, ack: ChatServerMessageAck): void;
+    /**
+     * Called when the server indicates that there are no further messages in the message queue.
+     *
+     * Note that further messages may still be delivered; this merely indicates that all messages that
+     * were in the queue *when the connection was established* have been delivered.
+     */
+    onQueueEmpty(): void;
+    /**
+     * Called when the server has alerts for the current device.
+     *
+     * In practice this happens as part of the connecting process.
+     */
+    onReceivedAlerts?(alerts: string[]): void;
+}
+/**
+ * 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';
+    toString: () => string;
+}
+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>;
+    /**
+     * Creates a chat connection backed by a fake remote end.
+     *
+     * @param asyncContext the async runtime to use
+     * @param listener the listener to send events to
+     * @param alerts alerts to send immediately upon connect
+     * @returns an {@link AuthenticatedChatConnection} and handle for the remote
+     * end of the fake connection.
+     */
+    static fakeConnect(asyncContext: TokioAsyncContext, listener: ChatServiceListener, alerts?: ReadonlyArray<string>): [AuthenticatedChatConnection, Wrapper<Native.FakeChatRemoteEnd>];
+    private constructor();
+    fetch(chatRequest: ChatRequest, options?: {
+        abortSignal?: AbortSignal;
+    }): Promise<Native.ChatResponse>;
+    disconnect(): Promise<void>;
+    connectionInfo(): ConnectionInfo;
+}
+export declare function buildHttpRequest(chatRequest: ChatRequest): Wrapper<Native.HttpRequest>;
+export {};

package/dist/net/Chat.js

@@ -0,0 +1,196 @@
+"use strict";
+//
+// Copyright 2025 Signal Messenger, LLC.
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildHttpRequest = exports.AuthenticatedChatConnection = exports.UnauthenticatedChatConnection = exports.ChatServerMessageAck = void 0;
+const Native = require("../../Native");
+const node_buffer_1 = require("node:buffer");
+const net_1 = require("../net");
+const DEFAULT_CHAT_REQUEST_TIMEOUT_MILLIS = 5000;
+class ChatServerMessageAck {
+    constructor(_nativeHandle) {
+        this._nativeHandle = _nativeHandle;
+    }
+    send(statusCode) {
+        Native.ServerMessageAck_SendStatus(this, statusCode);
+    }
+}
+exports.ChatServerMessageAck = ChatServerMessageAck;
+class ConnectionInfoImpl {
+    constructor(_nativeHandle) {
+        this._nativeHandle = _nativeHandle;
+    }
+    get localPort() {
+        return Native.ChatConnectionInfo_local_port(this);
+    }
+    get ipVersion() {
+        const value = Native.ChatConnectionInfo_ip_version(this);
+        switch (value) {
+            case 1:
+                return 'IPv4';
+            case 2:
+                return 'IPv6';
+            default:
+                throw new TypeError(`ip type was unexpectedly ${value}`);
+        }
+    }
+    toString() {
+        return Native.ChatConnectionInfo_description(this);
+    }
+}
+class UnauthenticatedChatConnection {
+    static async connect(asyncContext, connectionManager, listener, options) {
+        const nativeChatListener = makeNativeChatListener(asyncContext, listener);
+        const connect = Native.UnauthenticatedChatConnection_connect(asyncContext, connectionManager);
+        const chat = await asyncContext.makeCancellable(options?.abortSignal, connect);
+        const connection = (0, net_1.newNativeHandle)(chat);
+        Native.UnauthenticatedChatConnection_init_listener(connection, new WeakListenerWrapper(nativeChatListener));
+        return new UnauthenticatedChatConnection(asyncContext, connection, 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);
+        const chat = await asyncContext.makeCancellable(options?.abortSignal, connect);
+        const connection = (0, net_1.newNativeHandle)(chat);
+        Native.AuthenticatedChatConnection_init_listener(connection, new WeakListenerWrapper(nativeChatListener));
+        return new AuthenticatedChatConnection(asyncContext, connection, nativeChatListener);
+    }
+    /**
+     * Creates a chat connection backed by a fake remote end.
+     *
+     * @param asyncContext the async runtime to use
+     * @param listener the listener to send events to
+     * @param alerts alerts to send immediately upon connect
+     * @returns an {@link AuthenticatedChatConnection} and handle for the remote
+     * end of the fake connection.
+     */
+    static fakeConnect(asyncContext, listener, alerts) {
+        const nativeChatListener = makeNativeChatListener(asyncContext, listener);
+        const fakeChat = (0, net_1.newNativeHandle)(Native.TESTING_FakeChatConnection_Create(asyncContext, new WeakListenerWrapper(nativeChatListener), alerts?.join('\n') ?? ''));
+        const chat = (0, net_1.newNativeHandle)(Native.TESTING_FakeChatConnection_TakeAuthenticatedChat(fakeChat));
+        return [
+            new AuthenticatedChatConnection(asyncContext, chat, nativeChatListener),
+            (0, net_1.newNativeHandle)(Native.TESTING_FakeChatConnection_TakeRemote(fakeChat)),
+        ];
+    }
+    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();
+    }
+    _received_alerts(alerts) {
+        this.listener.deref()?._received_alerts(alerts);
+    }
+}
+function makeNativeChatListener(asyncContext, listener) {
+    if ('onQueueEmpty' in listener) {
+        return {
+            _incoming_message(envelope, timestamp, ack) {
+                listener.onIncomingMessage(envelope, timestamp, new ChatServerMessageAck(ack));
+            },
+            _queue_empty() {
+                listener.onQueueEmpty();
+            },
+            _received_alerts(alerts) {
+                listener.onReceivedAlerts?.(alerts);
+            },
+            _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');
+        },
+        _received_alerts(_alerts) {
+            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;
+    const httpRequest = {
+        _nativeHandle: Native.HttpRequest_new(verb, path, bodyBuffer),
+    };
+    headers.forEach((header) => {
+        const [name, value] = header;
+        Native.HttpRequest_add_header(httpRequest, name, value);
+    });
+    return httpRequest;
+}
+exports.buildHttpRequest = buildHttpRequest;
+//# sourceMappingURL=Chat.js.map

package/dist/net.d.ts

@@ -1,9 +1,11 @@
 /// <reference types="node" />
 import type { ReadonlyDeep } from 'type-fest';
 import * as Native from '../Native';
-import { LibSignalError } from './Errors';
-import { Wrapper } from '../Native';
 import { Buffer } from 'node:buffer';
+import { CDSRequestOptionsType, CDSResponseType } from './net/CDSI';
+import { ConnectionEventsListener, UnauthenticatedChatConnection, AuthenticatedChatConnection, ChatServiceListener } from './net/Chat';
+export * from './net/CDSI';
+export * from './net/Chat';
 export declare enum Environment {
     Staging = 0,
     Production = 1
@@ -12,28 +14,6 @@ export type ServiceAuth = {
     username: string;
     password: string;
 };
-export type CDSRequestOptionsType = {
-    e164s: Array<string>;
-    acisAndAccessKeys: Array<{
-        aci: string;
-        accessKey: string;
-    }>;
-    /**
-     * @deprecated this option is ignored by the server.
-     */
-    returnAcisWithoutUaks: boolean;
-    abortSignal?: AbortSignal;
-    useNewConnectLogic?: boolean;
-};
-export type CDSResponseEntryType<Aci, Pni> = {
-    aci: Aci | undefined;
-    pni: Pni | undefined;
-};
-export type CDSResponseEntries<Aci, Pni> = Map<string, CDSResponseEntryType<Aci, Pni>>;
-export interface CDSResponseType<Aci, Pni> {
-    entries: CDSResponseEntries<Aci, Pni>;
-    debugPermitsUsed: number;
-}
 export type ChatRequest = Readonly<{
     verb: string;
     path: string;
@@ -41,113 +21,14 @@ export type ChatRequest = Readonly<{
     body?: Uint8Array;
     timeoutMillis?: number;
 }>;
-type ConnectionManager = Wrapper<Native.ConnectionManager>;
-export declare function newNativeHandle<T>(handle: T): Wrapper<T>;
+type ConnectionManager = Native.Wrapper<Native.ConnectionManager>;
+export declare function newNativeHandle<T>(handle: T): Native.Wrapper<T>;
 /** Low-level async runtime control, mostly just exported for testing. */
 export declare class TokioAsyncContext {
     readonly _nativeHandle: Native.TokioAsyncContext;
     constructor(handle: Native.TokioAsyncContext);
     makeCancellable<T>(abortSignal: AbortSignal | undefined, promise: Native.CancellablePromise<T>): Promise<T>;
 }
-export declare class ChatServerMessageAck {
-    readonly _nativeHandle: Native.ServerMessageAck;
-    constructor(_nativeHandle: Native.ServerMessageAck);
-    send(statusCode: number): void;
-}
-export interface ConnectionEventsListener {
-    /**
-     * Called when the client gets disconnected from the server.
-     *
-     * This includes both deliberate disconnects as well as unexpected socket
-     * closures. If the closure was not due to a deliberate disconnect, the error
-     * will be provided.
-     */
-    onConnectionInterrupted(cause: LibSignalError | null): void;
-}
-export interface ChatServiceListener extends ConnectionEventsListener {
-    /**
-     * Called when the server delivers an incoming message to the client.
-     *
-     * `timestamp` is in milliseconds.
-     *
-     * If `ack`'s `send` method is not called, the server will leave this message in the message
-     * queue and attempt to deliver it again in the future.
-     */
-    onIncomingMessage(envelope: Buffer, timestamp: number, ack: ChatServerMessageAck): void;
-    /**
-     * Called when the server indicates that there are no further messages in the message queue.
-     *
-     * Note that further messages may still be delivered; this merely indicates that all messages that
-     * were in the queue *when the connection was established* have been delivered.
-     */
-    onQueueEmpty(): void;
-}
-/**
- * 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';
-    toString: () => string;
-}
-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>;
-    /**
-     * Creates a chat connection backed by a fake remote end.
-     *
-     * @param asyncContext the async runtime to use
-     * @param listener the listener to send events to
-     * @returns an {@link AuthenticatedChatConnection} and handle for the remote
-     * end of the fake connection.
-     */
-    static fakeConnect(asyncContext: TokioAsyncContext, listener: ChatServiceListener): [AuthenticatedChatConnection, Wrapper<Native.FakeChatRemoteEnd>];
-    private constructor();
-    fetch(chatRequest: ChatRequest, options?: {
-        abortSignal?: AbortSignal;
-    }): Promise<Native.ChatResponse>;
-    disconnect(): Promise<void>;
-    connectionInfo(): ConnectionInfo;
-}
-export declare function buildHttpRequest(chatRequest: ChatRequest): Wrapper<Native.HttpRequest>;
 export type NetConstructorOptions = Readonly<{
     localTestServer?: false;
     env: Environment;
@@ -279,6 +160,5 @@ 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, abortSignal, useNewConnectLogic, }: ReadonlyDeep<CDSRequestOptionsType>): Promise<CDSResponseType<string, string>>;
+    cdsiLookup(auth: Readonly<ServiceAuth>, options: ReadonlyDeep<CDSRequestOptionsType>): Promise<CDSResponseType<string, string>>;
 }
-export {};

package/dist/net.js

@@ -3,12 +3,27 @@
 // Copyright 2023 Signal Messenger, LLC.
 // SPDX-License-Identifier: AGPL-3.0-only
 //
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Net = exports.SIGNAL_TLS_PROXY_SCHEME = exports.buildHttpRequest = exports.AuthenticatedChatConnection = exports.UnauthenticatedChatConnection = exports.ChatServerMessageAck = exports.TokioAsyncContext = exports.newNativeHandle = exports.Environment = void 0;
+exports.Net = exports.SIGNAL_TLS_PROXY_SCHEME = exports.TokioAsyncContext = exports.newNativeHandle = exports.Environment = void 0;
 const Native = require("../Native");
-const Address_1 = require("./Address");
-const node_buffer_1 = require("node:buffer");
-const DEFAULT_CHAT_REQUEST_TIMEOUT_MILLIS = 5000;
+const CDSI_1 = require("./net/CDSI");
+const Chat_1 = require("./net/Chat");
+__exportStar(require("./net/CDSI"), exports);
+__exportStar(require("./net/Chat"), exports);
 // This must match the libsignal-bridge Rust enum of the same name.
 var Environment;
 (function (Environment) {
@@ -43,180 +58,6 @@ class TokioAsyncContext {
     }
 }
 exports.TokioAsyncContext = TokioAsyncContext;
-class ChatServerMessageAck {
-    constructor(_nativeHandle) {
-        this._nativeHandle = _nativeHandle;
-    }
-    send(statusCode) {
-        Native.ServerMessageAck_SendStatus(this, statusCode);
-    }
-}
-exports.ChatServerMessageAck = ChatServerMessageAck;
-class ConnectionInfoImpl {
-    constructor(_nativeHandle) {
-        this._nativeHandle = _nativeHandle;
-    }
-    get localPort() {
-        return Native.ChatConnectionInfo_local_port(this);
-    }
-    get ipVersion() {
-        const value = Native.ChatConnectionInfo_ip_version(this);
-        switch (value) {
-            case 1:
-                return 'IPv4';
-            case 2:
-                return 'IPv6';
-            default:
-                throw new TypeError(`ip type was unexpectedly ${value}`);
-        }
-    }
-    toString() {
-        return Native.ChatConnectionInfo_description(this);
-    }
-}
-class UnauthenticatedChatConnection {
-    static async connect(asyncContext, connectionManager, listener, options) {
-        const nativeChatListener = makeNativeChatListener(asyncContext, listener);
-        const connect = Native.UnauthenticatedChatConnection_connect(asyncContext, connectionManager);
-        const chat = await asyncContext.makeCancellable(options?.abortSignal, connect);
-        const connection = newNativeHandle(chat);
-        Native.UnauthenticatedChatConnection_init_listener(connection, new WeakListenerWrapper(nativeChatListener));
-        return new UnauthenticatedChatConnection(asyncContext, connection, 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);
-        const chat = await asyncContext.makeCancellable(options?.abortSignal, connect);
-        const connection = newNativeHandle(chat);
-        Native.AuthenticatedChatConnection_init_listener(connection, new WeakListenerWrapper(nativeChatListener));
-        return new AuthenticatedChatConnection(asyncContext, connection, nativeChatListener);
-    }
-    /**
-     * Creates a chat connection backed by a fake remote end.
-     *
-     * @param asyncContext the async runtime to use
-     * @param listener the listener to send events to
-     * @returns an {@link AuthenticatedChatConnection} and handle for the remote
-     * end of the fake connection.
-     */
-    static fakeConnect(asyncContext, listener) {
-        const nativeChatListener = makeNativeChatListener(asyncContext, listener);
-        const fakeChat = newNativeHandle(Native.TESTING_FakeChatConnection_Create(asyncContext, new WeakListenerWrapper(nativeChatListener)));
-        const chat = newNativeHandle(Native.TESTING_FakeChatConnection_TakeAuthenticatedChat(fakeChat));
-        return [
-            new AuthenticatedChatConnection(asyncContext, chat, nativeChatListener),
-            newNativeHandle(Native.TESTING_FakeChatConnection_TakeRemote(fakeChat)),
-        ];
-    }
-    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();
-    }
-}
-function makeNativeChatListener(asyncContext, listener) {
-    if ('onQueueEmpty' in listener) {
-        return {
-            _incoming_message(envelope, timestamp, ack) {
-                listener.onIncomingMessage(envelope, timestamp, new ChatServerMessageAck(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;
-    const httpRequest = {
-        _nativeHandle: Native.HttpRequest_new(verb, path, bodyBuffer),
-    };
-    headers.forEach((header) => {
-        const [name, value] = header;
-        Native.HttpRequest_add_header(httpRequest, name, value);
-    });
-    return httpRequest;
-}
-exports.buildHttpRequest = buildHttpRequest;
 /** The "scheme" for Signal TLS proxies. See {@link Net.setProxy()}. */
 exports.SIGNAL_TLS_PROXY_SCHEME = 'org.signal.tls';
 class Net {
@@ -238,13 +79,13 @@ class Net {
      * @returns the connected listener, if the connection succeeds.
      */
     async connectUnauthenticatedChat(listener, options) {
-        return UnauthenticatedChatConnection.connect(this.asyncContext, this._connectionManager, listener, options);
+        return Chat_1.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);
+        return Chat_1.AuthenticatedChatConnection.connect(this.asyncContext, this._connectionManager, username, password, receiveStories, listener, options);
     }
     /**
      * Enables/disables IPv6 for all new connections (until changed).
@@ -376,19 +217,11 @@ class Net {
     onNetworkChange() {
         Native.ConnectionManager_on_network_change(this._connectionManager);
     }
-    async cdsiLookup({ username, password }, { e164s, acisAndAccessKeys, abortSignal, useNewConnectLogic, }) {
-        const request = newNativeHandle(Native.LookupRequest_new());
-        e164s.forEach((e164) => {
-            Native.LookupRequest_addE164(request, e164);
-        });
-        acisAndAccessKeys.forEach(({ aci: aciStr, accessKey: accessKeyStr }) => {
-            Native.LookupRequest_addAciAndAccessKey(request, Address_1.Aci.parseFromServiceIdString(aciStr).getServiceIdFixedWidthBinary(), node_buffer_1.Buffer.from(accessKeyStr, 'base64'));
-        });
-        const startLookup = useNewConnectLogic
-            ? Native.CdsiLookup_new_routes
-            : Native.CdsiLookup_new;
-        const lookup = await this.asyncContext.makeCancellable(abortSignal, startLookup(this.asyncContext, this._connectionManager, username, password, request));
-        return await this.asyncContext.makeCancellable(abortSignal, Native.CdsiLookup_complete(this.asyncContext, newNativeHandle(lookup)));
+    async cdsiLookup(auth, options) {
+        return (0, CDSI_1.cdsiLookup)({
+            asyncContext: this.asyncContext,
+            connectionManager: this._connectionManager,
+        }, auth, options);
     }
 }
 exports.Net = Net;

package/dist/zkgroup/ServerPublicParams.d.ts

@@ -4,6 +4,12 @@ import NotarySignature from './NotarySignature';
 export default class ServerPublicParams {
     readonly _nativeHandle: Native.ServerPublicParams;
     constructor(contents: Buffer | Native.ServerPublicParams);
+    /**
+     * Get the serialized form of the params' endorsement key.
+     *
+     * Allows decoupling RingRTC's use of endorsements from libsignal's.
+     */
+    getEndorsementPublicKey(): Buffer;
     verifySignature(message: Buffer, notarySignature: NotarySignature): void;
     serialize(): Buffer;
 }

package/dist/zkgroup/ServerPublicParams.js

@@ -14,6 +14,14 @@ class ServerPublicParams {
             this._nativeHandle = contents;
         }
     }
+    /**
+     * Get the serialized form of the params' endorsement key.
+     *
+     * Allows decoupling RingRTC's use of endorsements from libsignal's.
+     */
+    getEndorsementPublicKey() {
+        return Native.ServerPublicParams_GetEndorsementPublicKey(this);
+    }
     verifySignature(message, notarySignature) {
         Native.ServerPublicParams_VerifySignature(this, message, notarySignature.getContents());
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signalapp/libsignal-client",
-  "version": "0.67.1",
+  "version": "0.67.3",
   "license": "AGPL-3.0-only",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,6 +8,8 @@
     "dist/acknowledgments.md",
     "dist/*.js",
     "dist/*.d.ts",
+    "dist/net/**/*.js",
+    "dist/net/**/*.d.ts",
     "dist/zkgroup/**/*.js",
     "dist/zkgroup/**/*.d.ts",
     "Native.js",