@signalapp/libsignal-client 0.67.6 → 0.68.1

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;
@@ -567,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;
@@ -652,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/acknowledgments.md

@@ -3338,7 +3338,7 @@ THE SOFTWARE.
 
 ```
 
-## either 1.15.0, itertools 0.10.5, itertools 0.14.0, petgraph 0.7.1
+## either 1.15.0, itertools 0.10.5, itertools 0.14.0, petgraph 0.7.1, serde_with 3.12.0, serde_with_macros 3.12.0
 
 ```
 Copyright (c) 2015
@@ -3481,7 +3481,7 @@ DEALINGS IN THE SOFTWARE.
 
 ```
 
-## gimli 0.31.1, heck 0.5.0
+## gimli 0.31.1, heck 0.5.0, unicode-xid 0.2.6
 
 ```
 Copyright (c) 2015 The Rust Project Developers
@@ -4713,38 +4713,6 @@ DEALINGS IN THE SOFTWARE.
 
 ```
 
-## hex-literal 0.4.1
-
-```
-Copyright (c) 2018 Artyom Pavlov
-Copyright (c) 2018 The RustCrypto Project Developers
-
-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.
-
-```
-
 ## bytes 1.10.1
 
 ```

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/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.6",
+  "version": "0.68.1",
   "license": "AGPL-3.0-only",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",