@wireapp/core-crypto 0.6.0-rc.3 → 0.6.0-rc.4

package/platforms/web/corecrypto.js

@@ -252,7 +252,7 @@ function makeMutClosure(arg0, arg1, dtor, f) {
 function __wbg_adapter_52(arg0, arg1, arg2) {
     try {
         const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
-        wasm$1._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h5a2d63dc59f76e61(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm$1._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h577395c5a39b7036(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getInt32Memory0()[retptr / 4 + 0];
         var r1 = getInt32Memory0()[retptr / 4 + 1];
         if (r1) {
@@ -264,31 +264,7 @@ function __wbg_adapter_52(arg0, arg1, arg2) {
 }
 
 function __wbg_adapter_55(arg0, arg1, arg2) {
-    wasm$1._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h6d113a8418e47593(arg0, arg1, addHeapObject(arg2));
-}
-
-/**
-* Returns the current version of CoreCrypto
-* @returns {string}
-*/
-function version() {
-    try {
-        const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
-        wasm$1.version(retptr);
-        var r0 = getInt32Memory0()[retptr / 4 + 0];
-        var r1 = getInt32Memory0()[retptr / 4 + 1];
-        return getStringFromWasm0(r0, r1);
-    } finally {
-        wasm$1.__wbindgen_add_to_stack_pointer(16);
-        wasm$1.__wbindgen_free(r0, r1);
-    }
-}
-
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1);
-    getUint8Memory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
+    wasm$1._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h6fecff61d3f85de1(arg0, arg1, addHeapObject(arg2));
 }
 
 function _assertClass(instance, klass) {
@@ -317,6 +293,39 @@ function passArrayJsValueToWasm0(array, malloc) {
     return ptr;
 }
 
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1);
+    getUint8Memory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    const mem = getUint32Memory0();
+    const slice = mem.subarray(ptr / 4, ptr / 4 + len);
+    const result = [];
+    for (let i = 0; i < slice.length; i++) {
+        result.push(takeObject(slice[i]));
+    }
+    return result;
+}
+/**
+* Returns the current version of CoreCrypto
+* @returns {string}
+*/
+function version() {
+    try {
+        const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+        wasm$1.version(retptr);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm$1.__wbindgen_add_to_stack_pointer(16);
+        wasm$1.__wbindgen_free(r0, r1);
+    }
+}
+
 function handleError(f, args) {
     try {
         return f.apply(this, args);
@@ -328,8 +337,8 @@ function handleError(f, args) {
 function getArrayU8FromWasm0(ptr, len) {
     return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
 }
-function __wbg_adapter_220(arg0, arg1, arg2, arg3) {
-    wasm$1.wasm_bindgen__convert__closures__invoke2_mut__h05b8fb12110402b0(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wbg_adapter_260(arg0, arg1, arg2, arg3) {
+    wasm$1.wasm_bindgen__convert__closures__invoke2_mut__ha446eb95921e2107(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 /**
@@ -377,6 +386,202 @@ MLS_256_DHKEMX448_CHACHA20POLY1305_SHA512_Ed448:6,"6":"MLS_256_DHKEMX448_CHACHA2
 */
 MLS_256_DHKEMP384_AES256GCM_SHA384_P384:7,"7":"MLS_256_DHKEMP384_AES256GCM_SHA384_P384", });
 /**
+* See [core_crypto::e2e_identity::types::E2eiAcmeChallenge]
+*/
+class AcmeChallenge {
+
+    static __wrap(ptr) {
+        const obj = Object.create(AcmeChallenge.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm$1.__wbg_acmechallenge_free(ptr);
+    }
+    /**
+    * @param {Uint8Array} delegate
+    * @param {string} url
+    */
+    constructor(delegate, url) {
+        const ptr0 = passStringToWasm0(url, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm$1.acmechallenge_new(addHeapObject(delegate), ptr0, len0);
+        return AcmeChallenge.__wrap(ret);
+    }
+    /**
+    * @returns {Uint8Array}
+    */
+    get delegate() {
+        const ret = wasm$1.acmechallenge_delegate(this.ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @returns {string}
+    */
+    get url() {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.acmechallenge_url(retptr, this.ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+            wasm$1.__wbindgen_free(r0, r1);
+        }
+    }
+}
+/**
+* See [core_crypto::e2e_identity::types::E2eiAcmeDirectory]
+*/
+class AcmeDirectory {
+
+    static __wrap(ptr) {
+        const obj = Object.create(AcmeDirectory.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm$1.__wbg_acmedirectory_free(ptr);
+    }
+    /**
+    * @param {string} new_nonce
+    * @param {string} new_account
+    * @param {string} new_order
+    */
+    constructor(new_nonce, new_account, new_order) {
+        const ptr0 = passStringToWasm0(new_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(new_account, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(new_order, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm$1.acmedirectory_new(ptr0, len0, ptr1, len1, ptr2, len2);
+        return AcmeDirectory.__wrap(ret);
+    }
+    /**
+    * @returns {string}
+    */
+    get new_nonce() {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.acmedirectory_new_nonce(retptr, this.ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+            wasm$1.__wbindgen_free(r0, r1);
+        }
+    }
+    /**
+    * @returns {string}
+    */
+    get new_account() {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.acmechallenge_url(retptr, this.ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+            wasm$1.__wbindgen_free(r0, r1);
+        }
+    }
+    /**
+    * @returns {string}
+    */
+    get new_order() {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.acmedirectory_new_order(retptr, this.ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+            wasm$1.__wbindgen_free(r0, r1);
+        }
+    }
+}
+/**
+* See [core_crypto::e2e_identity::types::E2eiAcmeFinalize]
+*/
+class AcmeFinalize {
+
+    static __wrap(ptr) {
+        const obj = Object.create(AcmeFinalize.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm$1.__wbg_acmefinalize_free(ptr);
+    }
+    /**
+    * @param {Uint8Array} delegate
+    * @param {string} certificate_url
+    */
+    constructor(delegate, certificate_url) {
+        const ptr0 = passStringToWasm0(certificate_url, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm$1.acmechallenge_new(addHeapObject(delegate), ptr0, len0);
+        return AcmeFinalize.__wrap(ret);
+    }
+    /**
+    * @returns {Uint8Array}
+    */
+    get delegate() {
+        const ret = wasm$1.acmechallenge_delegate(this.ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @returns {string}
+    */
+    get certificate_url() {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.acmechallenge_url(retptr, this.ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+            wasm$1.__wbindgen_free(r0, r1);
+        }
+    }
+}
+/**
 */
 class CommitBundle {
 
@@ -1233,6 +1438,15 @@ class CoreCrypto$1 {
         const ret = wasm$1.corecrypto_get_client_ids(this.ptr, ptr0, len0);
         return takeObject(ret);
     }
+    /**
+    * see [core_crypto::MlsCentral::new_acme_enrollment]
+    * @param {number} ciphersuite
+    * @returns {Promise<WireE2eIdentity>}
+    */
+    new_acme_enrollment(ciphersuite) {
+        const ret = wasm$1.corecrypto_new_acme_enrollment(this.ptr, ciphersuite);
+        return takeObject(ret);
+    }
 }
 /**
 * see [core_crypto::prelude::CoreCryptoCallbacks]
@@ -1469,6 +1683,130 @@ class MemberAddedMessages {
     }
 }
 /**
+* See [core_crypto::e2e_identity::types::E2eiNewAcmeAuthz]
+*/
+class NewAcmeAuthz {
+
+    static __wrap(ptr) {
+        const obj = Object.create(NewAcmeAuthz.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm$1.__wbg_newacmeauthz_free(ptr);
+    }
+    /**
+    * @param {string} identifier
+    * @param {AcmeChallenge | undefined} wire_http_challenge
+    * @param {AcmeChallenge | undefined} wire_oidc_challenge
+    */
+    constructor(identifier, wire_http_challenge, wire_oidc_challenge) {
+        const ptr0 = passStringToWasm0(identifier, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        let ptr1 = 0;
+        if (!isLikeNone(wire_http_challenge)) {
+            _assertClass(wire_http_challenge, AcmeChallenge);
+            ptr1 = wire_http_challenge.ptr;
+            wire_http_challenge.ptr = 0;
+        }
+        let ptr2 = 0;
+        if (!isLikeNone(wire_oidc_challenge)) {
+            _assertClass(wire_oidc_challenge, AcmeChallenge);
+            ptr2 = wire_oidc_challenge.ptr;
+            wire_oidc_challenge.ptr = 0;
+        }
+        const ret = wasm$1.newacmeauthz_new(ptr0, len0, ptr1, ptr2);
+        return NewAcmeAuthz.__wrap(ret);
+    }
+    /**
+    * @returns {string}
+    */
+    get identifier() {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.acmedirectory_new_nonce(retptr, this.ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+            wasm$1.__wbindgen_free(r0, r1);
+        }
+    }
+    /**
+    * @returns {AcmeChallenge | undefined}
+    */
+    get wire_http_challenge() {
+        const ret = wasm$1.newacmeauthz_wire_http_challenge(this.ptr);
+        return ret === 0 ? undefined : AcmeChallenge.__wrap(ret);
+    }
+    /**
+    * @returns {AcmeChallenge | undefined}
+    */
+    get wire_oidc_challenge() {
+        const ret = wasm$1.newacmeauthz_wire_oidc_challenge(this.ptr);
+        return ret === 0 ? undefined : AcmeChallenge.__wrap(ret);
+    }
+}
+/**
+* See [core_crypto::e2e_identity::types::E2eiNewAcmeOrder]
+*/
+class NewAcmeOrder {
+
+    static __wrap(ptr) {
+        const obj = Object.create(NewAcmeOrder.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm$1.__wbg_newacmeorder_free(ptr);
+    }
+    /**
+    * @param {Uint8Array} delegate
+    * @param {(Uint8Array)[]} authorizations
+    */
+    constructor(delegate, authorizations) {
+        const ptr0 = passArrayJsValueToWasm0(authorizations, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm$1.newacmeorder_new(addHeapObject(delegate), ptr0, len0);
+        return NewAcmeOrder.__wrap(ret);
+    }
+    /**
+    * @returns {Uint8Array}
+    */
+    get delegate() {
+        const ret = wasm$1.acmechallenge_delegate(this.ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @returns {Array<any>}
+    */
+    get authorizations() {
+        const ret = wasm$1.newacmeorder_authorizations(this.ptr);
+        return takeObject(ret);
+    }
+}
+/**
 */
 class ProposalBundle {
 
@@ -1493,60 +1831,467 @@ class ProposalBundle {
     /**
     * @returns {Uint8Array}
     */
-    get proposal() {
-        const ret = wasm$1.commitbundle_commit(this.ptr);
-        return takeObject(ret);
+    get proposal() {
+        const ret = wasm$1.commitbundle_commit(this.ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @returns {Uint8Array}
+    */
+    get proposal_ref() {
+        const ret = wasm$1.conversationinitbundle_commit(this.ptr);
+        return takeObject(ret);
+    }
+}
+/**
+*/
+class PublicGroupStateBundle {
+
+    static __wrap(ptr) {
+        const obj = Object.create(PublicGroupStateBundle.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm$1.__wbg_publicgroupstatebundle_free(ptr);
+    }
+    /**
+    * @returns {number}
+    */
+    get encryption_type() {
+        const ret = wasm$1.publicgroupstatebundle_encryption_type(this.ptr);
+        return ret;
+    }
+    /**
+    * @returns {number}
+    */
+    get ratchet_tree_type() {
+        const ret = wasm$1.publicgroupstatebundle_ratchet_tree_type(this.ptr);
+        return ret;
+    }
+    /**
+    * @returns {Uint8Array}
+    */
+    get payload() {
+        const ret = wasm$1.commitbundle_commit(this.ptr);
+        return takeObject(ret);
+    }
+}
+/**
+*/
+class WireE2eIdentity$1 {
+
+    static __wrap(ptr) {
+        const obj = Object.create(WireE2eIdentity$1.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm$1.__wbg_wiree2eidentity_free(ptr);
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::directory_response]
+    * @param {Uint8Array} directory
+    * @returns {any}
+    */
+    directory_response(directory) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(directory, wasm$1.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm$1.wiree2eidentity_directory_response(retptr, this.ptr, ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::new_account_request]
+    * @param {any} directory
+    * @param {string} previous_nonce
+    * @returns {Uint8Array}
+    */
+    new_account_request(directory, previous_nonce) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm$1.wiree2eidentity_new_account_request(retptr, this.ptr, addHeapObject(directory), ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::new_account_response]
+    * @param {Uint8Array} account
+    * @returns {Uint8Array}
+    */
+    new_account_response(account) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.wiree2eidentity_new_account_response(retptr, this.ptr, addHeapObject(account));
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::new_order_request]
+    * @param {string} handle
+    * @param {string} client_id
+    * @param {number} expiry_days
+    * @param {any} directory
+    * @param {Uint8Array} account
+    * @param {string} previous_nonce
+    * @returns {Uint8Array}
+    */
+    new_order_request(handle, client_id, expiry_days, directory, account, previous_nonce) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(handle, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(client_id, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len2 = WASM_VECTOR_LEN;
+            wasm$1.wiree2eidentity_new_order_request(retptr, this.ptr, ptr0, len0, ptr1, len1, expiry_days, addHeapObject(directory), addHeapObject(account), ptr2, len2);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::new_order_response]
+    * @param {Uint8Array} order
+    * @returns {any}
+    */
+    new_order_response(order) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.wiree2eidentity_new_order_response(retptr, this.ptr, addHeapObject(order));
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::new_authz_request]
+    * @param {string} url
+    * @param {Uint8Array} account
+    * @param {string} previous_nonce
+    * @returns {Uint8Array}
+    */
+    new_authz_request(url, account, previous_nonce) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(url, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            wasm$1.wiree2eidentity_new_authz_request(retptr, this.ptr, ptr0, len0, addHeapObject(account), ptr1, len1);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::new_authz_response]
+    * @param {Uint8Array} authz
+    * @returns {any}
+    */
+    new_authz_response(authz) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.wiree2eidentity_new_authz_response(retptr, this.ptr, addHeapObject(authz));
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::create_dpop_token]
+    * @param {string} access_token_url
+    * @param {string} user_id
+    * @param {bigint} client_id
+    * @param {string} domain
+    * @param {any} client_id_challenge
+    * @param {string} backend_nonce
+    * @param {number} expiry_days
+    * @returns {string}
+    */
+    create_dpop_token(access_token_url, user_id, client_id, domain, client_id_challenge, backend_nonce, expiry_days) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(access_token_url, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(user_id, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(domain, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passStringToWasm0(backend_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len3 = WASM_VECTOR_LEN;
+            wasm$1.wiree2eidentity_create_dpop_token(retptr, this.ptr, ptr0, len0, ptr1, len1, client_id, ptr2, len2, addHeapObject(client_id_challenge), ptr3, len3, expiry_days);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            var r3 = getInt32Memory0()[retptr / 4 + 3];
+            var ptr4 = r0;
+            var len4 = r1;
+            if (r3) {
+                ptr4 = 0; len4 = 0;
+                throw takeObject(r2);
+            }
+            return getStringFromWasm0(ptr4, len4);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+            wasm$1.__wbindgen_free(ptr4, len4);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::new_challenge_request]
+    * @param {any} handle_challenge
+    * @param {Uint8Array} account
+    * @param {string} previous_nonce
+    * @returns {Uint8Array}
+    */
+    new_challenge_request(handle_challenge, account, previous_nonce) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm$1.wiree2eidentity_new_challenge_request(retptr, this.ptr, addHeapObject(handle_challenge), addHeapObject(account), ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::new_challenge_response]
+    * @param {Uint8Array} challenge
+    */
+    new_challenge_response(challenge) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.wiree2eidentity_new_challenge_response(retptr, this.ptr, addHeapObject(challenge));
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::check_order_request]
+    * @param {string} order_url
+    * @param {Uint8Array} account
+    * @param {string} previous_nonce
+    * @returns {Uint8Array}
+    */
+    check_order_request(order_url, account, previous_nonce) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(order_url, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            wasm$1.wiree2eidentity_check_order_request(retptr, this.ptr, ptr0, len0, addHeapObject(account), ptr1, len1);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::check_order_response]
+    * @param {Uint8Array} order
+    * @returns {Uint8Array}
+    */
+    check_order_response(order) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.wiree2eidentity_check_order_response(retptr, this.ptr, addHeapObject(order));
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
+    * See [core_crypto::e2e_identity::WireE2eIdentity::finalize_request]
+    * @param {(Uint8Array)[]} domains
+    * @param {Uint8Array} order
+    * @param {Uint8Array} account
+    * @param {string} previous_nonce
     * @returns {Uint8Array}
     */
-    get proposal_ref() {
-        const ret = wasm$1.conversationinitbundle_commit(this.ptr);
-        return takeObject(ret);
-    }
-}
-/**
-*/
-class PublicGroupStateBundle {
-
-    static __wrap(ptr) {
-        const obj = Object.create(PublicGroupStateBundle.prototype);
-        obj.ptr = ptr;
-
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
-
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm$1.__wbg_publicgroupstatebundle_free(ptr);
+    finalize_request(domains, order, account, previous_nonce) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayJsValueToWasm0(domains, wasm$1.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            wasm$1.wiree2eidentity_finalize_request(retptr, this.ptr, ptr0, len0, addHeapObject(order), addHeapObject(account), ptr1, len1);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
-    * @returns {number}
+    * See [core_crypto::e2e_identity::WireE2eIdentity::finalize_response]
+    * @param {Uint8Array} finalize
+    * @returns {any}
     */
-    get encryption_type() {
-        const ret = wasm$1.publicgroupstatebundle_encryption_type(this.ptr);
-        return ret;
+    finalize_response(finalize) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.wiree2eidentity_finalize_response(retptr, this.ptr, addHeapObject(finalize));
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
-    * @returns {number}
+    * See [core_crypto::e2e_identity::WireE2eIdentity::certificate_request]
+    * @param {any} finalize
+    * @param {Uint8Array} account
+    * @param {string} previous_nonce
+    * @returns {Uint8Array}
     */
-    get ratchet_tree_type() {
-        const ret = wasm$1.publicgroupstatebundle_ratchet_tree_type(this.ptr);
-        return ret;
+    certificate_request(finalize, account, previous_nonce) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(previous_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm$1.wiree2eidentity_certificate_request(retptr, this.ptr, addHeapObject(finalize), addHeapObject(account), ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
-    * @returns {Uint8Array}
+    * See [core_crypto::e2e_identity::WireE2eIdentity::certificate_response]
+    * @param {string} certificate_chain
+    * @returns {(Uint8Array)[]}
     */
-    get payload() {
-        const ret = wasm$1.commitbundle_commit(this.ptr);
-        return takeObject(ret);
+    certificate_response(certificate_chain) {
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(certificate_chain, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm$1.wiree2eidentity_certificate_response(retptr, this.ptr, ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            var r3 = getInt32Memory0()[retptr / 4 + 3];
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm$1.__wbindgen_free(r0, r1 * 4);
+            return v1;
+        } finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+        }
     }
 }
 
@@ -1701,6 +2446,10 @@ function getImports() {
         const ret = CoreCrypto$1.__wrap(arg0);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_new_0b9bfdd97583284e = function() {
+        const ret = new Object();
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_set_20cbc34131e76824 = function(arg0, arg1, arg2) {
         getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
     };
@@ -1708,8 +2457,8 @@ function getImports() {
         const ret = arg0;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_new_0b9bfdd97583284e = function() {
-        const ret = new Object();
+    imports.wbg.__wbg_wiree2eidentity_new = function(arg0) {
+        const ret = WireE2eIdentity$1.__wrap(arg0);
         return addHeapObject(ret);
     };
     imports.wbg.__wbg_call_168da88779e35f61 = function() { return handleError(function (arg0, arg1, arg2) {
@@ -1727,7 +2476,7 @@ function getImports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_220(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_260(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -1742,9 +2491,6 @@ function getImports() {
         const ret = new Array();
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_set_a68214f35c417fa9 = function(arg0, arg1, arg2) {
-        getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
-    };
     imports.wbg.__wbg_push_740e4b286702d964 = function(arg0, arg1) {
         const ret = getObject(arg0).push(getObject(arg1));
         return ret;
@@ -1757,6 +2503,9 @@ function getImports() {
         const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_set_a68214f35c417fa9 = function(arg0, arg1, arg2) {
+        getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+    };
     imports.wbg.__wbg_call_3999bee59e9f7719 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
         const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
         return addHeapObject(ret);
@@ -1773,6 +2522,14 @@ function getImports() {
         const ret = ProposalBundle.__wrap(arg0);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_now_4d4a1d65c7a8c0ba = function() {
+        const ret = Date.now();
+        return ret;
+    };
+    imports.wbg.__wbg_now_78244d2ced74c026 = function() {
+        const ret = performance.now();
+        return ret;
+    };
     imports.wbg.__wbg_new_abda76e883ba8a5f = function() {
         const ret = new Error();
         return addHeapObject(ret);
@@ -1824,25 +2581,22 @@ function getImports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbg_open_a31c3fe1fdc244eb = function() { return handleError(function (arg0, arg1, arg2) {
-        const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2));
+    imports.wbg.__wbg_openCursor_e036069f0e326708 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).openCursor(getObject(arg1));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_open_c5d5fb2df44b9d10 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
-        const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
+    imports.wbg.__wbg_openCursor_f055654a98eeab7f = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).openCursor();
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_setonupgradeneeded_17d0b9530f1e0cac = function(arg0, arg1) {
-        getObject(arg0).onupgradeneeded = getObject(arg1);
-    };
     imports.wbg.__wbg_setonsuccess_5f71593bc51653a3 = function(arg0, arg1) {
         getObject(arg0).onsuccess = getObject(arg1);
     };
     imports.wbg.__wbg_setonerror_d5771cc5bf9ea74c = function(arg0, arg1) {
         getObject(arg0).onerror = getObject(arg1);
     };
-    imports.wbg.__wbg_delete_8abedd1043b4105d = function() { return handleError(function (arg0, arg1) {
-        const ret = getObject(arg0).delete(getObject(arg1));
+    imports.wbg.__wbg_get_6285bf458a1ee758 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).get(getObject(arg1));
         return addHeapObject(ret);
     }, arguments) };
     imports.wbg.__wbg_count_b0e88953a0ea909c = function() { return handleError(function (arg0) {
@@ -1853,8 +2607,8 @@ function getImports() {
         const ret = getObject(arg0).count(getObject(arg1));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_get_6285bf458a1ee758 = function() { return handleError(function (arg0, arg1) {
-        const ret = getObject(arg0).get(getObject(arg1));
+    imports.wbg.__wbg_delete_8abedd1043b4105d = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).delete(getObject(arg1));
         return addHeapObject(ret);
     }, arguments) };
     imports.wbg.__wbg_put_84e7fc93eee27b28 = function() { return handleError(function (arg0, arg1, arg2) {
@@ -1865,14 +2619,17 @@ function getImports() {
         const ret = getObject(arg0).put(getObject(arg1));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_openCursor_e036069f0e326708 = function() { return handleError(function (arg0, arg1) {
-        const ret = getObject(arg0).openCursor(getObject(arg1));
+    imports.wbg.__wbg_open_a31c3fe1fdc244eb = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_openCursor_f055654a98eeab7f = function() { return handleError(function (arg0) {
-        const ret = getObject(arg0).openCursor();
+    imports.wbg.__wbg_open_c5d5fb2df44b9d10 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+        const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
         return addHeapObject(ret);
     }, arguments) };
+    imports.wbg.__wbg_setonupgradeneeded_17d0b9530f1e0cac = function(arg0, arg1) {
+        getObject(arg0).onupgradeneeded = getObject(arg1);
+    };
     imports.wbg.__wbg_index_86861edf1478f49c = function() { return handleError(function (arg0, arg1, arg2) {
         const ret = getObject(arg0).index(getStringFromWasm0(arg1, arg2));
         return addHeapObject(ret);
@@ -2021,10 +2778,6 @@ function getImports() {
         const ret = getObject(arg0).result;
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_error_aacf5ac191e54ed0 = function() { return handleError(function (arg0) {
-        const ret = getObject(arg0).error;
-        return isLikeNone(ret) ? 0 : addHeapObject(ret);
-    }, arguments) };
     imports.wbg.__wbg_contains_6cf516181cd86571 = function(arg0, arg1, arg2) {
         const ret = getObject(arg0).contains(getStringFromWasm0(arg1, arg2));
         return ret;
@@ -2051,6 +2804,10 @@ function getImports() {
     imports.wbg.__wbg_deleteObjectStore_1b698c5fd1bc077d = function() { return handleError(function (arg0, arg1, arg2) {
         getObject(arg0).deleteObjectStore(getStringFromWasm0(arg1, arg2));
     }, arguments) };
+    imports.wbg.__wbg_error_aacf5ac191e54ed0 = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).error;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    }, arguments) };
     imports.wbg.__wbindgen_is_falsy = function(arg0) {
         const ret = !getObject(arg0);
         return ret;
@@ -2076,6 +2833,24 @@ function getImports() {
         const ret = getObject(arg0).toString();
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_instanceof_Window_acc97ff9f5d2c7b4 = function(arg0) {
+        let result;
+        try {
+            result = getObject(arg0) instanceof Window;
+        } catch {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
+    imports.wbg.__wbg_crypto_9f07beb1e97bfa1b = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).crypto;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_getRandomValues_f134f772d240c51f = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).getRandomValues(getArrayU8FromWasm0(arg1, arg2));
+        return addHeapObject(ret);
+    }, arguments) };
     imports.wbg.__wbg_instanceof_Uint8Array_971eeda69eb75003 = function(arg0) {
         let result;
         try {
@@ -2151,12 +2926,12 @@ function getImports() {
         const ret = getObject(arg0).objectStore(getStringFromWasm0(arg1, arg2));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbindgen_closure_wrapper2373 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 122, __wbg_adapter_52);
+    imports.wbg.__wbindgen_closure_wrapper2639 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 142, __wbg_adapter_52);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper3847 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 122, __wbg_adapter_55);
+    imports.wbg.__wbindgen_closure_wrapper4541 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 142, __wbg_adapter_55);
         return addHeapObject(ret);
     };
 
@@ -2189,9 +2964,7 @@ function initSync(module) {
 }
 
 async function init(input) {
-    if (typeof input === 'undefined') {
-        input = new URL('index_bg.wasm', import.meta.url);
-    }
+
     const imports = getImports();
 
     if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
@@ -2208,6 +2981,9 @@ var exports = /*#__PURE__*/Object.freeze({
     version: version,
     WirePolicy: WirePolicy$1,
     Ciphersuite: Ciphersuite$1,
+    AcmeChallenge: AcmeChallenge,
+    AcmeDirectory: AcmeDirectory,
+    AcmeFinalize: AcmeFinalize,
     CommitBundle: CommitBundle,
     ConversationConfiguration: ConversationConfiguration,
     ConversationInitBundle: ConversationInitBundle,
@@ -2217,8 +2993,11 @@ var exports = /*#__PURE__*/Object.freeze({
     DecryptedMessage: DecryptedMessage,
     Invitee: Invitee,
     MemberAddedMessages: MemberAddedMessages,
+    NewAcmeAuthz: NewAcmeAuthz,
+    NewAcmeOrder: NewAcmeOrder,
     ProposalBundle: ProposalBundle,
     PublicGroupStateBundle: PublicGroupStateBundle,
+    WireE2eIdentity: WireE2eIdentity$1,
     initSync: initSync,
     'default': init
 });
@@ -2226,7 +3005,7 @@ var exports = /*#__PURE__*/Object.freeze({
 var wasm = async (opt = {}) => {
                 let {importHook, serverPath} = opt;
 
-                let path = "assets/core_crypto_ffi-69d2b02f.wasm";
+                let path = "assets/core_crypto_ffi-7a5675cc.wasm";
 
                 if (serverPath != null) {
                     path = serverPath + /[^\/\\]*$/.exec(path)[0];
@@ -2242,39 +3021,39 @@ var wasm = async (opt = {}) => {
 
 // Wire
 // Copyright (C) 2022 Wire Swiss GmbH
-var _a, _CoreCrypto_module, _CoreCrypto_cc;
+var _a, _CoreCrypto_module, _CoreCrypto_cc, _b, _WireE2eIdentity_module, _WireE2eIdentity_e2ei;
 /**
-* see [core_crypto::prelude::CiphersuiteName]
-*/
+ * see [core_crypto::prelude::CiphersuiteName]
+ */
 var Ciphersuite;
 (function (Ciphersuite) {
     /**
-    * DH KEM x25519 | AES-GCM 128 | SHA2-256 | Ed25519
-    */
+     * DH KEM x25519 | AES-GCM 128 | SHA2-256 | Ed25519
+     */
     Ciphersuite[Ciphersuite["MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519"] = 1] = "MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519";
     /**
-    * DH KEM P256 | AES-GCM 128 | SHA2-256 | EcDSA P256
-    */
+     * DH KEM P256 | AES-GCM 128 | SHA2-256 | EcDSA P256
+     */
     Ciphersuite[Ciphersuite["MLS_128_DHKEMP256_AES128GCM_SHA256_P256"] = 2] = "MLS_128_DHKEMP256_AES128GCM_SHA256_P256";
     /**
-    * DH KEM x25519 | Chacha20Poly1305 | SHA2-256 | Ed25519
-    */
+     * DH KEM x25519 | Chacha20Poly1305 | SHA2-256 | Ed25519
+     */
     Ciphersuite[Ciphersuite["MLS_128_DHKEMX25519_CHACHA20POLY1305_SHA256_Ed25519"] = 3] = "MLS_128_DHKEMX25519_CHACHA20POLY1305_SHA256_Ed25519";
     /**
-    * DH KEM x448 | AES-GCM 256 | SHA2-512 | Ed448
-    */
+     * DH KEM x448 | AES-GCM 256 | SHA2-512 | Ed448
+     */
     Ciphersuite[Ciphersuite["MLS_256_DHKEMX448_AES256GCM_SHA512_Ed448"] = 4] = "MLS_256_DHKEMX448_AES256GCM_SHA512_Ed448";
     /**
-    * DH KEM P521 | AES-GCM 256 | SHA2-512 | EcDSA P521
-    */
+     * DH KEM P521 | AES-GCM 256 | SHA2-512 | EcDSA P521
+     */
     Ciphersuite[Ciphersuite["MLS_256_DHKEMP521_AES256GCM_SHA512_P521"] = 5] = "MLS_256_DHKEMP521_AES256GCM_SHA512_P521";
     /**
-    * DH KEM x448 | Chacha20Poly1305 | SHA2-512 | Ed448
-    */
+     * DH KEM x448 | Chacha20Poly1305 | SHA2-512 | Ed448
+     */
     Ciphersuite[Ciphersuite["MLS_256_DHKEMX448_CHACHA20POLY1305_SHA512_Ed448"] = 6] = "MLS_256_DHKEMX448_CHACHA20POLY1305_SHA512_Ed448";
     /**
-    * DH KEM P384 | AES-GCM 256 | SHA2-384 | EcDSA P384
-    */
+     * DH KEM P384 | AES-GCM 256 | SHA2-384 | EcDSA P384
+     */
     Ciphersuite[Ciphersuite["MLS_256_DHKEMP384_AES256GCM_SHA384_P384"] = 7] = "MLS_256_DHKEMP384_AES256GCM_SHA384_P384";
 })(Ciphersuite || (Ciphersuite = {}));
 /**
@@ -2820,7 +3599,7 @@ class CoreCrypto {
      * **CAUTION**: only use this when you had an explicit response from the Delivery Service
      * e.g. 403. Do not use otherwise e.g. 5xx responses, timeout etc..
      * **DO NOT** use when Delivery Service responds 409, pending state will be renewed
-     * in {@link CoreCrypto.decrypt_message}
+     * in {@link CoreCrypto.decryptMessage}
      *
      * @param conversationId - The group's ID
      */
@@ -3006,7 +3785,7 @@ class CoreCrypto {
      *
      * @param prekey - the prekey bundle to get the fingerprint from
      * @returns Hex-encoded public key string
-    **/
+     **/
     static proteusFingerprintPrekeybundle(prekey) {
         return __classPrivateFieldGet(this, _a, "f", _CoreCrypto_module).CoreCrypto.proteus_fingerprint_prekeybundle(prekey);
     }
@@ -3018,6 +3797,18 @@ class CoreCrypto {
     async proteusCryptoboxMigrate(storeName) {
         return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_cryptobox_migrate(storeName);
     }
+    /**
+     * Creates an enrollment instance with private key material you can use in order to fetch
+     * a new x509 certificate from the acme server.
+     * Make sure to call [WireE2eIdentity::free] (not yet available) to dispose this instance and its associated
+     * keying material.
+     *
+     * @param ciphersuite - For generating signing key material. Only {@link Ciphersuite.MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519} is supported currently
+     */
+    async newAcmeEnrollment() {
+        const e2ei = await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").new_acme_enrollment(Ciphersuite.MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519);
+        return new WireE2eIdentity(e2ei, __classPrivateFieldGet(CoreCrypto, _a, "f", _CoreCrypto_module));
+    }
     /**
      * Returns the current version of {@link CoreCrypto}
      *
@@ -3033,5 +3824,197 @@ class CoreCrypto {
 _a = CoreCrypto, _CoreCrypto_cc = new WeakMap();
 /** @hidden */
 _CoreCrypto_module = { value: void 0 };
+class WireE2eIdentity {
+    /** @hidden */
+    constructor(e2ei, module) {
+        /** @hidden */
+        _WireE2eIdentity_e2ei.set(this, void 0);
+        __classPrivateFieldSet(this, _WireE2eIdentity_e2ei, e2ei, "f");
+        if (!__classPrivateFieldGet(WireE2eIdentity, _b, "f", _WireE2eIdentity_module)) {
+            __classPrivateFieldSet(WireE2eIdentity, _b, module, "f", _WireE2eIdentity_module);
+        }
+    }
+    /**
+     * Parses the response from `GET /acme/{provisioner-name}/directory`.
+     * Use this {@link AcmeDirectory} in the next step to fetch the first nonce from the acme server. Use
+     * {@link AcmeDirectory.newNonce}.
+     *
+     * @param directory HTTP response body
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.1.1
+     */
+    directoryResponse(directory) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").directory_response(directory);
+    }
+    /**
+     * For creating a new acme account. This returns a signed JWS-alike request body to send to
+     * `POST /acme/{provisioner-name}/new-account`.
+     *
+     * @param directory you got from {@link directoryResponse}
+     * @param previousNonce you got from calling `HEAD {@link AcmeDirectory.newNonce}`
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.3
+     */
+    newAccountRequest(directory, previousNonce) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_account_request(directory, previousNonce);
+    }
+    /**
+     * Parses the response from `POST /acme/{provisioner-name}/new-account`.
+     * @param account HTTP response body
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.3
+     */
+    newAccountResponse(account) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_account_response(account);
+    }
+    /**
+     * Creates a new acme order for the handle (userId + display name) and the clientId.
+     *
+     * @param handle domain of the authorization server e.g. `idp.example.org`
+     * @param clientId domain of the wire-server e.g. `wire.example.org`
+     * @param expiryDays generated x509 certificate expiry
+     * @param directory you got from {@link directoryResponse}
+     * @param account you got from {@link newAccountResponse}
+     * @param previousNonce `replay-nonce` response header from `POST /acme/{provisioner-name}/new-account`
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4
+     */
+    newOrderRequest(handle, clientId, expiryDays, directory, account, previousNonce) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_order_request(handle, clientId, expiryDays, directory, account, previousNonce);
+    }
+    /**
+     * Parses the response from `POST /acme/{provisioner-name}/new-order`.
+     *
+     * @param order HTTP response body
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4
+     */
+    newOrderResponse(order) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_order_response(order);
+    }
+    /**
+     * Creates a new authorization request.
+     *
+     * @param url one of the URL in new order's authorizations (use {@link NewAcmeOrder.authorizations} from {@link newOrderResponse})
+     * @param account you got from {@link newAccountResponse}
+     * @param previousNonce `replay-nonce` response header from `POST /acme/{provisioner-name}/new-order` (or from the
+     * previous to this method if you are creating the second authorization)
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.5
+     */
+    newAuthzRequest(url, account, previousNonce) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_authz_request(url, account, previousNonce);
+    }
+    /**
+     * Parses the response from `POST /acme/{provisioner-name}/authz/{authz-id}`
+     *
+     * You then have to map the challenge from this authorization object. The `client_id_challenge`
+     * will be the one with the `client_id_host` (you supplied to {@link newOrderRequest}) identifier,
+     * the other will be your `handle_challenge`.
+     *
+     * @param authz HTTP response body
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.5
+     */
+    newAuthzResponse(authz) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_authz_response(authz);
+    }
+    /**
+     * Generates a new client Dpop JWT token. It demonstrates proof of possession of the nonces
+     * (from wire-server & acme server) and will be verified by the acme server when verifying the
+     * challenge (in order to deliver a certificate).
+     *
+     * Then send it to `POST /clients/{id}/access-token`
+     * {@link https://staging-nginz-https.zinfra.io/api/swagger-ui/#/default/post_clients__cid__access_token} on wire-server.
+     *
+     * @param accessTokenUrl backend endpoint where this token will be sent. Should be this one {@link https://staging-nginz-https.zinfra.io/api/swagger-ui/#/default/post_clients__cid__access_token}
+     * @param userId an UUIDv4 uniquely identifying the user
+     * @param clientId client identifier
+     * @param domain owning backend domain e.g. `wire.com`
+     * @param clientIdChallenge you found after {@link newAuthzResponse}
+     * @param backendNonce you get by calling `GET /clients/token/nonce` on wire-server as defined here {@link https://staging-nginz-https.zinfra.io/api/swagger-ui/#/default/get_clients__client__nonce}
+     * @param expiryDays token expiry in days
+     */
+    createDpopToken(accessTokenUrl, userId, clientId, domain, clientIdChallenge, backendNonce, expiryDays) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").create_dpop_token(accessTokenUrl, userId, clientId, domain, clientIdChallenge, backendNonce, expiryDays);
+    }
+    /**
+     * Creates a new challenge request.
+     *
+     * @param handleChallenge you found after {@link newAuthzResponse}
+     * @param account you found after {@link newAccountResponse}
+     * @param previousNonce `replay-nonce` response header from `POST /acme/{provisioner-name}/authz/{authz-id}`
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.5.1
+     */
+    newChallengeRequest(handleChallenge, account, previousNonce) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_challenge_request(handleChallenge, account, previousNonce);
+    }
+    /**
+     * Parses the response from `POST /acme/{provisioner-name}/challenge/{challenge-id}`.
+     *
+     * @param challenge HTTP response body
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.5.1
+     */
+    newChallengeResponse(challenge) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").new_challenge_response(challenge);
+    }
+    /**
+     * Verifies that the previous challenge has been completed.
+     *
+     * @param orderUrl `location` header from http response you got from {@link newOrderResponse}
+     * @param account you found after {@link newAccountResponse}
+     * @param previousNonce `replay-nonce` response header from `POST /acme/{provisioner-name}/challenge/{challenge-id}`
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4
+     */
+    checkOrderRequest(orderUrl, account, previousNonce) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").check_order_request(orderUrl, account, previousNonce);
+    }
+    /**
+     * Parses the response from `POST /acme/{provisioner-name}/order/{order-id}`.
+     *
+     * @param order HTTP response body
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4
+     */
+    checkOrderResponse(order) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").check_order_response(order);
+    }
+    /**
+     * Final step before fetching the certificate.
+     *
+     * @param domains you want to generate a certificate for e.g. `["wire.com"]`
+     * @param order you got from {@link checkOrderResponse}
+     * @param account you found after {@link newAccountResponse}
+     * @param previousNonce `replay-nonce` response header from `POST /acme/{provisioner-name}/order/{order-id}`
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4
+     */
+    finalizeRequest(domains, order, account, previousNonce) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").finalize_request(domains, order, account, previousNonce);
+    }
+    /**
+     * Parses the response from `POST /acme/{provisioner-name}/order/{order-id}/finalize`.
+     *
+     * @param finalize HTTP response body
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4
+     */
+    finalizeResponse(finalize) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").finalize_response(finalize);
+    }
+    /**
+     * Creates a request for finally fetching the x509 certificate.
+     *
+     * @param finalize you got from {@link finalizeResponse}
+     * @param account you got from {@link newAccountResponse}
+     * @param previousNonce `replay-nonce` response header from `POST /acme/{provisioner-name}/order/{order-id}/finalize`
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4.2
+     */
+    certificateRequest(finalize, account, previousNonce) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").certificate_request(finalize, account, previousNonce);
+    }
+    /**
+     * Parses the response from `POST /acme/{provisioner-name}/certificate/{certificate-id}`.
+     *
+     * @param certificateChain HTTP string response body
+     * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4.2
+     */
+    certificateResponse(certificateChain) {
+        return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").certificate_response(certificateChain);
+    }
+}
+_b = WireE2eIdentity, _WireE2eIdentity_e2ei = new WeakMap();
+/** @hidden */
+_WireE2eIdentity_module = { value: void 0 };
 
-export { Ciphersuite, CoreCrypto, ExternalProposalType, ProposalType, PublicGroupStateEncryptionType, RatchetTreeType, WirePolicy };
+export { Ciphersuite, CoreCrypto, ExternalProposalType, ProposalType, PublicGroupStateEncryptionType, RatchetTreeType, WireE2eIdentity, WirePolicy };