@signalapp/libsignal-client 0.43.0 → 0.44.0

package/Native.d.ts

@@ -115,9 +115,9 @@ export abstract class InputStream {
 
 export abstract class SyncInputStream extends Buffer {}
 
-interface Wrapper<T> {
-  readonly _nativeHandle: T;
-}
+type Wrapper<T> = Readonly<{
+  _nativeHandle: T;
+}>;
 
 interface MessageBackupValidationOutcome {
   errorMessage: string | null;
@@ -177,7 +177,9 @@ export function ChatService_unauth_send_and_debug(asyncRuntime: Wrapper<TokioAsy
 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 ConnectionManager_clear_proxy(connectionManager: Wrapper<ConnectionManager>): void;
 export function ConnectionManager_new(environment: number): ConnectionManager;
+export function ConnectionManager_set_proxy(connectionManager: Wrapper<ConnectionManager>, host: string, port: number): void;
 export function CreateCallLinkCredentialPresentation_CheckValidContents(presentationBytes: Buffer): void;
 export function CreateCallLinkCredentialPresentation_Verify(presentationBytes: Buffer, roomId: Buffer, now: Timestamp, serverParamsBytes: Buffer, callLinkParamsBytes: Buffer): void;
 export function CreateCallLinkCredentialRequestContext_CheckValidContents(contextBytes: Buffer): void;

package/dist/acknowledgments.md

@@ -669,7 +669,7 @@ For more information on this, and how to apply and follow the GNU AGPL, see
 
 ```
 
-## attest 0.1.0, device-transfer 0.1.0, libsignal-bridge 0.1.0, libsignal-bridge-macros 0.1.0, libsignal-core 0.1.0, libsignal-ffi 0.43.0, libsignal-jni 0.43.0, libsignal-message-backup 0.1.0, libsignal-message-backup-macros 0.1.0, libsignal-net 0.1.0, libsignal-node 0.43.0, libsignal-protocol 0.1.0, libsignal-svr3 0.1.0, poksho 0.7.0, signal-crypto 0.1.0, signal-media 0.1.0, signal-neon-futures 0.1.0, signal-neon-futures-tests 0.1.0, signal-pin 0.1.0, usernames 0.1.0, zkcredential 0.1.0, zkgroup 0.9.0
+## attest 0.1.0, device-transfer 0.1.0, libsignal-bridge 0.1.0, libsignal-bridge-macros 0.1.0, libsignal-core 0.1.0, libsignal-ffi 0.44.0, libsignal-jni 0.44.0, libsignal-message-backup 0.1.0, libsignal-message-backup-macros 0.1.0, libsignal-net 0.1.0, libsignal-node 0.44.0, libsignal-protocol 0.1.0, libsignal-svr3 0.1.0, poksho 0.7.0, signal-crypto 0.1.0, signal-media 0.1.0, signal-neon-futures 0.1.0, signal-neon-futures-tests 0.1.0, signal-pin 0.1.0, usernames 0.1.0, zkcredential 0.1.0, zkgroup 0.9.0
 
 ```
 GNU AFFERO GENERAL PUBLIC LICENSE

package/dist/net.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import type { ReadonlyDeep } from 'type-fest';
 import * as Native from '../Native';
+import { Wrapper } from '../Native';
 export declare enum Environment {
     Staging = 0,
     Production = 1
@@ -33,31 +34,34 @@ export type ChatRequest = Readonly<{
     body?: Uint8Array;
     timeoutMillis?: number;
 }>;
-export declare class Net {
-    private readonly _asyncContext;
-    private readonly _chatService;
-    private readonly _connectionManager;
-    /**
-     * Instance of the {@link Svr3Client} to access SVR3.
-     */
-    svr3: Svr3Client;
-    constructor(env: Environment);
+type TokioAsyncContext = Wrapper<Native.TokioAsyncContext>;
+type ConnectionManager = Wrapper<Native.ConnectionManager>;
+/**
+ * Provides API methods to connect and communicate with the Chat Service.
+ * Before using either authenticated or unauthenticated channels,
+ * a corresponding `connect*` method must be called.
+ * It's also important to call {@link #disconnect()} method when the instance is no longer needed.
+ */
+export declare class ChatService {
+    private readonly asyncContext;
+    private readonly chatService;
+    constructor(asyncContext: TokioAsyncContext, connectionManager: ConnectionManager);
     /**
      * Initiates termination of the underlying connection to the Chat Service. After the service is
      * disconnected, it will not attempt to automatically reconnect until you call
-     * {@link Net#connectAuthenticatedChatService} and/or {@link Net#connectUnauthenticatedChatService}.
+     * {@link #connectAuthenticated()} and/or {@link #connectUnauthenticated()}.
      *
-     * Note: the same instance of {@code ChatService} can be reused after {@code disconnect()} was
+     * Note: the same instance of `ChatService` can be reused after `disconnect()` was
      * called.
      */
-    disconnectChatService(): Promise<void>;
+    disconnect(): Promise<void>;
     /**
      * Initiates establishing of the underlying unauthenticated connection to the Chat Service. Once
      * the service is connected, all the requests will be using the established connection. Also, if
      * the connection is lost for any reason other than the call to {@link #disconnect()}, an
      * automatic reconnect attempt will be made.
      */
-    connectUnauthenticatedChatService(): Promise<Native.ChatServiceDebugInfo>;
+    connectUnauthenticated(): Promise<Native.ChatServiceDebugInfo>;
     /**
      * Initiates establishing of the underlying authenticated connection to the Chat Service. Once the
      * service is connected, all the requests will be using the established connection. Also, if the
@@ -66,25 +70,53 @@ export declare class Net {
      *
      * Calling this method will result in starting to accept incoming requests from the Chat Service.
      */
-    connectAuthenticatedChatService(): Promise<Native.ChatServiceDebugInfo>;
+    connectAuthenticated(): Promise<Native.ChatServiceDebugInfo>;
     /**
      * Sends request to the Chat Service over an unauthenticated channel.
      *
      * In addition to the response, an object containing debug information about the request flow is
      * returned.
      *
-     * @throws {ChatServiceInactive} if you haven't called {@link Net#connectUnauthenticatedChatService()}.
+     * @throws {ChatServiceInactive} if you haven't called {@link #connectUnauthenticated()}.
      */
     unauthenticatedFetchAndDebug(chatRequest: ChatRequest): Promise<Native.ResponseAndDebugInfo>;
     /**
      * Sends request to the Chat Service over an unauthenticated channel.
      *
-     * @throws {ChatServiceInactive} if you haven't called {@link Net#connectUnauthenticatedChatService()}.
+     * @throws {ChatServiceInactive} if you haven't called {@link #connectUnauthenticated()}.
      */
     unauthenticatedFetch(chatRequest: ChatRequest): Promise<Native.ChatResponse>;
     static buildHttpRequest(chatRequest: ChatRequest): {
         _nativeHandle: Native.HttpRequest;
     };
+}
+export declare class Net {
+    private readonly asyncContext;
+    private readonly connectionManager;
+    /**
+     * Instance of the {@link Svr3Client} to access SVR3.
+     */
+    svr3: Svr3Client;
+    constructor(env: Environment);
+    /**
+     * Creates a new instance of {@link ChatService}.
+     */
+    newChatService(): ChatService;
+    /**
+     * Sets the proxy host to be used for all new connections (until overridden).
+     *
+     * Sets a domain name and port to be used to proxy all new outgoing
+     * connections. The proxy can be overridden by calling this method again or
+     * unset by calling {@link #clearProxy}.
+     */
+    setProxy(host: string, port: number): void;
+    /**
+     * Ensures that future connections will be made directly, not through a proxy.
+     *
+     * Clears any proxy configuration set via {@link #setProxy}. If none was set, calling this
+     * method is a no-op.
+     */
+    clearProxy(): void;
     cdsiLookup({ username, password }: Readonly<ServiceAuth>, { e164s, acisAndAccessKeys, returnAcisWithoutUaks, }: ReadonlyDeep<CDSRequestOptionsType>): Promise<CDSResponseType<string, string>>;
 }
 /**
@@ -180,3 +212,4 @@ export interface Svr3Client {
      */
     restore(password: string, shareSet: Buffer, auth: Readonly<ServiceAuth>): Promise<Buffer>;
 }
+export {};

package/dist/net.js

@@ -4,7 +4,7 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 //
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Net = exports.Environment = void 0;
+exports.Net = exports.ChatService = exports.Environment = void 0;
 const Native = require("../Native");
 const Address_1 = require("./Address");
 const DEFAULT_CHAT_REQUEST_TIMEOUT_MILLIS = 5000;
@@ -14,27 +14,32 @@ var Environment;
     Environment[Environment["Staging"] = 0] = "Staging";
     Environment[Environment["Production"] = 1] = "Production";
 })(Environment = exports.Environment || (exports.Environment = {}));
-class Net {
-    constructor(env) {
-        this._asyncContext = { _nativeHandle: Native.TokioAsyncContext_new() };
-        this._connectionManager = {
-            _nativeHandle: Native.ConnectionManager_new(env),
-        };
-        this._chatService = {
-            _nativeHandle: Native.ChatService_new(this._connectionManager, '', ''),
-        };
-        this.svr3 = new Svr3ClientImpl(this._asyncContext, this._connectionManager);
+function newNativeHandle(handle) {
+    return {
+        _nativeHandle: handle,
+    };
+}
+/**
+ * Provides API methods to connect and communicate with the Chat Service.
+ * Before using either authenticated or unauthenticated channels,
+ * a corresponding `connect*` method must be called.
+ * It's also important to call {@link #disconnect()} method when the instance is no longer needed.
+ */
+class ChatService {
+    constructor(asyncContext, connectionManager) {
+        this.asyncContext = asyncContext;
+        this.chatService = newNativeHandle(Native.ChatService_new(connectionManager, '', ''));
     }
     /**
      * Initiates termination of the underlying connection to the Chat Service. After the service is
      * disconnected, it will not attempt to automatically reconnect until you call
-     * {@link Net#connectAuthenticatedChatService} and/or {@link Net#connectUnauthenticatedChatService}.
+     * {@link #connectAuthenticated()} and/or {@link #connectUnauthenticated()}.
      *
-     * Note: the same instance of {@code ChatService} can be reused after {@code disconnect()} was
+     * Note: the same instance of `ChatService` can be reused after `disconnect()` was
      * called.
      */
-    async disconnectChatService() {
-        await Native.ChatService_disconnect(this._asyncContext, this._chatService);
+    async disconnect() {
+        await Native.ChatService_disconnect(this.asyncContext, this.chatService);
     }
     /**
      * Initiates establishing of the underlying unauthenticated connection to the Chat Service. Once
@@ -42,8 +47,8 @@ class Net {
      * the connection is lost for any reason other than the call to {@link #disconnect()}, an
      * automatic reconnect attempt will be made.
      */
-    async connectUnauthenticatedChatService() {
-        return await Native.ChatService_connect_unauth(this._asyncContext, this._chatService);
+    async connectUnauthenticated() {
+        return await Native.ChatService_connect_unauth(this.asyncContext, this.chatService);
     }
     /**
      * Initiates establishing of the underlying authenticated connection to the Chat Service. Once the
@@ -53,8 +58,8 @@ class Net {
      *
      * Calling this method will result in starting to accept incoming requests from the Chat Service.
      */
-    async connectAuthenticatedChatService() {
-        return await Native.ChatService_connect_auth(this._asyncContext, this._chatService);
+    async connectAuthenticated() {
+        return await Native.ChatService_connect_auth(this.asyncContext, this.chatService);
     }
     /**
      * Sends request to the Chat Service over an unauthenticated channel.
@@ -62,18 +67,18 @@ class Net {
      * In addition to the response, an object containing debug information about the request flow is
      * returned.
      *
-     * @throws {ChatServiceInactive} if you haven't called {@link Net#connectUnauthenticatedChatService()}.
+     * @throws {ChatServiceInactive} if you haven't called {@link #connectUnauthenticated()}.
      */
     async unauthenticatedFetchAndDebug(chatRequest) {
-        return await Native.ChatService_unauth_send_and_debug(this._asyncContext, this._chatService, Net.buildHttpRequest(chatRequest), chatRequest.timeoutMillis ?? DEFAULT_CHAT_REQUEST_TIMEOUT_MILLIS);
+        return await Native.ChatService_unauth_send_and_debug(this.asyncContext, this.chatService, ChatService.buildHttpRequest(chatRequest), chatRequest.timeoutMillis ?? DEFAULT_CHAT_REQUEST_TIMEOUT_MILLIS);
     }
     /**
      * Sends request to the Chat Service over an unauthenticated channel.
      *
-     * @throws {ChatServiceInactive} if you haven't called {@link Net#connectUnauthenticatedChatService()}.
+     * @throws {ChatServiceInactive} if you haven't called {@link #connectUnauthenticated()}.
      */
     async unauthenticatedFetch(chatRequest) {
-        return await Native.ChatService_unauth_send(this._asyncContext, this._chatService, Net.buildHttpRequest(chatRequest), chatRequest.timeoutMillis ?? DEFAULT_CHAT_REQUEST_TIMEOUT_MILLIS);
+        return await Native.ChatService_unauth_send(this.asyncContext, this.chatService, ChatService.buildHttpRequest(chatRequest), chatRequest.timeoutMillis ?? DEFAULT_CHAT_REQUEST_TIMEOUT_MILLIS);
     }
     static buildHttpRequest(chatRequest) {
         const { verb, path, body, headers } = chatRequest;
@@ -87,8 +92,41 @@ class Net {
         });
         return httpRequest;
     }
+}
+exports.ChatService = ChatService;
+class Net {
+    constructor(env) {
+        this.asyncContext = newNativeHandle(Native.TokioAsyncContext_new());
+        this.connectionManager = newNativeHandle(Native.ConnectionManager_new(env));
+        this.svr3 = new Svr3ClientImpl(this.asyncContext, this.connectionManager);
+    }
+    /**
+     * Creates a new instance of {@link ChatService}.
+     */
+    newChatService() {
+        return new ChatService(this.asyncContext, this.connectionManager);
+    }
+    /**
+     * Sets the proxy host to be used for all new connections (until overridden).
+     *
+     * Sets a domain name and port to be used to proxy all new outgoing
+     * connections. The proxy can be overridden by calling this method again or
+     * unset by calling {@link #clearProxy}.
+     */
+    setProxy(host, port) {
+        Native.ConnectionManager_set_proxy(this.connectionManager, host, port);
+    }
+    /**
+     * Ensures that future connections will be made directly, not through a proxy.
+     *
+     * Clears any proxy configuration set via {@link #setProxy}. If none was set, calling this
+     * method is a no-op.
+     */
+    clearProxy() {
+        Native.ConnectionManager_clear_proxy(this.connectionManager);
+    }
     async cdsiLookup({ username, password }, { e164s, acisAndAccessKeys, returnAcisWithoutUaks, }) {
-        const request = { _nativeHandle: Native.LookupRequest_new() };
+        const request = newNativeHandle(Native.LookupRequest_new());
         e164s.forEach((e164) => {
             Native.LookupRequest_addE164(request, e164);
         });
@@ -96,23 +134,21 @@ class Net {
             Native.LookupRequest_addAciAndAccessKey(request, Address_1.Aci.parseFromServiceIdString(aciStr).getServiceIdFixedWidthBinary(), Buffer.from(accessKeyStr, 'base64'));
         });
         Native.LookupRequest_setReturnAcisWithoutUaks(request, returnAcisWithoutUaks);
-        const lookup = await Native.CdsiLookup_new(this._asyncContext, this._connectionManager, username, password, request);
-        return await Native.CdsiLookup_complete(this._asyncContext, {
-            _nativeHandle: lookup,
-        });
+        const lookup = await Native.CdsiLookup_new(this.asyncContext, this.connectionManager, username, password, request);
+        return await Native.CdsiLookup_complete(this.asyncContext, newNativeHandle(lookup));
     }
 }
 exports.Net = Net;
 class Svr3ClientImpl {
-    constructor(_asyncContext, _connectionManager) {
-        this._asyncContext = _asyncContext;
-        this._connectionManager = _connectionManager;
+    constructor(asyncContext, connectionManager) {
+        this.asyncContext = asyncContext;
+        this.connectionManager = connectionManager;
     }
     async backup(what, password, maxTries, auth) {
-        return Native.Svr3Backup(this._asyncContext, this._connectionManager, what, password, maxTries, auth.username, auth.password);
+        return Native.Svr3Backup(this.asyncContext, this.connectionManager, what, password, maxTries, auth.username, auth.password);
     }
     async restore(password, shareSet, auth) {
-        return Native.Svr3Restore(this._asyncContext, this._connectionManager, password, shareSet, auth.username, auth.password);
+        return Native.Svr3Restore(this.asyncContext, this.connectionManager, password, shareSet, auth.username, auth.password);
     }
 }
 //# sourceMappingURL=net.js.map

package/package.json

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