@textrp/briij-js-sdk 41.0.1 → 42.0.0

package/src/rust-crypto/OutgoingRequestsManager.ts

@@ -1,170 +1,170 @@
-/*
-Copyright 2023 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import { type OlmMachine, type OutgoingRequest } from "@matrix-org/matrix-sdk-crypto-wasm";
-
-import { type OutgoingRequestProcessor } from "./OutgoingRequestProcessor.ts";
-import { type Logger } from "../logger.ts";
-import { logDuration } from "../utils.ts";
-
-/**
- * OutgoingRequestsManager: responsible for processing outgoing requests from the OlmMachine.
- * Ensure that only one loop is going on at once, and that the requests are processed in order.
- */
-export class OutgoingRequestsManager {
-    /** whether {@link stop} has been called */
-    private stopped = false;
-
-    /** whether {@link outgoingRequestLoop} is currently running */
-    private outgoingRequestLoopRunning = false;
-
-    /**
-     * If there are additional calls to doProcessOutgoingRequests() while there is a current call running
-     * we need to remember in order to call `doProcessOutgoingRequests` again (as there could be new requests).
-     *
-     * If this is defined, it is an indication that we need to do another iteration; in this case the deferred
-     * will resolve once that next iteration completes. If it is undefined, there have been no new calls
-     * to `doProcessOutgoingRequests` since the current iteration started.
-     */
-    private nextLoopDeferred?: PromiseWithResolvers<void>;
-
-    public constructor(
-        private readonly logger: Logger,
-        private readonly olmMachine: OlmMachine,
-        public readonly outgoingRequestProcessor: OutgoingRequestProcessor,
-    ) {}
-
-    /**
-     * Shut down as soon as possible the current loop of outgoing requests processing.
-     */
-    public stop(): void {
-        this.stopped = true;
-    }
-
-    /**
-     * Process the OutgoingRequests from the OlmMachine.
-     *
-     * This should be called at the end of each sync, to process any OlmMachine OutgoingRequests created by the rust sdk.
-     * In some cases if OutgoingRequests need to be sent immediately, this can be called directly.
-     *
-     * Calls to doProcessOutgoingRequests() are processed synchronously, one after the other, in order.
-     * If doProcessOutgoingRequests() is called while another call is still being processed, it will be queued.
-     * Multiple calls to doProcessOutgoingRequests() when a call is already processing will be batched together.
-     */
-    public doProcessOutgoingRequests(): Promise<void> {
-        // Flag that we need at least one more iteration of the loop.
-        //
-        // It is important that we do this even if the loop is currently running. There is potential for a race whereby
-        // a request is added to the queue *after* `OlmMachine.outgoingRequests` checks the queue, but *before* it
-        // returns. In such a case, the item could sit there unnoticed for some time.
-        //
-        // In order to circumvent the race, we set a flag which tells the loop to go round once again even if the
-        // queue appears to be empty.
-        if (!this.nextLoopDeferred) {
-            this.nextLoopDeferred = Promise.withResolvers();
-        }
-
-        // ... and wait for it to complete.
-        const result = this.nextLoopDeferred.promise;
-
-        // set the loop going if it is not already.
-        if (!this.outgoingRequestLoopRunning) {
-            this.outgoingRequestLoop().catch((e) => {
-                // this should not happen; outgoingRequestLoop should return any errors via `nextLoopDeferred`.
-                /* istanbul ignore next */
-                this.logger.error("Uncaught error in outgoing request loop", e);
-            });
-        }
-        return result;
-    }
-
-    private async outgoingRequestLoop(): Promise<void> {
-        /* istanbul ignore if */
-        if (this.outgoingRequestLoopRunning) {
-            throw new Error("Cannot run two outgoing request loops");
-        }
-        this.outgoingRequestLoopRunning = true;
-        try {
-            while (!this.stopped && this.nextLoopDeferred) {
-                const loopTickResolvers = this.nextLoopDeferred;
-
-                // reset `nextLoopDeferred` so that any future calls to `doProcessOutgoingRequests` are queued
-                // for another additional iteration.
-                this.nextLoopDeferred = undefined;
-
-                // make the requests and feed the results back to the `nextLoopDeferred`
-                await this.processOutgoingRequests().then(loopTickResolvers.resolve, loopTickResolvers.reject);
-            }
-        } finally {
-            this.outgoingRequestLoopRunning = false;
-        }
-
-        if (this.nextLoopDeferred) {
-            // the loop was stopped, but there was a call to `doProcessOutgoingRequests`. Make sure that
-            // we reject the promise in case anything is waiting for it.
-            this.nextLoopDeferred.reject(new Error("OutgoingRequestsManager was stopped"));
-        }
-    }
-
-    /**
-     * Make a single request to `olmMachine.outgoingRequests` and do the corresponding requests.
-     */
-    private async processOutgoingRequests(): Promise<void> {
-        if (this.stopped) return;
-
-        const outgoingRequests: OutgoingRequest[] = await this.olmMachine.outgoingRequests();
-
-        let successes = 0;
-        for (const request of outgoingRequests) {
-            if (this.stopped) return;
-            try {
-                await logDuration(this.logger, `Make outgoing request ${request.type}`, async () => {
-                    await this.outgoingRequestProcessor.makeOutgoingRequest(request);
-                    successes++;
-                });
-            } catch (e) {
-                // as part of the loop we silently ignore errors, but log them.
-                // The rust sdk will retry the request later as it won't have been marked as sent.
-                this.logger.error(`Failed to process outgoing request ${request.type}: ${e}`);
-            }
-        }
-
-        // If we successfully handled any requests this time, more may have been queued as
-        // part of that handling.
-        //
-        // For example, we may have processed a `/keys/claim` request, which
-        // meant the rust side could establish an Olm session and is now ready to
-        // send out an `m.secret.send` message.
-        // (See https://github.com/element-hq/element-web/issues/30988.)
-        //
-        // So, if we have successfully processed any requests, flag that we need to make another
-        // pass around the outgoing-requests loop, to make sure we handle any
-        // pending requests immediately.
-        //
-        // If all requests failed (or there weren't any) we don't want to retry them in a tight
-        // loop. They will be retried after the next sync.
-        // (See https://github.com/element-hq/element-web/issues/31790.)
-        if (successes > 0) {
-            // We call doProcessOutgoingRequests but since we expect that we are
-            // already processing outgoing requests, this call will not kick off
-            // the processing loop, but just set `nextLoopDeferred` and return,
-            // which will mean we loop one more time.
-            this.doProcessOutgoingRequests().catch((e) => {
-                this.logger.warn("processOutgoingRequests: Error re-checking outgoing requests", e);
-            });
-        }
-    }
-}
+/*
+Copyright 2023 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { type OlmMachine, type OutgoingRequest } from "@matrix-org/matrix-sdk-crypto-wasm";
+
+import { type OutgoingRequestProcessor } from "./OutgoingRequestProcessor.ts";
+import { type Logger } from "../logger.ts";
+import { logDuration } from "../utils.ts";
+
+/**
+ * OutgoingRequestsManager: responsible for processing outgoing requests from the OlmMachine.
+ * Ensure that only one loop is going on at once, and that the requests are processed in order.
+ */
+export class OutgoingRequestsManager {
+    /** whether {@link stop} has been called */
+    private stopped = false;
+
+    /** whether {@link outgoingRequestLoop} is currently running */
+    private outgoingRequestLoopRunning = false;
+
+    /**
+     * If there are additional calls to doProcessOutgoingRequests() while there is a current call running
+     * we need to remember in order to call `doProcessOutgoingRequests` again (as there could be new requests).
+     *
+     * If this is defined, it is an indication that we need to do another iteration; in this case the deferred
+     * will resolve once that next iteration completes. If it is undefined, there have been no new calls
+     * to `doProcessOutgoingRequests` since the current iteration started.
+     */
+    private nextLoopDeferred?: PromiseWithResolvers<void>;
+
+    public constructor(
+        private readonly logger: Logger,
+        private readonly olmMachine: OlmMachine,
+        public readonly outgoingRequestProcessor: OutgoingRequestProcessor,
+    ) {}
+
+    /**
+     * Shut down as soon as possible the current loop of outgoing requests processing.
+     */
+    public stop(): void {
+        this.stopped = true;
+    }
+
+    /**
+     * Process the OutgoingRequests from the OlmMachine.
+     *
+     * This should be called at the end of each sync, to process any OlmMachine OutgoingRequests created by the rust sdk.
+     * In some cases if OutgoingRequests need to be sent immediately, this can be called directly.
+     *
+     * Calls to doProcessOutgoingRequests() are processed synchronously, one after the other, in order.
+     * If doProcessOutgoingRequests() is called while another call is still being processed, it will be queued.
+     * Multiple calls to doProcessOutgoingRequests() when a call is already processing will be batched together.
+     */
+    public doProcessOutgoingRequests(): Promise<void> {
+        // Flag that we need at least one more iteration of the loop.
+        //
+        // It is important that we do this even if the loop is currently running. There is potential for a race whereby
+        // a request is added to the queue *after* `OlmMachine.outgoingRequests` checks the queue, but *before* it
+        // returns. In such a case, the item could sit there unnoticed for some time.
+        //
+        // In order to circumvent the race, we set a flag which tells the loop to go round once again even if the
+        // queue appears to be empty.
+        if (!this.nextLoopDeferred) {
+            this.nextLoopDeferred = Promise.withResolvers();
+        }
+
+        // ... and wait for it to complete.
+        const result = this.nextLoopDeferred.promise;
+
+        // set the loop going if it is not already.
+        if (!this.outgoingRequestLoopRunning) {
+            this.outgoingRequestLoop().catch((e) => {
+                // this should not happen; outgoingRequestLoop should return any errors via `nextLoopDeferred`.
+                /* istanbul ignore next */
+                this.logger.error("Uncaught error in outgoing request loop", e);
+            });
+        }
+        return result;
+    }
+
+    private async outgoingRequestLoop(): Promise<void> {
+        /* istanbul ignore if */
+        if (this.outgoingRequestLoopRunning) {
+            throw new Error("Cannot run two outgoing request loops");
+        }
+        this.outgoingRequestLoopRunning = true;
+        try {
+            while (!this.stopped && this.nextLoopDeferred) {
+                const loopTickResolvers = this.nextLoopDeferred;
+
+                // reset `nextLoopDeferred` so that any future calls to `doProcessOutgoingRequests` are queued
+                // for another additional iteration.
+                this.nextLoopDeferred = undefined;
+
+                // make the requests and feed the results back to the `nextLoopDeferred`
+                await this.processOutgoingRequests().then(loopTickResolvers.resolve, loopTickResolvers.reject);
+            }
+        } finally {
+            this.outgoingRequestLoopRunning = false;
+        }
+
+        if (this.nextLoopDeferred) {
+            // the loop was stopped, but there was a call to `doProcessOutgoingRequests`. Make sure that
+            // we reject the promise in case anything is waiting for it.
+            this.nextLoopDeferred.reject(new Error("OutgoingRequestsManager was stopped"));
+        }
+    }
+
+    /**
+     * Make a single request to `olmMachine.outgoingRequests` and do the corresponding requests.
+     */
+    private async processOutgoingRequests(): Promise<void> {
+        if (this.stopped) return;
+
+        const outgoingRequests: OutgoingRequest[] = await this.olmMachine.outgoingRequests();
+
+        let successes = 0;
+        for (const request of outgoingRequests) {
+            if (this.stopped) return;
+            try {
+                await logDuration(this.logger, `Make outgoing request ${request.type}`, async () => {
+                    await this.outgoingRequestProcessor.makeOutgoingRequest(request);
+                    successes++;
+                });
+            } catch (e) {
+                // as part of the loop we silently ignore errors, but log them.
+                // The rust sdk will retry the request later as it won't have been marked as sent.
+                this.logger.error(`Failed to process outgoing request ${request.type}: ${e}`);
+            }
+        }
+
+        // If we successfully handled any requests this time, more may have been queued as
+        // part of that handling.
+        //
+        // For example, we may have processed a `/keys/claim` request, which
+        // meant the rust side could establish an Olm session and is now ready to
+        // send out an `m.secret.send` message.
+        // (See https://github.com/element-hq/element-web/issues/30988.)
+        //
+        // So, if we have successfully processed any requests, flag that we need to make another
+        // pass around the outgoing-requests loop, to make sure we handle any
+        // pending requests immediately.
+        //
+        // If all requests failed (or there weren't any) we don't want to retry them in a tight
+        // loop. They will be retried after the next sync.
+        // (See https://github.com/element-hq/element-web/issues/31790.)
+        if (successes > 0) {
+            // We call doProcessOutgoingRequests but since we expect that we are
+            // already processing outgoing requests, this call will not kick off
+            // the processing loop, but just set `nextLoopDeferred` and return,
+            // which will mean we loop one more time.
+            this.doProcessOutgoingRequests().catch((e) => {
+                this.logger.warn("processOutgoingRequests: Error re-checking outgoing requests", e);
+            });
+        }
+    }
+}

package/src/rust-crypto/device-converter.ts

@@ -1,128 +1,128 @@
-/*
-Copyright 2023 The Matrix.org Foundation C.I.C.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-import * as RustSdkCryptoJs from "@matrix-org/matrix-sdk-crypto-wasm";
-
-import { Device, DeviceVerification } from "../models/device.ts";
-import { type DeviceKeys } from "../client.ts";
-
-/**
- * Convert a {@link RustSdkCryptoJs.Device} to a {@link Device}
- * @param device - Rust Sdk device
- * @param userId - owner of the device
- *
- * @internal
- */
-export function rustDeviceToJsDevice(device: RustSdkCryptoJs.Device, userId: RustSdkCryptoJs.UserId): Device {
-    // Copy rust device keys to Device.keys
-    const keys = new Map<string, string>();
-    for (const [keyId, key] of device.keys.entries()) {
-        keys.set(keyId.toString(), key.toBase64());
-    }
-
-    // Compute verified from device state
-    let verified: DeviceVerification = DeviceVerification.Unverified;
-    if (device.isBlacklisted()) {
-        verified = DeviceVerification.Blocked;
-    } else if (device.isVerified()) {
-        verified = DeviceVerification.Verified;
-    }
-
-    // Convert rust signatures to Device.signatures
-    const signatures = new Map<string, Map<string, string>>();
-    const mayBeSignatureMap: Map<string, RustSdkCryptoJs.MaybeSignature> | undefined = device.signatures.get(userId);
-    if (mayBeSignatureMap) {
-        const convertedSignatures = new Map<string, string>();
-        // Convert maybeSignatures map to a Map<string, string>
-        for (const [key, value] of mayBeSignatureMap.entries()) {
-            if (value.isValid() && value.signature) {
-                convertedSignatures.set(key, value.signature.toBase64());
-            }
-        }
-
-        signatures.set(userId.toString(), convertedSignatures);
-    }
-
-    // Convert rust algorithms to algorithms
-    const rustAlgorithms: RustSdkCryptoJs.EncryptionAlgorithm[] = device.algorithms;
-    // Use set to ensure that algorithms are not duplicated
-    const algorithms = new Set<string>();
-    rustAlgorithms.forEach((algorithm) => {
-        switch (algorithm) {
-            case RustSdkCryptoJs.EncryptionAlgorithm.MegolmV1AesSha2:
-                algorithms.add("m.megolm.v1.aes-sha2");
-                break;
-            case RustSdkCryptoJs.EncryptionAlgorithm.OlmV1Curve25519AesSha2:
-            default:
-                algorithms.add("m.olm.v1.curve25519-aes-sha2");
-                break;
-        }
-    });
-
-    return new Device({
-        deviceId: device.deviceId.toString(),
-        userId: userId.toString(),
-        keys,
-        algorithms: Array.from(algorithms),
-        verified,
-        signatures,
-        displayName: device.displayName,
-        dehydrated: device.isDehydrated,
-    });
-}
-
-/**
- * Convert {@link DeviceKeys}  from `/keys/query` request to a `Map<string, Device>`
- * @param deviceKeys - Device keys object to convert
- *
- * @internal
- */
-export function deviceKeysToDeviceMap(deviceKeys: DeviceKeys): Map<string, Device> {
-    return new Map(
-        Object.entries(deviceKeys).map(([deviceId, device]) => [deviceId, downloadDeviceToJsDevice(device)]),
-    );
-}
-
-// Device from `/keys/query` request
-type QueryDevice = DeviceKeys[keyof DeviceKeys];
-
-/**
- * Convert `/keys/query` {@link QueryDevice} device to {@link Device}
- * @param device - Device from `/keys/query` request
- *
- * @internal
- */
-export function downloadDeviceToJsDevice(device: QueryDevice): Device {
-    const keys = new Map(Object.entries(device.keys));
-    const displayName = device.unsigned?.device_display_name;
-
-    const signatures = new Map<string, Map<string, string>>();
-    if (device.signatures) {
-        for (const userId in device.signatures) {
-            signatures.set(userId, new Map(Object.entries(device.signatures[userId])));
-        }
-    }
-
-    return new Device({
-        deviceId: device.device_id,
-        userId: device.user_id,
-        keys,
-        algorithms: device.algorithms,
-        verified: DeviceVerification.Unverified,
-        signatures,
-        displayName,
-    });
-}
+/*
+Copyright 2023 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import * as RustSdkCryptoJs from "@matrix-org/matrix-sdk-crypto-wasm";
+
+import { Device, DeviceVerification } from "../models/device.ts";
+import { type DeviceKeys } from "../client.ts";
+
+/**
+ * Convert a {@link RustSdkCryptoJs.Device} to a {@link Device}
+ * @param device - Rust Sdk device
+ * @param userId - owner of the device
+ *
+ * @internal
+ */
+export function rustDeviceToJsDevice(device: RustSdkCryptoJs.Device, userId: RustSdkCryptoJs.UserId): Device {
+    // Copy rust device keys to Device.keys
+    const keys = new Map<string, string>();
+    for (const [keyId, key] of device.keys.entries()) {
+        keys.set(keyId.toString(), key.toBase64());
+    }
+
+    // Compute verified from device state
+    let verified: DeviceVerification = DeviceVerification.Unverified;
+    if (device.isBlacklisted()) {
+        verified = DeviceVerification.Blocked;
+    } else if (device.isVerified()) {
+        verified = DeviceVerification.Verified;
+    }
+
+    // Convert rust signatures to Device.signatures
+    const signatures = new Map<string, Map<string, string>>();
+    const mayBeSignatureMap: Map<string, RustSdkCryptoJs.MaybeSignature> | undefined = device.signatures.get(userId);
+    if (mayBeSignatureMap) {
+        const convertedSignatures = new Map<string, string>();
+        // Convert maybeSignatures map to a Map<string, string>
+        for (const [key, value] of mayBeSignatureMap.entries()) {
+            if (value.isValid() && value.signature) {
+                convertedSignatures.set(key, value.signature.toBase64());
+            }
+        }
+
+        signatures.set(userId.toString(), convertedSignatures);
+    }
+
+    // Convert rust algorithms to algorithms
+    const rustAlgorithms: RustSdkCryptoJs.EncryptionAlgorithm[] = device.algorithms;
+    // Use set to ensure that algorithms are not duplicated
+    const algorithms = new Set<string>();
+    rustAlgorithms.forEach((algorithm) => {
+        switch (algorithm) {
+            case RustSdkCryptoJs.EncryptionAlgorithm.MegolmV1AesSha2:
+                algorithms.add("m.megolm.v1.aes-sha2");
+                break;
+            case RustSdkCryptoJs.EncryptionAlgorithm.OlmV1Curve25519AesSha2:
+            default:
+                algorithms.add("m.olm.v1.curve25519-aes-sha2");
+                break;
+        }
+    });
+
+    return new Device({
+        deviceId: device.deviceId.toString(),
+        userId: userId.toString(),
+        keys,
+        algorithms: Array.from(algorithms),
+        verified,
+        signatures,
+        displayName: device.displayName,
+        dehydrated: device.isDehydrated,
+    });
+}
+
+/**
+ * Convert {@link DeviceKeys}  from `/keys/query` request to a `Map<string, Device>`
+ * @param deviceKeys - Device keys object to convert
+ *
+ * @internal
+ */
+export function deviceKeysToDeviceMap(deviceKeys: DeviceKeys): Map<string, Device> {
+    return new Map(
+        Object.entries(deviceKeys).map(([deviceId, device]) => [deviceId, downloadDeviceToJsDevice(device)]),
+    );
+}
+
+// Device from `/keys/query` request
+type QueryDevice = DeviceKeys[keyof DeviceKeys];
+
+/**
+ * Convert `/keys/query` {@link QueryDevice} device to {@link Device}
+ * @param device - Device from `/keys/query` request
+ *
+ * @internal
+ */
+export function downloadDeviceToJsDevice(device: QueryDevice): Device {
+    const keys = new Map(Object.entries(device.keys));
+    const displayName = device.unsigned?.device_display_name;
+
+    const signatures = new Map<string, Map<string, string>>();
+    if (device.signatures) {
+        for (const userId in device.signatures) {
+            signatures.set(userId, new Map(Object.entries(device.signatures[userId])));
+        }
+    }
+
+    return new Device({
+        deviceId: device.device_id,
+        userId: device.user_id,
+        keys,
+        algorithms: device.algorithms,
+        verified: DeviceVerification.Unverified,
+        signatures,
+        displayName,
+    });
+}