@wireapp/core-crypto 0.5.2 → 0.6.0-pre.2

package/platforms/web/corecrypto.js

@@ -151,6 +151,15 @@ function getFloat64Memory0() {
     return cachedFloat64Memory0;
 }
 
+let cachedBigInt64Memory0 = new BigInt64Array();
+
+function getBigInt64Memory0() {
+    if (cachedBigInt64Memory0.byteLength === 0) {
+        cachedBigInt64Memory0 = new BigInt64Array(wasm$1.memory.buffer);
+    }
+    return cachedBigInt64Memory0;
+}
+
 function debugString(val) {
     // primitive types
     const type = typeof val;
@@ -240,10 +249,10 @@ function makeMutClosure(arg0, arg1, dtor, f) {
 
     return real;
 }
-function __wbg_adapter_40(arg0, arg1, arg2) {
+function __wbg_adapter_52(arg0, arg1, arg2) {
     try {
         const retptr = wasm$1.__wbindgen_add_to_stack_pointer(-16);
-        wasm$1._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h9a17b153655eda08(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm$1._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__he93426143887b9de(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getInt32Memory0()[retptr / 4 + 0];
         var r1 = getInt32Memory0()[retptr / 4 + 1];
         if (r1) {
@@ -254,11 +263,12 @@ function __wbg_adapter_40(arg0, arg1, arg2) {
     }
 }
 
-function __wbg_adapter_43(arg0, arg1, arg2) {
-    wasm$1._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hd0c9431a12465019(arg0, arg1, addHeapObject(arg2));
+function __wbg_adapter_55(arg0, arg1, arg2) {
+    wasm$1._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h582590a1b3576cbe(arg0, arg1, addHeapObject(arg2));
 }
 
 /**
+* Returns the current version of CoreCrypto
 * @returns {string}
 */
 function version() {
@@ -318,10 +328,18 @@ function handleError(f, args) {
 function getArrayU8FromWasm0(ptr, len) {
     return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
 }
-function __wbg_adapter_175(arg0, arg1, arg2, arg3) {
-    wasm$1.wasm_bindgen__convert__closures__invoke2_mut__h4f9148fafb82166d(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wbg_adapter_212(arg0, arg1, arg2, arg3) {
+    wasm$1.wasm_bindgen__convert__closures__invoke2_mut__hd463cd1468254416(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
+/**
+* see [core_crypto::prelude::mls::conversation::public_group_state::MlsRatchetTreeType]
+*/
+const RatchetTreeType$1 = Object.freeze({ Full:1,"1":"Full",Delta:2,"2":"Delta",ByRef:3,"3":"ByRef", });
+/**
+* see [core_crypto::prelude::mls::conversation::public_group_state::MlsPublicGroupStateEncryptionType]
+*/
+const PublicGroupStateEncryptionType$1 = Object.freeze({ Plaintext:1,"1":"Plaintext",JweEncrypted:2,"2":"JweEncrypted", });
 /**
 * see [core_crypto::prelude::CiphersuiteName]
 */
@@ -384,11 +402,11 @@ class CommitBundle {
         return takeObject(ret);
     }
     /**
-    * @returns {Uint8Array}
+    * @returns {PublicGroupStateBundle}
     */
     get public_group_state() {
         const ret = wasm$1.commitbundle_public_group_state(this.ptr);
-        return takeObject(ret);
+        return PublicGroupStateBundle.__wrap(ret);
     }
 }
 /**
@@ -431,6 +449,43 @@ class ConversationConfiguration {
 }
 /**
 */
+class ConversationInitBundle {
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm$1.__wbg_conversationinitbundle_free(ptr);
+    }
+    /**
+    * @returns {Uint8Array}
+    */
+    get conversation_id() {
+        const ret = wasm$1.conversationinitbundle_conversation_id(this.ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @returns {Uint8Array}
+    */
+    get commit() {
+        const ret = wasm$1.conversationinitbundle_commit(this.ptr);
+        return takeObject(ret);
+    }
+    /**
+    * @returns {PublicGroupStateBundle}
+    */
+    get public_group_state() {
+        const ret = wasm$1.conversationinitbundle_public_group_state(this.ptr);
+        return PublicGroupStateBundle.__wrap(ret);
+    }
+}
+/**
+*/
 class CoreCrypto$1 {
 
     static __wrap(ptr) {
@@ -651,62 +706,6 @@ class CoreCrypto$1 {
         return takeObject(ret);
     }
     /**
-    * Returns: [`WasmCryptoResult<Option<MemberAddedMessages>>`]
-    *
-    * see [core_crypto::MlsCentral::add_members_to_conversation]
-    * @param {Uint8Array} conversation_id
-    * @param {any[]} clients
-    * @returns {Promise<any>}
-    */
-    final_add_clients_to_conversation(conversation_id, clients) {
-        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayJsValueToWasm0(clients, wasm$1.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_final_add_clients_to_conversation(this.ptr, ptr0, len0, ptr1, len1);
-        return takeObject(ret);
-    }
-    /**
-    * Returns: [`WasmCryptoResult<Option<js_sys::Uint8Array>>`]
-    *
-    * see [core_crypto::MlsCentral::remove_members_from_conversation]
-    * @param {Uint8Array} conversation_id
-    * @param {(Uint8Array)[]} clients
-    * @returns {Promise<any>}
-    */
-    final_remove_clients_from_conversation(conversation_id, clients) {
-        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArrayJsValueToWasm0(clients, wasm$1.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_final_remove_clients_from_conversation(this.ptr, ptr0, len0, ptr1, len1);
-        return takeObject(ret);
-    }
-    /**
-    * Returns: [`WasmCryptoResult<CommitBundle>`]
-    *
-    * see [core_crypto::MlsCentral::update_keying_material]
-    * @param {Uint8Array} conversation_id
-    * @returns {Promise<any>}
-    */
-    final_update_keying_material(conversation_id) {
-        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_final_update_keying_material(this.ptr, ptr0, len0);
-        return takeObject(ret);
-    }
-    /**
-    * see [core_crypto::MlsCentral::commit_pending_proposals]
-    * @param {Uint8Array} conversation_id
-    * @returns {Promise<any>}
-    */
-    final_commit_pending_proposals(conversation_id) {
-        const ptr0 = passArray8ToWasm0(conversation_id, wasm$1.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm$1.corecrypto_final_commit_pending_proposals(this.ptr, ptr0, len0);
-        return takeObject(ret);
-    }
-    /**
     * Returns: [`WasmCryptoResult<()>`]
     *
     * see [core_crypto::MlsCentral::wipe_conversation]
@@ -841,14 +840,14 @@ class CoreCrypto$1 {
         return takeObject(ret);
     }
     /**
-    * Returns: [`WasmCryptoResult<MlsConversationInitMessage>`]
+    * Returns: [`WasmCryptoResult<ConversationInitBundle>`]
     *
     * see [core_crypto::MlsCentral::join_by_external_commit]
-    * @param {Uint8Array} group_state
+    * @param {Uint8Array} public_group_state
     * @returns {Promise<any>}
     */
-    join_by_external_commit(group_state) {
-        const ptr0 = passArray8ToWasm0(group_state, wasm$1.__wbindgen_malloc);
+    join_by_external_commit(public_group_state) {
+        const ptr0 = passArray8ToWasm0(public_group_state, wasm$1.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm$1.corecrypto_join_by_external_commit(this.ptr, ptr0, len0);
         return takeObject(ret);
@@ -871,6 +870,19 @@ class CoreCrypto$1 {
         return takeObject(ret);
     }
     /**
+    * Returns: [`WasmCryptoResult<()>`]
+    *
+    * see [core_crypto::MlsCentral::clear_pending_group_from_external_commit]
+    * @param {Uint8Array} conversation_id
+    * @returns {Promise<any>}
+    */
+    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);
+        return takeObject(ret);
+    }
+    /**
     * see [core_crypto::MlsCentral::commit_accepted]
     * @param {Uint8Array} conversation_id
     * @returns {Promise<any>}
@@ -930,6 +942,183 @@ class CoreCrypto$1 {
         const ret = wasm$1.corecrypto_reseed_rng(this.ptr, ptr0, len0);
         return takeObject(ret);
     }
+    /**
+    * Returns: [`WasmCryptoResult<()>`]
+    *
+    * see [core_crypto::proteus::ProteusCentral::try_new]
+    * @returns {Promise<any>}
+    */
+    proteus_init() {
+        const ret = wasm$1.corecrypto_proteus_init(this.ptr);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<()>`]
+    *
+    * see [core_crypto::proteus::ProteusCentral::session_from_prekey]
+    * @param {string} session_id
+    * @param {Uint8Array} prekey
+    * @returns {Promise<any>}
+    */
+    proteus_session_from_prekey(session_id, prekey) {
+        const ptr0 = passStringToWasm0(session_id, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        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);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<()>`]
+    *
+    * see [core_crypto::proteus::ProteusCentral::session_from_message]
+    * @param {string} session_id
+    * @param {Uint8Array} envelope
+    * @returns {Promise<any>}
+    */
+    proteus_session_from_message(session_id, envelope) {
+        const ptr0 = passStringToWasm0(session_id, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        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);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<()>`]
+    *
+    * see [core_crypto::proteus::ProteusCentral::session_save]
+    * @param {string} session_id
+    * @returns {Promise<any>}
+    */
+    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);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<()>`]
+    *
+    * see [core_crypto::proteus::ProteusCentral::session_delete]
+    * @param {string} session_id
+    * @returns {Promise<any>}
+    */
+    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);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<js_sys::Uint8Array>`]
+    *
+    * see [core_crypto::proteus::ProteusCentral::decrypt]
+    * @param {string} session_id
+    * @param {Uint8Array} ciphertext
+    * @returns {Promise<any>}
+    */
+    proteus_decrypt(session_id, ciphertext) {
+        const ptr0 = passStringToWasm0(session_id, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        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);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<js_sys::Uint8Array>`]
+    *
+    * see [core_crypto::proteus::ProteusCentral::encrypt]
+    * @param {string} session_id
+    * @param {Uint8Array} plaintext
+    * @returns {Promise<Uint8Array>}
+    */
+    proteus_encrypt(session_id, plaintext) {
+        const ptr0 = passStringToWasm0(session_id, wasm$1.__wbindgen_malloc, wasm$1.__wbindgen_realloc);
+        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);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<js_sys::Map<string, Uint8Array>>`]
+    *
+    * see [core_crypto::proteus::ProteusCentral::encrypt_batched]
+    * @param {(string)[]} sessions
+    * @param {Uint8Array} plaintext
+    * @returns {Promise<Map<any, any>>}
+    */
+    proteus_encrypt_batched(sessions, plaintext) {
+        const ptr0 = passArrayJsValueToWasm0(sessions, wasm$1.__wbindgen_malloc);
+        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);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<Uint8Array>`]
+    *
+    * see [core_crypto::proteus::ProteusCentral::new_prekey]
+    * @param {number} prekey_id
+    * @returns {Promise<Uint8Array>}
+    */
+    proteus_new_prekey(prekey_id) {
+        const ret = wasm$1.corecrypto_proteus_new_prekey(this.ptr, prekey_id);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<String>`]
+    *
+    * see [core_crypto::proteus::ProteusCentral::fingerprint]
+    * @returns {Promise<string>}
+    */
+    proteus_fingerprint() {
+        const ret = wasm$1.corecrypto_proteus_fingerprint(this.ptr);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<()>`]
+    *
+    * see [core_crypto::proteus::ProteusCentral::cryptobox_migrate]
+    * @param {string} path
+    * @returns {Promise<any>}
+    */
+    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);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<Vec<u8>>`]
+    *
+    * see [core_crypto::MlsCentral::export_secret_key]
+    * @param {Uint8Array} conversation_id
+    * @param {number} key_length
+    * @returns {Promise<any>}
+    */
+    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);
+        return takeObject(ret);
+    }
+    /**
+    * Returns: [`WasmCryptoResult<Box<[js_sys::Uint8Array]>`]
+    *
+    * see [core_crypto::MlsCentral::get_client_ids]
+    * @param {Uint8Array} conversation_id
+    * @returns {Promise<any>}
+    */
+    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);
+        return takeObject(ret);
+    }
 }
 /**
 * see [core_crypto::prelude::CoreCryptoCallbacks]
@@ -956,10 +1145,11 @@ class CoreCryptoWasmCallbacks {
     }
     /**
     * @param {Function} authorize
-    * @param {Function} client_id_belongs_to_one_of
+    * @param {Function} user_authorize
+    * @param {Function} client_is_existing_group_user
     */
-    constructor(authorize, client_id_belongs_to_one_of) {
-        const ret = wasm$1.corecryptowasmcallbacks_new(addHeapObject(authorize), addHeapObject(client_id_belongs_to_one_of));
+    constructor(authorize, user_authorize, client_is_existing_group_user) {
+        const ret = wasm$1.corecryptowasmcallbacks_new(addHeapObject(authorize), addHeapObject(user_authorize), addHeapObject(client_is_existing_group_user));
         return CoreCryptoWasmCallbacks.__wrap(ret);
     }
 }
@@ -1021,6 +1211,13 @@ class DecryptedMessage {
         const ret = wasm$1.decryptedmessage_sender_client_id(this.ptr);
         return takeObject(ret);
     }
+    /**
+    * @returns {boolean}
+    */
+    get has_epoch_changed() {
+        const ret = wasm$1.decryptedmessage_has_epoch_changed(this.ptr);
+        return ret !== 0;
+    }
 }
 /**
 * see [core_crypto::prelude::ConversationMember]
@@ -1094,10 +1291,13 @@ class MemberAddedMessages {
     /**
     * @param {Uint8Array} welcome
     * @param {Uint8Array} commit
-    * @param {Uint8Array} public_group_state
+    * @param {PublicGroupStateBundle} public_group_state
     */
     constructor(welcome, commit, public_group_state) {
-        const ret = wasm$1.memberaddedmessages_new(addHeapObject(welcome), addHeapObject(commit), addHeapObject(public_group_state));
+        _assertClass(public_group_state, PublicGroupStateBundle);
+        var ptr0 = public_group_state.ptr;
+        public_group_state.ptr = 0;
+        const ret = wasm$1.memberaddedmessages_new(addHeapObject(welcome), addHeapObject(commit), ptr0);
         return MemberAddedMessages.__wrap(ret);
     }
     /**
@@ -1115,16 +1315,23 @@ class MemberAddedMessages {
         return takeObject(ret);
     }
     /**
-    * @returns {Uint8Array}
+    * @returns {PublicGroupStateBundle}
     */
     get public_group_state() {
         const ret = wasm$1.memberaddedmessages_public_group_state(this.ptr);
-        return takeObject(ret);
+        return PublicGroupStateBundle.__wrap(ret);
     }
 }
 /**
 */
-class MlsConversationInitMessage {
+class ProposalBundle {
+
+    static __wrap(ptr) {
+        const obj = Object.create(ProposalBundle.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
 
     __destroy_into_raw() {
         const ptr = this.ptr;
@@ -1135,29 +1342,29 @@ class MlsConversationInitMessage {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm$1.__wbg_mlsconversationinitmessage_free(ptr);
+        wasm$1.__wbg_proposalbundle_free(ptr);
     }
     /**
     * @returns {Uint8Array}
     */
-    get commit() {
-        const ret = wasm$1.mlsconversationinitmessage_commit(this.ptr);
+    get proposal() {
+        const ret = wasm$1.proposalbundle_proposal(this.ptr);
         return takeObject(ret);
     }
     /**
     * @returns {Uint8Array}
     */
-    get group() {
-        const ret = wasm$1.mlsconversationinitmessage_group(this.ptr);
+    get proposal_ref() {
+        const ret = wasm$1.proposalbundle_proposal_ref(this.ptr);
         return takeObject(ret);
     }
 }
 /**
 */
-class ProposalBundle {
+class PublicGroupStateBundle {
 
     static __wrap(ptr) {
-        const obj = Object.create(ProposalBundle.prototype);
+        const obj = Object.create(PublicGroupStateBundle.prototype);
         obj.ptr = ptr;
 
         return obj;
@@ -1172,20 +1379,27 @@ class ProposalBundle {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm$1.__wbg_proposalbundle_free(ptr);
+        wasm$1.__wbg_publicgroupstatebundle_free(ptr);
     }
     /**
-    * @returns {Uint8Array}
+    * @returns {number}
     */
-    get proposal() {
-        const ret = wasm$1.proposalbundle_proposal(this.ptr);
-        return takeObject(ret);
+    get encryption_type() {
+        const ret = wasm$1.publicgroupstatebundle_encryption_type(this.ptr);
+        return ret >>> 0;
+    }
+    /**
+    * @returns {number}
+    */
+    get ratchet_tree_type() {
+        const ret = wasm$1.publicgroupstatebundle_ratchet_tree_type(this.ptr);
+        return ret >>> 0;
     }
     /**
     * @returns {Uint8Array}
     */
-    get proposal_ref() {
-        const ret = wasm$1.proposalbundle_proposal_ref(this.ptr);
+    get payload() {
+        const ret = wasm$1.publicgroupstatebundle_payload(this.ptr);
         return takeObject(ret);
     }
 }
@@ -1236,83 +1450,68 @@ function getImports() {
         const ret = typeof(val) === 'object' && val !== null;
         return ret;
     };
-    imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
-        const ret = new Error(getStringFromWasm0(arg0, arg1));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_new0_a57059d72c5b7aee = function() {
-        const ret = new Date();
+    imports.wbg.__wbg_getwithrefkey_15c62c2b8546208d = function(arg0, arg1) {
+        const ret = getObject(arg0)[getObject(arg1)];
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_getTime_cb82adb2556ed13e = function(arg0) {
-        const ret = getObject(arg0).getTime();
+    imports.wbg.__wbindgen_is_undefined = function(arg0) {
+        const ret = getObject(arg0) === undefined;
         return ret;
     };
-    imports.wbg.__wbg_set_c943d600fa71e4dd = function(arg0, arg1, arg2) {
-        getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+    imports.wbg.__wbindgen_in = function(arg0, arg1) {
+        const ret = getObject(arg0) in getObject(arg1);
+        return ret;
     };
-    imports.wbg.__wbg_new_8c3f0052272a457a = function(arg0) {
-        const ret = new Uint8Array(getObject(arg0));
+    imports.wbg.__wbindgen_number_new = function(arg0) {
+        const ret = arg0;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_new_0b9bfdd97583284e = function() {
-        const ret = new Object();
+    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+        const ret = getStringFromWasm0(arg0, arg1);
         return addHeapObject(ret);
     };
     imports.wbg.__wbg_new_1d9a920c6bfc44a8 = function() {
         const ret = new Array();
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_push_740e4b286702d964 = function(arg0, arg1) {
-        const ret = getObject(arg0).push(getObject(arg1));
-        return ret;
-    };
     imports.wbg.__wbg_set_a68214f35c417fa9 = function(arg0, arg1, arg2) {
         getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
     };
-    imports.wbg.__wbindgen_number_new = function(arg0) {
-        const ret = arg0;
+    imports.wbg.__wbg_new_268f7b7dd3430798 = function() {
+        const ret = new Map();
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
-        const ret = BigInt.asUintN(64, arg0);
+    imports.wbg.__wbg_new_0b9bfdd97583284e = function() {
+        const ret = new Object();
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_corecrypto_new = function(arg0) {
-        const ret = CoreCrypto$1.__wrap(arg0);
+    imports.wbg.__wbg_set_933729cf5b66ac11 = function(arg0, arg1, arg2) {
+        const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_boolean_get = function(arg0) {
-        const v = getObject(arg0);
-        const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
+    imports.wbg.__wbindgen_is_string = function(arg0) {
+        const ret = typeof(getObject(arg0)) === 'string';
         return ret;
     };
-    imports.wbg.__wbg_new_9962f939219f1820 = 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_175(a, state0.b, arg0, arg1);
-                } finally {
-                    state0.a = a;
-                }
-            };
-            const ret = new Promise(cb0);
-            return addHeapObject(ret);
-        } finally {
-            state0.a = state0.b = 0;
-        }
+    imports.wbg.__wbg_set_20cbc34131e76824 = function(arg0, arg1, arg2) {
+        getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
     };
-    imports.wbg.__wbg_proposalbundle_new = function(arg0) {
-        const ret = ProposalBundle.__wrap(arg0);
+    imports.wbg.__wbindgen_bigint_from_i64 = function(arg0) {
+        const ret = arg0;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_get_2268d91a19a98b92 = function(arg0, arg1) {
-        const ret = getObject(arg0)[takeObject(arg1)];
+    imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
+        const ret = BigInt.asUintN(64, arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_objectStoreNames_8c06c40d2b05141c = function(arg0) {
+        const ret = getObject(arg0).objectStoreNames;
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_length_b59f358f797fd9f4 = function(arg0) {
+        const ret = getObject(arg0).length;
+        return ret;
+    };
     imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
         const obj = getObject(arg1);
         const ret = typeof(obj) === 'string' ? obj : undefined;
@@ -1321,45 +1520,34 @@ function getImports() {
         getInt32Memory0()[arg0 / 4 + 1] = len0;
         getInt32Memory0()[arg0 / 4 + 0] = ptr0;
     };
-    imports.wbg.__wbg_isArray_27c46c67f498e15d = function(arg0) {
-        const ret = Array.isArray(getObject(arg0));
-        return ret;
-    };
     imports.wbg.__wbg_length_6e3bbe7c8bd4dbd8 = function(arg0) {
         const ret = getObject(arg0).length;
         return ret;
     };
-    imports.wbg.__wbg_iterator_6f9d4f28845f426c = function() {
-        const ret = Symbol.iterator;
+    imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
+        const ret = new Error(getStringFromWasm0(arg0, arg1));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_get_765201544a2b6869 = function() { return handleError(function (arg0, arg1) {
-        const ret = Reflect.get(getObject(arg0), getObject(arg1));
+    imports.wbg.__wbg_new0_a57059d72c5b7aee = function() {
+        const ret = new Date();
         return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbindgen_is_function = function(arg0) {
-        const ret = typeof(getObject(arg0)) === 'function';
+    };
+    imports.wbg.__wbg_getTime_cb82adb2556ed13e = function(arg0) {
+        const ret = getObject(arg0).getTime();
         return ret;
     };
-    imports.wbg.__wbg_call_97ae9d8645dc388b = function() { return handleError(function (arg0, arg1) {
-        const ret = getObject(arg0).call(getObject(arg1));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_next_579e583d33566a86 = function(arg0) {
-        const ret = getObject(arg0).next;
-        return addHeapObject(ret);
+    imports.wbg.__wbindgen_jsval_loose_eq = function(arg0, arg1) {
+        const ret = getObject(arg0) == getObject(arg1);
+        return ret;
     };
-    imports.wbg.__wbg_next_aaef7c8aa5e212ac = function() { return handleError(function (arg0) {
-        const ret = getObject(arg0).next();
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_done_1b73b0672e15f234 = function(arg0) {
-        const ret = getObject(arg0).done;
+    imports.wbg.__wbindgen_boolean_get = function(arg0) {
+        const v = getObject(arg0);
+        const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
         return ret;
     };
-    imports.wbg.__wbg_value_1ccc36bc03462d71 = function(arg0) {
-        const ret = getObject(arg0).value;
-        return addHeapObject(ret);
+    imports.wbg.__wbindgen_is_bigint = function(arg0) {
+        const ret = typeof(getObject(arg0)) === 'bigint';
+        return ret;
     };
     imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
         const obj = getObject(arg1);
@@ -1371,16 +1559,99 @@ function getImports() {
         const ret = Number.isSafeInteger(getObject(arg0));
         return ret;
     };
+    imports.wbg.__wbindgen_bigint_get_as_i64 = function(arg0, arg1) {
+        const v = getObject(arg1);
+        const ret = typeof(v) === 'bigint' ? v : undefined;
+        getBigInt64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0n : ret;
+        getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
+    };
+    imports.wbg.__wbindgen_jsval_eq = function(arg0, arg1) {
+        const ret = getObject(arg0) === getObject(arg1);
+        return ret;
+    };
+    imports.wbg.__wbg_isArray_27c46c67f498e15d = function(arg0) {
+        const ret = Array.isArray(getObject(arg0));
+        return ret;
+    };
+    imports.wbg.__wbg_iterator_6f9d4f28845f426c = function() {
+        const ret = Symbol.iterator;
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_get_57245cc7d7c7619d = function(arg0, arg1) {
         const ret = getObject(arg0)[arg1 >>> 0];
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_is_null = function(arg0) {
-        const ret = getObject(arg0) === null;
+    imports.wbg.__wbg_new_8c3f0052272a457a = function(arg0) {
+        const ret = new Uint8Array(getObject(arg0));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_push_740e4b286702d964 = function(arg0, arg1) {
+        const ret = getObject(arg0).push(getObject(arg1));
         return ret;
     };
-    imports.wbg.__wbindgen_is_undefined = function(arg0) {
-        const ret = getObject(arg0) === undefined;
+    imports.wbg.__wbg_corecrypto_new = function(arg0) {
+        const ret = CoreCrypto$1.__wrap(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_call_e1f72c051cdab859 = 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_new_9962f939219f1820 = 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_212(a, state0.b, arg0, arg1);
+                } finally {
+                    state0.a = a;
+                }
+            };
+            const ret = new Promise(cb0);
+            return addHeapObject(ret);
+        } finally {
+            state0.a = state0.b = 0;
+        }
+    };
+    imports.wbg.__wbg_reject_72477563edad55b7 = function(arg0) {
+        const ret = Promise.reject(getObject(arg0));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_proposalbundle_new = function(arg0) {
+        const ret = ProposalBundle.__wrap(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_new_abda76e883ba8a5f = function() {
+        const ret = new Error();
+        return addHeapObject(ret);
+    };
+    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;
+    };
+    imports.wbg.__wbg_error_f851667af71bcfc6 = function(arg0, arg1) {
+        try {
+            console.error(getStringFromWasm0(arg0, arg1));
+        } finally {
+            wasm$1.__wbindgen_free(arg0, arg1);
+        }
+    };
+    imports.wbg.__wbg_commit_73ecc83e291e455b = function() { return handleError(function (arg0) {
+        getObject(arg0).commit();
+    }, arguments) };
+    imports.wbg.__wbg_setoncomplete_3e57a8cec8327f66 = function(arg0, arg1) {
+        getObject(arg0).oncomplete = getObject(arg1);
+    };
+    imports.wbg.__wbg_setonerror_00051c0213f27b2c = function(arg0, arg1) {
+        getObject(arg0).onerror = getObject(arg1);
+    };
+    imports.wbg.__wbindgen_is_null = function(arg0) {
+        const ret = getObject(arg0) === null;
         return ret;
     };
     imports.wbg.__wbg_name_ebb75bfad2bf6938 = function(arg0, arg1) {
@@ -1390,10 +1661,6 @@ function getImports() {
         getInt32Memory0()[arg0 / 4 + 1] = len0;
         getInt32Memory0()[arg0 / 4 + 0] = ptr0;
     };
-    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
-        const ret = getStringFromWasm0(arg0, arg1);
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbg_transaction_83b53b72aa710599 = function() { return handleError(function (arg0, arg1, arg2) {
         const ret = getObject(arg0).transaction(getObject(arg1), takeObject(arg2));
         return addHeapObject(ret);
@@ -1407,17 +1674,8 @@ function getImports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbg_commit_73ecc83e291e455b = function() { return handleError(function (arg0) {
-        getObject(arg0).commit();
-    }, arguments) };
-    imports.wbg.__wbg_setoncomplete_3e57a8cec8327f66 = function(arg0, arg1) {
-        getObject(arg0).oncomplete = getObject(arg1);
-    };
-    imports.wbg.__wbg_setonerror_00051c0213f27b2c = function(arg0, arg1) {
-        getObject(arg0).onerror = getObject(arg1);
-    };
-    imports.wbg.__wbg_get_6285bf458a1ee758 = function() { return handleError(function (arg0, arg1) {
-        const ret = getObject(arg0).get(getObject(arg1));
+    imports.wbg.__wbg_delete_8abedd1043b4105d = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).delete(getObject(arg1));
         return addHeapObject(ret);
     }, arguments) };
     imports.wbg.__wbg_setonsuccess_5f71593bc51653a3 = function(arg0, arg1) {
@@ -1442,16 +1700,12 @@ function getImports() {
         const ret = getObject(arg0).put(getObject(arg1));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_delete_8abedd1043b4105d = function() { return handleError(function (arg0, arg1) {
-        const ret = getObject(arg0).delete(getObject(arg1));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_count_b0e88953a0ea909c = function() { return handleError(function (arg0) {
-        const ret = getObject(arg0).count();
+    imports.wbg.__wbg_get_6285bf458a1ee758 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).get(getObject(arg1));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_count_46eda68a16dbe30e = function() { return handleError(function (arg0, arg1) {
-        const ret = getObject(arg0).count(getObject(arg1));
+    imports.wbg.__wbg_get_765201544a2b6869 = function() { return handleError(function (arg0, arg1) {
+        const ret = Reflect.get(getObject(arg0), getObject(arg1));
         return addHeapObject(ret);
     }, arguments) };
     imports.wbg.__wbg_get_3c3e41997e95952c = function() { return handleError(function (arg0, arg1) {
@@ -1466,13 +1720,6 @@ function getImports() {
         const ret = getObject(arg0).openCursor(getObject(arg1));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_close_5a04b9ce11dade22 = function(arg0) {
-        getObject(arg0).close();
-    };
-    imports.wbg.__wbg_deleteDatabase_f6454de6a88aebde = function() { return handleError(function (arg0, arg1, arg2) {
-        const ret = getObject(arg0).deleteDatabase(getStringFromWasm0(arg1, arg2));
-        return addHeapObject(ret);
-    }, arguments) };
     imports.wbg.__wbg_open_a31c3fe1fdc244eb = function() { return handleError(function (arg0, arg1, arg2) {
         const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2));
         return addHeapObject(ret);
@@ -1484,49 +1731,64 @@ function getImports() {
     imports.wbg.__wbg_setonupgradeneeded_17d0b9530f1e0cac = function(arg0, arg1) {
         getObject(arg0).onupgradeneeded = getObject(arg1);
     };
-    imports.wbg.__wbg_randomFillSync_065afffde01daa66 = function() { return handleError(function (arg0, arg1, arg2) {
+    imports.wbg.__wbg_count_b0e88953a0ea909c = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).count();
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_count_46eda68a16dbe30e = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).count(getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_deleteDatabase_f6454de6a88aebde = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).deleteDatabase(getStringFromWasm0(arg1, arg2));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_close_5a04b9ce11dade22 = function(arg0) {
+        getObject(arg0).close();
+    };
+    imports.wbg.__wbg_randomFillSync_6894564c2c334c42 = function() { return handleError(function (arg0, arg1, arg2) {
         getObject(arg0).randomFillSync(getArrayU8FromWasm0(arg1, arg2));
     }, arguments) };
     imports.wbg.__wbg_subarray_58ad4efbb5bcb886 = function(arg0, arg1, arg2) {
         const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_getRandomValues_b99eec4244a475bb = function() { return handleError(function (arg0, arg1) {
+    imports.wbg.__wbg_getRandomValues_805f1c3d65988a5a = function() { return handleError(function (arg0, arg1) {
         getObject(arg0).getRandomValues(getObject(arg1));
     }, arguments) };
     imports.wbg.__wbg_length_9e1ae1900cb0fbd5 = function(arg0) {
         const ret = getObject(arg0).length;
         return ret;
     };
-    imports.wbg.__wbg_process_0cc2ada8524d6f83 = function(arg0) {
+    imports.wbg.__wbg_crypto_e1d53a1d73fb10b8 = function(arg0) {
+        const ret = getObject(arg0).crypto;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_process_038c26bf42b093f8 = function(arg0) {
         const ret = getObject(arg0).process;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_versions_c11acceab27a6c87 = function(arg0) {
+    imports.wbg.__wbg_versions_ab37218d2f0b24a8 = function(arg0) {
         const ret = getObject(arg0).versions;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_node_7ff1ce49caf23815 = function(arg0) {
+    imports.wbg.__wbg_node_080f4b19d15bc1fe = function(arg0) {
         const ret = getObject(arg0).node;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_is_string = function(arg0) {
-        const ret = typeof(getObject(arg0)) === 'string';
-        return ret;
-    };
-    imports.wbg.__wbg_static_accessor_NODE_MODULE_cf6401cc1091279e = function() {
-        const ret = module;
+    imports.wbg.__wbg_require_78a3dcfbdba9cbce = function() { return handleError(function () {
+        const ret = module.require;
         return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbindgen_is_function = function(arg0) {
+        const ret = typeof(getObject(arg0)) === 'function';
+        return ret;
     };
-    imports.wbg.__wbg_require_a746e79b322b9336 = function() { return handleError(function (arg0, arg1, arg2) {
-        const ret = getObject(arg0).require(getStringFromWasm0(arg1, arg2));
+    imports.wbg.__wbg_call_168da88779e35f61 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_crypto_2036bed7c44c25e7 = function(arg0) {
-        const ret = getObject(arg0).crypto;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_msCrypto_a21fc88caf1ecdc8 = function(arg0) {
+    imports.wbg.__wbg_msCrypto_6e7d3e1f92610cbb = function(arg0) {
         const ret = getObject(arg0).msCrypto;
         return addHeapObject(ret);
     };
@@ -1534,6 +1796,26 @@ function getImports() {
         const ret = new Uint8Array(arg0 >>> 0);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_next_aaef7c8aa5e212ac = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).next();
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_done_1b73b0672e15f234 = function(arg0) {
+        const ret = getObject(arg0).done;
+        return ret;
+    };
+    imports.wbg.__wbg_value_1ccc36bc03462d71 = function(arg0) {
+        const ret = getObject(arg0).value;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_call_97ae9d8645dc388b = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).call(getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_next_579e583d33566a86 = function(arg0) {
+        const ret = getObject(arg0).next;
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_self_6d479506f72c6a71 = function() { return handleError(function () {
         const ret = self.self;
         return addHeapObject(ret);
@@ -1554,10 +1836,6 @@ function getImports() {
         const ret = new Function(getStringFromWasm0(arg0, arg1));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_call_168da88779e35f61 = function() { return handleError(function (arg0, arg1, arg2) {
-        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
-        return addHeapObject(ret);
-    }, arguments) };
     imports.wbg.__wbg_call_3999bee59e9f7719 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
         const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
         return addHeapObject(ret);
@@ -1589,10 +1867,10 @@ function getImports() {
         const ret = getObject(arg0).target;
         return isLikeNone(ret) ? 0 : addHeapObject(ret);
     };
-    imports.wbg.__wbg_objectStoreNames_8c06c40d2b05141c = function(arg0) {
-        const ret = getObject(arg0).objectStoreNames;
-        return addHeapObject(ret);
-    };
+    imports.wbg.__wbg_error_aacf5ac191e54ed0 = function() { return handleError(function (arg0) {
+        const ret = getObject(arg0).error;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    }, arguments) };
     imports.wbg.__wbg_contains_6cf516181cd86571 = function(arg0, arg1, arg2) {
         const ret = getObject(arg0).contains(getStringFromWasm0(arg1, arg2));
         return ret;
@@ -1613,20 +1891,12 @@ function getImports() {
         const ret = getObject(arg0).createIndex(getStringFromWasm0(arg1, arg2), getObject(arg3), getObject(arg4));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_length_b59f358f797fd9f4 = function(arg0) {
-        const ret = getObject(arg0).length;
-        return ret;
-    };
     imports.wbg.__wbg_deleteIndex_2f8e18b00c1554e1 = function() { return handleError(function (arg0, arg1, arg2) {
         getObject(arg0).deleteIndex(getStringFromWasm0(arg1, arg2));
     }, arguments) };
     imports.wbg.__wbg_deleteObjectStore_1b698c5fd1bc077d = function() { return handleError(function (arg0, arg1, arg2) {
         getObject(arg0).deleteObjectStore(getStringFromWasm0(arg1, arg2));
     }, arguments) };
-    imports.wbg.__wbg_error_aacf5ac191e54ed0 = function() { return handleError(function (arg0) {
-        const ret = getObject(arg0).error;
-        return isLikeNone(ret) ? 0 : addHeapObject(ret);
-    }, arguments) };
     imports.wbg.__wbindgen_is_falsy = function(arg0) {
         const ret = !getObject(arg0);
         return ret;
@@ -1656,10 +1926,6 @@ function getImports() {
         const ret = getObject(arg0).toString();
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_new_8d2af00bc1e329ee = function(arg0, arg1) {
-        const ret = new Error(getStringFromWasm0(arg0, arg1));
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbg_instanceof_Uint8Array_971eeda69eb75003 = function(arg0) {
         let result;
         try {
@@ -1680,7 +1946,11 @@ function getImports() {
         const ret = result;
         return ret;
     };
-    imports.wbg.__wbg_String_c9c0f9be374874ba = function(arg0, arg1) {
+    imports.wbg.__wbg_entries_65a76a413fc91037 = function(arg0) {
+        const ret = Object.entries(getObject(arg0));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_String_91fba7ded13ba54c = 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;
@@ -1735,12 +2005,12 @@ function getImports() {
         const ret = getObject(arg0).objectStore(getStringFromWasm0(arg1, arg2));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbindgen_closure_wrapper2456 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 106, __wbg_adapter_40);
+    imports.wbg.__wbindgen_closure_wrapper2895 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 130, __wbg_adapter_52);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper4423 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 114, __wbg_adapter_43);
+    imports.wbg.__wbindgen_closure_wrapper4971 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 137, __wbg_adapter_55);
         return addHeapObject(ret);
     };
 
@@ -1750,6 +2020,7 @@ function getImports() {
 function finalizeInit(instance, module) {
     wasm$1 = instance.exports;
     init.__wbindgen_wasm_module = module;
+    cachedBigInt64Memory0 = new BigInt64Array();
     cachedFloat64Memory0 = new Float64Array();
     cachedInt32Memory0 = new Int32Array();
     cachedUint32Memory0 = new Uint32Array();
@@ -1789,16 +2060,19 @@ async function init(input) {
 var exports = /*#__PURE__*/Object.freeze({
     __proto__: null,
     version: version,
+    RatchetTreeType: RatchetTreeType$1,
+    PublicGroupStateEncryptionType: PublicGroupStateEncryptionType$1,
     Ciphersuite: Ciphersuite$1,
     CommitBundle: CommitBundle,
     ConversationConfiguration: ConversationConfiguration,
+    ConversationInitBundle: ConversationInitBundle,
     CoreCrypto: CoreCrypto$1,
     CoreCryptoWasmCallbacks: CoreCryptoWasmCallbacks,
     DecryptedMessage: DecryptedMessage,
     Invitee: Invitee,
     MemberAddedMessages: MemberAddedMessages,
-    MlsConversationInitMessage: MlsConversationInitMessage,
     ProposalBundle: ProposalBundle,
+    PublicGroupStateBundle: PublicGroupStateBundle,
     initSync: initSync,
     'default': init
 });
@@ -1806,7 +2080,7 @@ var exports = /*#__PURE__*/Object.freeze({
 var wasm = async (opt = {}) => {
                 let {importHook, serverPath} = opt;
 
-                let path = "assets/core_crypto_ffi-a1279c23.wasm";
+                let path = "assets/core_crypto_ffi-90af066e.wasm";
 
                 if (serverPath != null) {
                     path = serverPath + /[^\/\\]*$/.exec(path)[0];
@@ -1857,6 +2131,40 @@ var Ciphersuite;
     */
     Ciphersuite[Ciphersuite["MLS_256_DHKEMP384_AES256GCM_SHA384_P384"] = 7] = "MLS_256_DHKEMP384_AES256GCM_SHA384_P384";
 })(Ciphersuite || (Ciphersuite = {}));
+/**
+ * Informs whether the PublicGroupState is confidential
+ * see [core_crypto::mls::conversation::public_group_state::PublicGroupStateEncryptionType]
+ */
+var PublicGroupStateEncryptionType;
+(function (PublicGroupStateEncryptionType) {
+    /**
+     * Unencrypted
+     */
+    PublicGroupStateEncryptionType[PublicGroupStateEncryptionType["Plaintext"] = 1] = "Plaintext";
+    /**
+     * Encrypted in a JWE (not yet implemented)
+     */
+    PublicGroupStateEncryptionType[PublicGroupStateEncryptionType["JweEncrypted"] = 2] = "JweEncrypted";
+})(PublicGroupStateEncryptionType || (PublicGroupStateEncryptionType = {}));
+/**
+ * Represents different ways of carrying the Ratchet Tree with some optimizations to save some space
+ * see [core_crypto::mls::conversation::public_group_state::RatchetTreeType]
+ */
+var RatchetTreeType;
+(function (RatchetTreeType) {
+    /**
+     * Complete PublicGroupState
+     */
+    RatchetTreeType[RatchetTreeType["Full"] = 1] = "Full";
+    /**
+     * Contains the difference since previous epoch (not yet implemented)
+     */
+    RatchetTreeType[RatchetTreeType["Delta"] = 2] = "Delta";
+    /**
+     * To define (not yet implemented)
+     */
+    RatchetTreeType[RatchetTreeType["ByRef"] = 3] = "ByRef";
+})(RatchetTreeType || (RatchetTreeType = {}));
 /**
  * MLS Proposal type
  */
@@ -1963,7 +2271,7 @@ class CoreCrypto {
      * @param callbacks - Any interface following the {@link CoreCryptoCallbacks} interface
      */
     registerCallbacks(callbacks) {
-        const wasmCallbacks = new (__classPrivateFieldGet(CoreCrypto, _a, "f", _CoreCrypto_module).CoreCryptoWasmCallbacks)(callbacks.authorize, callbacks.clientIdBelongsToOneOf);
+        const wasmCallbacks = new (__classPrivateFieldGet(CoreCrypto, _a, "f", _CoreCrypto_module).CoreCryptoWasmCallbacks)(callbacks.authorize, callbacks.userAuthorize, callbacks.clientIsExistingGroupUser);
         __classPrivateFieldGet(this, _CoreCrypto_cc, "f").set_callbacks(wasmCallbacks);
     }
     /**
@@ -2043,6 +2351,7 @@ class CoreCrypto {
             isActive: ffiDecryptedMessage.is_active,
             senderClientId: ffiDecryptedMessage.sender_client_id,
             commitDelay,
+            hasEpochChanged: ffiDecryptedMessage.has_epoch_changed,
         };
         return ret;
     }
@@ -2106,7 +2415,11 @@ class CoreCrypto {
         const ret = {
             welcome: ffiRet.welcome,
             commit: ffiRet.commit,
-            publicGroupState: ffiRet.public_group_state,
+            publicGroupState: {
+                encryptionType: ffiRet.public_group_state.encryption_type,
+                ratchetTreeType: ffiRet.public_group_state.ratchet_tree_type,
+                payload: ffiRet.public_group_state.payload
+            },
         };
         return ret;
     }
@@ -2128,7 +2441,11 @@ class CoreCrypto {
         const ret = {
             welcome: ffiRet.welcome,
             commit: ffiRet.commit,
-            publicGroupState: ffiRet.public_group_state,
+            publicGroupState: {
+                encryptionType: ffiRet.public_group_state.encryption_type,
+                ratchetTreeType: ffiRet.public_group_state.ratchet_tree_type,
+                payload: ffiRet.public_group_state.payload
+            },
         };
         return ret;
     }
@@ -2148,7 +2465,11 @@ class CoreCrypto {
         const ret = {
             welcome: ffiRet.welcome,
             commit: ffiRet.commit,
-            publicGroupState: ffiRet.public_group_state,
+            publicGroupState: {
+                encryptionType: ffiRet.public_group_state.encryption_type,
+                ratchetTreeType: ffiRet.public_group_state.ratchet_tree_type,
+                payload: ffiRet.public_group_state.payload
+            },
         };
         return ret;
     }
@@ -2168,86 +2489,13 @@ class CoreCrypto {
         return ffiCommitBundle ? {
             welcome: ffiCommitBundle.welcome,
             commit: ffiCommitBundle.commit,
-            publicGroupState: ffiCommitBundle.public_group_state,
+            publicGroupState: {
+                encryptionType: ffiCommitBundle.public_group_state.encryption_type,
+                ratchetTreeType: ffiCommitBundle.public_group_state.ratchet_tree_type,
+                payload: ffiCommitBundle.public_group_state.payload
+            },
         } : undefined;
     }
-    /**
-     * Adds new clients to a conversation, assuming the current client has the right to add new clients to the conversation.
-     * The returned {@link CommitBundle} is a TLS struct that needs to be fanned out to Delivery Service in order to validate the commit.
-     * It also contains a Welcome message the Delivery Service will forward to invited clients and
-     * an updated PublicGroupState required by clients willing to join the group by an external commit.
-     *
-     * **CAUTION**: {@link CoreCrypto.commitAccepted} **HAS TO** be called afterwards **ONLY IF** the Delivery Service responds
-     * '200 OK' to the {@link CommitBundle} upload. It will "merge" the commit locally i.e. increment the local group
-     * epoch, use new encryption secrets etc...
-     *
-     * @param conversationId - The ID of the conversation
-     * @param clients - Array of {@link Invitee} (which are Client ID / KeyPackage pairs)
-     *
-     * @returns A {@link CommitBundle} byte array to fan out to the Delivery Service
-     */
-    async finalAddClientsToConversation(conversationId, clients) {
-        const ffiClients = clients.map((invitee) => new (__classPrivateFieldGet(CoreCrypto, _a, "f", _CoreCrypto_module).Invitee)(invitee.id, invitee.kp));
-        const ret = await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").add_clients_to_conversation(conversationId, ffiClients);
-        ffiClients.forEach(c => c.free());
-        return ret;
-    }
-    /**
-     * Removes the provided clients from a conversation; Assuming those clients exist and the current client is allowed
-     * to do so, otherwise this operation does nothing.
-     *
-     * The returned {@link CommitBundle} is a TLS struct that needs to be fanned out to Delivery Service in order to validate the commit.
-     * It also contains a Welcome message the Delivery Service will forward to invited clients and
-     * an updated PublicGroupState required by clients willing to join the group by an external commit.
-     *
-     * **CAUTION**: {@link CoreCrypto.commitAccepted} **HAS TO** be called afterwards **ONLY IF** the Delivery Service responds
-     * '200 OK' to the {@link CommitBundle} upload. It will "merge" the commit locally i.e. increment the local group
-     * epoch, use new encryption secrets etc...
-     *
-     * @param conversationId - The ID of the conversation
-     * @param clientIds - Array of Client IDs to remove.
-     *
-     * @returns A {@link CommitBundle} byte array to fan out to the Delivery Service, or `undefined` if for any reason, the operation would result in an empty commit
-     */
-    async finalRemoveClientsFromConversation(conversationId, clientIds) {
-        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").remove_clients_from_conversation(conversationId, clientIds);
-    }
-    /**
-     * Creates an update commit which forces every client to update their keypackages in the conversation
-     *
-     * The returned {@link CommitBundle} is a TLS struct that needs to be fanned out to Delivery Service in order to validate the commit.
-     * It also contains a Welcome message the Delivery Service will forward to invited clients and
-     * an updated PublicGroupState required by clients willing to join the group by an external commit.
-     *
-     * **CAUTION**: {@link CoreCrypto.commitAccepted} **HAS TO** be called afterwards **ONLY IF** the Delivery Service responds
-     * '200 OK' to the {@link CommitBundle} upload. It will "merge" the commit locally i.e. increment the local group
-     * epoch, use new encryption secrets etc...
-     *
-     * @param conversationId - The ID of the conversation
-     *
-     * @returns A {@link CommitBundle} byte array to fan out to the Delivery Service
-     */
-    async finalUpdateKeyingMaterial(conversationId) {
-        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").update_keying_material(conversationId);
-    }
-    /**
-     * Commits the local pending proposals and returns the {@link CommitBundle} object containing what can result from this operation.
-     *
-     * The returned {@link CommitBundle} is a TLS struct that needs to be fanned out to Delivery Service in order to validate the commit.
-     * It also contains a Welcome message the Delivery Service will forward to invited clients and
-     * an updated PublicGroupState required by clients willing to join the group by an external commit.
-     *
-     * **CAUTION**: {@link CoreCrypto.commitAccepted} **HAS TO** be called afterwards **ONLY IF** the Delivery Service responds
-     * '200 OK' to the {@link CommitBundle} upload. It will "merge" the commit locally i.e. increment the local group
-     * epoch, use new encryption secrets etc...
-     *
-     * @param conversationId - The ID of the conversation
-     *
-     * @returns A {@link CommitBundle} byte array to fan out to the Delivery Service or `undefined` when there was no pending proposal to commit
-     */
-    async finalCommitPendingProposals(conversationId) {
-        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").commit_pending_proposals(conversationId);
-    }
     /**
      * Creates a new proposal for the provided Conversation ID
      *
@@ -2302,25 +2550,34 @@ class CoreCrypto {
         return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").export_group_state(conversationId);
     }
     /**
-     * Allows to create an external commit to "apply" to join a group through its public group state
+     * Allows to create an external commit to "apply" to join a group through its public group state.
      *
-     * Also see the second step of this process: {@link CoreCrypto.mergePendingGroupFromExternalCommit}
+     * If the Delivery Service accepts the external commit, you have to {@link CoreCrypto.mergePendingGroupFromExternalCommit}
+     * in order to get back a functional MLS group. On the opposite, if it rejects it, you can either retry by just
+     * calling again {@link CoreCrypto.joinByExternalCommit}, no need to {@link CoreCrypto.clearPendingGroupFromExternalCommit}.
+     * If you want to abort the operation (too many retries or the user decided to abort), you can use
+     * {@link CoreCrypto.clearPendingGroupFromExternalCommit} in order not to bloat the user's storage but nothing
+     * bad can happen if you forget to except some storage space wasted.
      *
-     * @param publicGroupState - The public group state that can be fetched from the backend for a given conversation
-     * @returns see {@link MlsConversationInitMessage}
+     * @param publicGroupState - a TLS encoded PublicGroupState fetched from the Delivery Service
+     * @returns see {@link ConversationInitBundle}
      */
     async joinByExternalCommit(publicGroupState) {
         const ffiInitMessage = await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").join_by_external_commit(publicGroupState);
         const ret = {
-            group: ffiInitMessage.group,
+            conversationId: ffiInitMessage.conversation_id,
             commit: ffiInitMessage.commit,
+            publicGroupState: {
+                encryptionType: ffiInitMessage.public_group_state.encryption_type,
+                ratchetTreeType: ffiInitMessage.public_group_state.ratchet_tree_type,
+                payload: ffiInitMessage.public_group_state.payload
+            },
         };
         return ret;
     }
     /**
-     * This is the second step of the process of joining a group through an external commit
-     *
-     * This step makes the group operational and ready to encrypt/decrypt message
+     * This merges the commit generated by {@link CoreCrypto.joinByExternalCommit}, persists the group permanently
+     * and deletes the temporary one. This step makes the group operational and ready to encrypt/decrypt message
      *
      * @param conversationId - The ID of the conversation
      * @param configuration - Configuration of the group, see {@link ConversationConfiguration}
@@ -2330,6 +2587,16 @@ class CoreCrypto {
         const config = new (__classPrivateFieldGet(CoreCrypto, _a, "f", _CoreCrypto_module).ConversationConfiguration)(admins, ciphersuite, keyRotationSpan, externalSenders);
         return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").merge_pending_group_from_external_commit(conversationId, config);
     }
+    /**
+     * In case the external commit generated by {@link CoreCrypto.joinByExternalCommit} is rejected by the Delivery Service, and we
+     * want to abort this external commit once for all, we can wipe out the pending group from the keystore in order
+     * not to waste space
+     *
+     * @param conversationId - The ID of the conversation
+     */
+    async clearPendingGroupFromExternalCommit(conversationId) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").clear_pending_group_from_external_commit(conversationId);
+    }
     /**
      * Allows to mark the latest commit produced as "accepted" and be able to safely merge it
      * into the local group state
@@ -2366,6 +2633,28 @@ class CoreCrypto {
     async clearPendingCommit(conversationId) {
         return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").clear_pending_commit(conversationId);
     }
+    /**
+     * Derives a new key from the group
+     *
+     * @param conversationId - The group's ID
+     * @param keyLength - the length of the key to be derived. If the value is higher than the
+     * bounds of `u16` or the context hash * 255, an error will be returned
+     *
+     * @returns A `Uint8Array` representing the derived key
+     */
+    async exportSecretKey(conversationId, keyLength) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").export_secret_key(conversationId, keyLength);
+    }
+    /**
+     * Returns all clients from group's members
+     *
+     * @param conversationId - The group's ID
+     *
+     * @returns A list of clients from the members of the group
+     */
+    async getClientIds(conversationId) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").get_client_ids(conversationId);
+    }
     /**
      * Allows {@link CoreCrypto} to act as a CSPRNG provider
      * @note The underlying CSPRNG algorithm is ChaCha20 and takes in account the external seed provider either at init time or provided with {@link CoreCrypto.reseedRng}
@@ -2388,6 +2677,104 @@ class CoreCrypto {
         }
         return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").reseed_rng(seed);
     }
+    /**
+     * Initiailizes the proteus client
+     */
+    async proteusInit() {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_init();
+    }
+    /**
+     * Create a Proteus session using a prekey
+     *
+     * @param sessionId - ID of the Proteus session
+     * @param prekey - CBOR-encoded Proteus prekey of the other client
+     */
+    async proteusSessionFromPrekey(sessionId, prekey) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_session_from_prekey(sessionId, prekey);
+    }
+    /**
+     * Create a Proteus session from a handshake message
+     *
+     * @param sessionId - ID of the Proteus session
+     * @param envelope - CBOR-encoded Proteus message
+     */
+    async proteusSessionFromMessage(sessionId, envelope) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_session_from_message(sessionId, envelope);
+    }
+    /**
+     * Locally persists a session to the keystore
+     *
+     * @param sessionId - ID of the Proteus session
+     */
+    async proteusSessionSave(sessionId) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_session_save(sessionId);
+    }
+    /**
+     * Deletes a session
+     * Note: this also deletes the persisted data within the keystore
+     *
+     * @param sessionId - ID of the Proteus session
+     */
+    async proteusSessionDelete(sessionId) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_session_delete(sessionId);
+    }
+    /**
+     * Decrypt an incoming message for an existing Proteus session
+     *
+     * @param sessionId - ID of the Proteus session
+     * @param ciphertext - CBOR encoded, encrypted proteus message
+     * @returns The decrypted payload contained within the message
+     */
+    async proteusDecrypt(sessionId, ciphertext) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_decrypt(sessionId, ciphertext);
+    }
+    /**
+     * Encrypt a message for a given Proteus session
+     *
+     * @param sessionId - ID of the Proteus session
+     * @param plaintext - payload to encrypt
+     * @returns The CBOR-serialized encrypted message
+     */
+    async proteusEncrypt(sessionId, plaintext) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_encrypt(sessionId, plaintext);
+    }
+    /**
+     * Batch encryption for proteus messages
+     * This is used to minimize FFI roundtrips when used in the context of a multi-client session (i.e. conversation)
+     *
+     * @param sessions - List of Proteus session IDs to encrypt the message for
+     * @param plaintext - payload to encrypt
+     * @returns A map indexed by each session ID and the corresponding CBOR-serialized encrypted message for this session
+     */
+    async proteusEncryptBatched(sessions, plaintext) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_encrypt_batched(sessions, plaintext);
+    }
+    /**
+     * Creates a new prekey with the requested ID.
+     *
+     * @param prekeyId - ID of the PreKey to generate. This cannot be bigger than a u16
+     * @returns: A CBOR-serialized version of the PreKeyBundle corresponding to the newly generated and stored PreKey
+     */
+    async proteusNewPrekey(prekeyId) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_new_prekey(prekeyId);
+    }
+    /**
+     * Proteus public key fingerprint
+     * It's basically the public key encoded as an hex string
+     *
+     * @returns Hex-encoded public key string
+     */
+    async proteusFingerprint() {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_fingerprint();
+    }
+    /**
+     * Imports all the data stored by Cryptobox into the CoreCrypto keystore
+     *
+     * @param storeName - The name of the IndexedDB store where the data is stored
+     */
+    async proteusCryptoboxMigrate(storeName) {
+        return await __classPrivateFieldGet(this, _CoreCrypto_cc, "f").proteus_cryptobox_migrate(storeName);
+    }
     /**
      * Returns the current version of {@link CoreCrypto}
      *
@@ -2404,4 +2791,4 @@ _a = CoreCrypto, _CoreCrypto_cc = new WeakMap();
 /** @hidden */
 _CoreCrypto_module = { value: void 0 };
 
-export { Ciphersuite, CoreCrypto, ExternalProposalType, ProposalType };
+export { Ciphersuite, CoreCrypto, ExternalProposalType, ProposalType, PublicGroupStateEncryptionType, RatchetTreeType };