npm - @wireapp/core-crypto - Versions diffs - 0.8.2 → 0.9.1 - Mend

@wireapp/core-crypto 0.8.2 → 0.9.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/package.json +1 -1
package/platforms/web/assets/core_crypto_ffi-3aab42da.wasm +0 -0
package/platforms/web/corecrypto.d.ts +78 -21
package/platforms/web/corecrypto.js +672 -457
package/platforms/web/assets/core_crypto_ffi-70438e2d.wasm +0 -0

package/platforms/web/corecrypto.js CHANGED Viewed

@@ -12,6 +12,7 @@ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
+/* global Reflect, Promise */
 function __classPrivateFieldGet(receiver, state, kind, f) {
     if (kind === "a" && !f)
         throw new TypeError("Private accessor was defined without a getter");
@@ -34,14 +35,6 @@ const heap = new Array(128).fill(undefined);
 heap.push(undefined, null, true, false);
 function getObject(idx) { return heap[idx]; }
 let heap_next = heap.length;
-function addHeapObject(obj) {
-    if (heap_next === heap.length)
-        heap.push(heap.length + 1);
-    const idx = heap_next;
-    heap_next = heap[idx];
-    heap[idx] = obj;
-    return idx;
-}
 function dropObject(idx) {
     if (idx < 132)
         return;
@@ -53,8 +46,18 @@ function takeObject(idx) {
     dropObject(idx);
     return ret;
 }
-const cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-cachedTextDecoder.decode();
+function addHeapObject(obj) {
+    if (heap_next === heap.length)
+        heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+    heap[idx] = obj;
+    return idx;
+}
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available'); } });
+if (typeof TextDecoder !== 'undefined') {
+    cachedTextDecoder.decode();
+}
 let cachedUint8Memory0 = null;
 function getUint8Memory0() {
     if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
@@ -63,10 +66,11 @@ function getUint8Memory0() {
     return cachedUint8Memory0;
 }
 function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
     return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
 }
 let WASM_VECTOR_LEN = 0;
-const cachedTextEncoder = new TextEncoder('utf-8');
+const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available'); } });
 const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
     ? function (arg, view) {
         return cachedTextEncoder.encodeInto(arg, view);
@@ -82,13 +86,13 @@ const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);
-        const ptr = malloc(buf.length);
+        const ptr = malloc(buf.length) >>> 0;
         getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
         WASM_VECTOR_LEN = buf.length;
         return ptr;
     }
     let len = arg.length;
-    let ptr = malloc(len);
+    let ptr = malloc(len) >>> 0;
     const mem = getUint8Memory0();
     let offset = 0;
     for (; offset < len; offset++) {
@@ -101,7 +105,7 @@ function passStringToWasm0(arg, malloc, realloc) {
         if (offset !== 0) {
             arg = arg.slice(offset);
         }
-        ptr = realloc(ptr, len, len = offset + arg.length * 3);
+        ptr = realloc(ptr, len, len = offset + arg.length * 3) >>> 0;
         const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
         const ret = encodeString(arg, view);
         offset += ret.written;
@@ -226,12 +230,12 @@ function makeMutClosure(arg0, arg1, dtor, f) {
     return real;
 }
 function __wbg_adapter_52(arg0, arg1, arg2) {
-    wasm$1._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h56c36d723a01191f(arg0, arg1, addHeapObject(arg2));
+    wasm$1._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hca6e257aac6d0416(arg0, arg1, addHeapObject(arg2));
 }
 function __wbg_adapter_55(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__hdcf886fad5e08d14(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm$1._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h82968d72c5531950(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getInt32Memory0()[retptr / 4 + 0];
         var r1 = getInt32Memory0()[retptr / 4 + 1];
         if (r1) {
@@ -256,7 +260,7 @@ function getUint32Memory0() {
     return cachedUint32Memory0;
 }
 function passArrayJsValueToWasm0(array, malloc) {
-    const ptr = malloc(array.length * 4);
+    const ptr = malloc(array.length * 4) >>> 0;
     const mem = getUint32Memory0();
     for (let i = 0; i < array.length; i++) {
         mem[ptr / 4 + i] = addHeapObject(array[i]);
@@ -265,12 +269,26 @@ function passArrayJsValueToWasm0(array, malloc) {
     return ptr;
 }
 function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1);
+    const ptr = malloc(arg.length * 1) >>> 0;
     getUint8Memory0().set(arg, ptr / 1);
     WASM_VECTOR_LEN = arg.length;
     return ptr;
 }
+let cachedUint16Memory0 = null;
+function getUint16Memory0() {
+    if (cachedUint16Memory0 === null || cachedUint16Memory0.byteLength === 0) {
+        cachedUint16Memory0 = new Uint16Array(wasm$1.memory.buffer);
+    }
+    return cachedUint16Memory0;
+}
+function passArray16ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 2) >>> 0;
+    getUint16Memory0().set(arg, ptr / 2);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
 function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
     return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
 }
 function handleError(f, args) {
@@ -281,8 +299,8 @@ function handleError(f, args) {
         wasm$1.__wbindgen_exn_store(addHeapObject(e));
     }
 }
-function __wbg_adapter_285(arg0, arg1, arg2, arg3) {
-    wasm$1.wasm_bindgen__convert__closures__invoke2_mut__h1ca1c588492035e5(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wbg_adapter_288(arg0, arg1, arg2, arg3) {
+    wasm$1.wasm_bindgen__convert__closures__invoke2_mut__ha54056c10ac24945(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 /**
 * see [core_crypto::prelude::MlsWirePolicy]
@@ -298,6 +316,19 @@ const WirePolicy$1 = Object.freeze({
     Ciphertext: 2, "2": "Ciphertext",
 });
 /**
+* see [core_crypto::prelude::MlsCredentialType]
+*/
+const CredentialType$1 = Object.freeze({
+    /**
+    * Just a KeyPair
+    */
+    Basic: 1, "1": "Basic",
+    /**
+    * A certificate obtained through e2e identity enrollment process
+    */
+    X509: 2, "2": "X509",
+});
+/**
 * see [core_crypto::prelude::CiphersuiteName]
 */
 const Ciphersuite$1 = Object.freeze({
@@ -335,13 +366,14 @@ const Ciphersuite$1 = Object.freeze({
 */
 class AcmeChallenge {
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(AcmeChallenge.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
         return obj;
     }
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
         return ptr;
     }
     free() {
@@ -351,34 +383,61 @@ class AcmeChallenge {
     /**
     * @param {Uint8Array} delegate
     * @param {string} url
+    * @param {string} target
     */
-    constructor(delegate, url) {
+    constructor(delegate, url, target) {
         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);
+        const ptr1 = passStringToWasm0(target, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm$1.acmechallenge_new(addHeapObject(delegate), ptr0, len0, ptr1, len1);
         return AcmeChallenge.__wrap(ret);
     }
     /**
     * @returns {Uint8Array}
     */
     get delegate() {
-        const ret = wasm$1.acmechallenge_delegate(this.ptr);
+        const ret = wasm$1.acmechallenge_delegate(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
     * @returns {string}
     */
     get url() {
+        let deferred1_0;
+        let deferred1_1;
         try {
             const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
-            wasm$1.acmechallenge_url(retptr, this.ptr);
+            wasm$1.acmechallenge_url(retptr, this.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
             return getStringFromWasm0(r0, r1);
         }
         finally {
             wasm$1.__wbindgen_add_to_stack_pointer(16);
-            wasm$1.__wbindgen_free(r0, r1);
+            wasm$1.__wbindgen_free(deferred1_0, deferred1_1);
+        }
+    }
+    /**
+    * @returns {string}
+    */
+    get target() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
+            wasm$1.acmechallenge_target(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        }
+        finally {
+            wasm$1.__wbindgen_add_to_stack_pointer(16);
+            wasm$1.__wbindgen_free(deferred1_0, deferred1_1);
         }
     }
 }
@@ -387,13 +446,14 @@ class AcmeChallenge {
 */
 class AcmeDirectory {
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(AcmeDirectory.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
         return obj;
     }
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
         return ptr;
     }
     free() {
@@ -419,48 +479,60 @@ class AcmeDirectory {
     * @returns {string}
     */
     get newNonce() {
+        let deferred1_0;
+        let deferred1_1;
         try {
             const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
-            wasm$1.acmedirectory_newNonce(retptr, this.ptr);
+            wasm$1.acmedirectory_newNonce(retptr, this.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
             return getStringFromWasm0(r0, r1);
         }
         finally {
             wasm$1.__wbindgen_add_to_stack_pointer(16);
-            wasm$1.__wbindgen_free(r0, r1);
+            wasm$1.__wbindgen_free(deferred1_0, deferred1_1);
         }
     }
     /**
     * @returns {string}
     */
     get newAccount() {
+        let deferred1_0;
+        let deferred1_1;
         try {
             const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
-            wasm$1.acmechallenge_url(retptr, this.ptr);
+            wasm$1.acmechallenge_url(retptr, this.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
             return getStringFromWasm0(r0, r1);
         }
         finally {
             wasm$1.__wbindgen_add_to_stack_pointer(16);
-            wasm$1.__wbindgen_free(r0, r1);
+            wasm$1.__wbindgen_free(deferred1_0, deferred1_1);
         }
     }
     /**
     * @returns {string}
     */
     get newOrder() {
+        let deferred1_0;
+        let deferred1_1;
         try {
             const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
-            wasm$1.acmedirectory_newOrder(retptr, this.ptr);
+            wasm$1.acmechallenge_target(retptr, this.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
             return getStringFromWasm0(r0, r1);
         }
         finally {
             wasm$1.__wbindgen_add_to_stack_pointer(16);
-            wasm$1.__wbindgen_free(r0, r1);
+            wasm$1.__wbindgen_free(deferred1_0, deferred1_1);
         }
     }
 }
@@ -468,8 +540,8 @@ class AcmeDirectory {
 */
 class CommitBundle {
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
         return ptr;
     }
     free() {
@@ -480,21 +552,21 @@ class CommitBundle {
     * @returns {Uint8Array}
     */
     get commit() {
-        const ret = wasm$1.commitbundle_commit(this.ptr);
+        const ret = wasm$1.commitbundle_commit(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
     * @returns {Uint8Array | undefined}
     */
     get welcome() {
-        const ret = wasm$1.commitbundle_welcome(this.ptr);
+        const ret = wasm$1.commitbundle_welcome(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
     * @returns {PublicGroupStateBundle}
     */
     get public_group_state() {
-        const ret = wasm$1.commitbundle_public_group_state(this.ptr);
+        const ret = wasm$1.commitbundle_public_group_state(this.__wbg_ptr);
         return PublicGroupStateBundle.__wrap(ret);
     }
 }
@@ -503,13 +575,14 @@ class CommitBundle {
 */
 class ConversationConfiguration {
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(ConversationConfiguration.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
         return obj;
     }
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
         return ptr;
     }
     free() {
@@ -533,8 +606,8 @@ class ConversationConfiguration {
 */
 class ConversationInitBundle {
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
         return ptr;
     }
     free() {
@@ -545,21 +618,21 @@ class ConversationInitBundle {
     * @returns {Uint8Array}
     */
     get conversation_id() {
-        const ret = wasm$1.conversationinitbundle_conversation_id(this.ptr);
+        const ret = wasm$1.conversationinitbundle_conversation_id(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
     * @returns {Uint8Array}
     */
     get commit() {
-        const ret = wasm$1.commitbundle_commit(this.ptr);
+        const ret = wasm$1.commitbundle_commit(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
     * @returns {PublicGroupStateBundle}
     */
     get public_group_state() {
-        const ret = wasm$1.commitbundle_public_group_state(this.ptr);
+        const ret = wasm$1.commitbundle_public_group_state(this.__wbg_ptr);
         return PublicGroupStateBundle.__wrap(ret);
     }
 }
@@ -567,13 +640,14 @@ class ConversationInitBundle {
 */
 let CoreCrypto$1 = class CoreCrypto {
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(CoreCrypto.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
         return obj;
     }
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
         return ptr;
     }
     free() {
@@ -583,7 +657,7 @@ let CoreCrypto$1 = class CoreCrypto {
     /**
     * Returns: [`WasmCryptoResult<WireE2eIdentity>`]
     *
-    * see [core_crypto::mls::MlsCentral::new_acme_enrollment]
+    * see [core_crypto::mls::MlsCentral::e2ei_new_enrollment]
     * @param {string} client_id
     * @param {string} display_name
     * @param {string} handle
@@ -591,28 +665,50 @@ let CoreCrypto$1 = class CoreCrypto {
     * @param {number} ciphersuite
     * @returns {Promise<any>}
     */
-    new_acme_enrollment(client_id, display_name, handle, expiry_days, ciphersuite) {
+    e2ei_new_enrollment(client_id, display_name, handle, expiry_days, ciphersuite) {
         const ptr0 = passStringToWasm0(client_id, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(display_name, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
         const ptr2 = passStringToWasm0(handle, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
         const len2 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_new_acme_enrollment(this.ptr, ptr0, len0, ptr1, len1, ptr2, len2, expiry_days, ciphersuite);
+        const ret = wasm$1.corecrypto_e2ei_new_enrollment(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, expiry_days, ciphersuite);
         return takeObject(ret);
     }
     /**
     * see [core_crypto::mls::MlsCentral::e2ei_mls_init]
-    * @param {FfiWireE2EIdentity} e2ei
+    * @param {FfiWireE2EIdentity} enrollment
     * @param {string} certificate_chain
     * @returns {Promise<any>}
     */
-    e2ei_mls_init(e2ei, certificate_chain) {
-        _assertClass(e2ei, FfiWireE2EIdentity);
-        var ptr0 = e2ei.__destroy_into_raw();
+    e2ei_mls_init(enrollment, certificate_chain) {
+        _assertClass(enrollment, FfiWireE2EIdentity);
+        var ptr0 = enrollment.__destroy_into_raw();
         const ptr1 = passStringToWasm0(certificate_chain, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_e2ei_mls_init(this.ptr, ptr0, ptr1, len1);
+        const ret = wasm$1.corecrypto_e2ei_mls_init(this.__wbg_ptr, ptr0, ptr1, len1);
+        return takeObject(ret);
+    }
+    /**
+    * see [core_crypto::mls::MlsCentral::e2ei_enrollment_stash]
+    * @param {FfiWireE2EIdentity} enrollment
+    * @returns {Promise<any>}
+    */
+    e2ei_enrollment_stash(enrollment) {
+        _assertClass(enrollment, FfiWireE2EIdentity);
+        var ptr0 = enrollment.__destroy_into_raw();
+        const ret = wasm$1.corecrypto_e2ei_enrollment_stash(this.__wbg_ptr, ptr0);
+        return takeObject(ret);
+    }
+    /**
+    * see [core_crypto::mls::MlsCentral::e2ei_enrollment_stash_pop]
+    * @param {Uint8Array} handle
+    * @returns {Promise<any>}
+    */
+    e2ei_enrollment_stash_pop(handle) {
+        const ptr0 = passArray8ToWasm0(handle, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_e2ei_enrollment_stash_pop(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
@@ -620,16 +716,20 @@ let CoreCrypto$1 = class CoreCrypto {
     * @returns {string}
     */
     static version() {
+        let deferred1_0;
+        let deferred1_1;
         try {
             const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
             wasm$1.corecrypto_version(retptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
             return getStringFromWasm0(r0, r1);
         }
         finally {
             wasm$1.__wbindgen_add_to_stack_pointer(16);
-            wasm$1.__wbindgen_free(r0, r1);
+            wasm$1.__wbindgen_free(deferred1_0, deferred1_1);
         }
     }
     /**
@@ -637,57 +737,69 @@ let CoreCrypto$1 = class CoreCrypto {
     * @param {string} path
     * @param {string} key
     * @param {Uint8Array} client_id
+    * @param {Uint16Array} ciphersuites
     * @param {Uint8Array | undefined} entropy_seed
     * @returns {Promise<CoreCrypto>}
     */
-    static _internal_new(path, key, client_id, entropy_seed) {
+    static _internal_new(path, key, client_id, ciphersuites, entropy_seed) {
         const ptr0 = passStringToWasm0(path, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(key, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
         const ptr2 = passArray8ToWasm0(client_id, wasm$1.__wbindgen_malloc);
         const len2 = WASM_VECTOR_LEN;
-        var ptr3 = isLikeNone(entropy_seed) ? 0 : passArray8ToWasm0(entropy_seed, wasm$1.__wbindgen_malloc);
-        var len3 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto__internal_new(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        const ptr3 = passArray16ToWasm0(ciphersuites, wasm$1.__wbindgen_malloc);
+        const len3 = WASM_VECTOR_LEN;
+        var ptr4 = isLikeNone(entropy_seed) ? 0 : passArray8ToWasm0(entropy_seed, wasm$1.__wbindgen_malloc);
+        var len4 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto__internal_new(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
         return takeObject(ret);
     }
     /**
     * see [core_crypto::mls::MlsCentral::try_new]
     * @param {string} path
     * @param {string} key
+    * @param {Uint16Array} ciphersuites
     * @param {Uint8Array | undefined} entropy_seed
     * @returns {Promise<CoreCrypto>}
     */
-    static deferred_init(path, key, entropy_seed) {
+    static deferred_init(path, key, ciphersuites, entropy_seed) {
         const ptr0 = passStringToWasm0(path, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(key, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        var ptr2 = isLikeNone(entropy_seed) ? 0 : passArray8ToWasm0(entropy_seed, wasm$1.__wbindgen_malloc);
-        var len2 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_deferred_init(ptr0, len0, ptr1, len1, ptr2, len2);
+        const ptr2 = passArray16ToWasm0(ciphersuites, wasm$1.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        var ptr3 = isLikeNone(entropy_seed) ? 0 : passArray8ToWasm0(entropy_seed, wasm$1.__wbindgen_malloc);
+        var len3 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_deferred_init(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
         return takeObject(ret);
     }
     /**
     * see [core_crypto::mls::MlsCentral::mls_init]
     * @param {Uint8Array} client_id
+    * @param {Uint16Array} ciphersuites
     * @returns {Promise<Promise<any>>}
     */
-    mls_init(client_id) {
+    mls_init(client_id, ciphersuites) {
         const ptr0 = passArray8ToWasm0(client_id, wasm$1.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_mls_init(this.ptr, ptr0, len0);
+        const ptr1 = passArray16ToWasm0(ciphersuites, wasm$1.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_mls_init(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return takeObject(ret);
     }
     /**
     * Returns [`WasmCryptoResult<Vec<u8>>`]
     *
     * See [core_crypto::mls::MlsCentral::mls_generate_keypair]
+    * @param {Uint16Array} ciphersuites
     * @returns {Promise<any>}
     */
-    mls_generate_keypair() {
-        const ret = wasm$1.corecrypto_mls_generate_keypair(this.ptr);
+    mls_generate_keypair(ciphersuites) {
+        const ptr0 = passArray16ToWasm0(ciphersuites, wasm$1.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_mls_generate_keypair(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
@@ -695,15 +807,18 @@ let CoreCrypto$1 = class CoreCrypto {
     *
     * See [core_crypto::mls::MlsCentral::mls_init_with_client_id]
     * @param {Uint8Array} client_id
-    * @param {Uint8Array} signature_public_key
+    * @param {(Uint8Array)[]} signature_public_keys
+    * @param {Uint16Array} ciphersuites
     * @returns {Promise<any>}
     */
-    mls_init_with_client_id(client_id, signature_public_key) {
+    mls_init_with_client_id(client_id, signature_public_keys, ciphersuites) {
         const ptr0 = passArray8ToWasm0(client_id, wasm$1.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArray8ToWasm0(signature_public_key, wasm$1.__wbindgen_malloc);
+        const ptr1 = passArrayJsValueToWasm0(signature_public_keys, wasm$1.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_mls_init_with_client_id(this.ptr, ptr0, len0, ptr1, len1);
+        const ptr2 = passArray16ToWasm0(ciphersuites, wasm$1.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm$1.corecrypto_mls_init_with_client_id(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
         return takeObject(ret);
     }
     /**
@@ -711,7 +826,7 @@ let CoreCrypto$1 = class CoreCrypto {
     * @returns {boolean}
     */
     has_outstanding_refs() {
-        const ret = wasm$1.corecrypto_has_outstanding_refs(this.ptr);
+        const ret = wasm$1.corecrypto_has_outstanding_refs(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
@@ -746,38 +861,41 @@ let CoreCrypto$1 = class CoreCrypto {
     set_callbacks(callbacks) {
         _assertClass(callbacks, CoreCryptoWasmCallbacks);
         var ptr0 = callbacks.__destroy_into_raw();
-        const ret = wasm$1.corecrypto_set_callbacks(this.ptr, ptr0);
+        const ret = wasm$1.corecrypto_set_callbacks(this.__wbg_ptr, ptr0);
         return takeObject(ret);
     }
     /**
     * Returns:: [`WasmCryptoResult<js_sys::Uint8Array>`]
     *
     * see [core_crypto::mls::MlsCentral::client_public_key]
+    * @param {number} ciphersuite
     * @returns {Promise<any>}
     */
-    client_public_key() {
-        const ret = wasm$1.corecrypto_client_public_key(this.ptr);
+    client_public_key(ciphersuite) {
+        const ret = wasm$1.corecrypto_client_public_key(this.__wbg_ptr, ciphersuite);
         return takeObject(ret);
     }
     /**
     * Returns: [`WasmCryptoResult<js_sys::Array<js_sys::Uint8Array>>`]
     *
     * see [core_crypto::mls::MlsCentral::client_keypackages]
+    * @param {number} ciphersuite
     * @param {number} amount_requested
     * @returns {Promise<any>}
     */
-    client_keypackages(amount_requested) {
-        const ret = wasm$1.corecrypto_client_keypackages(this.ptr, amount_requested);
+    client_keypackages(ciphersuite, amount_requested) {
+        const ret = wasm$1.corecrypto_client_keypackages(this.__wbg_ptr, ciphersuite, amount_requested);
         return takeObject(ret);
     }
     /**
     * Returns: [`WasmCryptoResult<usize>`]
     *
     * see [core_crypto::mls::MlsCentral::client_valid_keypackages_count]
+    * @param {number} ciphersuite
     * @returns {Promise<any>}
     */
-    client_valid_keypackages_count() {
-        const ret = wasm$1.corecrypto_client_valid_keypackages_count(this.ptr);
+    client_valid_keypackages_count(ciphersuite) {
+        const ret = wasm$1.corecrypto_client_valid_keypackages_count(this.__wbg_ptr, ciphersuite);
         return takeObject(ret);
     }
     /**
@@ -793,7 +911,7 @@ let CoreCrypto$1 = class CoreCrypto {
         const len0 = WASM_VECTOR_LEN;
         _assertClass(config, ConversationConfiguration);
         var ptr1 = config.__destroy_into_raw();
-        const ret = wasm$1.corecrypto_create_conversation(this.ptr, ptr0, len0, ptr1);
+        const ret = wasm$1.corecrypto_create_conversation(this.__wbg_ptr, ptr0, len0, ptr1);
         return takeObject(ret);
     }
     /**
@@ -806,7 +924,7 @@ let CoreCrypto$1 = class CoreCrypto {
     conversation_epoch(conversation_id) {
         const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_conversation_epoch(this.ptr, ptr0, len0);
+        const ret = wasm$1.corecrypto_conversation_epoch(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
@@ -819,7 +937,7 @@ let CoreCrypto$1 = class CoreCrypto {
     conversation_exists(conversation_id) {
         const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_conversation_exists(this.ptr, ptr0, len0);
+        const ret = wasm$1.corecrypto_conversation_exists(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
@@ -835,7 +953,7 @@ let CoreCrypto$1 = class CoreCrypto {
         const len0 = WASM_VECTOR_LEN;
         _assertClass(custom_configuration, CustomConfiguration);
         var ptr1 = custom_configuration.__destroy_into_raw();
-        const ret = wasm$1.corecrypto_process_welcome_message(this.ptr, ptr0, len0, ptr1);
+        const ret = wasm$1.corecrypto_process_welcome_message(this.__wbg_ptr, ptr0, len0, ptr1);
         return takeObject(ret);
     }
     /**
@@ -851,7 +969,7 @@ let CoreCrypto$1 = class CoreCrypto {
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArrayJsValueToWasm0(clients, wasm$1.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_add_clients_to_conversation(this.ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm$1.corecrypto_add_clients_to_conversation(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return takeObject(ret);
     }
     /**
@@ -867,7 +985,7 @@ let CoreCrypto$1 = class CoreCrypto {
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArrayJsValueToWasm0(clients, wasm$1.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_remove_clients_from_conversation(this.ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm$1.corecrypto_remove_clients_from_conversation(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return takeObject(ret);
     }
     /**
@@ -883,7 +1001,7 @@ let CoreCrypto$1 = class CoreCrypto {
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArray8ToWasm0(parent_id, wasm$1.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_mark_conversation_as_child_of(this.ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm$1.corecrypto_mark_conversation_as_child_of(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return takeObject(ret);
     }
     /**
@@ -896,7 +1014,7 @@ let CoreCrypto$1 = class CoreCrypto {
     update_keying_material(conversation_id) {
         const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_update_keying_material(this.ptr, ptr0, len0);
+        const ret = wasm$1.corecrypto_update_keying_material(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
@@ -907,7 +1025,7 @@ let CoreCrypto$1 = class CoreCrypto {
     commit_pending_proposals(conversation_id) {
         const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_commit_pending_proposals(this.ptr, ptr0, len0);
+        const ret = wasm$1.corecrypto_commit_pending_proposals(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
@@ -920,7 +1038,7 @@ let CoreCrypto$1 = class CoreCrypto {
     wipe_conversation(conversation_id) {
         const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_wipe_conversation(this.ptr, ptr0, len0);
+        const ret = wasm$1.corecrypto_wipe_conversation(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
@@ -936,7 +1054,7 @@ let CoreCrypto$1 = class CoreCrypto {
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArray8ToWasm0(payload, wasm$1.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_decrypt_message(this.ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm$1.corecrypto_decrypt_message(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return takeObject(ret);
     }
     /**
@@ -952,7 +1070,7 @@ let CoreCrypto$1 = class CoreCrypto {
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArray8ToWasm0(message, wasm$1.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_encrypt_message(this.ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm$1.corecrypto_encrypt_message(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return takeObject(ret);
     }
     /**
@@ -968,7 +1086,7 @@ let CoreCrypto$1 = class CoreCrypto {
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArray8ToWasm0(keypackage, wasm$1.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_new_add_proposal(this.ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm$1.corecrypto_new_add_proposal(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return takeObject(ret);
     }
     /**
@@ -981,7 +1099,7 @@ let CoreCrypto$1 = class CoreCrypto {
     new_update_proposal(conversation_id) {
         const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_new_update_proposal(this.ptr, ptr0, len0);
+        const ret = wasm$1.corecrypto_new_update_proposal(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
@@ -997,7 +1115,7 @@ let CoreCrypto$1 = class CoreCrypto {
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArray8ToWasm0(client_id, wasm$1.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_new_remove_proposal(this.ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm$1.corecrypto_new_remove_proposal(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return takeObject(ret);
     }
     /**
@@ -1006,12 +1124,14 @@ let CoreCrypto$1 = class CoreCrypto {
     * see [core_crypto::mls::MlsCentral::new_external_add_proposal]
     * @param {Uint8Array} conversation_id
     * @param {number} epoch
+    * @param {number} ciphersuite
+    * @param {number} credential_type
     * @returns {Promise<any>}
     */
-    new_external_add_proposal(conversation_id, epoch) {
+    new_external_add_proposal(conversation_id, epoch, ciphersuite, credential_type) {
         const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_new_external_add_proposal(this.ptr, ptr0, len0, epoch);
+        const ret = wasm$1.corecrypto_new_external_add_proposal(this.__wbg_ptr, ptr0, len0, epoch, ciphersuite, credential_type);
         return takeObject(ret);
     }
     /**
@@ -1028,7 +1148,7 @@ let CoreCrypto$1 = class CoreCrypto {
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArray8ToWasm0(keypackage_ref, wasm$1.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_new_external_remove_proposal(this.ptr, ptr0, len0, epoch, ptr1, len1);
+        const ret = wasm$1.corecrypto_new_external_remove_proposal(this.__wbg_ptr, ptr0, len0, epoch, ptr1, len1);
         return takeObject(ret);
     }
     /**
@@ -1041,7 +1161,7 @@ let CoreCrypto$1 = class CoreCrypto {
     export_group_state(conversation_id) {
         const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_export_group_state(this.ptr, ptr0, len0);
+        const ret = wasm$1.corecrypto_export_group_state(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
@@ -1050,14 +1170,15 @@ let CoreCrypto$1 = class CoreCrypto {
     * see [core_crypto::mls::MlsCentral::join_by_external_commit]
     * @param {Uint8Array} public_group_state
     * @param {CustomConfiguration} custom_configuration
+    * @param {number} credential_type
     * @returns {Promise<any>}
     */
-    join_by_external_commit(public_group_state, custom_configuration) {
+    join_by_external_commit(public_group_state, custom_configuration, credential_type) {
         const ptr0 = passArray8ToWasm0(public_group_state, wasm$1.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         _assertClass(custom_configuration, CustomConfiguration);
         var ptr1 = custom_configuration.__destroy_into_raw();
-        const ret = wasm$1.corecrypto_join_by_external_commit(this.ptr, ptr0, len0, ptr1);
+        const ret = wasm$1.corecrypto_join_by_external_commit(this.__wbg_ptr, ptr0, len0, ptr1, credential_type);
         return takeObject(ret);
     }
     /**
@@ -1070,7 +1191,7 @@ let CoreCrypto$1 = class CoreCrypto {
     merge_pending_group_from_external_commit(conversation_id) {
         const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_merge_pending_group_from_external_commit(this.ptr, ptr0, len0);
+        const ret = wasm$1.corecrypto_merge_pending_group_from_external_commit(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
@@ -1083,7 +1204,7 @@ let CoreCrypto$1 = class CoreCrypto {
     clear_pending_group_from_external_commit(conversation_id) {
         const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_clear_pending_group_from_external_commit(this.ptr, ptr0, len0);
+        const ret = wasm$1.corecrypto_clear_pending_group_from_external_commit(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
@@ -1094,7 +1215,7 @@ let CoreCrypto$1 = class CoreCrypto {
     commit_accepted(conversation_id) {
         const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_commit_accepted(this.ptr, ptr0, len0);
+        const ret = wasm$1.corecrypto_commit_accepted(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
@@ -1108,7 +1229,7 @@ let CoreCrypto$1 = class CoreCrypto {
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArray8ToWasm0(proposal_ref, wasm$1.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_clear_pending_proposal(this.ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm$1.corecrypto_clear_pending_proposal(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return takeObject(ret);
     }
     /**
@@ -1119,7 +1240,7 @@ let CoreCrypto$1 = class CoreCrypto {
     clear_pending_commit(conversation_id) {
         const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_clear_pending_commit(this.ptr, ptr0, len0);
+        const ret = wasm$1.corecrypto_clear_pending_commit(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
@@ -1130,7 +1251,7 @@ let CoreCrypto$1 = class CoreCrypto {
     * @returns {Promise<any>}
     */
     random_bytes(len) {
-        const ret = wasm$1.corecrypto_random_bytes(this.ptr, len);
+        const ret = wasm$1.corecrypto_random_bytes(this.__wbg_ptr, len);
         return takeObject(ret);
     }
     /**
@@ -1143,7 +1264,7 @@ let CoreCrypto$1 = class CoreCrypto {
     reseed_rng(seed) {
         const ptr0 = passArray8ToWasm0(seed, wasm$1.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_reseed_rng(this.ptr, ptr0, len0);
+        const ret = wasm$1.corecrypto_reseed_rng(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
@@ -1153,7 +1274,7 @@ let CoreCrypto$1 = class CoreCrypto {
     * @returns {Promise<any>}
     */
     proteus_init() {
-        const ret = wasm$1.corecrypto_proteus_init(this.ptr);
+        const ret = wasm$1.corecrypto_proteus_init(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
@@ -1169,7 +1290,7 @@ let CoreCrypto$1 = class CoreCrypto {
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArray8ToWasm0(prekey, wasm$1.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_proteus_session_from_prekey(this.ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm$1.corecrypto_proteus_session_from_prekey(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return takeObject(ret);
     }
     /**
@@ -1185,7 +1306,7 @@ let CoreCrypto$1 = class CoreCrypto {
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArray8ToWasm0(envelope, wasm$1.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_proteus_session_from_message(this.ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm$1.corecrypto_proteus_session_from_message(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return takeObject(ret);
     }
     /**
@@ -1200,7 +1321,7 @@ let CoreCrypto$1 = class CoreCrypto {
     proteus_session_save(session_id) {
         const ptr0 = passStringToWasm0(session_id, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_proteus_session_save(this.ptr, ptr0, len0);
+        const ret = wasm$1.corecrypto_proteus_session_save(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
@@ -1213,7 +1334,7 @@ let CoreCrypto$1 = class CoreCrypto {
     proteus_session_delete(session_id) {
         const ptr0 = passStringToWasm0(session_id, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_proteus_session_delete(this.ptr, ptr0, len0);
+        const ret = wasm$1.corecrypto_proteus_session_delete(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
@@ -1226,7 +1347,7 @@ let CoreCrypto$1 = class CoreCrypto {
     proteus_session_exists(session_id) {
         const ptr0 = passStringToWasm0(session_id, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_proteus_session_exists(this.ptr, ptr0, len0);
+        const ret = wasm$1.corecrypto_proteus_session_exists(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
@@ -1242,7 +1363,7 @@ let CoreCrypto$1 = class CoreCrypto {
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArray8ToWasm0(ciphertext, wasm$1.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_proteus_decrypt(this.ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm$1.corecrypto_proteus_decrypt(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return takeObject(ret);
     }
     /**
@@ -1258,7 +1379,7 @@ let CoreCrypto$1 = class CoreCrypto {
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArray8ToWasm0(plaintext, wasm$1.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_proteus_encrypt(this.ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm$1.corecrypto_proteus_encrypt(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return takeObject(ret);
     }
     /**
@@ -1274,7 +1395,7 @@ let CoreCrypto$1 = class CoreCrypto {
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArray8ToWasm0(plaintext, wasm$1.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_proteus_encrypt_batched(this.ptr, ptr0, len0, ptr1, len1);
+        const ret = wasm$1.corecrypto_proteus_encrypt_batched(this.__wbg_ptr, ptr0, len0, ptr1, len1);
         return takeObject(ret);
     }
     /**
@@ -1285,7 +1406,7 @@ let CoreCrypto$1 = class CoreCrypto {
     * @returns {Promise<Promise<any>>}
     */
     proteus_new_prekey(prekey_id) {
-        const ret = wasm$1.corecrypto_proteus_new_prekey(this.ptr, prekey_id);
+        const ret = wasm$1.corecrypto_proteus_new_prekey(this.__wbg_ptr, prekey_id);
         return takeObject(ret);
     }
     /**
@@ -1295,7 +1416,7 @@ let CoreCrypto$1 = class CoreCrypto {
     * @returns {Promise<Promise<any>>}
     */
     proteus_new_prekey_auto() {
-        const ret = wasm$1.corecrypto_proteus_new_prekey_auto(this.ptr);
+        const ret = wasm$1.corecrypto_proteus_new_prekey_auto(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
@@ -1305,7 +1426,7 @@ let CoreCrypto$1 = class CoreCrypto {
     * @returns {Promise<any>}
     */
     proteus_last_resort_prekey() {
-        const ret = wasm$1.corecrypto_proteus_last_resort_prekey(this.ptr);
+        const ret = wasm$1.corecrypto_proteus_last_resort_prekey(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
@@ -1337,7 +1458,7 @@ let CoreCrypto$1 = class CoreCrypto {
     * @returns {Promise<string>}
     */
     proteus_fingerprint() {
-        const ret = wasm$1.corecrypto_proteus_fingerprint(this.ptr);
+        const ret = wasm$1.corecrypto_proteus_fingerprint(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
@@ -1350,7 +1471,7 @@ let CoreCrypto$1 = class CoreCrypto {
     proteus_fingerprint_local(session_id) {
         const ptr0 = passStringToWasm0(session_id, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_proteus_fingerprint_local(this.ptr, ptr0, len0);
+        const ret = wasm$1.corecrypto_proteus_fingerprint_local(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
@@ -1363,7 +1484,7 @@ let CoreCrypto$1 = class CoreCrypto {
     proteus_fingerprint_remote(session_id) {
         const ptr0 = passStringToWasm0(session_id, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_proteus_fingerprint_remote(this.ptr, ptr0, len0);
+        const ret = wasm$1.corecrypto_proteus_fingerprint_remote(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
@@ -1374,6 +1495,8 @@ let CoreCrypto$1 = class CoreCrypto {
     * @returns {string}
     */
     static proteus_fingerprint_prekeybundle(prekey) {
+        let deferred3_0;
+        let deferred3_1;
         try {
             const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
             const ptr0 = passArray8ToWasm0(prekey, wasm$1.__wbindgen_malloc);
@@ -1383,18 +1506,20 @@ let CoreCrypto$1 = class CoreCrypto {
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
             var r3 = getInt32Memory0()[retptr / 4 + 3];
-            var ptr1 = r0;
-            var len1 = r1;
+            var ptr2 = r0;
+            var len2 = r1;
             if (r3) {
-                ptr1 = 0;
-                len1 = 0;
+                ptr2 = 0;
+                len2 = 0;
                 throw takeObject(r2);
             }
-            return getStringFromWasm0(ptr1, len1);
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
         }
         finally {
             wasm$1.__wbindgen_add_to_stack_pointer(16);
-            wasm$1.__wbindgen_free(ptr1, len1);
+            wasm$1.__wbindgen_free(deferred3_0, deferred3_1);
         }
     }
     /**
@@ -1407,7 +1532,7 @@ let CoreCrypto$1 = class CoreCrypto {
     proteus_cryptobox_migrate(path) {
         const ptr0 = passStringToWasm0(path, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_proteus_cryptobox_migrate(this.ptr, ptr0, len0);
+        const ret = wasm$1.corecrypto_proteus_cryptobox_migrate(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
     /**
@@ -1415,7 +1540,7 @@ let CoreCrypto$1 = class CoreCrypto {
     * @returns {Promise<any>}
     */
     proteus_last_error_code() {
-        const ret = wasm$1.corecrypto_proteus_last_error_code(this.ptr);
+        const ret = wasm$1.corecrypto_proteus_last_error_code(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
@@ -1429,7 +1554,7 @@ let CoreCrypto$1 = class CoreCrypto {
     export_secret_key(conversation_id, key_length) {
         const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_export_secret_key(this.ptr, ptr0, len0, key_length);
+        const ret = wasm$1.corecrypto_export_secret_key(this.__wbg_ptr, ptr0, len0, key_length);
         return takeObject(ret);
     }
     /**
@@ -1442,7 +1567,7 @@ let CoreCrypto$1 = class CoreCrypto {
     get_client_ids(conversation_id) {
         const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_get_client_ids(this.ptr, ptr0, len0);
+        const ret = wasm$1.corecrypto_get_client_ids(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
 };
@@ -1451,13 +1576,14 @@ let CoreCrypto$1 = class CoreCrypto {
 */
 class CoreCryptoWasmCallbacks {
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(CoreCryptoWasmCallbacks.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
         return obj;
     }
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
         return ptr;
     }
     free() {
@@ -1480,13 +1606,14 @@ class CoreCryptoWasmCallbacks {
 */
 class CustomConfiguration {
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(CustomConfiguration.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
         return obj;
     }
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
         return ptr;
     }
     free() {
@@ -1507,8 +1634,8 @@ class CustomConfiguration {
 */
 class DecryptedMessage {
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
         return ptr;
     }
     free() {
@@ -1519,21 +1646,21 @@ class DecryptedMessage {
     * @returns {any}
     */
     get message() {
-        const ret = wasm$1.decryptedmessage_message(this.ptr);
+        const ret = wasm$1.decryptedmessage_message(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
     * @returns {Array<any>}
     */
     get proposals() {
-        const ret = wasm$1.decryptedmessage_proposals(this.ptr);
+        const ret = wasm$1.decryptedmessage_proposals(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
     * @returns {boolean}
     */
     get is_active() {
-        const ret = wasm$1.decryptedmessage_is_active(this.ptr);
+        const ret = wasm$1.decryptedmessage_is_active(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
@@ -1542,7 +1669,7 @@ class DecryptedMessage {
     get commit_delay() {
         try {
             const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
-            wasm$1.decryptedmessage_commit_delay(retptr, this.ptr);
+            wasm$1.decryptedmessage_commit_delay(retptr, this.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             return r0 === 0 ? undefined : r1 >>> 0;
@@ -1555,21 +1682,21 @@ class DecryptedMessage {
     * @returns {any}
     */
     get sender_client_id() {
-        const ret = wasm$1.decryptedmessage_sender_client_id(this.ptr);
+        const ret = wasm$1.decryptedmessage_sender_client_id(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
     * @returns {boolean}
     */
     get has_epoch_changed() {
-        const ret = wasm$1.decryptedmessage_has_epoch_changed(this.ptr);
+        const ret = wasm$1.decryptedmessage_has_epoch_changed(this.__wbg_ptr);
         return ret !== 0;
     }
     /**
     * @returns {WireIdentity | undefined}
     */
     get identity() {
-        const ret = wasm$1.decryptedmessage_identity(this.ptr);
+        const ret = wasm$1.decryptedmessage_identity(this.__wbg_ptr);
         return ret === 0 ? undefined : WireIdentity.__wrap(ret);
     }
 }
@@ -1577,13 +1704,14 @@ class DecryptedMessage {
 */
 class FfiWireE2EIdentity {
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(FfiWireE2EIdentity.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
         return obj;
     }
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
         return ptr;
     }
     free() {
@@ -1600,7 +1728,7 @@ class FfiWireE2EIdentity {
             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.ffiwiree2eidentity_directory_response(retptr, this.ptr, ptr0, len0);
+            wasm$1.ffiwiree2eidentity_directory_response(retptr, this.__wbg_ptr, ptr0, len0);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1623,7 +1751,7 @@ class FfiWireE2EIdentity {
             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.ffiwiree2eidentity_new_account_request(retptr, this.ptr, ptr0, len0);
+            wasm$1.ffiwiree2eidentity_new_account_request(retptr, this.__wbg_ptr, ptr0, len0);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1644,7 +1772,7 @@ class FfiWireE2EIdentity {
     new_account_response(account) {
         try {
             const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
-            wasm$1.ffiwiree2eidentity_new_account_response(retptr, this.ptr, addHeapObject(account));
+            wasm$1.ffiwiree2eidentity_new_account_response(retptr, this.__wbg_ptr, addHeapObject(account));
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1667,7 +1795,7 @@ class FfiWireE2EIdentity {
             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.ffiwiree2eidentity_new_order_request(retptr, this.ptr, ptr0, len0);
+            wasm$1.ffiwiree2eidentity_new_order_request(retptr, this.__wbg_ptr, ptr0, len0);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1688,7 +1816,7 @@ class FfiWireE2EIdentity {
     new_order_response(order) {
         try {
             const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
-            wasm$1.ffiwiree2eidentity_new_order_response(retptr, this.ptr, addHeapObject(order));
+            wasm$1.ffiwiree2eidentity_new_order_response(retptr, this.__wbg_ptr, addHeapObject(order));
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1714,7 +1842,7 @@ class FfiWireE2EIdentity {
             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.ffiwiree2eidentity_new_authz_request(retptr, this.ptr, ptr0, len0, ptr1, len1);
+            wasm$1.ffiwiree2eidentity_new_authz_request(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1735,7 +1863,7 @@ class FfiWireE2EIdentity {
     new_authz_response(authz) {
         try {
             const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
-            wasm$1.ffiwiree2eidentity_new_authz_response(retptr, this.ptr, addHeapObject(authz));
+            wasm$1.ffiwiree2eidentity_new_authz_response(retptr, this.__wbg_ptr, addHeapObject(authz));
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1750,19 +1878,16 @@ class FfiWireE2EIdentity {
     }
     /**
     * See [core_crypto::e2e_identity::WireE2eIdentity::create_dpop_token]
-    * @param {string} access_token_url
     * @param {number} expiry_secs
     * @param {string} backend_nonce
     * @returns {Uint8Array}
     */
-    create_dpop_token(access_token_url, expiry_secs, backend_nonce) {
+    create_dpop_token(expiry_secs, backend_nonce) {
         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 ptr0 = passStringToWasm0(backend_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
             const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passStringToWasm0(backend_nonce, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
-            const len1 = WASM_VECTOR_LEN;
-            wasm$1.ffiwiree2eidentity_create_dpop_token(retptr, this.ptr, ptr0, len0, expiry_secs, ptr1, len1);
+            wasm$1.ffiwiree2eidentity_create_dpop_token(retptr, this.__wbg_ptr, expiry_secs, ptr0, len0);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1788,7 +1913,7 @@ class FfiWireE2EIdentity {
             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.ffiwiree2eidentity_new_dpop_challenge_request(retptr, this.ptr, ptr0, len0, ptr1, len1);
+            wasm$1.ffiwiree2eidentity_new_dpop_challenge_request(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1814,7 +1939,7 @@ class FfiWireE2EIdentity {
             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.ffiwiree2eidentity_new_oidc_challenge_request(retptr, this.ptr, ptr0, len0, ptr1, len1);
+            wasm$1.ffiwiree2eidentity_new_oidc_challenge_request(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1835,7 +1960,7 @@ class FfiWireE2EIdentity {
     new_challenge_response(challenge) {
         try {
             const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
-            wasm$1.ffiwiree2eidentity_new_challenge_response(retptr, this.ptr, addHeapObject(challenge));
+            wasm$1.ffiwiree2eidentity_new_challenge_response(retptr, this.__wbg_ptr, addHeapObject(challenge));
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1861,7 +1986,7 @@ class FfiWireE2EIdentity {
             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.ffiwiree2eidentity_check_order_request(retptr, this.ptr, ptr0, len0, ptr1, len1);
+            wasm$1.ffiwiree2eidentity_check_order_request(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1877,22 +2002,32 @@ class FfiWireE2EIdentity {
     /**
     * See [core_crypto::e2e_identity::WireE2eIdentity::check_order_response]
     * @param {Uint8Array} order
-    * @returns {any}
+    * @returns {string}
     */
     check_order_response(order) {
+        let deferred2_0;
+        let deferred2_1;
         try {
             const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
-            wasm$1.ffiwiree2eidentity_check_order_response(retptr, this.ptr, addHeapObject(order));
+            wasm$1.ffiwiree2eidentity_check_order_response(retptr, this.__wbg_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);
+            var r3 = getInt32Memory0()[retptr / 4 + 3];
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0;
+                len1 = 0;
+                throw takeObject(r2);
             }
-            return takeObject(r0);
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
         }
         finally {
             wasm$1.__wbindgen_add_to_stack_pointer(16);
+            wasm$1.__wbindgen_free(deferred2_0, deferred2_1);
         }
     }
     /**
@@ -1905,7 +2040,7 @@ class FfiWireE2EIdentity {
             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.ffiwiree2eidentity_finalize_request(retptr, this.ptr, ptr0, len0);
+            wasm$1.ffiwiree2eidentity_finalize_request(retptr, this.__wbg_ptr, ptr0, len0);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1921,22 +2056,32 @@ class FfiWireE2EIdentity {
     /**
     * See [core_crypto::e2e_identity::WireE2eIdentity::finalize_response]
     * @param {Uint8Array} finalize
-    * @returns {any}
+    * @returns {string}
     */
     finalize_response(finalize) {
+        let deferred2_0;
+        let deferred2_1;
         try {
             const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
-            wasm$1.ffiwiree2eidentity_finalize_response(retptr, this.ptr, addHeapObject(finalize));
+            wasm$1.ffiwiree2eidentity_finalize_response(retptr, this.__wbg_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);
+            var r3 = getInt32Memory0()[retptr / 4 + 3];
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0;
+                len1 = 0;
+                throw takeObject(r2);
             }
-            return takeObject(r0);
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
         }
         finally {
             wasm$1.__wbindgen_add_to_stack_pointer(16);
+            wasm$1.__wbindgen_free(deferred2_0, deferred2_1);
         }
     }
     /**
@@ -1949,7 +2094,7 @@ class FfiWireE2EIdentity {
             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.ffiwiree2eidentity_certificate_request(retptr, this.ptr, ptr0, len0);
+            wasm$1.ffiwiree2eidentity_certificate_request(retptr, this.__wbg_ptr, ptr0, len0);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
@@ -1968,13 +2113,14 @@ class FfiWireE2EIdentity {
 */
 class Invitee {
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(Invitee.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
         return obj;
     }
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
         return ptr;
     }
     free() {
@@ -1993,14 +2139,14 @@ class Invitee {
     * @returns {Uint8Array}
     */
     get id() {
-        const ret = wasm$1.acmechallenge_delegate(this.ptr);
+        const ret = wasm$1.acmechallenge_delegate(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
     * @returns {Uint8Array}
     */
     get kp() {
-        const ret = wasm$1.invitee_kp(this.ptr);
+        const ret = wasm$1.invitee_kp(this.__wbg_ptr);
         return takeObject(ret);
     }
 }
@@ -2009,13 +2155,14 @@ class Invitee {
 */
 class MemberAddedMessages {
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(MemberAddedMessages.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
         return obj;
     }
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
         return ptr;
     }
     free() {
@@ -2037,21 +2184,21 @@ class MemberAddedMessages {
     * @returns {Uint8Array}
     */
     get welcome() {
-        const ret = wasm$1.conversationinitbundle_conversation_id(this.ptr);
+        const ret = wasm$1.conversationinitbundle_conversation_id(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
     * @returns {Uint8Array}
     */
     get commit() {
-        const ret = wasm$1.commitbundle_commit(this.ptr);
+        const ret = wasm$1.commitbundle_commit(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
     * @returns {PublicGroupStateBundle}
     */
     get public_group_state() {
-        const ret = wasm$1.commitbundle_public_group_state(this.ptr);
+        const ret = wasm$1.commitbundle_public_group_state(this.__wbg_ptr);
         return PublicGroupStateBundle.__wrap(ret);
     }
 }
@@ -2060,13 +2207,14 @@ class MemberAddedMessages {
 */
 class NewAcmeAuthz {
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(NewAcmeAuthz.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
         return obj;
     }
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
         return ptr;
     }
     free() {
@@ -2098,30 +2246,34 @@ class NewAcmeAuthz {
     * @returns {string}
     */
     get identifier() {
+        let deferred1_0;
+        let deferred1_1;
         try {
             const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
-            wasm$1.newacmeauthz_identifier(retptr, this.ptr);
+            wasm$1.newacmeauthz_identifier(retptr, this.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
             return getStringFromWasm0(r0, r1);
         }
         finally {
             wasm$1.__wbindgen_add_to_stack_pointer(16);
-            wasm$1.__wbindgen_free(r0, r1);
+            wasm$1.__wbindgen_free(deferred1_0, deferred1_1);
         }
     }
     /**
     * @returns {AcmeChallenge | undefined}
     */
     get wireDpopChallenge() {
-        const ret = wasm$1.newacmeauthz_wireDpopChallenge(this.ptr);
+        const ret = wasm$1.newacmeauthz_wireDpopChallenge(this.__wbg_ptr);
         return ret === 0 ? undefined : AcmeChallenge.__wrap(ret);
     }
     /**
     * @returns {AcmeChallenge | undefined}
     */
     get wireOidcChallenge() {
-        const ret = wasm$1.newacmeauthz_wireOidcChallenge(this.ptr);
+        const ret = wasm$1.newacmeauthz_wireOidcChallenge(this.__wbg_ptr);
         return ret === 0 ? undefined : AcmeChallenge.__wrap(ret);
     }
 }
@@ -2130,13 +2282,14 @@ class NewAcmeAuthz {
 */
 class NewAcmeOrder {
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(NewAcmeOrder.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
         return obj;
     }
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
         return ptr;
     }
     free() {
@@ -2157,14 +2310,14 @@ class NewAcmeOrder {
     * @returns {Uint8Array}
     */
     get delegate() {
-        const ret = wasm$1.acmechallenge_delegate(this.ptr);
+        const ret = wasm$1.acmechallenge_delegate(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
     * @returns {Array<any>}
     */
     get authorizations() {
-        const ret = wasm$1.newacmeorder_authorizations(this.ptr);
+        const ret = wasm$1.newacmeorder_authorizations(this.__wbg_ptr);
         return takeObject(ret);
     }
 }
@@ -2172,13 +2325,14 @@ class NewAcmeOrder {
 */
 class ProposalBundle {
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(ProposalBundle.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
         return obj;
     }
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
         return ptr;
     }
     free() {
@@ -2189,14 +2343,14 @@ class ProposalBundle {
     * @returns {Uint8Array}
     */
     get proposal() {
-        const ret = wasm$1.acmechallenge_delegate(this.ptr);
+        const ret = wasm$1.acmechallenge_delegate(this.__wbg_ptr);
         return takeObject(ret);
     }
     /**
     * @returns {Uint8Array}
     */
     get proposal_ref() {
-        const ret = wasm$1.invitee_kp(this.ptr);
+        const ret = wasm$1.invitee_kp(this.__wbg_ptr);
         return takeObject(ret);
     }
 }
@@ -2204,13 +2358,14 @@ class ProposalBundle {
 */
 class ProteusAutoPrekeyBundle {
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(ProteusAutoPrekeyBundle.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
         return obj;
     }
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
         return ptr;
     }
     free() {
@@ -2221,14 +2376,14 @@ class ProteusAutoPrekeyBundle {
     * @returns {number}
     */
     get id() {
-        const ret = wasm$1.__wbg_get_proteusautoprekeybundle_id(this.ptr);
+        const ret = wasm$1.__wbg_get_proteusautoprekeybundle_id(this.__wbg_ptr);
         return ret;
     }
     /**
     * @param {number} arg0
     */
     set id(arg0) {
-        wasm$1.__wbg_set_proteusautoprekeybundle_id(this.ptr, arg0);
+        wasm$1.__wbg_set_proteusautoprekeybundle_id(this.__wbg_ptr, arg0);
     }
     /**
     * @returns {Uint8Array}
@@ -2236,12 +2391,12 @@ class ProteusAutoPrekeyBundle {
     get pkb() {
         try {
             const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
-            wasm$1.__wbg_get_proteusautoprekeybundle_pkb(retptr, this.ptr);
+            wasm$1.__wbg_get_proteusautoprekeybundle_pkb(retptr, this.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
-            var v0 = getArrayU8FromWasm0(r0, r1).slice();
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
             wasm$1.__wbindgen_free(r0, r1 * 1);
-            return v0;
+            return v1;
         }
         finally {
             wasm$1.__wbindgen_add_to_stack_pointer(16);
@@ -2253,20 +2408,21 @@ class ProteusAutoPrekeyBundle {
     set pkb(arg0) {
         const ptr0 = passArray8ToWasm0(arg0, wasm$1.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm$1.__wbg_set_proteusautoprekeybundle_pkb(this.ptr, ptr0, len0);
+        wasm$1.__wbg_set_proteusautoprekeybundle_pkb(this.__wbg_ptr, ptr0, len0);
     }
 }
 /**
 */
 class PublicGroupStateBundle {
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(PublicGroupStateBundle.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
         return obj;
     }
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
         return ptr;
     }
     free() {
@@ -2277,21 +2433,21 @@ class PublicGroupStateBundle {
     * @returns {number}
     */
     get encryption_type() {
-        const ret = wasm$1.publicgroupstatebundle_encryption_type(this.ptr);
+        const ret = wasm$1.publicgroupstatebundle_encryption_type(this.__wbg_ptr);
         return ret;
     }
     /**
     * @returns {number}
     */
     get ratchet_tree_type() {
-        const ret = wasm$1.publicgroupstatebundle_ratchet_tree_type(this.ptr);
+        const ret = wasm$1.publicgroupstatebundle_ratchet_tree_type(this.__wbg_ptr);
         return ret;
     }
     /**
     * @returns {Uint8Array}
     */
     get payload() {
-        const ret = wasm$1.acmechallenge_delegate(this.ptr);
+        const ret = wasm$1.acmechallenge_delegate(this.__wbg_ptr);
         return takeObject(ret);
     }
 }
@@ -2300,13 +2456,14 @@ class PublicGroupStateBundle {
 */
 class WireIdentity {
     static __wrap(ptr) {
+        ptr = ptr >>> 0;
         const obj = Object.create(WireIdentity.prototype);
-        obj.ptr = ptr;
+        obj.__wbg_ptr = ptr;
         return obj;
     }
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
         return ptr;
     }
     free() {
@@ -2335,68 +2492,84 @@ class WireIdentity {
     * @returns {string}
     */
     get client_id() {
+        let deferred1_0;
+        let deferred1_1;
         try {
             const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
-            wasm$1.acmedirectory_newNonce(retptr, this.ptr);
+            wasm$1.acmedirectory_newNonce(retptr, this.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
             return getStringFromWasm0(r0, r1);
         }
         finally {
             wasm$1.__wbindgen_add_to_stack_pointer(16);
-            wasm$1.__wbindgen_free(r0, r1);
+            wasm$1.__wbindgen_free(deferred1_0, deferred1_1);
         }
     }
     /**
     * @returns {string}
     */
     get handle() {
+        let deferred1_0;
+        let deferred1_1;
         try {
             const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
-            wasm$1.acmechallenge_url(retptr, this.ptr);
+            wasm$1.acmechallenge_url(retptr, this.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
             return getStringFromWasm0(r0, r1);
         }
         finally {
             wasm$1.__wbindgen_add_to_stack_pointer(16);
-            wasm$1.__wbindgen_free(r0, r1);
+            wasm$1.__wbindgen_free(deferred1_0, deferred1_1);
         }
     }
     /**
     * @returns {string}
     */
     get display_name() {
+        let deferred1_0;
+        let deferred1_1;
         try {
             const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
-            wasm$1.acmedirectory_newOrder(retptr, this.ptr);
+            wasm$1.acmechallenge_target(retptr, this.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
             return getStringFromWasm0(r0, r1);
         }
         finally {
             wasm$1.__wbindgen_add_to_stack_pointer(16);
-            wasm$1.__wbindgen_free(r0, r1);
+            wasm$1.__wbindgen_free(deferred1_0, deferred1_1);
         }
     }
     /**
     * @returns {string}
     */
     get domain() {
+        let deferred1_0;
+        let deferred1_1;
         try {
             const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
-            wasm$1.wireidentity_domain(retptr, this.ptr);
+            wasm$1.wireidentity_domain(retptr, this.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
             return getStringFromWasm0(r0, r1);
         }
         finally {
             wasm$1.__wbindgen_add_to_stack_pointer(16);
-            wasm$1.__wbindgen_free(r0, r1);
+            wasm$1.__wbindgen_free(deferred1_0, deferred1_1);
         }
     }
 }
-async function load(module, imports) {
+async function __wbg_load(module, imports) {
     if (typeof Response === 'function' && module instanceof Response) {
         if (typeof WebAssembly.instantiateStreaming === 'function') {
             try {
@@ -2424,16 +2597,16 @@ async function load(module, imports) {
         }
     }
 }
-function getImports() {
+function __wbg_get_imports() {
     const imports = {};
     imports.wbg = {};
+    imports.wbg.__wbindgen_object_drop_ref = function (arg0) {
+        takeObject(arg0);
+    };
     imports.wbg.__wbindgen_object_clone_ref = function (arg0) {
         const ret = getObject(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_object_drop_ref = function (arg0) {
-        takeObject(arg0);
-    };
     imports.wbg.__wbindgen_is_object = function (arg0) {
         const val = getObject(arg0);
         const ret = typeof (val) === 'object' && val !== null;
@@ -2451,11 +2624,22 @@ function getImports() {
         const ret = getObject(arg0) in getObject(arg1);
         return ret;
     };
-    imports.wbg.__wbg_objectStoreNames_f0884fed45ebc81c = function (arg0) {
+    imports.wbg.__wbg_commit_008545ae6e591814 = function () {
+        return handleError(function (arg0) {
+            getObject(arg0).commit();
+        }, arguments);
+    };
+    imports.wbg.__wbg_setoncomplete_1a27889412475f6f = function (arg0, arg1) {
+        getObject(arg0).oncomplete = getObject(arg1);
+    };
+    imports.wbg.__wbg_setonerror_74c492184749a58a = function (arg0, arg1) {
+        getObject(arg0).onerror = getObject(arg1);
+    };
+    imports.wbg.__wbg_objectStoreNames_432a9424fbdfefda = function (arg0) {
         const ret = getObject(arg0).objectStoreNames;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_length_36c8debf8d623fc6 = function (arg0) {
+    imports.wbg.__wbg_length_4633dd9b984117b1 = function (arg0) {
         const ret = getObject(arg0).length;
         return ret;
     };
@@ -2470,33 +2654,41 @@ function getImports() {
     imports.wbg.__wbindgen_string_get = function (arg0, arg1) {
         const obj = getObject(arg1);
         const ret = typeof (obj) === 'string' ? obj : undefined;
-        var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        getInt32Memory0()[arg0 / 4 + 1] = len0;
-        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len1;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr1;
     };
-    imports.wbg.__wbg_length_e498fbc24f9c1d4f = function (arg0) {
+    imports.wbg.__wbg_length_820c786973abdd8a = function (arg0) {
         const ret = getObject(arg0).length;
         return ret;
     };
-    imports.wbg.__wbg_ffiwiree2eidentity_new = function (arg0) {
-        const ret = FfiWireE2EIdentity.__wrap(arg0);
+    imports.wbg.__wbg_new_09938a7d020f049b = function (arg0) {
+        const ret = new Uint8Array(getObject(arg0));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_call_9495de66fdbe016b = function () {
+    imports.wbg.__wbg_call_587b30eea3e09332 = function () {
         return handleError(function (arg0, arg1, arg2) {
             const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_new_9d3a9ce4282a18a8 = function (arg0, arg1) {
+    imports.wbg.__wbg_new_0394642eae39db16 = function () {
+        const ret = new Array();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_push_109cfc26d02582dd = function (arg0, arg1) {
+        const ret = getObject(arg0).push(getObject(arg1));
+        return ret;
+    };
+    imports.wbg.__wbg_new_2b55e405e4af4986 = function (arg0, arg1) {
         try {
             var state0 = { a: arg0, b: arg1 };
             var cb0 = (arg0, arg1) => {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_285(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_288(a, state0.b, arg0, arg1);
                 }
                 finally {
                     state0.a = a;
@@ -2509,43 +2701,39 @@ function getImports() {
             state0.a = state0.b = 0;
         }
     };
-    imports.wbg.__wbg_new_537b7341ce90bb31 = function (arg0) {
-        const ret = new Uint8Array(getObject(arg0));
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbindgen_number_new = function (arg0) {
         const ret = arg0;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_bigint_from_u64 = function (arg0) {
-        const ret = BigInt.asUintN(64, arg0);
+    imports.wbg.__wbg_new_0f2b71ca2f2a6029 = function () {
+        const ret = new Map();
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_new_f9876326328f45ed = function () {
-        const ret = new Object();
+    imports.wbg.__wbg_set_da7be7bf0e037b14 = function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_new_f841cc6f2098f4b5 = function () {
-        const ret = new Map();
+    imports.wbg.__wbindgen_bigint_from_u64 = function (arg0) {
+        const ret = BigInt.asUintN(64, arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_set_388c4c6422704173 = function (arg0, arg1, arg2) {
-        const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
+    imports.wbg.__wbg_proteusautoprekeybundle_new = function (arg0) {
+        const ret = ProteusAutoPrekeyBundle.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_new_b525de17f44a8943 = function () {
-        const ret = new Array();
+    imports.wbg.__wbg_new_2b6fea4ea03b1b95 = function () {
+        const ret = new Object();
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_push_49c286f04dd3bf59 = function (arg0, arg1) {
-        const ret = getObject(arg0).push(getObject(arg1));
-        return ret;
+    imports.wbg.__wbg_ffiwiree2eidentity_new = function (arg0) {
+        const ret = FfiWireE2EIdentity.__wrap(arg0);
+        return addHeapObject(ret);
     };
-    imports.wbg.__wbg_proteusautoprekeybundle_new = function (arg0) {
-        const ret = ProteusAutoPrekeyBundle.__wrap(arg0);
+    imports.wbg.__wbg_new_87297f22973157c8 = function (arg0, arg1) {
+        const ret = new Error(getStringFromWasm0(arg0, arg1));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_setonsuccess_925a7718d3f62bc1 = function (arg0, arg1) {
+    imports.wbg.__wbg_setonsuccess_d668ac71ae816a35 = function (arg0, arg1) {
         getObject(arg0).onsuccess = getObject(arg1);
     };
     imports.wbg.__wbindgen_jsval_loose_eq = function (arg0, arg1) {
@@ -2567,7 +2755,7 @@ function getImports() {
         getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
         getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
     };
-    imports.wbg.__wbg_isSafeInteger_8c4789029e885159 = function (arg0) {
+    imports.wbg.__wbg_isSafeInteger_2088b01008075470 = function (arg0) {
         const ret = Number.isSafeInteger(getObject(arg0));
         return ret;
     };
@@ -2589,15 +2777,15 @@ function getImports() {
         const ret = new Error(getStringFromWasm0(arg0, arg1));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_isArray_39d28997bf6b96b4 = function (arg0) {
+    imports.wbg.__wbg_isArray_04e59fb73f78ab5b = function (arg0) {
         const ret = Array.isArray(getObject(arg0));
         return ret;
     };
-    imports.wbg.__wbg_iterator_55f114446221aa5a = function () {
+    imports.wbg.__wbg_iterator_7c7e58f62eb84700 = function () {
         const ret = Symbol.iterator;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_get_27fe3dac1c4d0224 = function (arg0, arg1) {
+    imports.wbg.__wbg_get_7303ed2ef026b2f5 = function (arg0, arg1) {
         const ret = getObject(arg0)[arg1 >>> 0];
         return addHeapObject(ret);
     };
@@ -2608,11 +2796,7 @@ function getImports() {
     imports.wbg.__wbg_set_841ac57cff3d672b = function (arg0, arg1, arg2) {
         getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
     };
-    imports.wbg.__wbg_new_15d3966e9981a196 = function (arg0, arg1) {
-        const ret = new Error(getStringFromWasm0(arg0, arg1));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_instanceof_Promise_4333c4e5587e8936 = function (arg0) {
+    imports.wbg.__wbg_instanceof_Promise_4b9b76dc9c35f96e = function (arg0) {
         let result;
         try {
             result = getObject(arg0) instanceof Promise;
@@ -2623,30 +2807,30 @@ function getImports() {
         const ret = result;
         return ret;
     };
-    imports.wbg.__wbg_then_f753623316e2873a = function (arg0, arg1, arg2) {
+    imports.wbg.__wbg_then_835b073a479138e5 = function (arg0, arg1, arg2) {
         const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_warn_e57696dbb3977030 = function (arg0) {
+    imports.wbg.__wbg_warn_9bdd743e9f5fe1e0 = function (arg0) {
         console.warn(getObject(arg0));
     };
-    imports.wbg.__wbg_call_96878afb7a8201ca = function () {
+    imports.wbg.__wbg_call_4c73e4aecced6a7d = function () {
         return handleError(function (arg0, arg1, arg2, arg3) {
             const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_call_99043a1e2a9e5916 = function () {
+    imports.wbg.__wbg_call_7f98f4764e617d86 = function () {
         return handleError(function (arg0, arg1, arg2, arg3, arg4) {
             const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3), getObject(arg4));
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_of_4065463fbe892f00 = function (arg0, arg1, arg2, arg3) {
+    imports.wbg.__wbg_of_3ff36373618311f4 = function (arg0, arg1, arg2, arg3) {
         const ret = Array.of(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_apply_aedce30790c00792 = function () {
+    imports.wbg.__wbg_apply_8cf86cc6c93f52c1 = function () {
         return handleError(function (arg0, arg1, arg2) {
             const ret = getObject(arg0).apply(getObject(arg1), getObject(arg2));
             return addHeapObject(ret);
@@ -2656,11 +2840,11 @@ function getImports() {
         const ret = performance.now();
         return ret;
     };
-    imports.wbg.__wbg_reject_57029f54148d79c3 = function (arg0) {
+    imports.wbg.__wbg_reject_c2ad2ed69321f916 = function (arg0) {
         const ret = Promise.reject(getObject(arg0));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_set_17224bc548dd1d7b = function (arg0, arg1, arg2) {
+    imports.wbg.__wbg_set_b4da98d504ac6091 = function (arg0, arg1, arg2) {
         getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
     };
     imports.wbg.__wbg_proposalbundle_new = function (arg0) {
@@ -2677,44 +2861,37 @@ function getImports() {
     };
     imports.wbg.__wbg_stack_658279fe44541cf6 = function (arg0, arg1) {
         const ret = getObject(arg1).stack;
-        const ptr0 = passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        getInt32Memory0()[arg0 / 4 + 1] = len0;
-        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+        const ptr1 = passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len1;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr1;
     };
     imports.wbg.__wbg_error_f851667af71bcfc6 = function (arg0, arg1) {
+        let deferred0_0;
+        let deferred0_1;
         try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
             console.error(getStringFromWasm0(arg0, arg1));
         }
         finally {
-            wasm$1.__wbindgen_free(arg0, arg1);
+            wasm$1.__wbindgen_free(deferred0_0, deferred0_1);
         }
     };
-    imports.wbg.__wbg_commit_7f934e1d9fffde34 = function () {
-        return handleError(function (arg0) {
-            getObject(arg0).commit();
-        }, arguments);
-    };
-    imports.wbg.__wbg_setoncomplete_f32167d3f84be687 = function (arg0, arg1) {
-        getObject(arg0).oncomplete = getObject(arg1);
-    };
-    imports.wbg.__wbg_setonerror_7cbe775a0abc7a8e = function (arg0, arg1) {
-        getObject(arg0).onerror = getObject(arg1);
-    };
-    imports.wbg.__wbg_name_31ef05f12c1d72c6 = function (arg0, arg1) {
+    imports.wbg.__wbg_name_38df4c6ca8f369b9 = function (arg0, arg1) {
         const ret = getObject(arg1).name;
-        const ptr0 = passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        getInt32Memory0()[arg0 / 4 + 1] = len0;
-        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+        const ptr1 = passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len1;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr1;
     };
-    imports.wbg.__wbg_transaction_a31cc90bd4f34364 = function () {
+    imports.wbg.__wbg_transaction_7cffa0cd94a4c3fe = function () {
         return handleError(function (arg0, arg1, arg2) {
             const ret = getObject(arg0).transaction(getObject(arg1), takeObject(arg2));
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_setonerror_019196fbce756cc0 = function (arg0, arg1) {
+    imports.wbg.__wbg_setonerror_e1d069ec7a5315ee = function (arg0, arg1) {
         getObject(arg0).onerror = getObject(arg1);
     };
     imports.wbg.__wbindgen_cb_drop = function (arg0) {
@@ -2726,64 +2903,52 @@ function getImports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbg_close_98f3a5ab91060b8b = function (arg0) {
+    imports.wbg.__wbg_close_68facef204a0b48a = function (arg0) {
         getObject(arg0).close();
     };
-    imports.wbg.__wbg_deleteDatabase_f360deb7283ea232 = function () {
+    imports.wbg.__wbg_deleteDatabase_8531c5f474a3ff15 = function () {
         return handleError(function (arg0, arg1, arg2) {
             const ret = getObject(arg0).deleteDatabase(getStringFromWasm0(arg1, arg2));
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_put_fdcda25ee2a99b60 = function () {
+    imports.wbg.__wbg_put_f62eacfa59543435 = function () {
         return handleError(function (arg0, arg1, arg2) {
             const ret = getObject(arg0).put(getObject(arg1), getObject(arg2));
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_put_e078356619886001 = function () {
+    imports.wbg.__wbg_put_05619e738b4e6bc3 = function () {
         return handleError(function (arg0, arg1) {
             const ret = getObject(arg0).put(getObject(arg1));
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_count_5e2074144ab4e23d = function () {
-        return handleError(function (arg0) {
-            const ret = getObject(arg0).count();
-            return addHeapObject(ret);
-        }, arguments);
-    };
-    imports.wbg.__wbg_count_ca4ab5c7bcf928fa = function () {
-        return handleError(function (arg0, arg1) {
-            const ret = getObject(arg0).count(getObject(arg1));
-            return addHeapObject(ret);
-        }, arguments);
-    };
-    imports.wbg.__wbg_delete_d2905418845867ae = function () {
+    imports.wbg.__wbg_delete_4aef4c117a5e6c27 = function () {
         return handleError(function (arg0, arg1) {
             const ret = getObject(arg0).delete(getObject(arg1));
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_index_009fbb0b7b595020 = function () {
+    imports.wbg.__wbg_index_a508b592b002de8d = function () {
         return handleError(function (arg0, arg1, arg2) {
             const ret = getObject(arg0).index(getStringFromWasm0(arg1, arg2));
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_get_baf4855f9a986186 = function () {
+    imports.wbg.__wbg_get_f53c921291c381bd = function () {
         return handleError(function (arg0, arg1) {
             const ret = Reflect.get(getObject(arg0), getObject(arg1));
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_get_6b22d93eabf073bc = function () {
+    imports.wbg.__wbg_get_f5beff7314ca87fd = function () {
         return handleError(function (arg0, arg1) {
             const ret = getObject(arg0).get(getObject(arg1));
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_openCursor_54d7936e873b5120 = function () {
+    imports.wbg.__wbg_openCursor_9f2ba6afb4885925 = function () {
         return handleError(function (arg0, arg1) {
             const ret = getObject(arg0).openCursor(getObject(arg1));
             return addHeapObject(ret);
@@ -2793,11 +2958,11 @@ function getImports() {
         const ret = wasm$1.memory;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_buffer_cf65c07de34b9a08 = function (arg0) {
+    imports.wbg.__wbg_buffer_55ba7a6b1b92e2ac = function (arg0) {
         const ret = getObject(arg0).buffer;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_newwithbyteoffsetandlength_9fb2f11355ecadf5 = function (arg0, arg1, arg2) {
+    imports.wbg.__wbg_newwithbyteoffsetandlength_88d1d8be5df94b9b = function (arg0, arg1, arg2) {
         const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
         return addHeapObject(ret);
     };
@@ -2806,7 +2971,7 @@ function getImports() {
             getObject(arg0).randomFillSync(takeObject(arg1));
         }, arguments);
     };
-    imports.wbg.__wbg_subarray_7526649b91a252a6 = function (arg0, arg1, arg2) {
+    imports.wbg.__wbg_subarray_d82be056deb4ad27 = function (arg0, arg1, arg2) {
         const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
         return addHeapObject(ret);
     };
@@ -2849,145 +3014,145 @@ function getImports() {
         const ret = getObject(arg0).msCrypto;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_newwithlength_b56c882b57805732 = function (arg0) {
+    imports.wbg.__wbg_newwithlength_89eeca401d8918c2 = function (arg0) {
         const ret = new Uint8Array(arg0 >>> 0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_next_88560ec06a094dea = function () {
+    imports.wbg.__wbg_next_ec061e48a0e72a96 = function () {
         return handleError(function (arg0) {
             const ret = getObject(arg0).next();
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_done_1ebec03bbd919843 = function (arg0) {
+    imports.wbg.__wbg_done_b6abb27d42b63867 = function (arg0) {
         const ret = getObject(arg0).done;
         return ret;
     };
-    imports.wbg.__wbg_value_6ac8da5cc5b3efda = function (arg0) {
+    imports.wbg.__wbg_value_2f4ef2036bfad28e = function (arg0) {
         const ret = getObject(arg0).value;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_call_95d1ea488d03e4e8 = function () {
+    imports.wbg.__wbg_call_557a2f2deacc4912 = function () {
         return handleError(function (arg0, arg1) {
             const ret = getObject(arg0).call(getObject(arg1));
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_next_b7d530c04fd8b217 = function (arg0) {
+    imports.wbg.__wbg_next_f4bc0e96ea67da68 = function (arg0) {
         const ret = getObject(arg0).next;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_self_e7c1f827057f6584 = function () {
+    imports.wbg.__wbg_self_742dd6eab3e9211e = function () {
         return handleError(function () {
             const ret = self.self;
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_window_a09ec664e14b1b81 = function () {
+    imports.wbg.__wbg_window_c409e731db53a0e2 = function () {
         return handleError(function () {
             const ret = window.window;
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_globalThis_87cbb8506fecf3a9 = function () {
+    imports.wbg.__wbg_globalThis_b70c095388441f2d = function () {
         return handleError(function () {
             const ret = globalThis.globalThis;
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_global_c85a9259e621f3db = function () {
+    imports.wbg.__wbg_global_1c72617491ed7194 = function () {
         return handleError(function () {
             const ret = global.global;
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_newnoargs_2b8b6bd7753c76ba = function (arg0, arg1) {
+    imports.wbg.__wbg_newnoargs_c9e6043b8ad84109 = function (arg0, arg1) {
         const ret = new Function(getStringFromWasm0(arg0, arg1));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_set_6aa458a4ebdb65cb = function () {
+    imports.wbg.__wbg_set_07da13cc24b69217 = function () {
         return handleError(function (arg0, arg1, arg2) {
             const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
             return ret;
         }, arguments);
     };
-    imports.wbg.__wbg_set_17499e8aa4003ebd = function (arg0, arg1, arg2) {
+    imports.wbg.__wbg_set_3698e3ca519b3c3c = function (arg0, arg1, arg2) {
         getObject(arg0).set(getObject(arg1), arg2 >>> 0);
     };
-    imports.wbg.__wbg_length_27a2afe8ab42b09f = function (arg0) {
+    imports.wbg.__wbg_length_0aab7ffd65ad19ed = function (arg0) {
         const ret = getObject(arg0).length;
         return ret;
     };
-    imports.wbg.__wbg_now_931686b195a14f9d = function () {
+    imports.wbg.__wbg_now_c857fb0367c762cc = function () {
         const ret = Date.now();
         return ret;
     };
-    imports.wbg.__wbg_target_b629c177f9bee3da = function (arg0) {
+    imports.wbg.__wbg_target_bb43778021b84733 = function (arg0) {
         const ret = getObject(arg0).target;
         return isLikeNone(ret) ? 0 : addHeapObject(ret);
     };
-    imports.wbg.__wbg_result_3a1fef332bc47038 = function () {
+    imports.wbg.__wbg_error_a16f2288166003c0 = function () {
+        return handleError(function (arg0) {
+            const ret = getObject(arg0).error;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        }, arguments);
+    };
+    imports.wbg.__wbg_result_fcdf1e20f03fa375 = function () {
         return handleError(function (arg0) {
             const ret = getObject(arg0).result;
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_contains_eab173da4886df95 = function (arg0, arg1, arg2) {
+    imports.wbg.__wbg_contains_7ea02aa9686102c9 = function (arg0, arg1, arg2) {
         const ret = getObject(arg0).contains(getStringFromWasm0(arg1, arg2));
         return ret;
     };
-    imports.wbg.__wbg_createObjectStore_ed1e91faa3997893 = function () {
+    imports.wbg.__wbg_createObjectStore_cc4ffd0f671774b5 = function () {
         return handleError(function (arg0, arg1, arg2, arg3) {
             const ret = getObject(arg0).createObjectStore(getStringFromWasm0(arg1, arg2), getObject(arg3));
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_transaction_c231cf0e3feac876 = function (arg0) {
+    imports.wbg.__wbg_transaction_6ee3b434ba42d2ba = function (arg0) {
         const ret = getObject(arg0).transaction;
         return isLikeNone(ret) ? 0 : addHeapObject(ret);
     };
-    imports.wbg.__wbg_indexNames_7ef05cac7f9faea0 = function (arg0) {
+    imports.wbg.__wbg_indexNames_3d712486a8cca56f = function (arg0) {
         const ret = getObject(arg0).indexNames;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_createIndex_308667a6a7549b87 = function () {
+    imports.wbg.__wbg_createIndex_1754becb0a1eaade = function () {
         return handleError(function (arg0, arg1, arg2, arg3, arg4) {
             const ret = getObject(arg0).createIndex(getStringFromWasm0(arg1, arg2), getObject(arg3), getObject(arg4));
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_deleteIndex_4f7897daa8425a6c = function () {
+    imports.wbg.__wbg_deleteIndex_a2e0e2a52cf9efbb = function () {
         return handleError(function (arg0, arg1, arg2) {
             getObject(arg0).deleteIndex(getStringFromWasm0(arg1, arg2));
         }, arguments);
     };
-    imports.wbg.__wbg_deleteObjectStore_a67245ba486fb641 = function () {
+    imports.wbg.__wbg_deleteObjectStore_0e5499c492f82cfa = function () {
         return handleError(function (arg0, arg1, arg2) {
             getObject(arg0).deleteObjectStore(getStringFromWasm0(arg1, arg2));
         }, arguments);
     };
-    imports.wbg.__wbg_error_f64b8d41ed4d2fdc = 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;
     };
-    imports.wbg.__wbg_key_4b29c4de1db73033 = function () {
+    imports.wbg.__wbg_key_46cfc02e70598c46 = function () {
         return handleError(function (arg0) {
             const ret = getObject(arg0).key;
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_advance_b4ae7221325b28eb = function () {
+    imports.wbg.__wbg_advance_41fb7fb13309369f = function () {
         return handleError(function (arg0, arg1) {
             getObject(arg0).advance(arg1 >>> 0);
         }, arguments);
     };
-    imports.wbg.__wbg_instanceof_IdbFactory_9c5780a46ebd3426 = function (arg0) {
+    imports.wbg.__wbg_instanceof_IdbFactory_b27e3052d7c33961 = function (arg0) {
         let result;
         try {
             result = getObject(arg0) instanceof IDBFactory;
@@ -2998,26 +3163,26 @@ function getImports() {
         const ret = result;
         return ret;
     };
-    imports.wbg.__wbg_open_bd135117d9924392 = function () {
+    imports.wbg.__wbg_open_8fe2c4fdf4aa1f9d = function () {
         return handleError(function (arg0, arg1, arg2) {
             const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2));
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_open_2f9bdc2df25fc92e = function () {
+    imports.wbg.__wbg_open_d5031782c12da0d4 = 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_8961be061344d04a = function (arg0, arg1) {
+    imports.wbg.__wbg_setonupgradeneeded_73f521ef7c1bd5de = function (arg0, arg1) {
         getObject(arg0).onupgradeneeded = getObject(arg1);
     };
-    imports.wbg.__wbg_toString_cec163b212643722 = function (arg0) {
+    imports.wbg.__wbg_toString_506566b763774a16 = function (arg0) {
         const ret = getObject(arg0).toString();
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_instanceof_Uint8Array_01cebe79ca606cca = function (arg0) {
+    imports.wbg.__wbg_instanceof_Uint8Array_1349640af2da2e88 = function (arg0) {
         let result;
         try {
             result = getObject(arg0) instanceof Uint8Array;
@@ -3028,7 +3193,7 @@ function getImports() {
         const ret = result;
         return ret;
     };
-    imports.wbg.__wbg_instanceof_ArrayBuffer_a69f02ee4c4f5065 = function (arg0) {
+    imports.wbg.__wbg_instanceof_ArrayBuffer_ef2632aa0d4bfff8 = function (arg0) {
         let result;
         try {
             result = getObject(arg0) instanceof ArrayBuffer;
@@ -3039,138 +3204,143 @@ function getImports() {
         const ret = result;
         return ret;
     };
-    imports.wbg.__wbg_entries_4e1315b774245952 = function (arg0) {
+    imports.wbg.__wbg_entries_13e011453776468f = function (arg0) {
         const ret = Object.entries(getObject(arg0));
         return addHeapObject(ret);
     };
     imports.wbg.__wbg_String_88810dfeb4021902 = function (arg0, arg1) {
         const ret = String(getObject(arg1));
-        const ptr0 = passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        getInt32Memory0()[arg0 / 4 + 1] = len0;
-        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+        const ptr1 = passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len1;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr1;
     };
-    imports.wbg.__wbg_new0_25059e40b1c02766 = function () {
+    imports.wbg.__wbg_new0_494c19a27871d56f = function () {
         const ret = new Date();
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_getTime_7c59072d1651a3cf = function (arg0) {
+    imports.wbg.__wbg_getTime_40bd09e020e8bc8c = function (arg0) {
         const ret = getObject(arg0).getTime();
         return ret;
     };
     imports.wbg.__wbindgen_debug_string = function (arg0, arg1) {
         const ret = debugString(getObject(arg1));
-        const ptr0 = passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        getInt32Memory0()[arg0 / 4 + 1] = len0;
-        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+        const ptr1 = passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len1;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr1;
     };
     imports.wbg.__wbindgen_throw = function (arg0, arg1) {
         throw new Error(getStringFromWasm0(arg0, arg1));
     };
-    imports.wbg.__wbg_then_ec5db6d509eb475f = function (arg0, arg1) {
+    imports.wbg.__wbg_then_8df675b8bb5d5e3c = function (arg0, arg1) {
         const ret = getObject(arg0).then(getObject(arg1));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_resolve_fd40f858d9db1a04 = function (arg0) {
+    imports.wbg.__wbg_resolve_ae38ad63c43ff98b = function (arg0) {
         const ret = Promise.resolve(getObject(arg0));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_get_ed3fbcc16ce7b4bb = function (arg0, arg1, arg2) {
+    imports.wbg.__wbg_get_91d38ec2e4611a1e = function (arg0, arg1, arg2) {
         const ret = getObject(arg1)[arg2 >>> 0];
-        var ptr0 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        getInt32Memory0()[arg0 / 4 + 1] = len0;
-        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len1;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr1;
     };
-    imports.wbg.__wbg_continue_1df0825170e4d395 = function () {
+    imports.wbg.__wbg_continue_c081a1b978361679 = function () {
         return handleError(function (arg0) {
             getObject(arg0).continue();
         }, arguments);
     };
-    imports.wbg.__wbg_value_97772e372f20b04e = function () {
+    imports.wbg.__wbg_value_3b1dc8fee5cc6eb5 = function () {
         return handleError(function (arg0) {
             const ret = getObject(arg0).value;
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_openCursor_f07a2d20b356da80 = function () {
+    imports.wbg.__wbg_openCursor_5d4f2d7a9e60117c = function () {
         return handleError(function (arg0) {
             const ret = getObject(arg0).openCursor();
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_openCursor_03f95e6b2b64c86e = function () {
+    imports.wbg.__wbg_openCursor_88c75b521e6a6818 = function () {
         return handleError(function (arg0, arg1, arg2) {
             const ret = getObject(arg0).openCursor(getObject(arg1), takeObject(arg2));
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_get_18b8195859195e7e = function () {
+    imports.wbg.__wbg_get_a9b507527c0f6958 = function () {
         return handleError(function (arg0, arg1) {
             const ret = getObject(arg0).get(getObject(arg1));
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_openCursor_a00e5f8015710a1a = function () {
+    imports.wbg.__wbg_openCursor_2da32f6b7767a8f6 = function () {
         return handleError(function (arg0) {
             const ret = getObject(arg0).openCursor();
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_openCursor_51766f7156aa29ab = function () {
+    imports.wbg.__wbg_openCursor_63250aa904924858 = function () {
         return handleError(function (arg0, arg1) {
             const ret = getObject(arg0).openCursor(getObject(arg1));
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_openCursor_4bc8942a881766b1 = function () {
+    imports.wbg.__wbg_openCursor_4a2cac5b1c5cf36b = function () {
         return handleError(function (arg0, arg1, arg2) {
             const ret = getObject(arg0).openCursor(getObject(arg1), takeObject(arg2));
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbg_objectStore_cdc69f65ad4a71eb = function () {
+    imports.wbg.__wbg_objectStore_6eb812526333c917 = function () {
         return handleError(function (arg0, arg1, arg2) {
             const ret = getObject(arg0).objectStore(getStringFromWasm0(arg1, arg2));
             return addHeapObject(ret);
         }, arguments);
     };
-    imports.wbg.__wbindgen_closure_wrapper1537 = function (arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 158, __wbg_adapter_52);
+    imports.wbg.__wbindgen_closure_wrapper1663 = function (arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 162, __wbg_adapter_52);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper4621 = function (arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 158, __wbg_adapter_55);
+    imports.wbg.__wbindgen_closure_wrapper4791 = function (arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 162, __wbg_adapter_55);
         return addHeapObject(ret);
     };
     return imports;
 }
-function finalizeInit(instance, module) {
+function __wbg_finalize_init(instance, module) {
     wasm$1 = instance.exports;
-    init.__wbindgen_wasm_module = module;
+    __wbg_init.__wbindgen_wasm_module = module;
     cachedBigInt64Memory0 = null;
     cachedFloat64Memory0 = null;
     cachedInt32Memory0 = null;
+    cachedUint16Memory0 = null;
     cachedUint32Memory0 = null;
     cachedUint8Memory0 = null;
     return wasm$1;
 }
 function initSync(module) {
-    const imports = getImports();
+    if (wasm$1 !== undefined)
+        return wasm$1;
+    const imports = __wbg_get_imports();
     if (!(module instanceof WebAssembly.Module)) {
         module = new WebAssembly.Module(module);
     }
     const instance = new WebAssembly.Instance(module, imports);
-    return finalizeInit(instance, module);
+    return __wbg_finalize_init(instance, module);
 }
-async function init(input) {
-    const imports = getImports();
+async function __wbg_init(input) {
+    if (wasm$1 !== undefined)
+        return wasm$1;
+    const imports = __wbg_get_imports();
     if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
         input = fetch(input);
     }
-    const { instance, module } = await load(await input, imports);
-    return finalizeInit(instance, module);
+    const { instance, module } = await __wbg_load(await input, imports);
+    return __wbg_finalize_init(instance, module);
 }
 var exports = /*#__PURE__*/Object.freeze({
@@ -3183,6 +3353,7 @@ var exports = /*#__PURE__*/Object.freeze({
     ConversationInitBundle: ConversationInitBundle,
     CoreCrypto: CoreCrypto$1,
     CoreCryptoWasmCallbacks: CoreCryptoWasmCallbacks,
+    CredentialType: CredentialType$1,
     CustomConfiguration: CustomConfiguration,
     DecryptedMessage: DecryptedMessage,
     FfiWireE2EIdentity: FfiWireE2EIdentity,
@@ -3195,14 +3366,14 @@ var exports = /*#__PURE__*/Object.freeze({
     PublicGroupStateBundle: PublicGroupStateBundle,
     WireIdentity: WireIdentity,
     WirePolicy: WirePolicy$1,
-    default: init,
+    default: __wbg_init,
     initSync: initSync
 });
 var wasm = async (opt = {}) => {
                 let {importHook, serverPath} = opt;
-                let path = "assets/core_crypto_ffi-70438e2d.wasm";
+                let path = "assets/core_crypto_ffi-3aab42da.wasm";
                 if (serverPath != null) {
                     path = serverPath + /[^\/\\]*$/.exec(path)[0];
@@ -3212,7 +3383,7 @@ var wasm = async (opt = {}) => {
                     path = importHook(path);
                 }
-                await init(path);
+                await __wbg_init(path);
                 return exports;
             };
@@ -3311,6 +3482,17 @@ var Ciphersuite;
      */
     Ciphersuite[Ciphersuite["MLS_256_DHKEMP384_AES256GCM_SHA384_P384"] = 7] = "MLS_256_DHKEMP384_AES256GCM_SHA384_P384";
 })(Ciphersuite || (Ciphersuite = {}));
+var CredentialType;
+(function (CredentialType) {
+    /**
+     * Just a KeyPair
+     */
+    CredentialType[CredentialType["Basic"] = 1] = "Basic";
+    /**
+     * A certificate obtained through e2e identity enrollment process
+     */
+    CredentialType[CredentialType["X509"] = 2] = "X509";
+})(CredentialType || (CredentialType = {}));
 /**
  * see [core_crypto::prelude::MlsWirePolicy]
  */
@@ -3428,13 +3610,14 @@ class CoreCrypto {
      * });
      * ````
      */
-    static async init({ databaseName, key, clientId, wasmFilePath, entropySeed }) {
+    static async init({ databaseName, key, clientId, wasmFilePath, ciphersuites, entropySeed }) {
         if (!__classPrivateFieldGet(this, _a, "f", _CoreCrypto_module)) {
             const wasmImportArgs = wasmFilePath ? { importHook: () => wasmFilePath } : undefined;
             const exports = (await wasm(wasmImportArgs));
             __classPrivateFieldSet(this, _a, exports, "f", _CoreCrypto_module);
         }
-        const cc = await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _a, "f", _CoreCrypto_module).CoreCrypto._internal_new(databaseName, key, clientId, entropySeed));
+        let cs = ciphersuites.map(cs => cs.valueOf());
+        const cc = await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _a, "f", _CoreCrypto_module).CoreCrypto._internal_new(databaseName, key, clientId, Uint16Array.of(...cs), entropySeed));
         return new this(cc);
     }
     /**
@@ -3444,42 +3627,49 @@ class CoreCrypto {
      * Use this clientId to initialize MLS with {@link CoreCrypto.mlsInit}.
      * @param params - {@link CoreCryptoDeferredParams}
      */
-    static async deferredInit({ databaseName, key, entropySeed, wasmFilePath }) {
+    static async deferredInit({ databaseName, key, ciphersuites, entropySeed, wasmFilePath }) {
         if (!__classPrivateFieldGet(this, _a, "f", _CoreCrypto_module)) {
             const wasmImportArgs = wasmFilePath ? { importHook: () => wasmFilePath } : undefined;
             const exports = (await wasm(wasmImportArgs));
             __classPrivateFieldSet(this, _a, exports, "f", _CoreCrypto_module);
         }
-        const cc = await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _a, "f", _CoreCrypto_module).CoreCrypto.deferred_init(databaseName, key, entropySeed));
+        let cs = ciphersuites.map(cs => cs.valueOf());
+        const cc = await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _a, "f", _CoreCrypto_module).CoreCrypto.deferred_init(databaseName, key, Uint16Array.of(...cs), entropySeed));
         return new this(cc);
     }
     /**
      * Use this after {@link CoreCrypto.deferredInit} when you have a clientId. It initializes MLS.
      *
      * @param clientId - {@link CoreCryptoParams#clientId} but required
+     * @param ciphersuites - All the ciphersuites supported by this MLS client
      */
-    async mlsInit(clientId) {
-        return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").mls_init(clientId));
+    async mlsInit(clientId, ciphersuites) {
+        let cs = ciphersuites.map(cs => cs.valueOf());
+        return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").mls_init(clientId, Uint16Array.of(...cs)));
     }
     /**
      * Generates a MLS KeyPair/CredentialBundle with a temporary, random client ID.
-     * This method is designed to be used in conjunction with {@link CoreCrypto.mlsInitWithClientID} and represents the first step in this process
+     * This method is designed to be used in conjunction with {@link CoreCrypto.mlsInitWithClientId} and represents the first step in this process
      *
+     * @param ciphersuites - All the ciphersuites supported by this MLS client
      * @returns This returns the TLS-serialized identity key (i.e. the signature keypair's public key)
      */
-    async mlsGenerateKeypair() {
-        return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").mls_generate_keypair());
+    async mlsGenerateKeypair(ciphersuites) {
+        let cs = ciphersuites.map(cs => cs.valueOf());
+        return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").mls_generate_keypair(Uint16Array.of(...cs)));
     }
     /**
      * Updates the current temporary Client ID with the newly provided one. This is the second step in the externally-generated clients process
      *
-     * Important: This is designed to be called after {@link CoreCrypto.mlsGenerateKeyPair}
+     * Important: This is designed to be called after {@link CoreCrypto.mlsGenerateKeypair}
      *
      * @param clientId - The newly-allocated client ID by the MLS Authentication Service
-     * @param signaturePublicKey - The public key you were given at the first step; This is for authentication purposes
+     * @param signaturePublicKeys - The public key you were given at the first step; This is for authentication purposes
+     * @param ciphersuites - All the ciphersuites supported by this MLS client
      */
-    async mlsInitWithClientId(clientId, signaturePublicKey) {
-        return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").mls_init_with_client_id(clientId, signaturePublicKey));
+    async mlsInitWithClientId(clientId, signaturePublicKeys, ciphersuites) {
+        let cs = ciphersuites.map(cs => cs.valueOf());
+        return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").mls_init_with_client_id(clientId, signaturePublicKeys, Uint16Array.of(...cs)));
     }
     /** @hidden */
     constructor(cc) {
@@ -3663,23 +3853,26 @@ class CoreCrypto {
     /**
      * @returns The client's public key
      */
-    async clientPublicKey() {
-        return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").client_public_key());
+    async clientPublicKey(ciphersuite) {
+        return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").client_public_key(ciphersuite));
     }
     /**
+     *
+     * @param ciphersuite - of the KeyPackages to count
      * @returns The amount of valid, non-expired KeyPackages that are persisted in the backing storage
      */
-    async clientValidKeypackagesCount() {
-        return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").client_valid_keypackages_count());
+    async clientValidKeypackagesCount(ciphersuite) {
+        return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").client_valid_keypackages_count(ciphersuite));
     }
     /**
      * Fetches a requested amount of keypackages
      *
+     * @param ciphersuite - of the KeyPackages to generate
      * @param amountRequested - The amount of keypackages requested
      * @returns An array of length `amountRequested` containing TLS-serialized KeyPackages
      */
-    async clientKeypackages(amountRequested) {
-        return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").client_keypackages(amountRequested));
+    async clientKeypackages(ciphersuite, amountRequested) {
+        return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").client_keypackages(ciphersuite, amountRequested));
     }
     /**
      * Adds new clients to a conversation, assuming the current client has the right to add new clients to the conversation.
@@ -3840,7 +4033,8 @@ class CoreCrypto {
     async newExternalProposal(externalProposalType, args) {
         switch (externalProposalType) {
             case ExternalProposalType.Add: {
-                return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").new_external_add_proposal(args.conversationId, args.epoch));
+                let addArgs = args;
+                return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").new_external_add_proposal(args.conversationId, args.epoch, addArgs.ciphersuite, addArgs.credentialType));
             }
             case ExternalProposalType.Remove: {
                 if (!args.keyPackageRef) {
@@ -3872,14 +4066,17 @@ class CoreCrypto {
      * bad can happen if you forget to except some storage space wasted.
      *
      * @param publicGroupState - a TLS encoded PublicGroupState fetched from the Delivery Service
+     * @param credentialType - kind of Credential to use for joining this group. If {@link CredentialType.Basic} is
+     * chosen and no Credential has been created yet for it, a new one will be generated.
      * @param configuration - configuration of the MLS group
+     * When {@link CredentialType.X509} is chosen, it fails when no Credential has been created for the given {@link Ciphersuite}.
      * @returns see {@link ConversationInitBundle}
      */
-    async joinByExternalCommit(publicGroupState, configuration = {}) {
+    async joinByExternalCommit(publicGroupState, credentialType, configuration = {}) {
         try {
             const { keyRotationSpan, wirePolicy } = configuration || {};
             const config = new (__classPrivateFieldGet(CoreCrypto, _a, "f", _CoreCrypto_module).CustomConfiguration)(keyRotationSpan, wirePolicy);
-            const ffiInitMessage = await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").join_by_external_commit(publicGroupState, config));
+            const ffiInitMessage = await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").join_by_external_commit(publicGroupState, config, credentialType));
             const pgs = ffiInitMessage.public_group_state;
             const ret = {
                 conversationId: ffiInitMessage.conversation_id,
@@ -4177,24 +4374,41 @@ class CoreCrypto {
      * @param displayName human readable name displayed in the application e.g. `Smith, Alice M (QA)`
      * @param handle user handle e.g. `alice.smith.qa@example.com`
      * @param expiryDays generated x509 certificate expiry
-     * @param ciphersuite - For generating signing key material. Only {@link Ciphersuite.MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519} is supported currently
+     * @param ciphersuite - for generating signing key material
      * @returns The new {@link WireE2eIdentity} object
      */
-    async newAcmeEnrollment(clientId, displayName, handle, expiryDays, ciphersuite = Ciphersuite.MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519) {
-        if (ciphersuite !== Ciphersuite.MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519) {
-            throw new Error("This ACME ciphersuite isn't supported. Only `Ciphersuite.MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519` is as of now");
-        }
-        const e2ei = await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").new_acme_enrollment(clientId, displayName, handle, expiryDays, ciphersuite));
+    async e2eiNewEnrollment(clientId, displayName, handle, expiryDays, ciphersuite) {
+        const e2ei = await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").e2ei_new_enrollment(clientId, displayName, handle, expiryDays, ciphersuite));
         return new WireE2eIdentity(e2ei);
     }
     /**
      * Parses the ACME server response from the endpoint fetching x509 certificates and uses it to initialize the MLS client with a certificate
      *
-     * @param e2ei - the enrollment instance used to fetch the certificates
+     * @param enrollment - the enrollment instance used to fetch the certificates
      * @param certificateChain - the raw response from ACME server
      */
-    async e2eiMlsInit(e2ei, certificateChain) {
-        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").e2ei_mls_init(e2ei.inner(), certificateChain);
+    async e2eiMlsInit(enrollment, certificateChain) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").e2ei_mls_init(enrollment.inner(), certificateChain);
+    }
+    /**
+     * Allows persisting an active enrollment (for example while redirecting the user during OAuth) in order to resume
+     * it later with {@link e2eiEnrollmentStashPop}
+     *
+     * @param enrollment the enrollment instance to persist
+     * @returns a handle to fetch the enrollment later with {@link e2eiEnrollmentStashPop}
+     */
+    async e2eiEnrollmentStash(enrollment) {
+        return await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").e2ei_enrollment_stash(enrollment.inner()));
+    }
+    /**
+     * Fetches the persisted enrollment and deletes it from the keystore
+     *
+     * @param handle returned by {@link e2eiEnrollmentStash}
+     * @returns the persisted enrollment instance
+     */
+    async e2eiEnrollmentStashPop(handle) {
+        const e2ei = await CoreCryptoError.asyncMapErr(__classPrivateFieldGet(this, _CoreCrypto_cc, "f").e2ei_enrollment_stash_pop(handle));
+        return new WireE2eIdentity(e2ei);
     }
     /**
      * Returns the current version of {@link CoreCrypto}
@@ -4339,13 +4553,12 @@ class WireE2eIdentity {
      * 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 expirySecs of the client Dpop JWT. This should be equal to the grace period set in Team Management
      * @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}
      */
-    createDpopToken(accessTokenUrl, expirySecs, backendNonce) {
+    createDpopToken(expirySecs, backendNonce) {
         try {
-            return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").create_dpop_token(accessTokenUrl, expirySecs, backendNonce);
+            return __classPrivateFieldGet(this, _WireE2eIdentity_e2ei, "f").create_dpop_token(expirySecs, backendNonce);
         }
         catch (e) {
             throw CoreCryptoError.fromStdError(e);
@@ -4415,6 +4628,7 @@ class WireE2eIdentity {
      * Parses the response from `POST /acme/{provisioner-name}/order/{order-id}`.
      *
      * @param order HTTP response body
+     * @return the finalize url to use with {@link finalizeRequest}
      * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4
      */
     checkOrderResponse(order) {
@@ -4444,6 +4658,7 @@ class WireE2eIdentity {
      * Parses the response from `POST /acme/{provisioner-name}/order/{order-id}/finalize`.
      *
      * @param finalize HTTP response body
+     * @return the certificate url to use with {@link certificateRequest}
      * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.4
      */
     finalizeResponse(finalize) {
@@ -4471,4 +4686,4 @@ class WireE2eIdentity {
 }
 _WireE2eIdentity_e2ei = new WeakMap();
-export { Ciphersuite, CoreCrypto, CoreCryptoError, ExternalProposalType, ProposalType, PublicGroupStateEncryptionType, RatchetTreeType, WireE2eIdentity, WirePolicy };
+export { Ciphersuite, CoreCrypto, CoreCryptoError, CredentialType, ExternalProposalType, ProposalType, PublicGroupStateEncryptionType, RatchetTreeType, WireE2eIdentity, WirePolicy };