@wireapp/core-crypto 1.1.2 → 3.0.0

package/README.md

@@ -36,6 +36,13 @@ brew install gnu-sed
 ```
 and add an alias to your shell configuration file: `alias sed=gsed` (e.g. to `~/.zshenv` if you're using zsh).
 
+### Development Requirements
+
+#### Pre-commit
+
+- Install the [`pre-commit` framework](https://pre-commit.com/)
+- Run `pre-commit install` to initialize the pre-commit hooks
+
 ### Android
 
 Install Android SDK and Build-Tools for API level 30+
@@ -48,7 +55,7 @@ Install Android SDK and Build-Tools for API level 30+
 
 Install android rust targets:
 ```ignore
-rustup target add x86_64-linux-android aarch64-linux-android armv7-linux-androideabi i686-linux-android
+rustup target add x86_64-linux-android aarch64-linux-android armv7-linux-androideabi
 ```
 Build:
 ```ignore
@@ -137,11 +144,11 @@ cargo install cargo-nextest
 cargo nextest run
 ```
 
-#### Run core crypto tests on WASM target
+### Run core crypto internal tests on WASM target
 
 If you haven't already, install the target and wasm-pack:
 
-```ignore
+```sh
 rustup target add wasm32-unknown-unknown
 cargo install wasm-pack
 ```
@@ -164,28 +171,63 @@ wasm-pack test --headless --chrome ./<crate-folder-to-test>
 cargo nextest run --features test-all-cipher
 ```
 
-### Platform-specific testing
+### Platform-specific tests for Kotlin/JVM
 
-### Kotlin/Android
+Build the JVM target every timee the Rust code changes:
 
-* Take the steps to compile for Kotlin/Android
-* Then:
-```ignore
-cd crypto-ffi/bindings
-./gradlew test
+```sh
+# substitute with `jvm-darwin` on OSX
+core-crypto/crypto-ffi$ cargo make jvm-linux
+```
+
+Then run the tests each time the wrapper or wrapper tests change
+
+```sh
+core-crypto/crypto-ffi/bindings$ ./gradlew jvm:build -x lint -x lintRelease
+```
+
+### Platform-specific tests for Android
+
+Build the Android target every timee the Rust code changes:
+
+```sh
+core-crypto/crypto-ffi$ cargo make android
+```
+
+Then run the tests each time the wrapper or wrapper tests change
+
+```sh
+core-crypto/crypto-ffi/bindings$ ./gradlew android:build -x lint -x lintRelease
 ```
 
 ### Swift/iOS
 
 *No E2E testing is available as of now on Swift.*
 
-### WASM/Web
+### Platform-spcecific tests for WASM/Web
 
-* Take the steps to compile for WASM/Web
-* Then:
-```ignore
-cd crypto-ffi
-bun test
+Install TS dependencies on first go, and each time they change:
+
+```sh
+bun install
+```
+
+Build the WASM target every timee the Rust code changes:
+
+```sh
+core-crypto/crypto-ffi$ cargo make wasm
+```
+
+Then run the tests each time the wrapper or wrapper tests change
+
+```sh
+core-crypto/crypto-ffi$ bun run test
+```
+
+Note that CI will fail if it doesn't like your formatting. This can typically be automtically adjusted with
+
+```sh
+core-crypto/crypto-ffi$ bun eslinst bindings/js --max-warnings=0 --fix
 ```
 
 ## Benchmarks
@@ -276,4 +318,4 @@ cd crypto-ffi/bindings/android
 Publishing JS / WASM bindings happens automatically by a github workflow when a release tag is pushed.
 
 If you would like to publish to `@wireapp/core-crypto` manually, log into NPM and
-just run `npm publish`.
+just run `bun publish`.

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@wireapp/core-crypto",
-  "version": "1.1.2",
+  "version": "3.0.0",
   "description": "CoreCrypto bindings for the Web",
   "type": "module",
   "module": "platforms/web/corecrypto.js",
   "types": "platforms/web/corecrypto.d.ts",
   "scripts": {
-    "clean": "rm -f ./platforms/web/*.{js,ts,wasm,html} && rm -rf ./platforms/web/assets"
+    "clean": "rm -f ./platforms/web/*.{js,ts,wasm,html} && rm -rf ./platforms/web/assets",
+    "test": "[ \"$(basename $PWD)\" != \"crypto-ffi\" ] && echo \"Error: Not in crypto-ffi directory, do:\" && echo cd crypto-ffi && exit 1 || bun run build_ts.ts && wdio run bindings/js/wdio.conf.ts --spec bindings/js/test/**/*.test.ts",
+    "bench": "[ \"$(basename $PWD)\" != \"crypto-ffi\" ] && echo \"Error: Not in crypto-ffi directory, do:\" && echo cd crypto-ffi && exit 1 ||bun run build_ts.ts && wdio run bindings/js/wdio.conf.ts --spec bindings/js/benches/**/*.bench.ts --log-level warn"
   },
   "publishConfig": {
     "access": "public"
@@ -32,14 +34,22 @@
     "url": "https://github.com/wireapp/core-crypto/issues"
   },
   "devDependencies": {
+    "@types/bun": "^1.1.13",
+    "@types/mocha": "^10.0.9",
     "@typescript-eslint/eslint-plugin": "^7.0.2",
     "@typescript-eslint/parser": "^7.0.2",
+    "@wdio/browser-runner": "^9.2.12",
+    "@wdio/cli": "^9.2.12",
+    "@wdio/logger": "^9.1.3",
+    "@wdio/mocha-framework": "^9.2.8",
+    "@wdio/spec-reporter": "^9.2.14",
+    "@wdio/static-server-service": "^9.2.2",
     "bun-plugin-dts": "^0.2.1",
     "eslint": "^8.56.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-prettier": "^5.1.3",
+    "eslint-plugin-wdio": "^9.2.11",
     "prettier": "^3.2.5",
-    "puppeteer": "^22.2.0",
     "ts-loader": "^9.5.1",
     "typescript": "^5.3.3"
   }

package/platforms/web/corecrypto.d.ts

@@ -8,6 +8,16 @@ declare enum WirePolicy {
 	*/
 	Ciphertext = 2
 }
+declare enum CredentialType {
+	/**
+	* Just a KeyPair
+	*/
+	Basic = 1,
+	/**
+	* A certificate obtained through e2e identity enrollment process
+	*/
+	X509 = 2
+}
 declare enum Ciphersuite {
 	/**
 	* DH KEM x25519 | AES-GCM 128 | SHA2-256 | Ed25519
@@ -38,16 +48,6 @@ declare enum Ciphersuite {
 	*/
 	MLS_256_DHKEMP384_AES256GCM_SHA384_P384 = 7
 }
-declare enum CredentialType {
-	/**
-	* Just a KeyPair
-	*/
-	Basic = 1,
-	/**
-	* A certificate obtained through e2e identity enrollment process
-	*/
-	X509 = 2
-}
 /**
 * For creating a challenge.
 * @see https://www.rfc-editor.org/rfc/rfc8555.html#section-7.5.1
@@ -68,6 +68,53 @@ export class AcmeChallenge {
 	*/
 	readonly url: string;
 }
+declare class BuildMetadata {
+	/**
+	** Return copy of self without private attributes.
+	*/
+	toJSON(): Object;
+	/**
+	* Return stringified version of self.
+	*/
+	toString(): string;
+	free(): void;
+	/**
+	* Whether this build was in Debug mode (true) or Release mode (false)
+	*/
+	readonly cargoDebug: string;
+	/**
+	* Features enabled for this build
+	*/
+	readonly cargoFeatures: string;
+	/**
+	* Git branch
+	*/
+	readonly gitBranch: string;
+	/**
+	* Output of `git describe`
+	*/
+	readonly gitDescribe: string;
+	/**
+	* `true` when the source code differed from the commit at the most recent git hash
+	*/
+	readonly gitDirty: string;
+	/**
+	* Hash of current git commit
+	*/
+	readonly gitSha: string;
+	/**
+	* Optimization level
+	*/
+	readonly optLevel: string;
+	/**
+	* Build target triple
+	*/
+	readonly targetTriple: string;
+	/**
+	* Build Timestamp
+	*/
+	readonly timestamp: string;
+}
 /**
 * see [core_crypto::prelude::MlsConversationConfiguration]
 */
@@ -390,6 +437,13 @@ declare class CoreCryptoContext {
 	/**
 	* Returns: [`WasmCryptoResult<()>`]
 	*
+	* see [core_crypto::proteus::ProteusCentral::try_new]
+	* @returns {Promise<any>}
+	*/
+	proteus_init(): Promise<any>;
+	/**
+	* Returns: [`WasmCryptoResult<()>`]
+	*
 	* See [core_crypto::context::CentralContext::proteus_session_from_prekey]
 	* @param {string} session_id
 	* @param {Uint8Array} prekey
@@ -609,6 +663,7 @@ declare class CoreCryptoContext {
 	e2ei_mls_init_only(enrollment: FfiWireE2EIdentity, certificate_chain: string, nb_key_package?: number): Promise<any>;
 	/**
 	* Returns: [`WasmCryptoResult<CommitBundle>`]
+	*
 	* see [core_crypto::context::CentralContext::e2ei_rotate]
 	* @param {Uint8Array} conversation_id
 	* @returns {Promise<any>}
@@ -1233,6 +1288,10 @@ declare class CoreCryptoContext$1 {
 	 * @returns A `Uint8Array` buffer that contains `length` cryptographically-secure random bytes
 	 */
 	randomBytes(length: number): Promise<Uint8Array>;
+	/**
+	 * Initializes the proteus client
+	 */
+	proteusInit(): Promise<void>;
 	/**
 	 * Create a Proteus session using a prekey
 	 *
@@ -1533,6 +1592,12 @@ declare class CoreCryptoContext$1 {
 	 */
 	getCredentialInUse(groupInfo: Uint8Array, credentialType?: CredentialType$1): Promise<E2eiConversationState>;
 }
+export interface CoreCryptoRichError {
+	message: string;
+	error_name?: string;
+	error_stack?: string[];
+	proteus_error_code?: number;
+}
 /**
  * Error wrapper that takes care of extracting rich error details across the FFI (through JSON parsing)
  *
@@ -1543,8 +1608,8 @@ declare class CoreCryptoContext$1 {
  * Please note that in this case the extra properties will not be available.
  */
 export declare class CoreCryptoError extends Error {
-	rustStackTrace: string;
-	proteusErrorCode: number;
+	errorStack: string[];
+	proteusErrorCode: number | null;
 	private constructor();
 	private static fallback;
 	static build(msg: string, ...params: unknown[]): CoreCryptoError | Error;
@@ -2218,9 +2283,10 @@ export interface CoreCryptoLogger {
 	/**
 	 * This method will be called by Core Crypto to log messages. It is up to the implementer to decide how to handle the message and where to actually log it.
 	 * @param level - the level of the logged message. it will also be present in the json message
-	 * @param json_msg - message to log in json format
+	 * @param message - log message
+	 * @param context - additional context captured when the log was made.
 	 **/
-	log: (level: CoreCryptoLogLevel, json_msg: string) => void;
+	log: (level: CoreCryptoLogLevel, message: string, context: string) => void;
 }
 /**
  * Defines the maximum log level for the logs from Core Crypto
@@ -2234,13 +2300,30 @@ export declare enum CoreCryptoLogLevel {
 	Error = 6
 }
 /**
- * Initializes the global logger for Core Crypto and registers the callback. Can be called only once
+ * Initializes the global logger for Core Crypto and registers the callback.
+ *
+ * **NOTE:** you must call this after `await CoreCrypto.init(params)` or `await CoreCrypto.deferredInit(params)`.
+ *
+ * @deprecated use {@link CoreCrypto.setLogger} instead.
+ *
  * @param logger - the interface to be called when something is going to be logged
  * @param level - the max level that should be logged
- *
- * NOTE: you must call this after `await CoreCrypto.init(params)` or `await CoreCrypto.deferredInit(params)`.
  **/
 export declare function initLogger(logger: CoreCryptoLogger, level: CoreCryptoLogLevel, ctx?: unknown): void;
+/**
+ * Initializes the global logger for Core Crypto and registers the callback.
+ *
+ * **NOTE:** you must call this after `await CoreCrypto.init(params)` or `await CoreCrypto.deferredInit(params)`.
+ *
+ * @param logger - the interface to be called when something is going to be logged
+ **/
+export declare function setLogger(logger: CoreCryptoLogger, ctx?: unknown): void;
+/**
+ * Sets maximum log level for logs forwarded to the logger, defaults to `Warn`.
+ *
+ * @param level - the max level that should be logged
+ */
+export declare function setMaxLogLevel(level: CoreCryptoLogLevel): void;
 /**
  * Wrapper for the WASM-compiled version of CoreCrypto
  */
@@ -2250,7 +2333,8 @@ export declare class CoreCrypto {
 	 * Should only be used internally
 	 */
 	inner(): unknown;
-	static setLogger(logger: CoreCryptoWasmLogger, level: CoreCryptoLogLevel): void;
+	static setLogger(logger: CoreCryptoWasmLogger): void;
+	static setMaxLogLevel(level: CoreCryptoLogLevel): void;
 	/**
 	 * This is your entrypoint to initialize {@link CoreCrypto}!
 	 *
@@ -2588,6 +2672,9 @@ export declare class CoreCrypto {
 	reseedRng(seed: Uint8Array): Promise<void>;
 	/**
 	 * Initializes the proteus client
+	 *
+	 * @deprecated Create a transaction with {@link CoreCrypto.transaction}
+	 * and use {@link CoreCryptoContext.proteusInit} instead.
 	 */
 	proteusInit(): Promise<void>;
 	/**
@@ -2873,6 +2960,12 @@ export declare class CoreCrypto {
 	 * @returns The `core-crypto-ffi` version as defined in its `Cargo.toml` file
 	 */
 	static version(): string;
+	/**
+	 * Returns build metadata for the {@link CoreCrypto} libary.
+	 *
+	 * @returns varous build metadata for `core-crypto`.
+	 */
+	static buildMetadata(): BuildMetadata;
 }
 type JsonRawData = Uint8Array;
 export declare class E2eiEnrollment {

package/platforms/web/corecrypto.js

@@ -184,13 +184,13 @@ function makeMutClosure(arg0, arg1, dtor, f) {
   return real;
 }
 function __wbg_adapter_54(arg0, arg1, arg2) {
-  wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h04c8e12eab94d8e7(arg0, arg1, addHeapObject(arg2));
+  wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h5286e98832f56995(arg0, arg1, addHeapObject(arg2));
 }
 function __wbg_adapter_57(arg0, arg1, arg2) {
-  wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h07cca67d94fc484f(arg0, arg1, addHeapObject(arg2));
+  wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hc681a33fe1ead8b3(arg0, arg1, addHeapObject(arg2));
 }
 function __wbg_adapter_60(arg0, arg1, arg2) {
-  wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hec7f3798e268a664(arg0, arg1, addHeapObject(arg2));
+  wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h2e1bdf8eee89b946(arg0, arg1, addHeapObject(arg2));
 }
 function getArrayJsValueFromWasm0(ptr, len) {
   ptr = ptr >>> 0;
@@ -242,15 +242,10 @@ function handleError(f, args) {
     wasm.__wbindgen_exn_store(addHeapObject(e));
   }
 }
-function __wbg_adapter_497(arg0, arg1, arg2, arg3) {
-  wasm.wasm_bindgen__convert__closures__invoke2_mut__h5053bb07030a5de3(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wbg_adapter_512(arg0, arg1, arg2, arg3) {
+  wasm.wasm_bindgen__convert__closures__invoke2_mut__h5d1db9fa3036c038(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
-var WirePolicy = Object.freeze({
-  Plaintext: 1,
-  "1": "Plaintext",
-  Ciphertext: 2,
-  "2": "Ciphertext"
-});
+var CoreCryptoLogLevel = Object.freeze({ Off: 1, "1": "Off", Trace: 2, "2": "Trace", Debug: 3, "3": "Debug", Info: 4, "4": "Info", Warn: 5, "5": "Warn", Error: 6, "6": "Error" });
 var DeviceStatus = Object.freeze({
   Valid: 1,
   "1": "Valid",
@@ -259,6 +254,18 @@ var DeviceStatus = Object.freeze({
   Revoked: 3,
   "3": "Revoked"
 });
+var WirePolicy = Object.freeze({
+  Plaintext: 1,
+  "1": "Plaintext",
+  Ciphertext: 2,
+  "2": "Ciphertext"
+});
+var CredentialType = Object.freeze({
+  Basic: 1,
+  "1": "Basic",
+  X509: 2,
+  "2": "X509"
+});
 var Ciphersuite = Object.freeze({
   MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519: 1,
   "1": "MLS_128_DHKEMX25519_AES128GCM_SHA256_Ed25519",
@@ -275,13 +282,6 @@ var Ciphersuite = Object.freeze({
   MLS_256_DHKEMP384_AES256GCM_SHA384_P384: 7,
   "7": "MLS_256_DHKEMP384_AES256GCM_SHA384_P384"
 });
-var CoreCryptoLogLevel = Object.freeze({ Off: 1, "1": "Off", Trace: 2, "2": "Trace", Debug: 3, "3": "Debug", Info: 4, "4": "Info", Warn: 5, "5": "Warn", Error: 6, "6": "Error" });
-var CredentialType = Object.freeze({
-  Basic: 1,
-  "1": "Basic",
-  X509: 2,
-  "2": "X509"
-});
 var AcmeChallengeFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
 }, unregister: () => {
 } } : new FinalizationRegistry((ptr) => wasm.__wbg_acmechallenge_free(ptr >>> 0, 1));
@@ -499,6 +499,144 @@ class BufferedDecryptedMessage {
     return takeObject(ret);
   }
 }
+var BuildMetadataFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_buildmetadata_free(ptr >>> 0, 1));
+
+class BuildMetadata {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(BuildMetadata.prototype);
+    obj.__wbg_ptr = ptr;
+    BuildMetadataFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  toJSON() {
+    return {
+      timestamp: this.timestamp,
+      cargoDebug: this.cargoDebug,
+      cargoFeatures: this.cargoFeatures,
+      optLevel: this.optLevel,
+      targetTriple: this.targetTriple,
+      gitBranch: this.gitBranch,
+      gitDescribe: this.gitDescribe,
+      gitSha: this.gitSha,
+      gitDirty: this.gitDirty
+    };
+  }
+  toString() {
+    return JSON.stringify(this);
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    BuildMetadataFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_buildmetadata_free(ptr, 0);
+  }
+  get timestamp() {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.__wbg_get_buildmetadata_timestamp(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  get cargoDebug() {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.__wbg_get_buildmetadata_cargoDebug(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  get cargoFeatures() {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.__wbg_get_buildmetadata_cargoFeatures(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  get optLevel() {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.__wbg_get_buildmetadata_optLevel(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  get targetTriple() {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.__wbg_get_buildmetadata_targetTriple(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  get gitBranch() {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.__wbg_get_buildmetadata_gitBranch(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  get gitDescribe() {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.__wbg_get_buildmetadata_gitDescribe(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  get gitSha() {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.__wbg_get_buildmetadata_gitSha(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  get gitDirty() {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.__wbg_get_buildmetadata_gitDirty(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      return getStringFromWasm0(r0, r1);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+}
 var CommitBundleFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
 }, unregister: () => {
 } } : new FinalizationRegistry((ptr) => wasm.__wbg_commitbundle_free(ptr >>> 0, 1));
@@ -644,6 +782,10 @@ class CoreCrypto {
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
+  static build_metadata() {
+    const ret = wasm.corecrypto_build_metadata();
+    return BuildMetadata.__wrap(ret);
+  }
   static _internal_new(path, key, client_id, ciphersuites, entropy_seed, nb_key_package) {
     const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
@@ -682,10 +824,13 @@ class CoreCrypto {
     const ret = wasm.corecrypto_wipe(ptr);
     return takeObject(ret);
   }
-  static set_logger(logger, level) {
+  static set_logger(logger) {
     _assertClass(logger, CoreCryptoWasmLogger);
     var ptr0 = logger.__destroy_into_raw();
-    wasm.corecrypto_set_logger(ptr0, level);
+    wasm.corecrypto_set_logger(ptr0);
+  }
+  static set_max_log_level(level) {
+    wasm.corecrypto_set_max_log_level(level);
   }
   set_callbacks(callbacks) {
     _assertClass(callbacks, CoreCryptoWasmCallbacks);
@@ -725,10 +870,6 @@ class CoreCrypto {
     const ret = wasm.corecrypto_reseed_rng(this.__wbg_ptr, ptr0, len0);
     return takeObject(ret);
   }
-  proteus_init() {
-    const ret = wasm.corecrypto_proteus_init(this.__wbg_ptr);
-    return takeObject(ret);
-  }
   proteus_session_exists(session_id) {
     const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
@@ -1076,6 +1217,10 @@ class CoreCryptoContext {
     const ret = wasm.corecryptocontext_get_client_ids(this.__wbg_ptr, ptr0, len0);
     return takeObject(ret);
   }
+  proteus_init() {
+    const ret = wasm.corecryptocontext_proteus_init(this.__wbg_ptr);
+    return takeObject(ret);
+  }
   proteus_session_from_prekey(session_id, prekey) {
     const ptr0 = passStringToWasm0(session_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
@@ -2033,58 +2178,58 @@ function __wbg_get_imports() {
   imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
     takeObject(arg0);
   };
-  imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
-    const ret = BigInt.asUintN(64, arg0);
+  imports.wbg.__wbg_ffiwiree2eidentity_new = function(arg0) {
+    const ret = FfiWireE2EIdentity.__wrap(arg0);
     return addHeapObject(ret);
   };
   imports.wbg.__wbindgen_number_new = function(arg0) {
     const ret = arg0;
     return addHeapObject(ret);
   };
-  imports.wbg.__wbg_ffiwiree2eidentity_new = function(arg0) {
-    const ret = FfiWireE2EIdentity.__wrap(arg0);
-    return addHeapObject(ret);
-  };
-  imports.wbg.__wbg_execute_1168d8ced41f5786 = function() {
+  imports.wbg.__wbg_execute_a85f95e9599e213e = function() {
     return handleError(function(arg0, arg1) {
       const ret = getObject(arg0).execute(CoreCryptoContext.__wrap(arg1));
       return addHeapObject(ret);
     }, arguments);
   };
-  imports.wbg.__wbg_newacmeorder_new = function(arg0) {
-    const ret = NewAcmeOrder.__wrap(arg0);
-    return addHeapObject(ret);
-  };
-  imports.wbg.__wbg_newacmeauthz_new = function(arg0) {
-    const ret = NewAcmeAuthz.__wrap(arg0);
-    return addHeapObject(ret);
-  };
   imports.wbg.__wbg_proteusautoprekeybundle_new = function(arg0) {
     const ret = ProteusAutoPrekeyBundle.__wrap(arg0);
     return addHeapObject(ret);
   };
+  imports.wbg.__wbg_newacmeorder_new = function(arg0) {
+    const ret = NewAcmeOrder.__wrap(arg0);
+    return addHeapObject(ret);
+  };
   imports.wbg.__wbg_acmedirectory_new = function(arg0) {
     const ret = AcmeDirectory.__wrap(arg0);
     return addHeapObject(ret);
   };
+  imports.wbg.__wbg_newacmeauthz_new = function(arg0) {
+    const ret = NewAcmeAuthz.__wrap(arg0);
+    return addHeapObject(ret);
+  };
   imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
     const ret = getStringFromWasm0(arg0, arg1);
     return addHeapObject(ret);
   };
+  imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
+    const ret = BigInt.asUintN(64, arg0);
+    return addHeapObject(ret);
+  };
   imports.wbg.__wbg_buffereddecryptedmessage_new = function(arg0) {
     const ret = BufferedDecryptedMessage.__wrap(arg0);
     return addHeapObject(ret);
   };
-  imports.wbg.__wbg_corecrypto_new = function(arg0) {
-    const ret = CoreCrypto.__wrap(arg0);
+  imports.wbg.__wbg_commitbundle_new = function(arg0) {
+    const ret = CommitBundle.__wrap(arg0);
     return addHeapObject(ret);
   };
   imports.wbg.__wbg_proposalbundle_new = function(arg0) {
     const ret = ProposalBundle.__wrap(arg0);
     return addHeapObject(ret);
   };
-  imports.wbg.__wbg_commitbundle_new = function(arg0) {
-    const ret = CommitBundle.__wrap(arg0);
+  imports.wbg.__wbg_corecrypto_new = function(arg0) {
+    const ret = CoreCrypto.__wrap(arg0);
     return addHeapObject(ret);
   };
   imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
@@ -2099,6 +2244,14 @@ function __wbg_get_imports() {
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
   };
+  imports.wbg.__wbindgen_is_undefined = function(arg0) {
+    const ret = getObject(arg0) === undefined;
+    return ret;
+  };
+  imports.wbg.__wbindgen_in = function(arg0, arg1) {
+    const ret = getObject(arg0) in getObject(arg1);
+    return ret;
+  };
   imports.wbg.__wbindgen_boolean_get = function(arg0) {
     const v = getObject(arg0);
     const ret = typeof v === "boolean" ? v ? 1 : 0 : 2;
@@ -2127,10 +2280,6 @@ function __wbg_get_imports() {
     const ret = typeof val === "object" && val !== null;
     return ret;
   };
-  imports.wbg.__wbindgen_in = function(arg0, arg1) {
-    const ret = getObject(arg0) in getObject(arg1);
-    return ret;
-  };
   imports.wbg.__wbg_queueMicrotask_48421b3cc9052b68 = function(arg0) {
     const ret = getObject(arg0).queueMicrotask;
     return addHeapObject(ret);
@@ -2163,10 +2312,6 @@ function __wbg_get_imports() {
     const ret = getObject(arg0) === null;
     return ret;
   };
-  imports.wbg.__wbindgen_is_undefined = function(arg0) {
-    const ret = getObject(arg0) === undefined;
-    return ret;
-  };
   imports.wbg.__wbindgen_jsval_loose_eq = function(arg0, arg1) {
     const ret = getObject(arg0) == getObject(arg1);
     return ret;
@@ -2665,6 +2810,12 @@ function __wbg_get_imports() {
     const ret = new Error(getStringFromWasm0(arg0, arg1));
     return addHeapObject(ret);
   };
+  imports.wbg.__wbg_setcause_95acfe0bd827ffdb = function(arg0, arg1) {
+    getObject(arg0).cause = getObject(arg1);
+  };
+  imports.wbg.__wbg_setname_ef058a4c6ff7e6d4 = function(arg0, arg1, arg2) {
+    getObject(arg0).name = getStringFromWasm0(arg1, arg2);
+  };
   imports.wbg.__wbg_apply_353f4c9ca391d52b = function() {
     return handleError(function(arg0, arg1, arg2) {
       const ret = getObject(arg0).apply(getObject(arg1), getObject(arg2));
@@ -2748,7 +2899,7 @@ function __wbg_get_imports() {
         const a = state0.a;
         state0.a = 0;
         try {
-          return __wbg_adapter_497(a, state0.b, arg02, arg12);
+          return __wbg_adapter_512(a, state0.b, arg02, arg12);
         } finally {
           state0.a = a;
         }
@@ -2834,16 +2985,16 @@ function __wbg_get_imports() {
     const ret = v0;
     return addHeapObject(ret);
   };
-  imports.wbg.__wbindgen_closure_wrapper3447 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 751, __wbg_adapter_54);
+  imports.wbg.__wbindgen_closure_wrapper3710 = function(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 899, __wbg_adapter_54);
     return addHeapObject(ret);
   };
-  imports.wbg.__wbindgen_closure_wrapper13040 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 2019, __wbg_adapter_57);
+  imports.wbg.__wbindgen_closure_wrapper13415 = function(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 2169, __wbg_adapter_57);
     return addHeapObject(ret);
   };
-  imports.wbg.__wbindgen_closure_wrapper15217 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 2263, __wbg_adapter_60);
+  imports.wbg.__wbindgen_closure_wrapper15391 = function(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 2396, __wbg_adapter_60);
     return addHeapObject(ret);
   };
   return imports;
@@ -3147,6 +3298,9 @@ class CoreCryptoContext2 {
   async randomBytes(length) {
     return await CoreCryptoError.asyncMapErr(this.#ctx.random_bytes(length));
   }
+  async proteusInit() {
+    return await CoreCryptoError.asyncMapErr(this.#ctx.proteus_init());
+  }
   async proteusSessionFromPrekey(sessionId, prekey) {
     return await CoreCryptoError.asyncMapErr(this.#ctx.proteus_session_from_prekey(sessionId, prekey));
   }
@@ -3298,33 +3452,35 @@ class CoreCryptoContext2 {
 
 // bindings/js/CoreCrypto.ts
 class CoreCryptoError extends Error {
-  rustStackTrace;
+  errorStack;
   proteusErrorCode;
-  constructor(msg, richError, ...params) {
-    super(msg, ...params);
+  constructor(richError, ...params) {
+    super(richError.message, ...params);
     Object.setPrototypeOf(this, new.target.prototype);
-    this.name = richError.errorName;
-    this.rustStackTrace = richError.rustStackTrace;
-    this.proteusErrorCode = richError.proteusErrorCode;
+    if (richError.error_name) {
+      this.name = richError.error_name;
+    }
+    if (richError.error_stack) {
+      this.errorStack = richError.error_stack;
+    } else {
+      this.errorStack = [];
+    }
+    if (richError.proteus_error_code) {
+      this.proteusErrorCode = richError.proteus_error_code;
+    } else {
+      this.proteusErrorCode = null;
+    }
   }
   static fallback(msg, ...params) {
     console.warn(`Cannot build CoreCryptoError, falling back to standard Error! ctx: ${msg}`);
     return new Error(msg, ...params);
   }
   static build(msg, ...params) {
-    const parts = msg.split(`
-
-`);
-    if (parts.length < 2) {
-      const cause = new Error("CoreCrypto WASM FFI Error doesn't have enough elements to build a rich error");
-      return this.fallback(msg, { cause }, ...params);
-    }
-    const [errMsg, richErrorJSON] = parts;
     try {
-      const richError = JSON.parse(richErrorJSON);
-      return new this(errMsg, richError, ...params);
+      const richError = JSON.parse(msg);
+      return new this(richError, ...params);
     } catch (cause) {
-      return this.fallback(msg, { cause }, ...params);
+      return this.fallback(msg, ...params);
     }
   }
   static fromStdError(e) {
@@ -3434,7 +3590,15 @@ var CoreCryptoLogLevel2;
 })(CoreCryptoLogLevel2 ||= {});
 function initLogger(logger, level, ctx = null) {
   const wasmLogger = new CoreCryptoWasmLogger(logger.log, ctx);
-  CoreCrypto2.setLogger(wasmLogger, level);
+  CoreCrypto2.setLogger(wasmLogger);
+  CoreCrypto2.setMaxLogLevel(level);
+}
+function setLogger(logger, ctx = null) {
+  const wasmLogger = new CoreCryptoWasmLogger(logger.log, ctx);
+  CoreCrypto2.setLogger(wasmLogger);
+}
+function setMaxLogLevel(level) {
+  CoreCrypto2.setMaxLogLevel(level);
 }
 
 class CoreCrypto2 {
@@ -3453,9 +3617,13 @@ class CoreCrypto2 {
       this.#module = await core_crypto_ffi_default(wasmFilePath);
     }
   }
-  static setLogger(logger, level) {
+  static setLogger(logger) {
+    this.#assertModuleLoaded();
+    CoreCrypto.set_logger(logger);
+  }
+  static setMaxLogLevel(level) {
     this.#assertModuleLoaded();
-    CoreCrypto.set_logger(logger, level);
+    CoreCrypto.set_max_log_level(level);
   }
   static async init({
     databaseName,
@@ -3485,21 +3653,20 @@ class CoreCrypto2 {
     let result;
     let error = null;
     try {
-      await this.#cc.transaction({
+      await CoreCryptoError.asyncMapErr(this.#cc.transaction({
         execute: async (ctx) => {
           try {
-            result = await callback(CoreCryptoContext2.fromFfiContext(ctx));
+            result = await CoreCryptoError.asyncMapErr(callback(CoreCryptoContext2.fromFfiContext(ctx)));
           } catch (e) {
-            if (e instanceof CoreCryptoError) {
-              error = e;
-            } else {
-              error = CoreCryptoError.fromStdError(e);
-            }
+            error = e;
             throw error;
           }
         }
-      });
-    } catch (_) {
+      }));
+    } catch (e) {
+      if (error === null) {
+        error = e;
+      }
     }
     if (error !== null) {
       throw error;
@@ -3632,7 +3799,7 @@ class CoreCrypto2 {
     return await CoreCryptoError.asyncMapErr(this.#cc.reseed_rng(seed));
   }
   async proteusInit() {
-    return await CoreCryptoError.asyncMapErr(this.#cc.proteus_init());
+    return await this.transaction(async (ctx) => await ctx.proteusInit());
   }
   async proteusSessionFromPrekey(sessionId, prekey) {
     return await this.transaction(async (ctx) => await ctx.proteusSessionFromPrekey(sessionId, prekey));
@@ -3758,6 +3925,10 @@ class CoreCrypto2 {
     this.#assertModuleLoaded();
     return CoreCrypto.version();
   }
+  static buildMetadata() {
+    this.#assertModuleLoaded();
+    return CoreCrypto.build_metadata();
+  }
 }
 
 class E2eiEnrollment {
@@ -3836,6 +4007,8 @@ var E2eiConversationState;
   E2eiConversationState2[E2eiConversationState2["NotEnabled"] = 3] = "NotEnabled";
 })(E2eiConversationState ||= {});
 export {
+  setMaxLogLevel,
+  setLogger,
   normalizeEnum,
   mapWireIdentity,
   initLogger,