@wireapp/core 42.11.0 → 42.12.1

package/lib/messagingProtocols/mls/E2EIdentityService/Steps/DpopChallenge/index.js

@@ -0,0 +1,35 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2023 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("./DpopChallenge"), exports);

package/lib/messagingProtocols/mls/E2EIdentityService/Steps/OidcChallenge.d.ts

@@ -0,0 +1,28 @@
+import { GetAuthorizationReturnValue } from './Authorization';
+import { AcmeService } from '../Connection/AcmeServer';
+import { E2eiEnrollment, Nonce } from '../E2EIService.types';
+interface DoWireOidcChallengeParams {
+    authData: GetAuthorizationReturnValue;
+    identity: E2eiEnrollment;
+    connection: AcmeService;
+    nonce: Nonce;
+    oAuthIdToken: string;
+}
+export declare const doWireOidcChallenge: ({ connection, authData, identity, nonce, oAuthIdToken, }: DoWireOidcChallengeParams) => Promise<{
+    data: {
+        type: string;
+        url: string;
+        target: string;
+        status: string;
+        token: string;
+        validated?: string | undefined;
+        error?: {
+            type: string;
+            detail: string;
+        } | undefined;
+    };
+    nonce: string;
+    location?: string | undefined;
+}>;
+export {};
+//# sourceMappingURL=OidcChallenge.d.ts.map

package/lib/messagingProtocols/mls/E2EIdentityService/Steps/OidcChallenge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OidcChallenge.d.ts","sourceRoot":"","sources":["../../../../../src/messagingProtocols/mls/E2EIdentityService/Steps/OidcChallenge.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,2BAA2B,EAAC,MAAM,iBAAiB,CAAC;AAE5D,OAAO,EAAC,WAAW,EAAC,MAAM,0BAA0B,CAAC;AACrD,OAAO,EAAC,cAAc,EAAE,KAAK,EAAC,MAAM,sBAAsB,CAAC;AAE3D,UAAU,yBAAyB;IACjC,QAAQ,EAAE,2BAA2B,CAAC;IACtC,QAAQ,EAAE,cAAc,CAAC;IACzB,UAAU,EAAE,WAAW,CAAC;IACxB,KAAK,EAAE,KAAK,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,eAAO,MAAM,mBAAmB,6DAM7B,yBAAyB;;;;;;;;;;;;;;;EAc3B,CAAC"}

package/lib/messagingProtocols/mls/E2EIdentityService/Steps/OidcChallenge.js

@@ -0,0 +1,34 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2023 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.doWireOidcChallenge = void 0;
+const doWireOidcChallenge = async ({ connection, authData, identity, nonce, oAuthIdToken, }) => {
+    const { wireOidcChallenge } = authData.authorization;
+    if (!wireOidcChallenge) {
+        throw new Error('No wireOIDCChallenge defined');
+    }
+    const reqBody = identity.newOidcChallengeRequest(oAuthIdToken, nonce);
+    const oidcChallengeResponse = await connection.validateOidcChallenge(wireOidcChallenge.url, reqBody);
+    if (!oidcChallengeResponse) {
+        throw new Error('No response received while validating OIDC challenge');
+    }
+    return oidcChallengeResponse;
+};
+exports.doWireOidcChallenge = doWireOidcChallenge;

package/lib/messagingProtocols/mls/E2EIdentityService/Steps/Order.d.ts

@@ -0,0 +1,28 @@
+import { AcmeService } from '../Connection';
+import { AcmeDirectory, E2eiEnrollment, NewAcmeOrder, Nonce } from '../E2EIService.types';
+type OrderUrl = string;
+export interface CreateNewOrderParams {
+    identity: E2eiEnrollment;
+    nonce: Nonce;
+    directory: AcmeDirectory;
+    connection: AcmeService;
+}
+export type CreateNewOrderReturnValue = Promise<{
+    order: NewAcmeOrder;
+    nonce: string;
+    authzUrl: string;
+    orderUrl: OrderUrl;
+}>;
+export declare const createNewOrder: ({ identity, nonce, directory, connection, }: CreateNewOrderParams) => CreateNewOrderReturnValue;
+export interface FinalizeOrderParams {
+    connection: AcmeService;
+    identity: E2eiEnrollment;
+    nonce: Nonce;
+    orderUrl: OrderUrl;
+}
+export declare const finalizeOrder: ({ identity, nonce, orderUrl, connection }: FinalizeOrderParams) => Promise<{
+    certificateUrl: string;
+    nonce: string;
+}>;
+export {};
+//# sourceMappingURL=Order.d.ts.map

package/lib/messagingProtocols/mls/E2EIdentityService/Steps/Order.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Order.d.ts","sourceRoot":"","sources":["../../../../../src/messagingProtocols/mls/E2EIdentityService/Steps/Order.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,WAAW,EAAC,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAC,aAAa,EAAE,cAAc,EAAE,YAAY,EAAE,KAAK,EAAC,MAAM,sBAAsB,CAAC;AAGxF,KAAK,QAAQ,GAAG,MAAM,CAAC;AAEvB,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,cAAc,CAAC;IACzB,KAAK,EAAE,KAAK,CAAC;IACb,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,WAAW,CAAC;CACzB;AACD,MAAM,MAAM,yBAAyB,GAAG,OAAO,CAAC;IAC9C,KAAK,EAAE,YAAY,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,QAAQ,CAAC;CACpB,CAAC,CAAC;AAEH,eAAO,MAAM,cAAc,gDAKxB,oBAAoB,8BAatB,CAAC;AAEF,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,WAAW,CAAC;IACxB,QAAQ,EAAE,cAAc,CAAC;IACzB,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,EAAE,QAAQ,CAAC;CACpB;AACD,eAAO,MAAM,aAAa,8CAAmD,mBAAmB;;;EAqB/F,CAAC"}

package/lib/messagingProtocols/mls/E2EIdentityService/Steps/Order.js

@@ -0,0 +1,56 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2023 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.finalizeOrder = exports.createNewOrder = void 0;
+const Helper_1 = require("../Helper");
+const createNewOrder = async ({ identity, nonce, directory, connection, }) => {
+    var _a;
+    const reqBody = identity.newOrderRequest(nonce);
+    const response = await connection.createNewOrder(directory.newOrder, reqBody);
+    if ((response === null || response === void 0 ? void 0 : response.data) && !!response.data.status.length && !!response.nonce.length && !!((_a = response.location) === null || _a === void 0 ? void 0 : _a.length)) {
+        return {
+            order: identity.newOrderResponse((0, Helper_1.jsonToByteArray)(response.data)),
+            authzUrl: response.data.authorizations[0],
+            nonce: response.nonce,
+            orderUrl: response.location,
+        };
+    }
+    throw new Error('No createNewOrder-data received');
+};
+exports.createNewOrder = createNewOrder;
+const finalizeOrder = async ({ identity, nonce, orderUrl, connection }) => {
+    const statusReqBody = identity.checkOrderRequest(orderUrl, nonce);
+    const statusResponse = await connection.checkStatusOfOrder(orderUrl, statusReqBody);
+    if ((statusResponse === null || statusResponse === void 0 ? void 0 : statusResponse.data) && !!statusResponse.data.status.length && !!statusResponse.nonce.length) {
+        const finalizeUrl = identity.checkOrderResponse((0, Helper_1.jsonToByteArray)(statusResponse.data));
+        const finalizeReqBody = identity.finalizeRequest(statusResponse.nonce);
+        const finalizeResponse = await connection.finalizeOrder(finalizeUrl, finalizeReqBody);
+        if ((finalizeResponse === null || finalizeResponse === void 0 ? void 0 : finalizeResponse.data) && !!finalizeResponse.data.status.length && !!finalizeResponse.nonce.length) {
+            const certificateUrl = identity.finalizeResponse((0, Helper_1.jsonToByteArray)(finalizeResponse.data));
+            return {
+                certificateUrl,
+                nonce: finalizeResponse.nonce,
+            };
+        }
+        throw new Error('Error while finalizing order');
+    }
+    throw new Error('Error while checking status of order');
+};
+exports.finalizeOrder = finalizeOrder;

package/lib/messagingProtocols/mls/E2EIdentityService/Storage/E2EIStorage.d.ts

@@ -0,0 +1,28 @@
+import { AuthData, InitialData, OrderData } from './E2EIStorage.schema';
+export declare const E2EIStorage: {
+    store: {
+        handle: (handle: string) => void;
+        authData: (data: AuthData) => void;
+        orderData: (data: OrderData) => void;
+        initialData: (data: InitialData) => void;
+        certificate: (data: string) => void;
+    };
+    get: {
+        initialData: () => InitialData;
+        certificateData: () => string;
+        handle: () => string;
+        authData: () => AuthData;
+        orderData: () => OrderData;
+    };
+    has: {
+        handle: () => boolean;
+        initialData: () => boolean;
+        certificateData: () => boolean;
+    };
+    remove: {
+        temporaryData: () => void;
+        certificateData: () => void;
+        all: () => void;
+    };
+};
+//# sourceMappingURL=E2EIStorage.d.ts.map

package/lib/messagingProtocols/mls/E2EIdentityService/Storage/E2EIStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"E2EIStorage.d.ts","sourceRoot":"","sources":["../../../../../src/messagingProtocols/mls/E2EIdentityService/Storage/E2EIStorage.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,QAAQ,EAAkB,WAAW,EAAqB,SAAS,EAAC,MAAM,sBAAsB,CAAC;AAuFzG,eAAO,MAAM,WAAW;;yBA3EK,MAAM;yBAEN,QAAQ;0BADP,SAAS;4BAEP,WAAW;4BACX,MAAM;;;2BA0BX,WAAW;+BAoBP,MAAM;;wBA9BJ,QAAQ;yBAoBP,SAAS;;;;;;;;;;;;CA4D1C,CAAC"}

package/lib/messagingProtocols/mls/E2EIdentityService/Storage/E2EIStorage.js

@@ -0,0 +1,120 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2023 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.E2EIStorage = void 0;
+const E2EIStorage_schema_1 = require("./E2EIStorage.schema");
+const LocalStorageStore_1 = require("../../../../util/LocalStorageStore");
+const HandleKey = 'Handle';
+const AuthDataKey = 'AuthData';
+const OderDataKey = 'OrderData';
+const InitialDataKey = 'InitialData';
+const CertificateDataKey = 'CertificateData';
+const storage = (0, LocalStorageStore_1.LocalStorageStore)('E2EIStorage');
+const storeHandle = (handle) => storage.add(HandleKey, window.btoa(handle));
+const storeOrderData = (data) => storage.add(OderDataKey, window.btoa(JSON.stringify(data)));
+const storeAuthData = (data) => storage.add(AuthDataKey, window.btoa(JSON.stringify(data)));
+const storeInitialData = (data) => storage.add(InitialDataKey, window.btoa(JSON.stringify(data)));
+const storeCertificate = (data) => storage.add(CertificateDataKey, window.btoa(data));
+const hasHandle = () => storage.has(HandleKey);
+const hasInitialData = () => storage.has(InitialDataKey);
+const hasCertificateData = () => storage.has(CertificateDataKey);
+const getAndVerifyHandle = () => {
+    const handle = storage.get(HandleKey);
+    if (!handle) {
+        throw new Error('ACME: No handle found');
+    }
+    storage.remove(HandleKey);
+    const atob = window.atob(handle);
+    return atob;
+};
+const getAndVerifyAuthData = () => {
+    const data = storage.get(AuthDataKey);
+    if (!data) {
+        throw new Error('ACME: AuthData not found');
+    }
+    storage.remove(AuthDataKey);
+    const atob = window.atob(data);
+    return E2EIStorage_schema_1.AuthDataSchema.parse(JSON.parse(atob));
+};
+const getInitialData = () => {
+    const data = storage.get(InitialDataKey);
+    if (!data) {
+        throw new Error('ACME: InitialData not found');
+    }
+    storage.remove(InitialDataKey);
+    const atob = window.atob(data);
+    return E2EIStorage_schema_1.InitialDataSchema.parse(JSON.parse(atob));
+};
+const getAndVerifyOrderData = () => {
+    const data = storage.get(OderDataKey);
+    if (!data) {
+        throw new Error('ACME: OrderData not found');
+    }
+    storage.remove(OderDataKey);
+    const atob = window.atob(data);
+    return JSON.parse(atob);
+};
+const getCertificateData = () => {
+    const data = storage.get(CertificateDataKey);
+    if (!data) {
+        throw new Error('ACME: CertificateData not found');
+    }
+    const atob = window.atob(data);
+    return atob;
+};
+const removeTemporaryData = () => {
+    storage.remove(HandleKey);
+    storage.remove(AuthDataKey);
+    storage.remove(OderDataKey);
+    storage.remove(InitialDataKey);
+};
+const removeCertificateData = () => {
+    storage.remove(CertificateDataKey);
+};
+const removeAll = () => {
+    removeTemporaryData();
+    removeCertificateData();
+};
+exports.E2EIStorage = {
+    store: {
+        handle: storeHandle,
+        authData: storeAuthData,
+        orderData: storeOrderData,
+        initialData: storeInitialData,
+        certificate: storeCertificate,
+    },
+    get: {
+        initialData: getInitialData,
+        certificateData: getCertificateData,
+        handle: getAndVerifyHandle,
+        authData: getAndVerifyAuthData,
+        orderData: getAndVerifyOrderData,
+    },
+    has: {
+        handle: hasHandle,
+        initialData: hasInitialData,
+        certificateData: hasCertificateData,
+    },
+    remove: {
+        temporaryData: removeTemporaryData,
+        certificateData: removeCertificateData,
+        all: removeAll,
+    },
+};

package/lib/messagingProtocols/mls/E2EIdentityService/Storage/E2EIStorage.schema.d.ts

@@ -0,0 +1,136 @@
+import { z } from 'zod';
+export declare const InitialDataSchema: z.ZodObject<{
+    discoveryUrl: z.ZodString;
+    clientId: z.ZodString;
+    user: z.ZodObject<{
+        id: z.ZodString;
+        displayName: z.ZodString;
+        handle: z.ZodString;
+        domain: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        domain: string;
+        handle: string;
+        displayName: string;
+    }, {
+        id: string;
+        domain: string;
+        handle: string;
+        displayName: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    user: {
+        id: string;
+        domain: string;
+        handle: string;
+        displayName: string;
+    };
+    clientId: string;
+    discoveryUrl: string;
+}, {
+    user: {
+        id: string;
+        domain: string;
+        handle: string;
+        displayName: string;
+    };
+    clientId: string;
+    discoveryUrl: string;
+}>;
+export type InitialData = z.infer<typeof InitialDataSchema>;
+export declare const AuthDataSchema: z.ZodObject<{
+    authorization: z.ZodObject<{
+        identifier: z.ZodString;
+        wireDpopChallenge: z.ZodOptional<z.ZodObject<{
+            delegate: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
+            url: z.ZodString;
+            target: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            url: string;
+            target: string;
+            delegate: Uint8Array;
+        }, {
+            url: string;
+            target: string;
+            delegate: Uint8Array;
+        }>>;
+        wireOidcChallenge: z.ZodOptional<z.ZodObject<{
+            delegate: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
+            url: z.ZodString;
+            target: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            url: string;
+            target: string;
+            delegate: Uint8Array;
+        }, {
+            url: string;
+            target: string;
+            delegate: Uint8Array;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        identifier: string;
+        wireDpopChallenge?: {
+            url: string;
+            target: string;
+            delegate: Uint8Array;
+        } | undefined;
+        wireOidcChallenge?: {
+            url: string;
+            target: string;
+            delegate: Uint8Array;
+        } | undefined;
+    }, {
+        identifier: string;
+        wireDpopChallenge?: {
+            url: string;
+            target: string;
+            delegate: Uint8Array;
+        } | undefined;
+        wireOidcChallenge?: {
+            url: string;
+            target: string;
+            delegate: Uint8Array;
+        } | undefined;
+    }>;
+    nonce: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    nonce: string;
+    authorization: {
+        identifier: string;
+        wireDpopChallenge?: {
+            url: string;
+            target: string;
+            delegate: Uint8Array;
+        } | undefined;
+        wireOidcChallenge?: {
+            url: string;
+            target: string;
+            delegate: Uint8Array;
+        } | undefined;
+    };
+}, {
+    nonce: string;
+    authorization: {
+        identifier: string;
+        wireDpopChallenge?: {
+            url: string;
+            target: string;
+            delegate: Uint8Array;
+        } | undefined;
+        wireOidcChallenge?: {
+            url: string;
+            target: string;
+            delegate: Uint8Array;
+        } | undefined;
+    };
+}>;
+export type AuthData = z.infer<typeof AuthDataSchema>;
+export declare const OrderDataSchema: z.ZodObject<{
+    orderUrl: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    orderUrl: string;
+}, {
+    orderUrl: string;
+}>;
+export type OrderData = z.infer<typeof OrderDataSchema>;
+//# sourceMappingURL=E2EIStorage.schema.d.ts.map

package/lib/messagingProtocols/mls/E2EIdentityService/Storage/E2EIStorage.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"E2EIStorage.schema.d.ts","sourceRoot":"","sources":["../../../../../src/messagingProtocols/mls/E2EIdentityService/Storage/E2EIStorage.schema.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAS5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAU5D,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOzB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD,eAAO,MAAM,eAAe;;;;;;EAE1B,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/lib/messagingProtocols/mls/E2EIdentityService/Storage/E2EIStorage.schema.js

@@ -0,0 +1,49 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2023 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.OrderDataSchema = exports.AuthDataSchema = exports.InitialDataSchema = void 0;
+const zod_1 = require("zod");
+exports.InitialDataSchema = zod_1.z.object({
+    discoveryUrl: zod_1.z.string(),
+    clientId: zod_1.z.string(),
+    user: zod_1.z.object({
+        id: zod_1.z.string(),
+        displayName: zod_1.z.string(),
+        handle: zod_1.z.string(),
+        domain: zod_1.z.string(),
+    }),
+});
+const Uint8ArraySchema = zod_1.z.custom(value => value instanceof Uint8Array ? { success: true } : { success: false, message: 'Expected Uint8Array' });
+const AcmeChallengeSchema = zod_1.z.object({
+    delegate: Uint8ArraySchema,
+    url: zod_1.z.string(),
+    target: zod_1.z.string(),
+});
+exports.AuthDataSchema = zod_1.z.object({
+    authorization: zod_1.z.object({
+        identifier: zod_1.z.string(),
+        wireDpopChallenge: AcmeChallengeSchema.optional(),
+        wireOidcChallenge: AcmeChallengeSchema.optional(),
+    }),
+    nonce: zod_1.z.string(),
+});
+exports.OrderDataSchema = zod_1.z.object({
+    orderUrl: zod_1.z.string().url(),
+});

package/lib/messagingProtocols/mls/E2EIdentityService/index.d.ts

@@ -0,0 +1,4 @@
+export * from './E2EIService.types';
+export * from './E2EIServiceInternal';
+export * from './E2EIServiceExternal';
+//# sourceMappingURL=index.d.ts.map

package/lib/messagingProtocols/mls/E2EIdentityService/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/messagingProtocols/mls/E2EIdentityService/index.ts"],"names":[],"mappings":"AAmBA,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC"}

package/lib/messagingProtocols/mls/E2EIdentityService/index.js

@@ -0,0 +1,37 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2023 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("./E2EIService.types"), exports);
+__exportStar(require("./E2EIServiceInternal"), exports);
+__exportStar(require("./E2EIServiceExternal"), exports);

package/lib/messagingProtocols/mls/MLSService/MLSService.d.ts

@@ -11,7 +11,8 @@ import { MLSServiceConfig } from './MLSService.types';
 import { KeyPackageClaimUser } from '../../../conversation';
 import { CoreDatabase } from '../../../storage/CoreDB';
 import { RecurringTaskScheduler } from '../../../util/RecurringTaskScheduler';
-import { CommitPendingProposalsParams, HandlePendingProposalsParams, MLSCallbacks } from '../types';
+import { AcmeChallenge, E2EIServiceExternal, User } from '../E2EIdentityService';
+import { ClientId, CommitPendingProposalsParams, HandlePendingProposalsParams, MLSCallbacks } from '../types';
 export declare const optionalToUint8Array: (array: Uint8Array | []) => Uint8Array;
 interface LocalMLSServiceConfig extends MLSServiceConfig {
     /**
@@ -21,7 +22,7 @@ interface LocalMLSServiceConfig extends MLSServiceConfig {
 }
 export interface SubconversationEpochInfoMember {
     userid: string;
-    clientid: string;
+    clientid: ClientId;
     in_subconv: boolean;
 }
 type Events = {
@@ -122,7 +123,7 @@ export declare class MLSService extends TypedEventEmitter<Events> {
      * @param groupId groupId of the conversation
      * @param clientIds the list of **qualified** ids of the clients we want to remove from the group
      */
-    removeClientsFromConversation(groupId: string, clientIds: string[]): Promise<PostMlsMessageResponse>;
+    removeClientsFromConversation(groupId: string, clientIds: ClientId[]): Promise<PostMlsMessageResponse>;
     private commitProposals;
     /**
      * Will check if mls group exists in corecrypto.
@@ -153,7 +154,7 @@ export declare class MLSService extends TypedEventEmitter<Events> {
      * Will cancel the renewal of the key material for a given groupId
      * @param groupId The group that should stop having its key material updated
      */
-    cancelKeyMaterialRenewal(groupId: string): Promise<void>;
+    private cancelKeyMaterialRenewal;
     /**
      * Will schedule a task to update the key material of the conversation according to the threshold given as config
      * @param groupId
@@ -203,6 +204,9 @@ export declare class MLSService extends TypedEventEmitter<Events> {
      * @param eventTime time of the event that had the proposals
      */
     handlePendingProposals({ delayInMs, groupId, eventTime }: HandlePendingProposalsParams): Promise<void>;
+    private schedulePendingProposalsTask;
+    private cancelPendingProposalsTask;
+    private createPendingProposalsTaskKey;
     /**
      * Commit all pending proposals for a given groupId
      *
@@ -215,7 +219,7 @@ export declare class MLSService extends TypedEventEmitter<Events> {
      * Function must only be called once, after application start
      *
      */
-    checkExistingPendingProposals(): Promise<void>;
+    initialisePendingProposalsTasks(): Promise<void>;
     /**
      * Get all conversation members client ids.
      *
@@ -223,11 +227,22 @@ export declare class MLSService extends TypedEventEmitter<Events> {
      */
     getClientIds(groupId: string): Promise<{
         userId: string;
-        clientId: string;
+        clientId: ClientId;
         domain: string;
     }[]>;
     handleMLSMessageAddEvent(event: ConversationMLSMessageAddEvent): Promise<import("../../../notification").HandledEventPayload | null>;
     handleMLSWelcomeMessageEvent(event: ConversationMLSWelcomeEvent, clientId: string): Promise<import("../../../notification").HandledEventPayload>;
+    deleteMLSKeyPackages(clientId: ClientId, keyPackagRefs: Uint8Array[]): Promise<void>;
+    /**
+     *
+     * @param discoveryUrl URL of the acme server
+     * @param user User object
+     * @param clientId The client id of the current device
+     * @param nbPrekeys Amount of prekeys to generate
+     * @param oAuthIdToken The OAuth id token if the user is already authenticated
+     * @returns AcmeChallenge if the user is not authenticated, true if the user is authenticated
+     */
+    enrollE2EI(discoveryUrl: string, e2eiServiceExternal: E2EIServiceExternal, user: User, clientId: ClientId, nbPrekeys: number, oAuthIdToken?: string): Promise<AcmeChallenge | boolean>;
 }
 export {};
 //# sourceMappingURL=MLSService.d.ts.map