@unwanted/matrix-sdk-mini 34.12.0-1

package/lib/crypto/algorithms/base.js

@@ -0,0 +1,187 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+/*
+Copyright 2016 - 2021 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.
+*/
+
+/**
+ * Internal module. Defines the base classes of the encryption implementations
+ */
+
+/**
+ * Map of registered encryption algorithm classes. A map from string to {@link EncryptionAlgorithm} class
+ */
+export var ENCRYPTION_CLASSES = new Map();
+/**
+ * map of registered encryption algorithm classes. Map from string to {@link DecryptionAlgorithm} class
+ */
+export var DECRYPTION_CLASSES = new Map();
+/**
+ * base type for encryption implementations
+ */
+export class EncryptionAlgorithm {
+  /**
+   * @param params - parameters
+   */
+  constructor(params) {
+    _defineProperty(this, "userId", void 0);
+    _defineProperty(this, "deviceId", void 0);
+    _defineProperty(this, "crypto", void 0);
+    _defineProperty(this, "olmDevice", void 0);
+    _defineProperty(this, "baseApis", void 0);
+    this.userId = params.userId;
+    this.deviceId = params.deviceId;
+    this.crypto = params.crypto;
+    this.olmDevice = params.olmDevice;
+    this.baseApis = params.baseApis;
+  }
+
+  /**
+   * Perform any background tasks that can be done before a message is ready to
+   * send, in order to speed up sending of the message.
+   *
+   * @param room - the room the event is in
+   */
+  prepareToEncrypt(room) {}
+
+  /**
+   * Encrypt a message event
+   *
+   * @public
+   *
+   * @param content - event content
+   *
+   * @returns Promise which resolves to the new event body
+   */
+
+  /**
+   * Called when the membership of a member of the room changes.
+   *
+   * @param event -  event causing the change
+   * @param member -  user whose membership changed
+   * @param oldMembership -  previous membership
+   * @public
+   */
+  onRoomMembership(event, member, oldMembership) {}
+}
+
+/**
+ * base type for decryption implementations
+ */
+export class DecryptionAlgorithm {
+  constructor(params) {
+    _defineProperty(this, "userId", void 0);
+    _defineProperty(this, "crypto", void 0);
+    _defineProperty(this, "olmDevice", void 0);
+    _defineProperty(this, "baseApis", void 0);
+    this.userId = params.userId;
+    this.crypto = params.crypto;
+    this.olmDevice = params.olmDevice;
+    this.baseApis = params.baseApis;
+  }
+
+  /**
+   * Decrypt an event
+   *
+   * @param event - undecrypted event
+   *
+   * @returns promise which
+   * resolves once we have finished decrypting. Rejects with an
+   * `algorithms.DecryptionError` if there is a problem decrypting the event.
+   */
+
+  /**
+   * Handle a key event
+   *
+   * @param params - event key event
+   */
+  onRoomKeyEvent(params) {
+    return _asyncToGenerator(function* () {})();
+  } // ignore by default
+
+  /**
+   * Import a room key
+   *
+   * @param opts - object
+   */
+  importRoomKey(session, opts) {
+    return _asyncToGenerator(function* () {})();
+  } // ignore by default
+
+  /**
+   * Determine if we have the keys necessary to respond to a room key request
+   *
+   * @returns true if we have the keys and could (theoretically) share
+   *  them; else false.
+   */
+  hasKeysForKeyRequest(keyRequest) {
+    return Promise.resolve(false);
+  }
+
+  /**
+   * Send the response to a room key request
+   *
+   */
+  shareKeysWithDevice(keyRequest) {
+    throw new Error("shareKeysWithDevice not supported for this DecryptionAlgorithm");
+  }
+
+  /**
+   * Retry decrypting all the events from a sender that haven't been
+   * decrypted yet.
+   *
+   * @param senderKey - the sender's key
+   */
+  retryDecryptionFromSender(senderKey) {
+    return _asyncToGenerator(function* () {
+      // ignore by default
+      return false;
+    })();
+  }
+}
+export class UnknownDeviceError extends Error {
+  /**
+   * Exception thrown specifically when we want to warn the user to consider
+   * the security of their conversation before continuing
+   *
+   * @param msg - message describing the problem
+   * @param devices - set of unknown devices per user we're warning about
+   */
+  constructor(msg, devices, event) {
+    super(msg);
+    this.devices = devices;
+    this.event = event;
+    this.name = "UnknownDeviceError";
+    this.devices = devices;
+  }
+}
+
+/**
+ * Registers an encryption/decryption class for a particular algorithm
+ *
+ * @param algorithm - algorithm tag to register for
+ *
+ * @param encryptor - {@link EncryptionAlgorithm} implementation
+ *
+ * @param decryptor - {@link DecryptionAlgorithm} implementation
+ */
+export function registerAlgorithm(algorithm, encryptor, decryptor) {
+  ENCRYPTION_CLASSES.set(algorithm, encryptor);
+  DECRYPTION_CLASSES.set(algorithm, decryptor);
+}
+
+/* Re-export for backwards compatibility. Deprecated: this is an internal class. */
+export { DecryptionError } from "../../common-crypto/CryptoBackend.js";
+//# sourceMappingURL=base.js.map

package/lib/crypto/algorithms/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","names":["ENCRYPTION_CLASSES","Map","DECRYPTION_CLASSES","EncryptionAlgorithm","constructor","params","_defineProperty","userId","deviceId","crypto","olmDevice","baseApis","prepareToEncrypt","room","onRoomMembership","event","member","oldMembership","DecryptionAlgorithm","onRoomKeyEvent","_asyncToGenerator","importRoomKey","session","opts","hasKeysForKeyRequest","keyRequest","Promise","resolve","shareKeysWithDevice","Error","retryDecryptionFromSender","senderKey","UnknownDeviceError","msg","devices","name","registerAlgorithm","algorithm","encryptor","decryptor","set","DecryptionError"],"sources":["../../../src/crypto/algorithms/base.ts"],"sourcesContent":["/*\nCopyright 2016 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * Internal module. Defines the base classes of the encryption implementations\n */\n\nimport type { IMegolmSessionData } from \"../../@types/crypto.ts\";\nimport { MatrixClient } from \"../../client.ts\";\nimport { Room } from \"../../models/room.ts\";\nimport { OlmDevice } from \"../OlmDevice.ts\";\nimport { IContent, MatrixEvent, RoomMember } from \"../../matrix.ts\";\nimport { Crypto, IEncryptedContent, IEventDecryptionResult, IncomingRoomKeyRequest } from \"../index.ts\";\nimport { DeviceInfo } from \"../deviceinfo.ts\";\nimport { IRoomEncryption } from \"../RoomList.ts\";\nimport { DeviceInfoMap } from \"../DeviceList.ts\";\n\n/**\n * Map of registered encryption algorithm classes. A map from string to {@link EncryptionAlgorithm} class\n */\nexport const ENCRYPTION_CLASSES = new Map<string, new (params: IParams) => EncryptionAlgorithm>();\n\nexport type DecryptionClassParams<P extends IParams = IParams> = Omit<P, \"deviceId\" | \"config\">;\n\n/**\n * map of registered encryption algorithm classes. Map from string to {@link DecryptionAlgorithm} class\n */\nexport const DECRYPTION_CLASSES = new Map<string, new (params: DecryptionClassParams) => DecryptionAlgorithm>();\n\nexport interface IParams {\n    /** The UserID for the local user */\n    userId: string;\n    /** The identifier for this device. */\n    deviceId: string;\n    /** crypto core */\n    crypto: Crypto;\n    /** olm.js wrapper */\n    olmDevice: OlmDevice;\n    /** base matrix api interface */\n    baseApis: MatrixClient;\n    /** The ID of the room we will be sending to */\n    roomId?: string;\n    /** The body of the m.room.encryption event */\n    config: IRoomEncryption & object;\n}\n\n/**\n * base type for encryption implementations\n */\nexport abstract class EncryptionAlgorithm {\n    protected readonly userId: string;\n    protected readonly deviceId: string;\n    protected readonly crypto: Crypto;\n    protected readonly olmDevice: OlmDevice;\n    protected readonly baseApis: MatrixClient;\n\n    /**\n     * @param params - parameters\n     */\n    public constructor(params: IParams) {\n        this.userId = params.userId;\n        this.deviceId = params.deviceId;\n        this.crypto = params.crypto;\n        this.olmDevice = params.olmDevice;\n        this.baseApis = params.baseApis;\n    }\n\n    /**\n     * Perform any background tasks that can be done before a message is ready to\n     * send, in order to speed up sending of the message.\n     *\n     * @param room - the room the event is in\n     */\n    public prepareToEncrypt(room: Room): void {}\n\n    /**\n     * Encrypt a message event\n     *\n     * @public\n     *\n     * @param content - event content\n     *\n     * @returns Promise which resolves to the new event body\n     */\n    public abstract encryptMessage(room: Room, eventType: string, content: IContent): Promise<IEncryptedContent>;\n\n    /**\n     * Called when the membership of a member of the room changes.\n     *\n     * @param event -  event causing the change\n     * @param member -  user whose membership changed\n     * @param oldMembership -  previous membership\n     * @public\n     */\n    public onRoomMembership(event: MatrixEvent, member: RoomMember, oldMembership?: string): void {}\n\n    public reshareKeyWithDevice?(\n        senderKey: string,\n        sessionId: string,\n        userId: string,\n        device: DeviceInfo,\n    ): Promise<void>;\n\n    public forceDiscardSession?(): void;\n}\n\n/**\n * base type for decryption implementations\n */\nexport abstract class DecryptionAlgorithm {\n    protected readonly userId: string;\n    protected readonly crypto: Crypto;\n    protected readonly olmDevice: OlmDevice;\n    protected readonly baseApis: MatrixClient;\n\n    public constructor(params: DecryptionClassParams) {\n        this.userId = params.userId;\n        this.crypto = params.crypto;\n        this.olmDevice = params.olmDevice;\n        this.baseApis = params.baseApis;\n    }\n\n    /**\n     * Decrypt an event\n     *\n     * @param event - undecrypted event\n     *\n     * @returns promise which\n     * resolves once we have finished decrypting. Rejects with an\n     * `algorithms.DecryptionError` if there is a problem decrypting the event.\n     */\n    public abstract decryptEvent(event: MatrixEvent): Promise<IEventDecryptionResult>;\n\n    /**\n     * Handle a key event\n     *\n     * @param params - event key event\n     */\n    public async onRoomKeyEvent(params: MatrixEvent): Promise<void> {\n        // ignore by default\n    }\n\n    /**\n     * Import a room key\n     *\n     * @param opts - object\n     */\n    public async importRoomKey(session: IMegolmSessionData, opts: object): Promise<void> {\n        // ignore by default\n    }\n\n    /**\n     * Determine if we have the keys necessary to respond to a room key request\n     *\n     * @returns true if we have the keys and could (theoretically) share\n     *  them; else false.\n     */\n    public hasKeysForKeyRequest(keyRequest: IncomingRoomKeyRequest): Promise<boolean> {\n        return Promise.resolve(false);\n    }\n\n    /**\n     * Send the response to a room key request\n     *\n     */\n    public shareKeysWithDevice(keyRequest: IncomingRoomKeyRequest): void {\n        throw new Error(\"shareKeysWithDevice not supported for this DecryptionAlgorithm\");\n    }\n\n    /**\n     * Retry decrypting all the events from a sender that haven't been\n     * decrypted yet.\n     *\n     * @param senderKey - the sender's key\n     */\n    public async retryDecryptionFromSender(senderKey: string): Promise<boolean> {\n        // ignore by default\n        return false;\n    }\n\n    public onRoomKeyWithheldEvent?(event: MatrixEvent): Promise<void>;\n    public sendSharedHistoryInboundSessions?(devicesByUser: Map<string, DeviceInfo[]>): Promise<void>;\n}\n\nexport class UnknownDeviceError extends Error {\n    /**\n     * Exception thrown specifically when we want to warn the user to consider\n     * the security of their conversation before continuing\n     *\n     * @param msg - message describing the problem\n     * @param devices - set of unknown devices per user we're warning about\n     */\n    public constructor(\n        msg: string,\n        public readonly devices: DeviceInfoMap,\n        public event?: MatrixEvent,\n    ) {\n        super(msg);\n        this.name = \"UnknownDeviceError\";\n        this.devices = devices;\n    }\n}\n\n/**\n * Registers an encryption/decryption class for a particular algorithm\n *\n * @param algorithm - algorithm tag to register for\n *\n * @param encryptor - {@link EncryptionAlgorithm} implementation\n *\n * @param decryptor - {@link DecryptionAlgorithm} implementation\n */\nexport function registerAlgorithm<P extends IParams = IParams>(\n    algorithm: string,\n    encryptor: new (params: P) => EncryptionAlgorithm,\n    decryptor: new (params: DecryptionClassParams<P>) => DecryptionAlgorithm,\n): void {\n    ENCRYPTION_CLASSES.set(algorithm, encryptor as new (params: IParams) => EncryptionAlgorithm);\n    DECRYPTION_CLASSES.set(algorithm, decryptor as new (params: DecryptionClassParams) => DecryptionAlgorithm);\n}\n\n/* Re-export for backwards compatibility. Deprecated: this is an internal class. */\nexport { DecryptionError } from \"../../common-crypto/CryptoBackend.ts\";\n"],"mappings":"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","ignoreList":[]}

package/lib/crypto/algorithms/index.d.ts

@@ -0,0 +1,4 @@
+import "./olm.ts";
+import "./megolm.ts";
+export * from "./base.ts";
+//# sourceMappingURL=index.d.ts.map

package/lib/crypto/algorithms/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/crypto/algorithms/index.ts"],"names":[],"mappings":"AAgBA,OAAO,UAAU,CAAC;AAClB,OAAO,aAAa,CAAC;AAErB,cAAc,WAAW,CAAC"}

package/lib/crypto/algorithms/index.js

@@ -0,0 +1,20 @@
+/*
+Copyright 2016 - 2021 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 "./olm.js";
+import "./megolm.js";
+export * from "./base.js";
+//# sourceMappingURL=index.js.map

package/lib/crypto/algorithms/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/crypto/algorithms/index.ts"],"sourcesContent":["/*\nCopyright 2016 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport \"./olm.ts\";\nimport \"./megolm.ts\";\n\nexport * from \"./base.ts\";\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,OAAO,UAAU;AACjB,OAAO,aAAa;AAEpB,cAAc,WAAW","ignoreList":[]}

package/lib/crypto/algorithms/megolm.d.ts

@@ -0,0 +1,385 @@
+import type { IEventDecryptionResult, IMegolmSessionData } from "../../@types/crypto.ts";
+import { DecryptionAlgorithm, DecryptionClassParams, EncryptionAlgorithm, IParams } from "./base.ts";
+import { Room } from "../../models/room.ts";
+import { DeviceInfo } from "../deviceinfo.ts";
+import { IContent, MatrixEvent } from "../../models/event.ts";
+import { IMegolmEncryptedContent, IncomingRoomKeyRequest } from "../index.ts";
+export declare function isRoomSharedHistory(room: Room): boolean;
+export interface IOlmDevice<T = DeviceInfo> {
+    userId: string;
+    deviceInfo: T;
+}
+export interface IOutboundGroupSessionKey {
+    chain_index: number;
+    key: string;
+}
+/**
+ * Megolm encryption implementation
+ *
+ * @param params - parameters, as per {@link EncryptionAlgorithm}
+ */
+export declare class MegolmEncryption extends EncryptionAlgorithm {
+    private setupPromise;
+    private outboundSessions;
+    private readonly sessionRotationPeriodMsgs;
+    private readonly sessionRotationPeriodMs;
+    private encryptionPreparation?;
+    protected readonly roomId: string;
+    private readonly prefixedLogger;
+    constructor(params: IParams & Required<Pick<IParams, "roomId">>);
+    /**
+     * @internal
+     *
+     * @param devicesInRoom - The devices in this room, indexed by user ID
+     * @param blocked - The devices that are blocked, indexed by user ID
+     * @param singleOlmCreationPhase - Only perform one round of olm
+     *     session creation
+     *
+     * This method updates the setupPromise field of the class by chaining a new
+     * call on top of the existing promise, and then catching and discarding any
+     * errors that might happen while setting up the outbound group session. This
+     * is done to ensure that `setupPromise` always resolves to `null` or the
+     * `OutboundSessionInfo`.
+     *
+     * Using `>>=` to represent the promise chaining operation, it does the
+     * following:
+     *
+     * ```
+     * setupPromise = previousSetupPromise >>= setup >>= discardErrors
+     * ```
+     *
+     * The initial value for the `setupPromise` is a promise that resolves to
+     * `null`. The forceDiscardSession() resets setupPromise to this initial
+     * promise.
+     *
+     * @returns Promise which resolves to the
+     *    OutboundSessionInfo when setup is complete.
+     */
+    private ensureOutboundSession;
+    private prepareSession;
+    private shareSession;
+    /**
+     * @internal
+     *
+     *
+     * @returns session
+     */
+    private prepareNewSession;
+    /**
+     * Determines what devices in devicesByUser don't have an olm session as given
+     * in devicemap.
+     *
+     * @internal
+     *
+     * @param deviceMap - the devices that have olm sessions, as returned by
+     *     olmlib.ensureOlmSessionsForDevices.
+     * @param devicesByUser - a map of user IDs to array of deviceInfo
+     * @param noOlmDevices - an array to fill with devices that don't have
+     *     olm sessions
+     *
+     * @returns an array of devices that don't have olm sessions.  If
+     *     noOlmDevices is specified, then noOlmDevices will be returned.
+     */
+    private getDevicesWithoutSessions;
+    /**
+     * Splits the user device map into multiple chunks to reduce the number of
+     * devices we encrypt to per API call.
+     *
+     * @internal
+     *
+     * @param devicesByUser - map from userid to list of devices
+     *
+     * @returns the blocked devices, split into chunks
+     */
+    private splitDevices;
+    /**
+     * @internal
+     *
+     *
+     * @param chainIndex - current chain index
+     *
+     * @param userDeviceMap - mapping from userId to deviceInfo
+     *
+     * @param payload - fields to include in the encrypted payload
+     *
+     * @returns Promise which resolves once the key sharing
+     *     for the given userDeviceMap is generated and has been sent.
+     */
+    private encryptAndSendKeysToDevices;
+    /**
+     * @internal
+     *
+     *
+     * @param userDeviceMap - list of blocked devices to notify
+     *
+     * @param payload - fields to include in the notification payload
+     *
+     * @returns Promise which resolves once the notifications
+     *     for the given userDeviceMap is generated and has been sent.
+     */
+    private sendBlockedNotificationsToDevices;
+    /**
+     * Re-shares a megolm session key with devices if the key has already been
+     * sent to them.
+     *
+     * @param senderKey - The key of the originating device for the session
+     * @param sessionId - ID of the outbound session to share
+     * @param userId - ID of the user who owns the target device
+     * @param device - The target device
+     */
+    reshareKeyWithDevice(senderKey: string, sessionId: string, userId: string, device: DeviceInfo): Promise<void>;
+    /**
+     * @internal
+     *
+     *
+     * @param key - the session key as returned by
+     *    OlmDevice.getOutboundGroupSessionKey
+     *
+     * @param payload - the base to-device message payload for sharing keys
+     *
+     * @param devicesByUser - map from userid to list of devices
+     *
+     * @param errorDevices - array that will be populated with the devices that we can't get an
+     *    olm session for
+     *
+     * @param otkTimeout - The timeout in milliseconds when requesting
+     *     one-time keys for establishing new olm sessions.
+     *
+     * @param failedServers - An array to fill with remote servers that
+     *     failed to respond to one-time-key requests.
+     */
+    private shareKeyWithDevices;
+    private shareKeyWithOlmSessions;
+    /**
+     * Notify devices that we weren't able to create olm sessions.
+     *
+     *
+     *
+     * @param failedDevices - the devices that we were unable to
+     *     create olm sessions for, as returned by shareKeyWithDevices
+     */
+    private notifyFailedOlmDevices;
+    /**
+     * Notify blocked devices that they have been blocked.
+     *
+     *
+     * @param devicesByUser - map from userid to device ID to blocked data
+     */
+    private notifyBlockedDevices;
+    /**
+     * Perform any background tasks that can be done before a message is ready to
+     * send, in order to speed up sending of the message.
+     *
+     * @param room - the room the event is in
+     * @returns A function that, when called, will stop the preparation
+     */
+    prepareToEncrypt(room: Room): () => void;
+    /**
+     * @param content - plaintext event content
+     *
+     * @returns Promise which resolves to the new event body
+     */
+    encryptMessage(room: Room, eventType: string, content: IContent): Promise<IMegolmEncryptedContent>;
+    private isVerificationEvent;
+    /**
+     * Forces the current outbound group session to be discarded such
+     * that another one will be created next time an event is sent.
+     *
+     * This should not normally be necessary.
+     */
+    forceDiscardSession(): void;
+    /**
+     * Checks the devices we're about to send to and see if any are entirely
+     * unknown to the user.  If so, warn the user, and mark them as known to
+     * give the user a chance to go verify them before re-sending this message.
+     *
+     * @param devicesInRoom - `userId -> {deviceId -> object}`
+     *   devices we should shared the session with.
+     */
+    private checkForUnknownDevices;
+    /**
+     * Remove unknown devices from a set of devices.  The devicesInRoom parameter
+     * will be modified.
+     *
+     * @param devicesInRoom - `userId -> {deviceId -> object}`
+     *   devices we should shared the session with.
+     */
+    private removeUnknownDevices;
+    /**
+     * Get the list of unblocked devices for all users in the room
+     *
+     * @param forceDistributeToUnverified - if set to true will include the unverified devices
+     * even if setting is set to block them (useful for verification)
+     * @param isCancelled - will cause the procedure to abort early if and when it starts
+     * returning `true`. If omitted, cancellation won't happen.
+     *
+     * @returns Promise which resolves to `null`, or an array whose
+     *     first element is a {@link DeviceInfoMap} indicating
+     *     the devices that messages should be encrypted to, and whose second
+     *     element is a map from userId to deviceId to data indicating the devices
+     *     that are in the room but that have been blocked.
+     *     If `isCancelled` is provided and returns `true` while processing, `null`
+     *     will be returned.
+     *     If `isCancelled` is not provided, the Promise will never resolve to `null`.
+     */
+    private getDevicesInRoom;
+}
+/**
+ * Megolm decryption implementation
+ *
+ * @param params - parameters, as per {@link DecryptionAlgorithm}
+ */
+export declare class MegolmDecryption extends DecryptionAlgorithm {
+    private pendingEvents;
+    private olmlib;
+    protected readonly roomId: string;
+    private readonly prefixedLogger;
+    constructor(params: DecryptionClassParams<IParams & Required<Pick<IParams, "roomId">>>);
+    /**
+     * returns a promise which resolves to a
+     * {@link EventDecryptionResult} once we have finished
+     * decrypting, or rejects with an `algorithms.DecryptionError` if there is a
+     * problem decrypting the event.
+     */
+    decryptEvent(event: MatrixEvent): Promise<IEventDecryptionResult>;
+    private requestKeysForEvent;
+    /**
+     * Add an event to the list of those awaiting their session keys.
+     *
+     * @internal
+     *
+     */
+    private addEventToPendingList;
+    /**
+     * Remove an event from the list of those awaiting their session keys.
+     *
+     * @internal
+     *
+     */
+    private removeEventFromPendingList;
+    /**
+     * Parse a RoomKey out of an `m.room_key` event.
+     *
+     * @param event - the event containing the room key.
+     *
+     * @returns The `RoomKey` if it could be successfully parsed out of the
+     * event.
+     *
+     * @internal
+     *
+     */
+    private roomKeyFromEvent;
+    /**
+     * Parse a RoomKey out of an `m.forwarded_room_key` event.
+     *
+     * @param event - the event containing the forwarded room key.
+     *
+     * @returns The `RoomKey` if it could be successfully parsed out of the
+     * event.
+     *
+     * @internal
+     *
+     */
+    private forwardedRoomKeyFromEvent;
+    /**
+     * Determine if we should accept the forwarded room key that was found in the given
+     * event.
+     *
+     * @param event - An `m.forwarded_room_key` event.
+     * @param roomKey - The room key that was found in the event.
+     *
+     * @returns promise that will resolve to a boolean telling us if it's ok to
+     * accept the given forwarded room key.
+     *
+     * @internal
+     *
+     */
+    private shouldAcceptForwardedKey;
+    /**
+     * Did we ever request the given room key from the event sender and its
+     * accompanying device.
+     *
+     * @param event - An `m.forwarded_room_key` event.
+     * @param roomKey - The room key that was found in the event.
+     *
+     * @internal
+     *
+     */
+    private wasRoomKeyRequested;
+    private wasRoomKeyForwardedByInviter;
+    private wasRoomKeyForwardedAsHistory;
+    /**
+     * Check if a forwarded room key should be parked.
+     *
+     * A forwarded room key should be parked if it's a key for a room we're not
+     * in. We park the forwarded room key in case *this sender* invites us to
+     * that room later.
+     */
+    private shouldParkForwardedKey;
+    /**
+     * Park the given room key to our store.
+     *
+     * @param event - An `m.forwarded_room_key` event.
+     * @param roomKey - The room key that was found in the event.
+     *
+     * @internal
+     *
+     */
+    private parkForwardedKey;
+    /**
+     * Add the given room key to our store.
+     *
+     * @param roomKey - The room key that should be added to the store.
+     *
+     * @internal
+     *
+     */
+    private addRoomKey;
+    /**
+     * Handle room keys that have been forwarded to us as an
+     * `m.forwarded_room_key` event.
+     *
+     * Forwarded room keys need special handling since we have no way of knowing
+     * who the original creator of the room key was. This naturally means that
+     * forwarded room keys are always untrusted and should only be accepted in
+     * some cases.
+     *
+     * @param event - An `m.forwarded_room_key` event.
+     *
+     * @internal
+     *
+     */
+    private onForwardedRoomKey;
+    onRoomKeyEvent(event: MatrixEvent): Promise<void>;
+    /**
+     * @param event - key event
+     */
+    onRoomKeyWithheldEvent(event: MatrixEvent): Promise<void>;
+    private onNoOlmWithheldEvent;
+    hasKeysForKeyRequest(keyRequest: IncomingRoomKeyRequest): Promise<boolean>;
+    shareKeysWithDevice(keyRequest: IncomingRoomKeyRequest): void;
+    private buildKeyForwardingMessage;
+    /**
+     * @param untrusted - whether the key should be considered as untrusted
+     * @param source - where the key came from
+     */
+    importRoomKey(session: IMegolmSessionData, { untrusted, source }?: {
+        untrusted?: boolean;
+        source?: string;
+    }): Promise<void>;
+    /**
+     * Have another go at decrypting events after we receive a key. Resolves once
+     * decryption has been re-attempted on all events.
+     *
+     * @internal
+     * @param forceRedecryptIfUntrusted - whether messages that were already
+     *     successfully decrypted using untrusted keys should be re-decrypted
+     *
+     * @returns whether all messages were successfully
+     *     decrypted with trusted keys
+     */
+    private retryDecryption;
+    retryDecryptionFromSender(senderKey: string): Promise<boolean>;
+    sendSharedHistoryInboundSessions(devicesByUser: Map<string, DeviceInfo[]>): Promise<void>;
+}
+//# sourceMappingURL=megolm.d.ts.map

package/lib/crypto/algorithms/megolm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"megolm.d.ts","sourceRoot":"","sources":["../../../src/crypto/algorithms/megolm.ts"],"names":[],"mappings":"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"}