@signalapp/libsignal-client 0.65.4 → 0.65.5

package/Native.d.ts

@@ -233,8 +233,10 @@ export function ConnectionManager_clear_proxy(connectionManager: Wrapper<Connect
 export function ConnectionManager_new(environment: number, userAgent: string): ConnectionManager;
 export function ConnectionManager_on_network_change(connectionManager: Wrapper<ConnectionManager>): void;
 export function ConnectionManager_set_censorship_circumvention_enabled(connectionManager: Wrapper<ConnectionManager>, enabled: boolean): void;
+export function ConnectionManager_set_invalid_proxy(connectionManager: Wrapper<ConnectionManager>): void;
 export function ConnectionManager_set_ipv6_enabled(connectionManager: Wrapper<ConnectionManager>, ipv6Enabled: boolean): void;
-export function ConnectionManager_set_proxy(connectionManager: Wrapper<ConnectionManager>, host: string, port: number): void;
+export function ConnectionManager_set_proxy(connectionManager: Wrapper<ConnectionManager>, proxy: Wrapper<ConnectionProxyConfig>): void;
+export function ConnectionProxyConfig_new(scheme: string, host: string, port: number, username: string | null, password: string | null): ConnectionProxyConfig;
 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;
@@ -537,6 +539,7 @@ export function TESTING_ChatServiceResponseConvert(bodyPresent: boolean): ChatRe
 export function TESTING_ChatService_InjectConnectionInterrupted(chat: Wrapper<AuthChat>): void;
 export function TESTING_ChatService_InjectIntentionalDisconnect(chat: Wrapper<AuthChat>): void;
 export function TESTING_ChatService_InjectRawServerRequest(chat: Wrapper<AuthChat>, bytes: Buffer): void;
+export function TESTING_ConnectionManager_isUsingProxy(manager: Wrapper<ConnectionManager>): number;
 export function TESTING_ConnectionManager_newLocalOverride(userAgent: string, chatPort: number, cdsiPort: number, svr2Port: number, svr3SgxPort: number, svr3NitroPort: number, svr3Tpm2SnpPort: number, rootCertificateDer: Buffer): ConnectionManager;
 export function TESTING_ErrorOnBorrowAsync(_input: null): Promise<void>;
 export function TESTING_ErrorOnBorrowIo(asyncRuntime: Wrapper<NonSuspendingBackgroundThreadRuntime>, _input: null): CancellablePromise<void>;
@@ -544,6 +547,11 @@ 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_TakeAuthenticatedChat(chat: Wrapper<FakeChatConnection>): AuthenticatedChatConnection;
+export function TESTING_FakeChatConnection_TakeRemote(chat: Wrapper<FakeChatConnection>): FakeChatRemoteEnd;
+export function TESTING_FakeChatRemoteEnd_InjectConnectionInterrupted(chat: Wrapper<FakeChatRemoteEnd>): void;
+export function TESTING_FakeChatRemoteEnd_SendRawServerRequest(chat: Wrapper<FakeChatRemoteEnd>, bytes: Buffer): void;
 export function TESTING_FutureFailure(asyncRuntime: Wrapper<NonSuspendingBackgroundThreadRuntime>, _input: number): CancellablePromise<number>;
 export function TESTING_FutureProducesOtherPointerType(asyncRuntime: Wrapper<NonSuspendingBackgroundThreadRuntime>, input: string): CancellablePromise<OtherTestingHandleType>;
 export function TESTING_FutureProducesPointerType(asyncRuntime: Wrapper<NonSuspendingBackgroundThreadRuntime>, input: number): CancellablePromise<TestingHandleType>;
@@ -566,6 +574,11 @@ export function TESTING_PanicOnReturnIo(asyncRuntime: Wrapper<NonSuspendingBackg
 export function TESTING_PanicOnReturnSync(_needsCleanup: null): null;
 export function TESTING_ProcessBytestringArray(input: Buffer[]): Buffer[];
 export function TESTING_ReturnStringArray(): string[];
+export function TESTING_RoundTripI32(input: number): number;
+export function TESTING_RoundTripU16(input: number): number;
+export function TESTING_RoundTripU32(input: number): number;
+export function TESTING_RoundTripU64(input: bigint): bigint;
+export function TESTING_RoundTripU8(input: number): number;
 export function TESTING_ServerMessageAck_Create(): ServerMessageAck;
 export function TESTING_TestingHandleType_getValue(handle: Wrapper<TestingHandleType>): number;
 export function TokioAsyncContext_cancel(context: Wrapper<TokioAsyncContext>, rawCancellationId: bigint): void;
@@ -606,9 +619,12 @@ interface CiphertextMessage { readonly __type: unique symbol; }
 interface ComparableBackup { readonly __type: unique symbol; }
 interface ComparableBackup { readonly __type: unique symbol; }
 interface ConnectionManager { readonly __type: unique symbol; }
+interface ConnectionProxyConfig { readonly __type: unique symbol; }
 interface DecryptionErrorMessage { readonly __type: unique symbol; }
 interface ExpiringProfileKeyCredential { readonly __type: unique symbol; }
 interface ExpiringProfileKeyCredentialResponse { readonly __type: unique symbol; }
+interface FakeChatConnection { readonly __type: unique symbol; }
+interface FakeChatRemoteEnd { readonly __type: unique symbol; }
 interface Fingerprint { readonly __type: unique symbol; }
 interface GroupMasterKey { readonly __type: unique symbol; }
 interface GroupPublicParams { readonly __type: unique symbol; }

package/dist/acknowledgments.md

@@ -669,7 +669,7 @@ For more information on this, and how to apply and follow the GNU AGPL, see
 
 ```
 
-## libsignal-account-keys, attest, libsignal-ffi, libsignal-jni, libsignal-jni-testing, libsignal-node, signal-neon-futures, signal-neon-futures-tests, libsignal-bridge, libsignal-bridge-macros, libsignal-bridge-testing, libsignal-bridge-types, libsignal-core, signal-crypto, device-transfer, libsignal-keytrans, signal-media, libsignal-message-backup, libsignal-message-backup-macros, libsignal-net, libsignal-net-infra, poksho, libsignal-protocol, libsignal-svr3, usernames, zkcredential, zkgroup
+## libsignal-account-keys, attest, libsignal-ffi, libsignal-jni, libsignal-jni-impl, libsignal-jni-testing, libsignal-node, signal-neon-futures, signal-neon-futures-tests, libsignal-bridge, libsignal-bridge-macros, libsignal-bridge-testing, libsignal-bridge-types, libsignal-core, signal-crypto, device-transfer, libsignal-keytrans, signal-media, libsignal-message-backup, libsignal-message-backup-macros, libsignal-net, libsignal-net-infra, poksho, libsignal-protocol, libsignal-svr3, usernames, zkcredential, zkgroup
 
 ```
 GNU AFFERO GENERAL PUBLIC LICENSE

package/dist/net.d.ts

@@ -185,6 +185,15 @@ export declare class AuthenticatedChatConnection implements ChatConnection {
     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;
@@ -244,9 +253,20 @@ export type NetConstructorOptions = Readonly<{
     TESTING_localServer_svr3Tpm2SnpPort: number;
     TESTING_localServer_rootCertificateDer: Buffer;
 }>;
+/** See {@link Net.setProxy()}. */
+export type ProxyOptions = {
+    scheme: string;
+    host: string;
+    port?: number;
+    username?: string;
+    password?: string;
+};
+/** The "scheme" for Signal TLS proxies. See {@link Net.setProxy()}. */
+export declare const SIGNAL_TLS_PROXY_SCHEME = "org.signal.tls";
 export declare class Net {
     private readonly asyncContext;
-    private readonly connectionManager;
+    /** Exposed only for testing. */
+    readonly _connectionManager: ConnectionManager;
     constructor(options: NetConstructorOptions);
     /**
      * Creates a new instance of {@link AuthenticatedChatService}.
@@ -298,18 +318,62 @@ export declare class Net {
     /**
      * 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}.
+     * Sets a server 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}. Omitting the `port` means
+     * the default port for the scheme will be used.
+     *
+     * To specify a Signal transparent TLS proxy, use {@link SIGNAL_TLS_PROXY_SCHEME}, or the
+     * overload that takes a separate domain and port number.
+     *
+     * Throws if the scheme is unsupported or if the provided parameters are invalid for that scheme
+     * (e.g. Signal TLS proxies don't support authentication)
+     */
+    setProxy(options: Readonly<ProxyOptions>): void;
+    /**
+     * Sets the Signal TLS 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, using a Signal
+     * transparent TLS proxy. The proxy can be overridden by calling this method again or unset by
+     * calling {@link #clearProxy}.
      *
      * Throws if the host or port is structurally invalid, such as a port that doesn't fit in u16.
      */
-    setProxy(host: string, port: number): void;
+    setProxy(host: string, port?: number): void;
+    /**
+     * Like {@link #setProxy}, but parses the proxy options from a URL. See there for more
+     * information.
+     *
+     * Takes a string rather than a URL so that an *invalid* string can result in disabling
+     * connections until {@link #clearProxy} is called, consistent with other ways {@link #setProxy}
+     * might consider its parameters invalid.
+     *
+     * Throws if the URL contains unnecessary parts (like a query string), or if the resulting options
+     * are not supported.
+     */
+    setProxyFromUrl(urlString: string): void;
+    /**
+     * Parses a proxy URL into an options object, suitable for passing to {@link #setProxy}.
+     *
+     * It is recommended not to call this directly. Instead, use {@link #setProxyFromUrl}, which will
+     * treat an invalid URL uniformly with one that is structurally valid but unsupported by
+     * libsignal.
+     *
+     * Throws if the URL is known to not be a valid proxy URL; however it's still possible the
+     * resulting options object cannot be used as a proxy.
+     */
+    static proxyOptionsFromUrl(urlString: string): ProxyOptions;
+    /**
+     * Refuses to make any new connections until a new proxy configuration is set or
+     * {@link #clearProxy} is called.
+     *
+     * Existing connections will not be affected.
+     */
+    setInvalidProxy(): 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.
+     * Clears any proxy configuration set via {@link #setProxy} or {@link #setInvalidProxy}. If none
+     * was set, calling this method is a no-op.
      */
     clearProxy(): void;
     /**

package/dist/net.js

@@ -4,7 +4,7 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 //
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Net = exports.buildHttpRequest = exports.UnauthenticatedChatService = exports.AuthenticatedChatService = exports.AuthenticatedChatConnection = exports.UnauthenticatedChatConnection = exports.ChatServerMessageAck = exports.TokioAsyncContext = exports.newNativeHandle = exports.Environment = void 0;
+exports.Net = exports.SIGNAL_TLS_PROXY_SCHEME = exports.buildHttpRequest = exports.UnauthenticatedChatService = exports.AuthenticatedChatService = exports.AuthenticatedChatConnection = exports.UnauthenticatedChatConnection = exports.ChatServerMessageAck = exports.TokioAsyncContext = exports.newNativeHandle = exports.Environment = void 0;
 const Native = require("../Native");
 const Address_1 = require("./Address");
 const node_buffer_1 = require("node:buffer");
@@ -116,6 +116,23 @@ class AuthenticatedChatConnection {
         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.
@@ -263,14 +280,16 @@ function buildHttpRequest(chatRequest) {
     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 {
     constructor(options) {
         this.asyncContext = new TokioAsyncContext(Native.TokioAsyncContext_new());
         if (options.localTestServer) {
-            this.connectionManager = newNativeHandle(Native.TESTING_ConnectionManager_newLocalOverride(options.userAgent, options.TESTING_localServer_chatPort, options.TESTING_localServer_cdsiPort, options.TESTING_localServer_svr2Port, options.TESTING_localServer_svr3SgxPort, options.TESTING_localServer_svr3NitroPort, options.TESTING_localServer_svr3Tpm2SnpPort, options.TESTING_localServer_rootCertificateDer));
+            this._connectionManager = newNativeHandle(Native.TESTING_ConnectionManager_newLocalOverride(options.userAgent, options.TESTING_localServer_chatPort, options.TESTING_localServer_cdsiPort, options.TESTING_localServer_svr2Port, options.TESTING_localServer_svr3SgxPort, options.TESTING_localServer_svr3NitroPort, options.TESTING_localServer_svr3Tpm2SnpPort, options.TESTING_localServer_rootCertificateDer));
         }
         else {
-            this.connectionManager = newNativeHandle(Native.ConnectionManager_new(options.env, options.userAgent));
+            this._connectionManager = newNativeHandle(Native.ConnectionManager_new(options.env, options.userAgent));
         }
     }
     /**
@@ -282,13 +301,13 @@ class Net {
      * to eventually break it (either using a weak reference or by assigning over the strong reference).
      */
     newAuthenticatedChatService(username, password, receiveStories, listener) {
-        return new AuthenticatedChatService(this.asyncContext, this.connectionManager, username, password, receiveStories, listener);
+        return new AuthenticatedChatService(this.asyncContext, this._connectionManager, username, password, receiveStories, listener);
     }
     /**
      * Creates a new instance of {@link UnauthenticatedChatService}.
      */
     newUnauthenticatedChatService(listener) {
-        return new UnauthenticatedChatService(this.asyncContext, this.connectionManager, listener);
+        return new UnauthenticatedChatService(this.asyncContext, this._connectionManager, listener);
     }
     /**
      *
@@ -299,13 +318,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 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 AuthenticatedChatConnection.connect(this.asyncContext, this._connectionManager, username, password, receiveStories, listener, options);
     }
     /**
      * Enables/disables IPv6 for all new connections (until changed).
@@ -313,7 +332,7 @@ class Net {
      * The flag is `true` by default.
      */
     setIpv6Enabled(ipv6Enabled) {
-        Native.ConnectionManager_set_ipv6_enabled(this.connectionManager, ipv6Enabled);
+        Native.ConnectionManager_set_ipv6_enabled(this._connectionManager, ipv6Enabled);
     }
     /**
      * Enables or disables censorship circumvention for all new connections (until changed).
@@ -326,28 +345,108 @@ class Net {
      * CC is off by default.
      */
     setCensorshipCircumventionEnabled(enabled) {
-        Native.ConnectionManager_set_censorship_circumvention_enabled(this.connectionManager, enabled);
+        Native.ConnectionManager_set_censorship_circumvention_enabled(this._connectionManager, enabled);
+    }
+    setProxy(hostOrOptions, portOrNothing) {
+        if (typeof hostOrOptions === 'string') {
+            // Support <username>@<host> syntax to allow UNENCRYPTED_FOR_TESTING as a marker user.
+            // This is not a stable feature of the API and may go away in the future;
+            // the Rust layer will reject any other users anyway. But it's convenient for us.
+            const [before, after] = hostOrOptions.split('@', 2);
+            const [username, domain] = after ? [before, after] : [undefined, before];
+            hostOrOptions = {
+                scheme: exports.SIGNAL_TLS_PROXY_SCHEME,
+                host: domain,
+                port: portOrNothing,
+                username,
+            };
+        }
+        const { scheme, host, port, username, password } = hostOrOptions;
+        try {
+            const proxyConfig = newNativeHandle(Native.ConnectionProxyConfig_new(scheme, host, 
+            // i32::MIN represents "no port provided"; we don't expect anyone to pass that manually.
+            port ?? -2147483648, username ?? null, password ?? null));
+            Native.ConnectionManager_set_proxy(this._connectionManager, proxyConfig);
+        }
+        catch (e) {
+            this.setInvalidProxy();
+            throw e;
+        }
     }
     /**
-     * Sets the proxy host to be used for all new connections (until overridden).
+     * Like {@link #setProxy}, but parses the proxy options from a URL. See there for more
+     * information.
      *
-     * 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}.
+     * Takes a string rather than a URL so that an *invalid* string can result in disabling
+     * connections until {@link #clearProxy} is called, consistent with other ways {@link #setProxy}
+     * might consider its parameters invalid.
+     *
+     * Throws if the URL contains unnecessary parts (like a query string), or if the resulting options
+     * are not supported.
+     */
+    setProxyFromUrl(urlString) {
+        let options;
+        try {
+            options = Net.proxyOptionsFromUrl(urlString);
+        }
+        catch (e) {
+            // Make sure we set an invalid proxy on error,
+            // so no connection can be made until the problem is fixed.
+            this.setInvalidProxy();
+            throw e;
+        }
+        this.setProxy(options);
+    }
+    /**
+     * Parses a proxy URL into an options object, suitable for passing to {@link #setProxy}.
+     *
+     * It is recommended not to call this directly. Instead, use {@link #setProxyFromUrl}, which will
+     * treat an invalid URL uniformly with one that is structurally valid but unsupported by
+     * libsignal.
+     *
+     * Throws if the URL is known to not be a valid proxy URL; however it's still possible the
+     * resulting options object cannot be used as a proxy.
+     */
+    static proxyOptionsFromUrl(urlString) {
+        const url = new URL(urlString);
+        // Check all the parts of the URL.
+        // scheme://username:password@hostname:port/path?query#fragment
+        const scheme = url.protocol.slice(0, -1);
+        // This does not distinguish between "https://proxy.example" and "https://@proxy.example".
+        // This could be done by manually checking `url.href`.
+        // But until someone complains about it, let's not worry about it.
+        const username = url.username != '' ? url.username : undefined;
+        const password = url.password != '' ? url.password : undefined;
+        const host = url.hostname;
+        const port = url.port != '' ? Number.parseInt(url.port, 10) : undefined;
+        if (url.pathname != '' && url.pathname != '/') {
+            throw new Error('proxy URLs should not have path components');
+        }
+        if (url.search != '') {
+            throw new Error('proxy URLs should not have query components');
+        }
+        if (url.hash != '') {
+            throw new Error('proxy URLs should not have fragment components');
+        }
+        return { scheme, username, password, host, port };
+    }
+    /**
+     * Refuses to make any new connections until a new proxy configuration is set or
+     * {@link #clearProxy} is called.
      *
-     * Throws if the host or port is structurally invalid, such as a port that doesn't fit in u16.
+     * Existing connections will not be affected.
      */
-    setProxy(host, port) {
-        Native.ConnectionManager_set_proxy(this.connectionManager, host, port);
+    setInvalidProxy() {
+        Native.ConnectionManager_set_invalid_proxy(this._connectionManager);
     }
     /**
      * 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.
+     * Clears any proxy configuration set via {@link #setProxy} or {@link #setInvalidProxy}. If none
+     * was set, calling this method is a no-op.
      */
     clearProxy() {
-        Native.ConnectionManager_clear_proxy(this.connectionManager);
+        Native.ConnectionManager_clear_proxy(this._connectionManager);
     }
     /**
      * Notifies libsignal that the network has changed.
@@ -355,7 +454,7 @@ class Net {
      * This will lead to, e.g. caches being cleared and cooldowns being reset.
      */
     onNetworkChange() {
-        Native.ConnectionManager_on_network_change(this.connectionManager);
+        Native.ConnectionManager_on_network_change(this._connectionManager);
     }
     async cdsiLookup({ username, password }, { e164s, acisAndAccessKeys, abortSignal, }) {
         const request = newNativeHandle(Native.LookupRequest_new());
@@ -365,7 +464,7 @@ class Net {
         acisAndAccessKeys.forEach(({ aci: aciStr, accessKey: accessKeyStr }) => {
             Native.LookupRequest_addAciAndAccessKey(request, Address_1.Aci.parseFromServiceIdString(aciStr).getServiceIdFixedWidthBinary(), node_buffer_1.Buffer.from(accessKeyStr, 'base64'));
         });
-        const lookup = await this.asyncContext.makeCancellable(abortSignal, Native.CdsiLookup_new(this.asyncContext, this.connectionManager, username, password, request));
+        const lookup = await this.asyncContext.makeCancellable(abortSignal, Native.CdsiLookup_new(this.asyncContext, this._connectionManager, username, password, request));
         return await this.asyncContext.makeCancellable(abortSignal, Native.CdsiLookup_complete(this.asyncContext, newNativeHandle(lookup)));
     }
 }

package/package.json

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