@wireapp/core 37.5.0 → 38.0.0-beta

package/lib/Account.js

@@ -1,543 +0,0 @@
-"use strict";
-/*
- * Wire
- * Copyright (C) 2018 Wire Swiss GmbH
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see http://www.gnu.org/licenses/.
- *
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Account = exports.ConnectionState = void 0;
-const auth_1 = require("@wireapp/api-client/lib/auth");
-const client_1 = require("@wireapp/api-client/lib/client/");
-const event_1 = require("@wireapp/api-client/lib/event");
-const tcp_1 = require("@wireapp/api-client/lib/tcp/");
-const ReconnectingWebsocket_1 = require("@wireapp/api-client/lib/tcp/ReconnectingWebsocket");
-const axios_1 = __importDefault(require("axios"));
-const bazinga64_1 = require("bazinga64");
-const http_status_codes_1 = require("http-status-codes");
-const logdown_1 = __importDefault(require("logdown"));
-const events_1 = require("events");
-const api_client_1 = require("@wireapp/api-client");
-const core_crypto_1 = require("@wireapp/core-crypto");
-const cryptobox = __importStar(require("@wireapp/cryptobox"));
-const store_engine_1 = require("@wireapp/store-engine");
-const account_1 = require("./account/");
-const auth_2 = require("./auth/");
-const broadcast_1 = require("./broadcast/");
-const client_2 = require("./client/");
-const connection_1 = require("./connection/");
-const conversation_1 = require("./conversation/");
-const messageSender_1 = require("./conversation/message/messageSender");
-const cryptography_1 = require("./cryptography/");
-const giphy_1 = require("./giphy/");
-const linkPreview_1 = require("./linkPreview");
-const mls_1 = require("./messagingProtocols/mls");
-const proteus_1 = require("./messagingProtocols/proteus");
-const notification_1 = require("./notification/");
-const self_1 = require("./self/");
-const team_1 = require("./team/");
-const user_1 = require("./user/");
-const encryptedStore_1 = require("./util/encryptedStore");
-var TOPIC;
-(function (TOPIC) {
-    TOPIC["ERROR"] = "Account.TOPIC.ERROR";
-})(TOPIC || (TOPIC = {}));
-var ConnectionState;
-(function (ConnectionState) {
-    /** The websocket is closed and notifications stream is not being processed */
-    ConnectionState["CLOSED"] = "closed";
-    /** The websocket is being opened */
-    ConnectionState["CONNECTING"] = "connecting";
-    /** The websocket is open but locked and notifications stream is being processed */
-    ConnectionState["PROCESSING_NOTIFICATIONS"] = "processing_notifications";
-    /** The websocket is open and message will go through and notifications stream is fully processed */
-    ConnectionState["LIVE"] = "live";
-})(ConnectionState = exports.ConnectionState || (exports.ConnectionState = {}));
-const coreDefaultClient = {
-    classification: client_1.ClientClassification.DESKTOP,
-    cookieLabel: 'default',
-    model: '@wireapp/core',
-};
-class Account extends events_1.EventEmitter {
-    /**
-     * @param apiClient The apiClient instance to use in the core (will create a new new one if undefined)
-     * @param accountOptions
-     */
-    constructor(apiClient = new api_client_1.APIClient(), { createStore = () => undefined, nbPrekeys = 2, cryptoProtocolConfig } = {}) {
-        super();
-        this.apiClient = apiClient;
-        this.backendFeatures = this.apiClient.backendFeatures;
-        this.cryptoProtocolConfig = cryptoProtocolConfig;
-        this.nbPrekeys = nbPrekeys;
-        this.createStore = createStore;
-        apiClient.on(api_client_1.APIClient.TOPIC.COOKIE_REFRESH, async (cookie) => {
-            if (cookie && this.storeEngine) {
-                try {
-                    await this.persistCookie(this.storeEngine, cookie);
-                }
-                catch (error) {
-                    this.logger.error(`Failed to save cookie: ${error.message}`, error);
-                }
-            }
-        });
-        this.logger = (0, logdown_1.default)('@wireapp/core/Account', {
-            logger: console,
-            markdown: false,
-        });
-    }
-    /**
-     * Will set the APIClient to use a specific version of the API (by default uses version 0)
-     * It will fetch the API Config and use the highest possible version
-     * @param acceptedVersions Which version the consumer supports
-     * @param useDevVersion allow the api-client to use development version of the api (if present). The dev version also need to be listed on the supportedVersions given as parameters
-     *   If we have version 2 that is a dev version, this is going to be the output of those calls
-     *   - useVersion([0, 1, 2], true) > version 2 is used
-     *   - useVersion([0, 1, 2], false) > version 1 is used
-     *   - useVersion([0, 1], true) > version 1 is used
-     * @return The highest version that is both supported by client and backend
-     */
-    async useAPIVersion(supportedVersions, useDevVersion) {
-        const features = await this.apiClient.useVersion(supportedVersions, useDevVersion);
-        this.backendFeatures = features;
-        return features;
-    }
-    persistCookie(storeEngine, cookie) {
-        const entity = { expiration: cookie.expiration, zuid: cookie.zuid };
-        return storeEngine.updateOrCreate(auth_1.AUTH_TABLE_NAME, auth_1.AUTH_COOKIE_KEY, entity);
-    }
-    get clientId() {
-        return this.apiClient.validatedClientId;
-    }
-    get userId() {
-        return this.apiClient.validatedUserId;
-    }
-    /**
-     * Will register a new user to the backend
-     *
-     * @param registration The user's data
-     * @param clientType Type of client to create (temporary or permanent)
-     */
-    async register(registration, clientType) {
-        const context = await this.apiClient.register(registration, clientType);
-        await this.initServices(context);
-        return context;
-    }
-    /**
-     * Will init the core with an already existing client (both on backend and local)
-     * Will fail if local client cannot be found
-     *
-     * @param clientType The type of client the user is using (temporary or permanent)
-     */
-    async init(clientType, { cookie, initClient = true, onNewClient } = {}) {
-        var _a, _b, _c, _d;
-        const context = await this.apiClient.init(clientType, cookie);
-        await this.initServices(context);
-        /** @fixme
-         * When we will start migrating to CoreCrypto encryption/decryption, those hooks won't be available anymore
-         * We will need to implement
-         *   - the mechanism to handle messages from an unknown sender
-         *   - the mechanism to generate new prekeys when we reach a certain threshold of prekeys
-         */
-        this.service.cryptography.setCryptoboxHooks({
-            onNewPrekeys: async (prekeys) => {
-                this.logger.debug(`Received '${prekeys.length}' new PreKeys.`);
-                await this.apiClient.api.client.putClient(context.clientId, { prekeys });
-                this.logger.debug(`Successfully uploaded '${prekeys.length}' PreKeys.`);
-            },
-            onNewSession: onNewClient,
-        });
-        // Assumption: client gets only initialized once
-        if (initClient) {
-            const { localClient } = await this.initClient({ clientType });
-            //call /access endpoint with client_id after client initialisation
-            await this.apiClient.transport.http.associateClientWithSession(localClient.id);
-            if (((_a = this.cryptoProtocolConfig) === null || _a === void 0 ? void 0 : _a.mls) && this.backendFeatures.supportsMLS) {
-                // initialize schedulers for pending mls proposals once client is initialized
-                await ((_b = this.service) === null || _b === void 0 ? void 0 : _b.mls.checkExistingPendingProposals());
-                // initialize schedulers for renewing key materials
-                (_c = this.service) === null || _c === void 0 ? void 0 : _c.mls.checkForKeyMaterialsUpdate();
-                // initialize scheduler for syncing key packages with backend
-                (_d = this.service) === null || _d === void 0 ? void 0 : _d.mls.checkForKeyPackagesBackendSync();
-            }
-        }
-        return context;
-    }
-    /**
-     * Will log the user in with the given credential.
-     * Will also create the local client and store it in DB
-     *
-     * @param loginData The credentials of the user
-     * @param initClient Should the call also create the local client
-     * @param clientInfo Info about the client to create (name, type...)
-     */
-    async login(loginData, initClient = true, clientInfo = coreDefaultClient) {
-        this.resetContext();
-        auth_2.LoginSanitizer.removeNonPrintableCharacters(loginData);
-        const context = await this.apiClient.login(loginData);
-        await this.initServices(context);
-        if (initClient) {
-            await this.initClient(loginData, clientInfo);
-        }
-        return context;
-    }
-    /**
-     * Will try to get the load the local client from local DB.
-     * If clientInfo are provided, will also create the client on backend and DB
-     * If clientInfo are not provided, the method will fail if local client cannot be found
-     *
-     * @param loginData User's credentials
-     * @param clientInfo Will allow creating the client if the local client cannot be found (else will fail if local client is not found)
-     * @param entropyData Additional entropy data
-     * @returns The local existing client or newly created client
-     */
-    async initClient(loginData, clientInfo, entropyData) {
-        var _a, _b;
-        if (!this.service) {
-            throw new Error('Services are not set.');
-        }
-        try {
-            const localClient = await this.loadAndValidateLocalClient(entropyData);
-            return { isNewClient: false, localClient };
-        }
-        catch (error) {
-            if (!clientInfo) {
-                // If no client info provided, the client should not be created
-                throw error;
-            }
-            // There was no client so we need to "create" and "register" a client
-            const notFoundInDatabase = error instanceof cryptobox.error.CryptoboxError ||
-                error.constructor.name === 'CryptoboxError' ||
-                error instanceof store_engine_1.error.RecordNotFoundError ||
-                error.constructor.name === store_engine_1.error.RecordNotFoundError.name;
-            const notFoundOnBackend = axios_1.default.isAxiosError(error) ? ((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === http_status_codes_1.StatusCodes.NOT_FOUND : false;
-            if (notFoundInDatabase) {
-                this.logger.log(`Could not find valid client in database "${(_b = this.storeEngine) === null || _b === void 0 ? void 0 : _b.storeName}".`);
-                return this.registerClient(loginData, clientInfo, entropyData);
-            }
-            if (notFoundOnBackend) {
-                this.logger.log('Could not find valid client on backend');
-                const client = await this.service.client.getLocalClient();
-                const shouldDeleteWholeDatabase = client.type === client_1.ClientType.TEMPORARY;
-                if (shouldDeleteWholeDatabase) {
-                    this.logger.log('Last client was temporary - Deleting database');
-                    if (this.storeEngine) {
-                        await this.storeEngine.clearTables();
-                    }
-                    const context = await this.apiClient.init(loginData.clientType);
-                    await this.initEngine(context);
-                    return this.registerClient(loginData, clientInfo, entropyData);
-                }
-                this.logger.log('Last client was permanent - Deleting cryptography stores');
-                await this.service.cryptography.deleteCryptographyStores();
-                return this.registerClient(loginData, clientInfo, entropyData);
-            }
-            throw error;
-        }
-    }
-    /**
-     * In order to be able to send MLS messages, the core needs a few information from the consumer.
-     * Namely:
-     * - is the current user allowed to administrate a specific conversation
-     * - what is the groupId of a conversation
-     * @param mlsCallbacks
-     */
-    configureMLSCallbacks(mlsCallbacks) {
-        var _a;
-        (_a = this.service) === null || _a === void 0 ? void 0 : _a.mls.configureMLSCallbacks(mlsCallbacks);
-    }
-    async initServices(context) {
-        var _a;
-        this.storeEngine = await this.initEngine(context);
-        const accountService = new account_1.AccountService(this.apiClient);
-        const assetService = new conversation_1.AssetService(this.apiClient);
-        const cryptographyService = new cryptography_1.CryptographyService(this.apiClient, this.storeEngine, {
-            // We want to encrypt with fully qualified session ids, only if the backend is federated with other backends
-            useQualifiedIds: this.backendFeatures.isFederated,
-            nbPrekeys: this.nbPrekeys,
-        });
-        const clientService = new client_2.ClientService(this.apiClient, this.storeEngine, cryptographyService);
-        const mlsService = new mls_1.MLSService(this.apiClient, () => this.coreCryptoClient, Object.assign(Object.assign({}, (_a = this.cryptoProtocolConfig) === null || _a === void 0 ? void 0 : _a.mls), { nbKeyPackages: this.nbPrekeys }));
-        const proteusService = new proteus_1.ProteusService(this.apiClient, cryptographyService, {
-            // We can use qualified ids to send messages as long as the backend supports federated endpoints
-            useQualifiedIds: this.backendFeatures.federationEndpoints,
-        });
-        const connectionService = new connection_1.ConnectionService(this.apiClient);
-        const giphyService = new giphy_1.GiphyService(this.apiClient);
-        const linkPreviewService = new linkPreview_1.LinkPreviewService(assetService);
-        const notificationService = new notification_1.NotificationService(this.apiClient, mlsService, proteusService, this.storeEngine);
-        const conversationService = new conversation_1.ConversationService(this.apiClient, cryptographyService, {
-            // We can use qualified ids to send messages as long as the backend supports federated endpoints
-            useQualifiedIds: this.backendFeatures.federationEndpoints,
-        }, mlsService, proteusService);
-        const selfService = new self_1.SelfService(this.apiClient);
-        const teamService = new team_1.TeamService(this.apiClient);
-        const broadcastService = new broadcast_1.BroadcastService(this.apiClient, cryptographyService);
-        const userService = new user_1.UserService(this.apiClient, broadcastService, connectionService);
-        this.service = {
-            mls: mlsService,
-            account: accountService,
-            asset: assetService,
-            broadcast: broadcastService,
-            client: clientService,
-            connection: connectionService,
-            conversation: conversationService,
-            cryptography: cryptographyService,
-            giphy: giphyService,
-            linkPreview: linkPreviewService,
-            notification: notificationService,
-            self: selfService,
-            team: teamService,
-            user: userService,
-        };
-    }
-    async loadAndValidateLocalClient(entropyData) {
-        var _a;
-        const loadedClient = await this.service.client.getLocalClient();
-        await this.apiClient.api.client.getClient(loadedClient.id);
-        this.apiClient.context.clientId = loadedClient.id;
-        await this.service.cryptography.initCryptobox();
-        if (((_a = this.cryptoProtocolConfig) === null || _a === void 0 ? void 0 : _a.mls) && this.backendFeatures.supportsMLS) {
-            this.coreCryptoClient = await this.createMLSClient(loadedClient, this.apiClient.context, this.cryptoProtocolConfig, entropyData);
-        }
-        return loadedClient;
-    }
-    async createMLSClient(client, context, cryptoProtocolConfig, entropyData) {
-        if (!this.service) {
-            throw new Error('Services are not set.');
-        }
-        const coreCryptoKeyId = 'corecrypto-key';
-        const dbName = this.generateSecretsDbName(context);
-        const secretStore = cryptoProtocolConfig.systemCrypto
-            ? await (0, encryptedStore_1.createCustomEncryptedStore)(dbName, cryptoProtocolConfig.systemCrypto)
-            : await (0, encryptedStore_1.createEncryptedStore)(dbName);
-        let key = await secretStore.getsecretValue(coreCryptoKeyId);
-        let isNewMLSDevice = false;
-        if (!key) {
-            key = window.crypto.getRandomValues(new Uint8Array(16));
-            await secretStore.saveSecretValue(coreCryptoKeyId, key);
-            // Keeping track that this device is a new MLS device (but can be an old proteus device)
-            isNewMLSDevice = true;
-        }
-        const { userId, domain } = this.apiClient.context;
-        const mlsClient = await core_crypto_1.CoreCrypto.init({
-            databaseName: `corecrypto-${this.generateDbName(context)}`,
-            key: bazinga64_1.Encoder.toBase64(key).asString,
-            clientId: `${userId}:${client.id}@${domain}`,
-            wasmFilePath: cryptoProtocolConfig.coreCrypoWasmFilePath,
-            entropySeed: entropyData,
-        });
-        if (isNewMLSDevice) {
-            // If the device is new, we need to upload keypackages and public key to the backend
-            await this.service.mls.uploadMLSPublicKeys(await mlsClient.clientPublicKey(), client.id);
-            await this.service.mls.uploadMLSKeyPackages(await mlsClient.clientKeypackages(this.nbPrekeys), client.id);
-        }
-        return mlsClient;
-    }
-    async registerClient(loginData, clientInfo = coreDefaultClient, entropyData) {
-        if (!this.service) {
-            throw new Error('Services are not set.');
-        }
-        this.logger.info(`Creating new client {mls: ${!!this.cryptoProtocolConfig}}`);
-        const registeredClient = await this.service.client.register(loginData, clientInfo, entropyData);
-        if (this.cryptoProtocolConfig && this.backendFeatures.supportsMLS) {
-            this.coreCryptoClient = await this.createMLSClient(registeredClient, this.apiClient.context, this.cryptoProtocolConfig, entropyData);
-        }
-        this.apiClient.context.clientId = registeredClient.id;
-        this.logger.info('Client is created');
-        await this.service.notification.initializeNotificationStream();
-        await this.service.client.synchronizeClients();
-        await this.service.cryptography.initCryptobox();
-        return { isNewClient: true, localClient: registeredClient };
-    }
-    resetContext() {
-        delete this.apiClient.context;
-        delete this.service;
-    }
-    /**
-     * Will logout the current user
-     * @param clearData if set to `true` will completely wipe any database that was created by the Account
-     */
-    async logout(clearData = false) {
-        if (clearData && this.coreCryptoClient) {
-            await this.coreCryptoClient.wipe();
-            await (0, encryptedStore_1.deleteEncryptedStore)(this.generateSecretsDbName(this.apiClient.context));
-        }
-        await this.apiClient.logout();
-        this.resetContext();
-    }
-    /**
-     * Will download and handle the notification stream since last stored notification id.
-     * Once the notification stream has been handled from backend, will then connect to the websocket and start listening to incoming events
-     *
-     * @param callbacks callbacks that will be called to handle different events
-     * @returns close a function that will disconnect from the websocket
-     */
-    listen({ onEvent = () => { }, onConnectionStateChanged = () => { }, onNotificationStreamProgress = () => { }, onMissedNotifications = () => { }, dryRun = false, } = {}) {
-        if (!this.apiClient.context) {
-            throw new Error('Context is not set - please login first');
-        }
-        const handleEvent = async (payload, source) => {
-            const { event } = payload;
-            switch (event === null || event === void 0 ? void 0 : event.type) {
-                case event_1.CONVERSATION_EVENT.MESSAGE_TIMER_UPDATE: {
-                    const { data: { message_timer }, conversation, } = event;
-                    const expireAfterMillis = Number(message_timer);
-                    this.service.conversation.messageTimer.setConversationLevelTimer(conversation, expireAfterMillis);
-                    break;
-                }
-            }
-            onEvent(payload, source);
-        };
-        const handleNotification = async (notification, source) => {
-            var _a, e_1, _b, _c;
-            try {
-                const messages = this.service.notification.handleNotification(notification, source, dryRun);
-                try {
-                    for (var _d = true, messages_1 = __asyncValues(messages), messages_1_1; messages_1_1 = await messages_1.next(), _a = messages_1_1.done, !_a;) {
-                        _c = messages_1_1.value;
-                        _d = false;
-                        try {
-                            const message = _c;
-                            await handleEvent(message, source);
-                        }
-                        finally {
-                            _d = true;
-                        }
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (!_d && !_a && (_b = messages_1.return)) await _b.call(messages_1);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
-            }
-            catch (error) {
-                this.logger.error(`Failed to handle notification ID "${notification.id}": ${error.message}`, error);
-            }
-        };
-        this.apiClient.transport.ws.removeAllListeners(tcp_1.WebSocketClient.TOPIC.ON_MESSAGE);
-        this.apiClient.transport.ws.on(tcp_1.WebSocketClient.TOPIC.ON_MESSAGE, notification => handleNotification(notification, notification_1.NotificationSource.WEBSOCKET));
-        this.apiClient.transport.ws.on(tcp_1.WebSocketClient.TOPIC.ON_STATE_CHANGE, wsState => {
-            const mapping = {
-                [ReconnectingWebsocket_1.WEBSOCKET_STATE.CLOSED]: ConnectionState.CLOSED,
-                [ReconnectingWebsocket_1.WEBSOCKET_STATE.CONNECTING]: ConnectionState.CONNECTING,
-            };
-            const connectionState = mapping[wsState];
-            if (connectionState) {
-                onConnectionStateChanged(connectionState);
-            }
-        });
-        const handleMissedNotifications = async (notificationId) => {
-            var _a, _b;
-            if (((_a = this.cryptoProtocolConfig) === null || _a === void 0 ? void 0 : _a.mls) && this.backendFeatures.supportsMLS) {
-                await ((_b = this.service) === null || _b === void 0 ? void 0 : _b.conversation.handleEpochMismatch());
-            }
-            return onMissedNotifications(notificationId);
-        };
-        const processNotificationStream = async (abortHandler) => {
-            // Lock websocket in order to buffer any message that arrives while we handle the notification stream
-            this.apiClient.transport.ws.lock();
-            (0, messageSender_1.pauseMessageSending)();
-            onConnectionStateChanged(ConnectionState.PROCESSING_NOTIFICATIONS);
-            const results = await this.service.notification.processNotificationStream(async (notification, source, progress) => {
-                await handleNotification(notification, source);
-                onNotificationStreamProgress(progress);
-            }, handleMissedNotifications, abortHandler);
-            this.logger.log(`Finished processing notifications ${JSON.stringify(results)}`, results);
-            if (abortHandler.isAborted()) {
-                this.logger.warn('Ending connection process as websocket was closed');
-                return;
-            }
-            onConnectionStateChanged(ConnectionState.LIVE);
-            // We can now unlock the websocket and let the new messages being handled and decrypted
-            this.apiClient.transport.ws.unlock();
-            // We need to wait for the notification stream to be fully handled before releasing the message sending queue.
-            // This is due to the nature of how message are encrypted, any change in mls epoch needs to happen before we start encrypting any kind of messages
-            this.logger.info(`Resuming message sending. ${(0, messageSender_1.getQueueLength)()} messages to be sent`);
-            (0, messageSender_1.resumeMessageSending)();
-        };
-        this.apiClient.connect(processNotificationStream);
-        return () => {
-            this.apiClient.disconnect();
-            onConnectionStateChanged(ConnectionState.CLOSED);
-            this.apiClient.transport.ws.removeAllListeners();
-        };
-    }
-    generateDbName(context) {
-        const clientType = context.clientType === client_1.ClientType.NONE ? '' : `@${context.clientType}`;
-        return `wire@${this.apiClient.config.urls.name}@${context.userId}${clientType}`;
-    }
-    generateSecretsDbName(context) {
-        return `secrets-${this.generateDbName(context)}`;
-    }
-    async initEngine(context) {
-        const dbName = this.generateDbName(context);
-        this.logger.log(`Initialising store with name "${dbName}"...`);
-        const openDb = async () => {
-            const initializedDb = await this.createStore(dbName, context);
-            if (initializedDb) {
-                this.logger.log(`Initialized store with existing engine "${dbName}".`);
-                return initializedDb;
-            }
-            this.logger.log(`Initialized store with new memory engine "${dbName}".`);
-            const memoryEngine = new store_engine_1.MemoryEngine();
-            await memoryEngine.init(dbName);
-            return memoryEngine;
-        };
-        const storeEngine = await openDb();
-        const cookie = auth_1.CookieStore.getCookie();
-        if (cookie) {
-            await this.persistCookie(storeEngine, cookie);
-        }
-        return storeEngine;
-    }
-}
-exports.Account = Account;
-Account.TOPIC = TOPIC;

package/lib/CoreError.d.ts

@@ -1,10 +0,0 @@
-import { Notification } from '@wireapp/api-client/lib/notification';
-export declare enum CoreError {
-    NOTIFICATION_ERROR = "CoreError.NOTIFICATION_ERROR"
-}
-export interface NotificationError {
-    error: Error;
-    notification: Notification;
-    type: CoreError.NOTIFICATION_ERROR;
-}
-//# sourceMappingURL=CoreError.d.ts.map

package/lib/CoreError.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CoreError.d.ts","sourceRoot":"","sources":["../src/CoreError.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,YAAY,EAAC,MAAM,sCAAsC,CAAC;AAElE,oBAAY,SAAS;IACnB,kBAAkB,iCAAiC;CACpD;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,KAAK,CAAC;IACb,YAAY,EAAE,YAAY,CAAC;IAC3B,IAAI,EAAE,SAAS,CAAC,kBAAkB,CAAC;CACpC"}

package/lib/CoreError.js

@@ -1,25 +0,0 @@
-"use strict";
-/*
- * Wire
- * Copyright (C) 2019 Wire Swiss GmbH
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see http://www.gnu.org/licenses/.
- *
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CoreError = void 0;
-var CoreError;
-(function (CoreError) {
-    CoreError["NOTIFICATION_ERROR"] = "CoreError.NOTIFICATION_ERROR";
-})(CoreError = exports.CoreError || (exports.CoreError = {}));

package/lib/account/AccountService.d.ts

@@ -1,8 +0,0 @@
-import { CallConfigData } from '@wireapp/api-client/lib/account/CallConfigData';
-import { APIClient } from '@wireapp/api-client';
-export declare class AccountService {
-    private readonly apiClient;
-    constructor(apiClient: APIClient);
-    getCallConfig(): Promise<CallConfigData>;
-}
-//# sourceMappingURL=AccountService.d.ts.map

package/lib/account/AccountService.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AccountService.d.ts","sourceRoot":"","sources":["../../src/account/AccountService.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,cAAc,EAAC,MAAM,gDAAgD,CAAC;AAE9E,OAAO,EAAC,SAAS,EAAC,MAAM,qBAAqB,CAAC;AAG9C,qBAAa,cAAc;IACb,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,EAAE,SAAS;IAEjD,aAAa,IAAI,OAAO,CAAC,cAAc,CAAC;CAIzC"}

package/lib/account/AccountService.js

@@ -1,32 +0,0 @@
-"use strict";
-/*
- * Wire
- * Copyright (C) 2020 Wire Swiss GmbH
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see http://www.gnu.org/licenses/.
- *
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AccountService = void 0;
-const commons_1 = require("@wireapp/commons");
-class AccountService {
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-    }
-    getCallConfig() {
-        const iceCandidateLimit = commons_1.Runtime.isFirefox() ? 3 : undefined;
-        return this.apiClient.api.account.getCallConfig(iceCandidateLimit);
-    }
-}
-exports.AccountService = AccountService;

package/lib/account/index.d.ts

@@ -1,2 +0,0 @@
-export * from './AccountService';
-//# sourceMappingURL=index.d.ts.map

package/lib/account/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/account/index.ts"],"names":[],"mappings":"AAmBA,cAAc,kBAAkB,CAAC"}