@signalapp/libsignal-client 0.67.4 → 0.68.0

package/Native.d.ts

@@ -130,6 +130,8 @@ type ChatListener = {
   ): void;
 };
 
+type RequestedInformation = 'pushChallenge' | 'captcha';
+
 type Wrapper<T> = Readonly<{
   _nativeHandle: T;
 }>;
@@ -406,6 +408,21 @@ export function ReceiptCredentialResponse_CheckValidContents(buffer: Buffer): vo
 export function ReceiptCredential_CheckValidContents(buffer: Buffer): void;
 export function ReceiptCredential_GetReceiptExpirationTime(receiptCredential: Serialized<ReceiptCredential>): Timestamp;
 export function ReceiptCredential_GetReceiptLevel(receiptCredential: Serialized<ReceiptCredential>): bigint;
+export function RegistrationService_CreateSession(asyncRuntime: Wrapper<TokioAsyncContext>, createSession: CreateSession, connectChat: ConnectChatBridge): CancellablePromise<RegistrationService>;
+export function RegistrationService_RegistrationSession(service: Wrapper<RegistrationService>): RegistrationSession;
+export function RegistrationService_RequestPushChallenge(asyncRuntime: Wrapper<TokioAsyncContext>, service: Wrapper<RegistrationService>, pushToken: string, pushTokenType: PushTokenType): CancellablePromise<void>;
+export function RegistrationService_RequestVerificationCode(asyncRuntime: Wrapper<TokioAsyncContext>, service: Wrapper<RegistrationService>, transport: string, client: string): CancellablePromise<void>;
+export function RegistrationService_ResumeSession(asyncRuntime: Wrapper<TokioAsyncContext>, sessionId: string, connectChat: ConnectChatBridge): CancellablePromise<RegistrationService>;
+export function RegistrationService_SessionId(service: Wrapper<RegistrationService>): string;
+export function RegistrationService_SubmitCaptcha(asyncRuntime: Wrapper<TokioAsyncContext>, service: Wrapper<RegistrationService>, captchaValue: string): CancellablePromise<void>;
+export function RegistrationService_SubmitPushChallenge(asyncRuntime: Wrapper<TokioAsyncContext>, service: Wrapper<RegistrationService>, pushChallenge: string): CancellablePromise<void>;
+export function RegistrationService_SubmitVerificationCode(asyncRuntime: Wrapper<TokioAsyncContext>, service: Wrapper<RegistrationService>, code: string): CancellablePromise<void>;
+export function RegistrationSession_GetAllowedToRequestCode(session: Wrapper<RegistrationSession>): boolean;
+export function RegistrationSession_GetNextCallSeconds(session: Wrapper<RegistrationSession>): number | null;
+export function RegistrationSession_GetNextSmsSeconds(session: Wrapper<RegistrationSession>): number | null;
+export function RegistrationSession_GetNextVerificationAttemptSeconds(session: Wrapper<RegistrationSession>): number | null;
+export function RegistrationSession_GetRequestedInformation(session: Wrapper<RegistrationSession>): RequestedInformation[];
+export function RegistrationSession_GetVerified(session: Wrapper<RegistrationSession>): boolean;
 export function SanitizedMetadata_GetDataLen(sanitized: Wrapper<SanitizedMetadata>): bigint;
 export function SanitizedMetadata_GetDataOffset(sanitized: Wrapper<SanitizedMetadata>): bigint;
 export function SanitizedMetadata_GetMetadata(sanitized: Wrapper<SanitizedMetadata>): Buffer;
@@ -522,6 +539,7 @@ export function TESTING_CdsiLookupErrorConvert(errorDescription: string): void;
 export function TESTING_CdsiLookupResponseConvert(asyncRuntime: Wrapper<TokioAsyncContext>): CancellablePromise<LookupResponse>;
 export function TESTING_ChatConnectErrorConvert(errorDescription: string): void;
 export function TESTING_ChatRequestGetBody(request: Wrapper<HttpRequest>): Buffer;
+export function TESTING_ChatRequestGetHeaderNames(request: Wrapper<HttpRequest>): string[];
 export function TESTING_ChatRequestGetHeaderValue(request: Wrapper<HttpRequest>, headerName: string): string;
 export function TESTING_ChatRequestGetMethod(request: Wrapper<HttpRequest>): string;
 export function TESTING_ChatRequestGetPath(request: Wrapper<HttpRequest>): string;
@@ -538,6 +556,7 @@ export function TESTING_ErrorOnReturnSync(_needsCleanup: null): null;
 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_FakeChatConnection_TakeUnauthenticatedChat(chat: Wrapper<FakeChatConnection>): UnauthenticatedChatConnection;
 export function TESTING_FakeChatRemoteEnd_InjectConnectionInterrupted(chat: Wrapper<FakeChatRemoteEnd>): void;
 export function TESTING_FakeChatRemoteEnd_ReceiveIncomingRequest(asyncRuntime: Wrapper<TokioAsyncContext>, chat: Wrapper<FakeChatRemoteEnd>): CancellablePromise<FakeChatSentRequest | null>;
 export function TESTING_FakeChatRemoteEnd_SendRawServerRequest(chat: Wrapper<FakeChatRemoteEnd>, bytes: Buffer): void;
@@ -565,6 +584,7 @@ export function TESTING_PanicOnReturnAsync(_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_RegistrationSessionInfoConvert(): RegistrationSession;
 export function TESTING_ReturnStringArray(): string[];
 export function TESTING_RoundTripI32(input: number): number;
 export function TESTING_RoundTripU16(input: number): number;
@@ -650,6 +670,8 @@ interface ReceiptCredentialPresentation { readonly __type: unique symbol; }
 interface ReceiptCredentialRequest { readonly __type: unique symbol; }
 interface ReceiptCredentialRequestContext { readonly __type: unique symbol; }
 interface ReceiptCredentialResponse { readonly __type: unique symbol; }
+interface RegistrationService { readonly __type: unique symbol; }
+interface RegistrationSession { readonly __type: unique symbol; }
 interface SanitizedMetadata { readonly __type: unique symbol; }
 interface SealedSenderDecryptionResult { readonly __type: unique symbol; }
 interface SenderCertificate { readonly __type: unique symbol; }

package/dist/MessageBackup.js

@@ -85,9 +85,17 @@ var Purpose;
  * @see OnlineBackupValidator
  */
 async function validate(backupKey, purpose, inputFactory, length) {
-    const firstStream = inputFactory();
-    const secondStream = inputFactory();
-    return new ValidationOutcome(await Native.MessageBackupValidator_Validate(backupKey, firstStream, secondStream, length, purpose));
+    let firstStream;
+    let secondStream;
+    try {
+        firstStream = inputFactory();
+        secondStream = inputFactory();
+        return new ValidationOutcome(await Native.MessageBackupValidator_Validate(backupKey, firstStream, secondStream, length, purpose));
+    }
+    finally {
+        await firstStream?.close();
+        await secondStream?.close();
+    }
 }
 exports.validate = validate;
 /**

package/dist/io.d.ts

@@ -7,6 +7,12 @@ import type { Buffer } from 'node:buffer';
 export declare abstract class InputStream implements Native.InputStream {
     _read(amount: number): Promise<Buffer>;
     _skip(amount: number): Promise<void>;
+    /**
+     * Called to indicate the stream's resources should be released.
+     *
+     * The default implementation does nothing and completes immediately. Subclasses should not expect
+     */
+    close(): Promise<void>;
     /**
      * Read an amount of bytes from the input stream.
      *

package/dist/io.js

@@ -15,6 +15,14 @@ class InputStream {
     _skip(amount) {
         return this.skip(amount);
     }
+    /**
+     * Called to indicate the stream's resources should be released.
+     *
+     * The default implementation does nothing and completes immediately. Subclasses should not expect
+     */
+    close() {
+        return Promise.resolve();
+    }
 }
 exports.InputStream = InputStream;
 //# sourceMappingURL=io.js.map

package/dist/net/Chat.d.ts

@@ -86,6 +86,15 @@ export declare class UnauthenticatedChatConnection implements ChatConnection {
     static connect(asyncContext: TokioAsyncContext, connectionManager: ConnectionManager, listener: ConnectionEventsListener, options?: {
         abortSignal?: AbortSignal;
     }): Promise<UnauthenticatedChatConnection>;
+    /**
+     * 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 UnauthenticatedChatConnection} and handle for the remote
+     * end of the fake connection.
+     */
+    static fakeConnect(asyncContext: TokioAsyncContext, listener: ChatServiceListener): [UnauthenticatedChatConnection, Wrapper<Native.FakeChatRemoteEnd>];
     private constructor();
     fetch(chatRequest: ChatRequest, options?: {
         abortSignal?: AbortSignal;

package/dist/net/Chat.js

@@ -49,6 +49,23 @@ class UnauthenticatedChatConnection {
         Native.UnauthenticatedChatConnection_init_listener(connection, new WeakListenerWrapper(nativeChatListener));
         return new UnauthenticatedChatConnection(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 UnauthenticatedChatConnection} and handle for the remote
+     * end of the fake connection.
+     */
+    static fakeConnect(asyncContext, listener) {
+        const nativeChatListener = makeNativeChatListener(asyncContext, listener);
+        const fakeChat = (0, net_1.newNativeHandle)(Native.TESTING_FakeChatConnection_Create(asyncContext, new WeakListenerWrapper(nativeChatListener), ''));
+        const chat = (0, net_1.newNativeHandle)(Native.TESTING_FakeChatConnection_TakeUnauthenticatedChat(fakeChat));
+        return [
+            new UnauthenticatedChatConnection(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.
@@ -172,8 +189,10 @@ function makeNativeChatListener(asyncContext, listener) {
         _queue_empty() {
             throw new Error('Event not supported on unauthenticated connection');
         },
-        _received_alerts(_alerts) {
-            throw new Error('Event not supported on unauthenticated connection');
+        _received_alerts(alerts) {
+            if (alerts.length != 0) {
+                throw new Error(`Got ${alerts.length} unexpected alerts on an unauthenticated connection`);
+            }
         },
         _connection_interrupted(cause) {
             listener.onConnectionInterrupted(cause);

package/dist/net/Registration.d.ts

@@ -0,0 +1,88 @@
+import type { ReadonlyDeep } from 'type-fest';
+import * as Native from '../../Native';
+import { type TokioAsyncContext } from '../net';
+type ConnectionManager = Native.Wrapper<Native.ConnectionManager>;
+type RegistrationOptions = {
+    tokioAsyncContext: TokioAsyncContext;
+    connectionManager: ConnectionManager;
+    connectionTimeoutMillis?: number;
+};
+export type RegistrationSessionState = {
+    allowedToRequestCode: boolean;
+    verified: boolean;
+    nextSmsSecs?: number;
+    nextCallSecs?: number;
+    nextVerificationAttemptSecs?: number;
+    requestedInformation: Set<'pushChallenge' | 'captcha'>;
+};
+/**
+ * A client for the Signal registration service.
+ *
+ * This wraps a {@link Net} to provide a reliable registration service client.
+ */
+export declare class RegistrationService {
+    readonly _nativeHandle: Native.RegistrationService;
+    private readonly tokioAsyncContext;
+    private constructor();
+    /**
+     * The stable identifier for the session.
+     *
+     * This can be persisted and used later for resuming a session that was
+     * interrupted.
+     */
+    get sessionId(): string;
+    /**
+     * The last known state of the session.
+     *
+     * The state received from the server is stored internally and is exposed via
+     * this property.
+     */
+    get sessionState(): RegistrationSessionState;
+    /**
+     * Resumes a previously created registration session.
+     *
+     * Asynchronously connects to the registration session and verifies that the
+     * session is still available. If so, returns an initialized
+     * `RegistrationService`. Otherwise the returned `Promise` is resolved with an
+     * error.
+     *
+     * Clients should not use this method directly, but should instead call
+     * {@link Net.resumeRegistrationSession}.
+     *
+     * @returns a `Promise` that resolves to the `RegistrationService` if
+     * resumption is successful, otherwise a {@link LibSignalError}.
+     */
+    static resumeSession(options: ReadonlyDeep<RegistrationOptions>, { sessionId }: {
+        sessionId: string;
+    }): Promise<RegistrationService>;
+    /**
+     * Starts a new registration session.
+     *
+     * Asynchronously connects to the registration session and requests a new session.
+     * If successful, returns an initialized `RegistrationService`. Otherwise the
+     * returned `Promise` is resolved with an error.
+     *
+     * Clients should not use this method directly, but should instead call
+     * {@link Net.createRegistrationSession}.
+     *
+     * @returns a `Promise` that resolves to the `RegistrationService` if
+     * creation is successful, otherwise a {@link RateLimitedError} or other
+     * {@link LibSignalError}.
+     */
+    static createSession(options: ReadonlyDeep<RegistrationOptions>, { e164 }: {
+        e164: string;
+    }): Promise<RegistrationService>;
+    submitCaptcha(captcha: string): Promise<{
+        allowedToRequestCode: boolean;
+    }>;
+    requestVerification({ transport, client, }: {
+        transport: 'sms' | 'voice';
+        client: string;
+    }): Promise<void>;
+    verifySession(code: string): Promise<boolean>;
+    /**
+     *  Internal, only public for testing
+     */
+    static _convertNativeSessionState(session: Native.Wrapper<Native.RegistrationSession>): RegistrationSessionState;
+}
+export {};

package/dist/net/Registration.js

@@ -0,0 +1,105 @@
+"use strict";
+//
+// Copyright 2025 Signal Messenger, LLC.
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistrationService = void 0;
+const Native = require("../../Native");
+const net_1 = require("../net");
+/**
+ * A client for the Signal registration service.
+ *
+ * This wraps a {@link Net} to provide a reliable registration service client.
+ */
+class RegistrationService {
+    constructor(_nativeHandle, tokioAsyncContext) {
+        this._nativeHandle = _nativeHandle;
+        this.tokioAsyncContext = tokioAsyncContext;
+    }
+    /**
+     * The stable identifier for the session.
+     *
+     * This can be persisted and used later for resuming a session that was
+     * interrupted.
+     */
+    get sessionId() {
+        return Native.RegistrationService_SessionId(this);
+    }
+    /**
+     * The last known state of the session.
+     *
+     * The state received from the server is stored internally and is exposed via
+     * this property.
+     */
+    get sessionState() {
+        return RegistrationService._convertNativeSessionState((0, net_1.newNativeHandle)(Native.RegistrationService_RegistrationSession(this)));
+    }
+    /**
+     * Resumes a previously created registration session.
+     *
+     * Asynchronously connects to the registration session and verifies that the
+     * session is still available. If so, returns an initialized
+     * `RegistrationService`. Otherwise the returned `Promise` is resolved with an
+     * error.
+     *
+     * Clients should not use this method directly, but should instead call
+     * {@link Net.resumeRegistrationSession}.
+     *
+     * @returns a `Promise` that resolves to the `RegistrationService` if
+     * resumption is successful, otherwise a {@link LibSignalError}.
+     */
+    static async resumeSession(options, { sessionId }) {
+        const session = await Native.RegistrationService_ResumeSession(options.tokioAsyncContext, sessionId, options.connectionManager);
+        return new RegistrationService(session, options.tokioAsyncContext);
+    }
+    /**
+     * Starts a new registration session.
+     *
+     * Asynchronously connects to the registration session and requests a new session.
+     * If successful, returns an initialized `RegistrationService`. Otherwise the
+     * returned `Promise` is resolved with an error.
+     *
+     * Clients should not use this method directly, but should instead call
+     * {@link Net.createRegistrationSession}.
+     *
+     * @returns a `Promise` that resolves to the `RegistrationService` if
+     * creation is successful, otherwise a {@link RateLimitedError} or other
+     * {@link LibSignalError}.
+     */
+    static async createSession(options, { e164 }) {
+        const session = await Native.RegistrationService_CreateSession(options.tokioAsyncContext, { number: e164 }, options.connectionManager);
+        return new RegistrationService(session, options.tokioAsyncContext);
+    }
+    async submitCaptcha(captcha) {
+        await Native.RegistrationService_SubmitCaptcha(this.tokioAsyncContext, this, captcha);
+        return this.sessionState;
+    }
+    async requestVerification({ transport, client, }) {
+        await Native.RegistrationService_RequestVerificationCode(this.tokioAsyncContext, this, transport, client);
+    }
+    async verifySession(code) {
+        await Native.RegistrationService_SubmitVerificationCode(this.tokioAsyncContext, this, code);
+        return this.sessionState.verified;
+    }
+    /**
+     *  Internal, only public for testing
+     */
+    static _convertNativeSessionState(session) {
+        const nextCallSecs = Native.RegistrationSession_GetNextCallSeconds(session);
+        const nextSmsSecs = Native.RegistrationSession_GetNextSmsSeconds(session);
+        const nextVerificationAttemptSecs = Native.RegistrationSession_GetNextVerificationAttemptSeconds(session);
+        return {
+            allowedToRequestCode: Native.RegistrationSession_GetAllowedToRequestCode(session),
+            verified: Native.RegistrationSession_GetVerified(session),
+            nextCallSecs: nextCallSecs != null ? nextCallSecs : undefined,
+            nextSmsSecs: nextSmsSecs != null ? nextSmsSecs : undefined,
+            nextVerificationAttemptSecs: nextVerificationAttemptSecs != null
+                ? nextVerificationAttemptSecs
+                : undefined,
+            requestedInformation: new Set(Native.RegistrationSession_GetRequestedInformation(session)),
+        };
+    }
+}
+exports.RegistrationService = RegistrationService;
+//# sourceMappingURL=Registration.js.map

package/dist/net.d.ts

@@ -4,8 +4,10 @@ import * as Native from '../Native';
 import { Buffer } from 'node:buffer';
 import { CDSRequestOptionsType, CDSResponseType } from './net/CDSI';
 import { ConnectionEventsListener, UnauthenticatedChatConnection, AuthenticatedChatConnection, ChatServiceListener } from './net/Chat';
+import { RegistrationService } from './net/Registration';
 export * from './net/CDSI';
 export * from './net/Chat';
+export * from './net/Registration';
 export declare enum Environment {
     Staging = 0,
     Production = 1
@@ -87,6 +89,14 @@ export declare class Net {
     connectAuthenticatedChat(username: string, password: string, receiveStories: boolean, listener: ChatServiceListener, options?: {
         abortSignal?: AbortSignal;
     }): Promise<AuthenticatedChatConnection>;
+    resumeRegistrationSession({ sessionId, connectionTimeoutMillis, }: {
+        sessionId: string;
+        connectionTimeoutMillis?: number;
+    }): Promise<RegistrationService>;
+    createRegistrationSession({ e164, connectionTimeoutMillis, }: {
+        e164: string;
+        connectionTimeoutMillis?: number;
+    }): Promise<RegistrationService>;
     /**
      * Enables/disables IPv6 for all new connections (until changed).
      *

package/dist/net.js

@@ -22,8 +22,10 @@ exports.Net = exports.SIGNAL_TLS_PROXY_SCHEME = exports.TokioAsyncContext = expo
 const Native = require("../Native");
 const CDSI_1 = require("./net/CDSI");
 const Chat_1 = require("./net/Chat");
+const Registration_1 = require("./net/Registration");
 __exportStar(require("./net/CDSI"), exports);
 __exportStar(require("./net/Chat"), exports);
+__exportStar(require("./net/Registration"), exports);
 // This must match the libsignal-bridge Rust enum of the same name.
 var Environment;
 (function (Environment) {
@@ -101,6 +103,20 @@ class Net {
     connectAuthenticatedChat(username, password, receiveStories, listener, options) {
         return Chat_1.AuthenticatedChatConnection.connect(this.asyncContext, this._connectionManager, username, password, receiveStories, listener, options);
     }
+    async resumeRegistrationSession({ sessionId, connectionTimeoutMillis, }) {
+        return Registration_1.RegistrationService.resumeSession({
+            connectionManager: this._connectionManager,
+            tokioAsyncContext: this.asyncContext,
+            connectionTimeoutMillis: connectionTimeoutMillis,
+        }, { sessionId });
+    }
+    async createRegistrationSession({ e164, connectionTimeoutMillis, }) {
+        return Registration_1.RegistrationService.createSession({
+            connectionManager: this._connectionManager,
+            tokioAsyncContext: this.asyncContext,
+            connectionTimeoutMillis: connectionTimeoutMillis,
+        }, { e164 });
+    }
     /**
      * Enables/disables IPv6 for all new connections (until changed).
      *

package/package.json

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