@wireapp/core 31.1.3 → 31.1.4

package/src/main/auth/index.js

@@ -0,0 +1,36 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./LoginSanitizer"), exports);
+//# sourceMappingURL=index.js.map

package/src/main/broadcast/AvailabilityType.d.ts

@@ -0,0 +1,2 @@
+import { Availability } from '@wireapp/protocol-messaging';
+export declare type AvailabilityType = Availability.Type;

package/src/main/broadcast/AvailabilityType.js

@@ -0,0 +1,21 @@
+"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/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=AvailabilityType.js.map

package/src/main/broadcast/BroadcastService.d.ts

@@ -0,0 +1,24 @@
+import { APIClient } from '@wireapp/api-client';
+import { ClientMismatch, MessageSendingStatus, QualifiedUserClients, UserClients } from '@wireapp/api-client/src/conversation';
+import { UserPreKeyBundleMap } from '@wireapp/api-client/src/user/';
+import { GenericMessage } from '@wireapp/protocol-messaging';
+import { CryptographyService } from '../cryptography/';
+export declare class BroadcastService {
+    private readonly apiClient;
+    private readonly cryptographyService;
+    private readonly messageService;
+    constructor(apiClient: APIClient, cryptographyService: CryptographyService);
+    /**
+     * Will create a key bundle for all the users of the team
+     *
+     * @param teamId
+     * @param skipOwnClients=false
+     * @param onlyDirectConnections=false Will generate a bundle only for directly connected users (users the self user has conversation with). Allows avoiding broadcasting messages to too many people
+     */
+    getPreKeyBundlesFromTeam(teamId: string, skipOwnClients?: boolean, onlyDirectConnections?: boolean): Promise<UserPreKeyBundleMap>;
+    broadcastGenericMessage(genericMessage: GenericMessage, recipients: UserPreKeyBundleMap | UserClients | QualifiedUserClients, sendAsProtobuf?: boolean, onClientMismatch?: (mismatch: ClientMismatch | MessageSendingStatus) => void | boolean | Promise<boolean>): Promise<(MessageSendingStatus & {
+        errored?: boolean | undefined;
+    }) | (ClientMismatch & {
+        errored?: boolean | undefined;
+    })>;
+}

package/src/main/broadcast/BroadcastService.js

@@ -0,0 +1,74 @@
+"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/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BroadcastService = void 0;
+const protocol_messaging_1 = require("@wireapp/protocol-messaging");
+const MessageService_1 = require("../conversation/message/MessageService");
+const UserClientsUtil_1 = require("../conversation/message/UserClientsUtil");
+const util_1 = require("../util");
+class BroadcastService {
+    constructor(apiClient, cryptographyService) {
+        this.apiClient = apiClient;
+        this.cryptographyService = cryptographyService;
+        this.messageService = new MessageService_1.MessageService(this.apiClient, this.cryptographyService);
+    }
+    /**
+     * Will create a key bundle for all the users of the team
+     *
+     * @param teamId
+     * @param skipOwnClients=false
+     * @param onlyDirectConnections=false Will generate a bundle only for directly connected users (users the self user has conversation with). Allows avoiding broadcasting messages to too many people
+     */
+    async getPreKeyBundlesFromTeam(teamId, skipOwnClients = false, onlyDirectConnections = false) {
+        const teamMembers = onlyDirectConnections
+            ? (await this.apiClient.api.conversation.getConversations()).conversations
+                .map(({ members }) => members.others.map(user => user.id).concat(members.self.id))
+                .flat()
+            : (await this.apiClient.api.teams.member.getAllMembers(teamId)).members.map(({ user }) => user);
+        let members = Array.from(new Set(teamMembers)).map(member => ({ id: member }));
+        if (skipOwnClients) {
+            const selfUser = await this.apiClient.api.self.getSelf();
+            members = members.filter(member => member.id !== selfUser.id);
+        }
+        const preKeys = await Promise.all(members.map(member => this.apiClient.api.user.getUserPreKeys(member.id)));
+        return preKeys.reduce((bundleMap, bundle) => {
+            bundleMap[bundle.user] = {};
+            for (const client of bundle.clients) {
+                bundleMap[bundle.user][client.client] = client.prekey;
+            }
+            return bundleMap;
+        }, {});
+    }
+    async broadcastGenericMessage(genericMessage, recipients, sendAsProtobuf, onClientMismatch) {
+        const plainTextArray = protocol_messaging_1.GenericMessage.encode(genericMessage).finish();
+        return (0, util_1.isQualifiedUserClients)(recipients)
+            ? this.messageService.sendFederatedMessage(this.apiClient.validatedClientId, recipients, plainTextArray, {
+                reportMissing: (0, UserClientsUtil_1.flattenQualifiedUserClients)(recipients).map(({ userId }) => userId),
+                onClientMismatch,
+            })
+            : this.messageService.sendMessage(this.apiClient.validatedClientId, recipients, plainTextArray, {
+                sendAsProtobuf,
+                reportMissing: Object.keys(recipients),
+                onClientMismatch,
+            });
+    }
+}
+exports.BroadcastService = BroadcastService;
+//# sourceMappingURL=BroadcastService.js.map

package/src/main/broadcast/index.d.ts

@@ -0,0 +1,2 @@
+export * from './AvailabilityType';
+export * from './BroadcastService';

package/src/main/broadcast/index.js

@@ -0,0 +1,37 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AvailabilityType"), exports);
+__exportStar(require("./BroadcastService"), exports);
+//# sourceMappingURL=index.js.map

package/src/main/client/ClientBackendRepository.d.ts

@@ -0,0 +1,11 @@
+import { APIClient } from '@wireapp/api-client';
+import { CreateClientPayload, RegisteredClient, UpdateClientPayload } from '@wireapp/api-client/src/client/';
+export declare class ClientBackendRepository {
+    private readonly apiClient;
+    constructor(apiClient: APIClient);
+    getClients(): Promise<RegisteredClient[]>;
+    postClient(client: CreateClientPayload): Promise<RegisteredClient>;
+    putClient(clientId: string, updates: UpdateClientPayload): Promise<void>;
+    deleteClient(clientId: string, password?: string): Promise<void>;
+    uploadMLSKeyPackages(clientId: string, keyPackages: string[]): Promise<void>;
+}

package/src/main/client/ClientBackendRepository.js

@@ -0,0 +1,43 @@
+"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/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientBackendRepository = void 0;
+class ClientBackendRepository {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    getClients() {
+        return this.apiClient.api.client.getClients();
+    }
+    postClient(client) {
+        return this.apiClient.api.client.postClient(client);
+    }
+    putClient(clientId, updates) {
+        return this.apiClient.api.client.putClient(clientId, updates);
+    }
+    deleteClient(clientId, password) {
+        return this.apiClient.api.client.deleteClient(clientId, password);
+    }
+    uploadMLSKeyPackages(clientId, keyPackages) {
+        return this.apiClient.api.client.uploadMLSKeyPackages(clientId, keyPackages);
+    }
+}
+exports.ClientBackendRepository = ClientBackendRepository;
+//# sourceMappingURL=ClientBackendRepository.js.map

package/src/main/client/ClientDatabaseRepository.d.ts

@@ -0,0 +1,27 @@
+import { RegisteredClient } from '@wireapp/api-client/src/client/';
+import { CRUDEngine } from '@wireapp/store-engine';
+import { CryptographyService } from '../cryptography/';
+import { MetaClient } from './ClientService';
+export declare enum DatabaseStores {
+    CLIENTS = "clients"
+}
+export declare class ClientDatabaseRepository {
+    private readonly storeEngine;
+    private readonly cryptographyService;
+    static readonly STORES: typeof DatabaseStores;
+    static KEYS: {
+        LOCAL_IDENTITY: string;
+    };
+    constructor(storeEngine: CRUDEngine, cryptographyService: CryptographyService);
+    getLocalClient(): Promise<MetaClient>;
+    getClient(sessionId: string): Promise<MetaClient>;
+    deleteLocalClient(): Promise<string>;
+    deleteClient(sessionId: string): Promise<string>;
+    createClientList(userId: string, clientList: RegisteredClient[], domain?: string): Promise<MetaClient[]>;
+    createLocalClient(client: RegisteredClient, domain?: string): Promise<MetaClient>;
+    updateLocalClient(client: RegisteredClient, domain?: string): Promise<MetaClient>;
+    updateClient(userId: string, client: RegisteredClient, domain?: string): Promise<MetaClient>;
+    createClient(userId: string, client: RegisteredClient, domain?: string): Promise<MetaClient>;
+    private transformClient;
+    private transformLocalClient;
+}

package/src/main/client/ClientDatabaseRepository.js

@@ -0,0 +1,85 @@
+"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/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientDatabaseRepository = exports.DatabaseStores = void 0;
+var DatabaseStores;
+(function (DatabaseStores) {
+    DatabaseStores["CLIENTS"] = "clients";
+})(DatabaseStores = exports.DatabaseStores || (exports.DatabaseStores = {}));
+class ClientDatabaseRepository {
+    constructor(storeEngine, cryptographyService) {
+        this.storeEngine = storeEngine;
+        this.cryptographyService = cryptographyService;
+    }
+    getLocalClient() {
+        return this.getClient(ClientDatabaseRepository.KEYS.LOCAL_IDENTITY);
+    }
+    getClient(sessionId) {
+        return this.storeEngine.read(ClientDatabaseRepository.STORES.CLIENTS, sessionId);
+    }
+    deleteLocalClient() {
+        return this.deleteClient(ClientDatabaseRepository.KEYS.LOCAL_IDENTITY);
+    }
+    deleteClient(sessionId) {
+        return this.storeEngine.delete(ClientDatabaseRepository.STORES.CLIENTS, sessionId);
+    }
+    createClientList(userId, clientList, domain) {
+        const createClientTasks = [];
+        for (const client of clientList) {
+            createClientTasks.push(this.createClient(userId, client, domain));
+        }
+        return Promise.all(createClientTasks);
+    }
+    async createLocalClient(client, domain) {
+        const transformedClient = this.transformLocalClient(client, domain);
+        await this.storeEngine.create(ClientDatabaseRepository.STORES.CLIENTS, ClientDatabaseRepository.KEYS.LOCAL_IDENTITY, transformedClient);
+        return transformedClient;
+    }
+    async updateLocalClient(client, domain) {
+        const transformedClient = this.transformLocalClient(client, domain);
+        await this.storeEngine.update(ClientDatabaseRepository.STORES.CLIENTS, ClientDatabaseRepository.KEYS.LOCAL_IDENTITY, transformedClient);
+        return transformedClient;
+    }
+    async updateClient(userId, client, domain) {
+        const transformedClient = this.transformClient(userId, client, false, domain);
+        await this.storeEngine.update(ClientDatabaseRepository.STORES.CLIENTS, this.cryptographyService.constructSessionId(userId, client.id, domain), transformedClient);
+        return transformedClient;
+    }
+    async createClient(userId, client, domain) {
+        const transformedClient = this.transformClient(userId, client, false, domain);
+        await this.storeEngine.create(ClientDatabaseRepository.STORES.CLIENTS, this.cryptographyService.constructSessionId(userId, client.id, domain), transformedClient);
+        return transformedClient;
+    }
+    transformClient(userId, client, verified, domain) {
+        return Object.assign(Object.assign({}, client), { domain, meta: {
+                is_verified: verified,
+                primary_key: this.cryptographyService.constructSessionId(userId, client.id, domain),
+            } });
+    }
+    transformLocalClient(client, domain) {
+        return Object.assign(Object.assign({}, client), { domain, meta: { is_verified: true, primary_key: ClientDatabaseRepository.KEYS.LOCAL_IDENTITY } });
+    }
+}
+exports.ClientDatabaseRepository = ClientDatabaseRepository;
+ClientDatabaseRepository.STORES = DatabaseStores;
+ClientDatabaseRepository.KEYS = {
+    LOCAL_IDENTITY: 'local_identity',
+};
+//# sourceMappingURL=ClientDatabaseRepository.js.map

package/src/main/client/ClientInfo.d.ts

@@ -0,0 +1,8 @@
+import { ClientClassification, Location } from '@wireapp/api-client/src/client/';
+export interface ClientInfo {
+    classification: ClientClassification.DESKTOP | ClientClassification.PHONE | ClientClassification.TABLET;
+    cookieLabel: string;
+    label?: string;
+    location?: Location;
+    model: string;
+}

package/src/main/client/ClientInfo.js

@@ -0,0 +1,21 @@
+"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/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ClientInfo.js.map

package/src/main/client/ClientService.d.ts

@@ -0,0 +1,40 @@
+import { APIClient } from '@wireapp/api-client';
+import { LoginData } from '@wireapp/api-client/src/auth/';
+import { RegisteredClient } from '@wireapp/api-client/src/client/';
+import { CRUDEngine } from '@wireapp/store-engine';
+import { CryptographyService } from '../cryptography/';
+import { ClientInfo } from './';
+export interface MetaClient extends RegisteredClient {
+    domain?: string;
+    meta: {
+        is_verified?: boolean;
+        primary_key: string;
+    };
+}
+export declare class ClientService {
+    private readonly apiClient;
+    private readonly storeEngine;
+    private readonly cryptographyService;
+    private readonly database;
+    private readonly backend;
+    constructor(apiClient: APIClient, storeEngine: CRUDEngine, cryptographyService: CryptographyService);
+    getClients(): Promise<RegisteredClient[]>;
+    /**
+     * Will delete the given client from backend and will also delete it from the local database
+     *
+     * note: use deleteLocalClient if you wish to delete the client currently used by the user
+     *
+     * @param clientId The id of the client to delete
+     * @param password? Password of the owning user. Can be omitted for temporary devices
+     */
+    deleteClient(clientId: string, password?: string): Promise<unknown>;
+    /**
+     * Will delete the local client (client currently in use by the user) from backend and will also delete it from the local database
+     * @param password? Password of the owning user. Can be omitted for temporary devices
+     */
+    deleteLocalClient(password?: string): Promise<string>;
+    getLocalClient(): Promise<MetaClient>;
+    createLocalClient(client: RegisteredClient, domain?: string): Promise<MetaClient>;
+    synchronizeClients(): Promise<MetaClient[]>;
+    register(loginData: LoginData, clientInfo: ClientInfo, entropyData?: Uint8Array): Promise<RegisteredClient>;
+}

package/src/main/client/ClientService.js

@@ -0,0 +1,103 @@
+"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/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientService = void 0;
+const client_1 = require("@wireapp/api-client/src/client/");
+const _1 = require("./");
+class ClientService {
+    constructor(apiClient, storeEngine, cryptographyService) {
+        this.apiClient = apiClient;
+        this.storeEngine = storeEngine;
+        this.cryptographyService = cryptographyService;
+        this.database = new _1.ClientDatabaseRepository(this.storeEngine, this.cryptographyService);
+        this.backend = new _1.ClientBackendRepository(this.apiClient);
+    }
+    getClients() {
+        return this.backend.getClients();
+    }
+    /**
+     * Will delete the given client from backend and will also delete it from the local database
+     *
+     * note: use deleteLocalClient if you wish to delete the client currently used by the user
+     *
+     * @param clientId The id of the client to delete
+     * @param password? Password of the owning user. Can be omitted for temporary devices
+     */
+    async deleteClient(clientId, password) {
+        const userId = { id: this.apiClient.userId, domain: this.apiClient.domain || '' };
+        await this.backend.deleteClient(clientId, password);
+        return this.database.deleteClient(this.cryptographyService.constructSessionId(userId, clientId));
+    }
+    /**
+     * Will delete the local client (client currently in use by the user) from backend and will also delete it from the local database
+     * @param password? Password of the owning user. Can be omitted for temporary devices
+     */
+    async deleteLocalClient(password) {
+        var _a;
+        const localClientId = (_a = this.apiClient.context) === null || _a === void 0 ? void 0 : _a.clientId;
+        if (!localClientId) {
+            throw new Error('Trying to delete local client, but local client has not been set');
+        }
+        await this.backend.deleteClient(localClientId, password);
+        return this.database.deleteLocalClient();
+    }
+    getLocalClient() {
+        return this.database.getLocalClient();
+    }
+    createLocalClient(client, domain) {
+        return this.database.createLocalClient(client, domain);
+    }
+    async synchronizeClients() {
+        var _a;
+        const registeredClients = await this.backend.getClients();
+        const filteredClients = registeredClients.filter(client => client.id !== this.apiClient.context.clientId);
+        return this.database.createClientList(this.apiClient.context.userId, filteredClients, (_a = this.apiClient.context) === null || _a === void 0 ? void 0 : _a.domain);
+    }
+    // TODO: Split functionality into "create" and "register" client
+    async register(loginData, clientInfo, entropyData) {
+        if (!this.apiClient.context) {
+            throw new Error('Context is not set.');
+        }
+        if (loginData.clientType === client_1.ClientType.NONE) {
+            throw new Error(`Can't register client of type "${client_1.ClientType.NONE}"`);
+        }
+        const serializedPreKeys = await this.cryptographyService.createCryptobox(entropyData);
+        if (!this.cryptographyService.cryptobox.lastResortPreKey) {
+            throw new Error('Cryptobox got initialized without a last resort PreKey.');
+        }
+        const newClient = {
+            class: clientInfo.classification,
+            cookie: clientInfo.cookieLabel,
+            label: clientInfo.label,
+            lastkey: this.cryptographyService.cryptobox.serialize_prekey(this.cryptographyService.cryptobox.lastResortPreKey),
+            location: clientInfo.location,
+            model: clientInfo.model,
+            password: loginData.password ? String(loginData.password) : undefined,
+            verification_code: loginData.verificationCode,
+            prekeys: serializedPreKeys,
+            type: loginData.clientType,
+        };
+        const client = await this.backend.postClient(newClient);
+        await this.createLocalClient(client, this.apiClient.context.domain);
+        return client;
+    }
+}
+exports.ClientService = ClientService;
+//# sourceMappingURL=ClientService.js.map

package/src/main/client/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ClientInfo';
+export * from './ClientService';
+export * from './ClientBackendRepository';
+export * from './ClientDatabaseRepository';

package/src/main/client/index.js

@@ -0,0 +1,39 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ClientInfo"), exports);
+__exportStar(require("./ClientService"), exports);
+__exportStar(require("./ClientBackendRepository"), exports);
+__exportStar(require("./ClientDatabaseRepository"), exports);
+//# sourceMappingURL=index.js.map

package/src/main/connection/ConnectionService.d.ts

@@ -0,0 +1,11 @@
+import { APIClient } from '@wireapp/api-client';
+import { Connection } from '@wireapp/api-client/src/connection/';
+import { QualifiedId } from '@wireapp/api-client/src/user';
+export declare class ConnectionService {
+    private readonly apiClient;
+    constructor(apiClient: APIClient);
+    getConnections(): Promise<Connection[]>;
+    acceptConnection(userId: string): Promise<Connection>;
+    ignoreConnection(userId: string): Promise<Connection>;
+    createConnection(userId: QualifiedId): Promise<Connection>;
+}

package/src/main/connection/ConnectionService.js

@@ -0,0 +1,45 @@
+"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/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionService = void 0;
+const connection_1 = require("@wireapp/api-client/src/connection/");
+class ConnectionService {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    getConnections() {
+        return this.apiClient.api.connection.getAllConnections();
+    }
+    acceptConnection(userId) {
+        return this.apiClient.api.connection.putConnection(userId, {
+            status: connection_1.ConnectionStatus.ACCEPTED,
+        });
+    }
+    ignoreConnection(userId) {
+        return this.apiClient.api.connection.putConnection(userId, {
+            status: connection_1.ConnectionStatus.IGNORED,
+        });
+    }
+    createConnection(userId) {
+        return this.apiClient.api.connection.postConnection(userId, '');
+    }
+}
+exports.ConnectionService = ConnectionService;
+//# sourceMappingURL=ConnectionService.js.map

package/src/main/connection/index.d.ts

@@ -0,0 +1 @@
+export * from './ConnectionService';