[Combined] First pass of JS->TS for MatrixClient

src/@types/partials.ts

@@ -0,0 +1,28 @@
+/*
+Copyright 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.
+*/
+
+export interface IImageInfo {
+    size?: number;
+    mimetype?: string;
+    thumbnail_info?: {
+        w?: number;
+        h?: number;
+        size?: number;
+        mimetype?: string;
+    };
+    w?: number;
+    h?: number;
+}

src/@types/requests.ts

@@ -0,0 +1,67 @@
+/*
+Copyright 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.
+*/
+
+export interface IJoinRoomOpts {
+    /**
+     * True to do a room initial sync on the resulting
+     * room. If false, the <strong>returned Room object will have no current state.
+     * </strong> Default: true.
+     */
+    syncRoom?: boolean;
+
+    /**
+     * If the caller has a keypair 3pid invite, the signing URL is passed in this parameter.
+     */
+    inviteSignUrl?: string;
+
+    /**
+     * The server names to try and join through in addition to those that are automatically chosen.
+     */
+    viaServers?: string[];
+}
+
+export interface IRedactOpts {
+    reason?: string;
+}
+
+export interface ISendEventResponse {
+    event_id: string;
+}
+
+export interface IPresenceOpts {
+    presence: "online" | "offline" | "unavailable";
+    status_msg?: string;
+}
+
+export interface IPaginateOpts {
+    backwards?: boolean;
+    limit?: number;
+}
+
+export interface IGuestAccessOpts {
+    allowJoin: boolean;
+    allowRead: boolean;
+}
+
+export interface ISearchOpts {
+    keys?: string[];
+    query: string;
+}
+
+export interface IEventSearchOpts {
+    filter: any; // TODO: Types
+    term: string;
+}

src/@types/signed.ts

@@ -0,0 +1,21 @@
+/*
+Copyright 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.
+*/
+
+export interface ISignatures {
+    [entity: string]: {
+        [keyId: string]: string;
+    };
+}

src/crypto/api.ts

@@ -0,0 +1,131 @@
+/*
+Copyright 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 { DeviceInfo } from "./deviceinfo";
+import { IKeyBackupVersion } from "./keybackup";
+import { ISecretStorageKeyInfo } from "../matrix";
+
+// TODO: Merge this with crypto.js once converted
+
+export enum CrossSigningKey {
+    Master = "master",
+    SelfSigning = "self_signing",
+    UserSigning = "user_signing",
+}
+
+export interface IEncryptedEventInfo {
+    /**
+     * whether the event is encrypted (if not encrypted, some of the other properties may not be set)
+     */
+    encrypted: boolean;
+
+    /**
+     * the sender's key
+     */
+    senderKey: string;
+
+    /**
+     * the algorithm used to encrypt the event
+     */
+    algorithm: string;
+
+    /**
+     * whether we can be sure that the owner of the senderKey sent the event
+     */
+    authenticated: boolean;
+
+    /**
+     * the sender's device information, if available
+     */
+    sender?: DeviceInfo;
+
+    /**
+     * if the event's ed25519 and curve25519 keys don't match (only meaningful if `sender` is set)
+     */
+    mismatchedSender: boolean;
+}
+
+export interface IRecoveryKey {
+    keyInfo: {
+        pubkey: Uint8Array;
+        passphrase?: {
+            algorithm: string;
+            iterations: number;
+            salt: string;
+        };
+    };
+    privateKey: Uint8Array;
+    encodedPrivateKey: string;
+}
+
+export interface ICreateSecretStorageOpts {
+    /**
+     * Function called to await a secret storage key creation flow.
+     * Returns:
+     *     {Promise<Object>} Object with public key metadata, encoded private
+     *     recovery key which should be disposed of after displaying to the user,
+     *     and raw private key to avoid round tripping if needed.
+     */
+    createSecretStorageKey?: () => Promise<IRecoveryKey>;
+
+    /**
+     * The current key backup object. If passed,
+     * the passphrase and recovery key from this backup will be used.
+     */
+    keyBackupInfo?: IKeyBackupVersion;
+
+    /**
+     * If true, a new key backup version will be
+     * created and the private key stored in the new SSSS store. Ignored if keyBackupInfo
+     * is supplied.
+     */
+    setupNewKeyBackup?: boolean;
+
+    /**
+     * Reset even if keys already exist.
+     */
+    setupNewSecretStorage?: boolean;
+
+    /**
+     * Function called to get the user's
+     * current key backup passphrase. Should return a promise that resolves with a Buffer
+     * containing the key, or rejects if the key cannot be obtained.
+     */
+    getKeyBackupPassphrase?: () => Promise<Buffer>;
+}
+
+export interface ISecretStorageKey {
+    keyId: string;
+    keyInfo: ISecretStorageKeyInfo;
+}
+
+export interface IAddSecretStorageKeyOpts {
+    // depends on algorithm
+    // TODO: Types
+}
+
+export interface IImportOpts {
+    stage: string; // TODO: Enum
+    successes: number;
+    failures: number;
+    total: number;
+}
+
+export interface IImportRoomKeysOpts {
+    progressCallback: (stage: IImportOpts) => void;
+    untrusted?: boolean;
+    source?: string; // TODO: Enum
+}

src/crypto/dehydration.ts

@@ -1,5 +1,5 @@
 /*
-Copyright 2020 The Matrix.org Foundation C.I.C.
+Copyright 2020-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.
@@ -19,10 +19,23 @@ import { IndexedDBCryptoStore } from '../crypto/store/indexeddb-crypto-store';
 import { decryptAES, encryptAES } from './aes';
 import anotherjson from "another-json";
 import { logger } from '../logger';
+import { ISecretStorageKeyInfo } from "../matrix";
 
 // FIXME: these types should eventually go in a different file
 type Signatures = Record<string, Record<string, string>>;
 
+export interface IDehydratedDevice {
+    device_id: string;
+    device_data: ISecretStorageKeyInfo & {
+        algorithm: string;
+        account: string; // pickle
+    };
+}
+
+export interface IDehydratedDeviceKeyInfo {
+    passphrase: string;
+}
+
 interface DeviceKeys {
     algorithms: Array<string>;
     device_id: string; // eslint-disable-line camelcase

src/crypto/keybackup.ts

@@ -0,0 +1,70 @@
+/*
+Copyright 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 { ISignatures } from "../@types/signed";
+import { DeviceInfo } from "./deviceinfo";
+
+export interface IKeyBackupSession {
+    first_message_index: number;
+    forwarded_count: number;
+    is_verified: boolean;
+    session_data: {
+        ciphertext: string;
+        ephemeral: string;
+        mac: string;
+    };
+}
+
+export interface IKeyBackupRoomSessions {
+    [sessionId: string]: IKeyBackupSession;
+}
+
+export interface IKeyBackupVersion {
+    algorithm: string;
+    auth_data: {
+        public_key: string;
+        signatures: ISignatures;
+    };
+    count: number;
+    etag: string;
+    version: string; // number contained within
+}
+
+// TODO: Verify types
+export interface IKeyBackupTrustInfo {
+    /**
+     * is the backup trusted, true if there is a sig that is valid & from a trusted device
+     */
+    usable: boolean[];
+    sigs: {
+        valid: boolean[];
+        device: DeviceInfo[];
+    }[];
+}
+
+export interface IKeyBackupPrepareOpts {
+    secureSecretStorage: boolean;
+}
+
+export interface IKeyBackupRestoreResult {
+    total: number;
+    imported: number;
+}
+
+export interface IKeyBackupRestoreOpts {
+    cacheCompleteCallback?: () => void;
+    progressCallback?: ({stage: string}) => void;
+}

src/event-mapper.ts

@@ -0,0 +1,48 @@
+/*
+Copyright 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 { MatrixClient } from "./1client";
+import {MatrixEvent} from "./models/event";
+
+export type EventMapper = (obj: any) => MatrixEvent;
+
+export interface MapperOpts {
+    preventReEmit?: boolean;
+    decrypt?: boolean;
+}
+
+export function eventMapperFor(client: MatrixClient, options: MapperOpts): EventMapper {
+    const preventReEmit = Boolean(options.preventReEmit);
+    const decrypt = options.decrypt !== false;
+    function mapper(plainOldJsObject) {
+        const event = new MatrixEvent(plainOldJsObject);
+        if (event.isEncrypted()) {
+            if (!preventReEmit) {
+                client.reEmitter.reEmit(event, [
+                    "Event.decrypted",
+                ]);
+            }
+            if (decrypt) {
+                client.decryptEventIfNeeded(event);
+            }
+        }
+        if (!preventReEmit) {
+            client.reEmitter.reEmit(event, ["Event.replaced"]);
+        }
+        return event;
+    }
+    return mapper;
+}

src/matrix.ts

@@ -1,7 +1,5 @@
 /*
-Copyright 2015, 2016 OpenMarket Ltd
+Copyright 2015-2021 The Matrix.org Foundation C.I.C.
-Copyright 2017 Vector Creations Ltd
-Copyright 2019, 2020 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.
@@ -16,18 +14,11 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import type Request from "request";
-
 import { MemoryCryptoStore } from "./crypto/store/memory-crypto-store";
-import { LocalStorageCryptoStore } from "./crypto/store/localStorage-crypto-store";
-import { IndexedDBCryptoStore } from "./crypto/store/indexeddb-crypto-store";
 import { MemoryStore } from "./store/memory";
-import { StubStore } from "./store/stub";
-import { LocalIndexedDBStoreBackend } from "./store/indexeddb-local-backend";
-import { RemoteIndexedDBStoreBackend } from "./store/indexeddb-remote-backend";
 import { MatrixScheduler } from "./scheduler";
 import { MatrixClient } from "./client";
-import { IIdentityServerProvider } from "./@types/IIdentityServerProvider";
+import { ICreateClientOpts } from "./1client";
 
 export * from "./client";
 export * from "./http-api";
@@ -95,11 +86,6 @@ export function wrapRequest(wrapper) {
     };
 }
 
-type Store =
-    StubStore | MemoryStore | LocalIndexedDBStoreBackend | RemoteIndexedDBStoreBackend;
-
-type CryptoStore = MemoryCryptoStore | LocalStorageCryptoStore | IndexedDBCryptoStore;
-
 let cryptoStoreFactory = () => new MemoryCryptoStore;
 
 /**
@@ -112,155 +98,6 @@ export function setCryptoStoreFactory(fac) {
     cryptoStoreFactory = fac;
 }
 
-export interface ICreateClientOpts {
-    baseUrl: string;
-
-    idBaseUrl?: string;
-
-    /**
-     * The data store used for sync data from the homeserver. If not specified,
-     * this client will not store any HTTP responses. The `createClient` helper
-     * will create a default store if needed.
-     */
-    store?: Store;
-
-    /**
-     * A store to be used for end-to-end crypto session data. If not specified,
-     * end-to-end crypto will be disabled. The `createClient` helper will create
-     * a default store if needed.
-     */
-    cryptoStore?: CryptoStore;
-
-    /**
-     * The scheduler to use. If not
-     * specified, this client will not retry requests on failure. This client
-     * will supply its own processing function to
-     * {@link module:scheduler~MatrixScheduler#setProcessFunction}.
-     */
-    scheduler?: MatrixScheduler;
-
-    /**
-     * The function to invoke for HTTP
-     * requests. The value of this property is typically <code>require("request")
-     * </code> as it returns a function which meets the required interface. See
-     * {@link requestFunction} for more information.
-     */
-    request?: Request;
-
-    userId?: string;
-
-    /**
-     * A unique identifier for this device; used for tracking things like crypto
-     * keys and access tokens. If not specified, end-to-end encryption will be
-     * disabled.
-     */
-    deviceId?: string;
-
-    accessToken?: string;
-
-    /**
-     * Identity server provider to retrieve the user's access token when accessing
-     * the identity server. See also https://github.com/vector-im/element-web/issues/10615
-     * which seeks to replace the previous approach of manual access tokens params
-     * with this callback throughout the SDK.
-     */
-    identityServer?: IIdentityServerProvider;
-
-    /**
-     * The default maximum amount of
-     * time to wait before timing out HTTP requests. If not specified, there is no timeout.
-     */
-    localTimeoutMs?: number;
-
-    /**
-     * Set to true to use
-     * Authorization header instead of query param to send the access token to the server.
-     *
-     * Default false.
-     */
-    useAuthorizationHeader?: boolean;
-
-    /**
-     * Set to true to enable
-     * improved timeline support ({@link module:client~MatrixClient#getEventTimeline getEventTimeline}). It is
-     * disabled by default for compatibility with older clients - in particular to
-     * maintain support for back-paginating the live timeline after a '/sync'
-     * result with a gap.
-     */
-    timelineSupport?: boolean;
-
-    /**
-     * Extra query parameters to append
-     * to all requests with this client. Useful for application services which require
-     * <code>?user_id=</code>.
-     */
-    queryParams?: Record<string, unknown>;
-
-    /**
-     * Device data exported with
-     * "exportDevice" method that must be imported to recreate this device.
-     * Should only be useful for devices with end-to-end crypto enabled.
-     * If provided, deviceId and userId should **NOT** be provided at the top
-     * level (they are present in the exported data).
-     */
-    deviceToImport?: {
-        olmDevice: {
-            pickledAccount: string;
-            sessions: Array<Record<string, any>>;
-            pickleKey: string;
-        };
-        userId: string;
-        deviceId: string;
-    };
-
-    /**
-     * Key used to pickle olm objects or other sensitive data.
-     */
-    pickleKey?: string;
-
-    /**
-     * A store to be used for end-to-end crypto session data. Most data has been
-     * migrated out of here to `cryptoStore` instead. If not specified,
-     * end-to-end crypto will be disabled. The `createClient` helper
-     * _will not_ create this store at the moment.
-     */
-    sessionStore?: any;
-
-    /**
-     * Set to true to enable client-side aggregation of event relations
-     * via `EventTimelineSet#getRelationsForEvent`.
-     * This feature is currently unstable and the API may change without notice.
-     */
-    unstableClientRelationAggregation?: boolean;
-
-    verificationMethods?: Array<any>;
-
-    /**
-     * Whether relaying calls through a TURN server should be forced. Default false.
-     */
-    forceTURN?: boolean;
-
-    /**
-     * Up to this many ICE candidates will be gathered when an incoming call arrives.
-     * Gathering does not send data to the caller, but will communicate with the configured TURN
-     * server. Default 0.
-     */
-    iceCandidatePoolSize?: number;
-
-    /**
-     * True to advertise support for call transfers to other parties on Matrix calls. Default false.
-     */
-    supportsCallTransfer?: boolean;
-
-    /**
-     * Whether to allow a fallback ICE server should be used for negotiating a
-     * WebRTC connection if the homeserver doesn't provide any servers. Defaults to false.
-     */
-    fallbackICEServerAllowed?: boolean;
-
-    cryptoCallbacks?: ICryptoCallbacks;
-}
-
 export interface ICryptoCallbacks {
     getCrossSigningKey?: (keyType: string, pubKey: Uint8Array) => Promise<Uint8Array>;
     saveCrossSigningKeys?: (keys: Record<string, Uint8Array>) => void;

src/sync.api.ts

@@ -0,0 +1,26 @@
+/*
+Copyright 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.
+*/
+
+// TODO: Merge this with sync.js once converted
+
+export enum SyncState {
+    Error = "ERROR",
+    Prepared = "PREPARED",
+    Stopped = "STOPPED",
+    Syncing = "SYNCING",
+    Catchup = "CATCHUP",
+    Reconnecting = "RECONNECTING",
+}

src/utils.ts

@@ -398,7 +398,7 @@ export function ensureNoTrailingSlash(url: string): string {
 }
 
 // Returns a promise which resolves with a given value after the given number of ms
-export function sleep<T>(ms: number, value: T): Promise<T> {
+export function sleep<T>(ms: number, value?: T): Promise<T> {
     return new Promise((resolve => {
         setTimeout(resolve, ms, value);
     }));