@massalabs/gossip-sdk 0.0.2-dev.20260128111120 → 0.0.2-dev.20260128160824

package/dist/assets/generated/wasm/gossip_wasm.js

@@ -1,53 +1,64 @@
 let wasm;
 
 function addToExternrefTable0(obj) {
-    const idx = wasm.__externref_table_alloc();
-    wasm.__wbindgen_export_2.set(idx, obj);
-    return idx;
+  const idx = wasm.__externref_table_alloc();
+  wasm.__wbindgen_export_2.set(idx, obj);
+  return idx;
 }
 
 function handleError(f, args) {
-    try {
-        return f.apply(this, args);
-    } catch (e) {
-        const idx = addToExternrefTable0(e);
-        wasm.__wbindgen_exn_store(idx);
-    }
+  try {
+    return f.apply(this, args);
+  } catch (e) {
+    const idx = addToExternrefTable0(e);
+    wasm.__wbindgen_exn_store(idx);
+  }
 }
 
 let cachedUint8ArrayMemory0 = null;
 
 function getUint8ArrayMemory0() {
-    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
-        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachedUint8ArrayMemory0;
+  if (
+    cachedUint8ArrayMemory0 === null ||
+    cachedUint8ArrayMemory0.byteLength === 0
+  ) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
 }
 
-let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+let cachedTextDecoder = new TextDecoder('utf-8', {
+  ignoreBOM: true,
+  fatal: true,
+});
 
 cachedTextDecoder.decode();
 
 const MAX_SAFARI_DECODE_BYTES = 2146435072;
 let numBytesDecoded = 0;
 function decodeText(ptr, len) {
-    numBytesDecoded += len;
-    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
-        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-        cachedTextDecoder.decode();
-        numBytesDecoded = len;
-    }
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+  numBytesDecoded += len;
+  if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+    cachedTextDecoder = new TextDecoder('utf-8', {
+      ignoreBOM: true,
+      fatal: true,
+    });
+    cachedTextDecoder.decode();
+    numBytesDecoded = len;
+  }
+  return cachedTextDecoder.decode(
+    getUint8ArrayMemory0().subarray(ptr, ptr + len)
+  );
 }
 
 function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return decodeText(ptr, len);
+  ptr = ptr >>> 0;
+  return decodeText(ptr, len);
 }
 
 function getArrayU8FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+  ptr = ptr >>> 0;
+  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
 let WASM_VECTOR_LEN = 0;
@@ -55,104 +66,157 @@ let WASM_VECTOR_LEN = 0;
 const cachedTextEncoder = new TextEncoder();
 
 if (!('encodeInto' in cachedTextEncoder)) {
-    cachedTextEncoder.encodeInto = function (arg, view) {
-        const buf = cachedTextEncoder.encode(arg);
-        view.set(buf);
-        return {
-            read: arg.length,
-            written: buf.length
-        };
-    }
+  cachedTextEncoder.encodeInto = function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+      read: arg.length,
+      written: buf.length,
+    };
+  };
 }
 
 function passStringToWasm0(arg, malloc, realloc) {
+  if (realloc === undefined) {
+    const buf = cachedTextEncoder.encode(arg);
+    const ptr = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory0()
+      .subarray(ptr, ptr + buf.length)
+      .set(buf);
+    WASM_VECTOR_LEN = buf.length;
+    return ptr;
+  }
 
-    if (realloc === undefined) {
-        const buf = cachedTextEncoder.encode(arg);
-        const ptr = malloc(buf.length, 1) >>> 0;
-        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
-        WASM_VECTOR_LEN = buf.length;
-        return ptr;
-    }
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
 
-    let len = arg.length;
-    let ptr = malloc(len, 1) >>> 0;
+  const mem = getUint8ArrayMemory0();
 
-    const mem = getUint8ArrayMemory0();
+  let offset = 0;
 
-    let offset = 0;
+  for (; offset < len; offset++) {
+    const code = arg.charCodeAt(offset);
+    if (code > 0x7f) break;
+    mem[ptr + offset] = code;
+  }
 
-    for (; offset < len; offset++) {
-        const code = arg.charCodeAt(offset);
-        if (code > 0x7F) break;
-        mem[ptr + offset] = code;
+  if (offset !== len) {
+    if (offset !== 0) {
+      arg = arg.slice(offset);
     }
+    ptr = realloc(ptr, len, (len = offset + arg.length * 3), 1) >>> 0;
+    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+    const ret = cachedTextEncoder.encodeInto(arg, view);
 
-    if (offset !== len) {
-        if (offset !== 0) {
-            arg = arg.slice(offset);
-        }
-        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
-        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
-        const ret = cachedTextEncoder.encodeInto(arg, view);
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
 
-        offset += ret.written;
-        ptr = realloc(ptr, len, offset, 1) >>> 0;
-    }
-
-    WASM_VECTOR_LEN = offset;
-    return ptr;
+  WASM_VECTOR_LEN = offset;
+  return ptr;
 }
 
 let cachedDataViewMemory0 = null;
 
 function getDataViewMemory0() {
-    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
-        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
-    }
-    return cachedDataViewMemory0;
+  if (
+    cachedDataViewMemory0 === null ||
+    cachedDataViewMemory0.buffer.detached === true ||
+    (cachedDataViewMemory0.buffer.detached === undefined &&
+      cachedDataViewMemory0.buffer !== wasm.memory.buffer)
+  ) {
+    cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+  }
+  return cachedDataViewMemory0;
 }
 
 function isLikeNone(x) {
-    return x === undefined || x === null;
+  return x === undefined || x === null;
 }
 
-export function start() {
-    wasm.start();
+function passArray8ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 1, 1) >>> 0;
+  getUint8ArrayMemory0().set(arg, ptr / 1);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
 }
 
 function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_export_2.get(idx);
-    wasm.__externref_table_dealloc(idx);
-    return value;
+  const value = wasm.__wbindgen_export_2.get(idx);
+  wasm.__externref_table_dealloc(idx);
+  return value;
 }
 
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1, 1) >>> 0;
-    getUint8ArrayMemory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
+export function start() {
+  wasm.start();
+}
+
+function _assertClass(instance, klass) {
+  if (!(instance instanceof klass)) {
+    throw new Error(`expected instance of ${klass.name}`);
+  }
 }
 /**
- * Generates user keys from a passphrase using password-based key derivation.
- * @param {string} passphrase
- * @returns {UserKeys}
+ * Decrypts data using AES-256-SIV authenticated encryption.
+ *
+ * # Parameters
+ *
+ * - `key`: The encryption key (64 bytes, must match encryption key)
+ * - `nonce`: The nonce (16 bytes, must match encryption nonce)
+ * - `ciphertext`: The encrypted data with authentication tag
+ * - `aad`: Additional authenticated data (must match encryption AAD)
+ *
+ * # Returns
+ *
+ * The decrypted plaintext, or `null` if authentication fails.
+ *
+ * # Security Notes
+ *
+ * - Returns `null` if:
+ *   - The ciphertext has been tampered with
+ *   - The wrong key or nonce is used
+ *   - The AAD doesn't match
+ * - Never ignore a decryption failure; it indicates tampering or corruption
+ *
+ * # Example
+ *
+ * ```javascript
+ * const plaintext = aead_decrypt(key, nonce, ciphertext, aad);
+ * if (plaintext) {
+ *     console.log("Decrypted:", new TextDecoder().decode(plaintext));
+ * } else {
+ *     console.error("Decryption failed - data may be corrupted or tampered");
+ * }
+ * ```
+ * @param {EncryptionKey} key
+ * @param {Nonce} nonce
+ * @param {Uint8Array} ciphertext
+ * @param {Uint8Array} aad
+ * @returns {Uint8Array | undefined}
  */
-export function generate_user_keys(passphrase) {
-    const ptr0 = passStringToWasm0(passphrase, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.generate_user_keys(ptr0, len0);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return UserKeys.__wrap(ret[0]);
+export function aead_decrypt(key, nonce, ciphertext, aad) {
+  _assertClass(key, EncryptionKey);
+  _assertClass(nonce, Nonce);
+  const ptr0 = passArray8ToWasm0(ciphertext, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passArray8ToWasm0(aad, wasm.__wbindgen_malloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ret = wasm.aead_decrypt(
+    key.__wbg_ptr,
+    nonce.__wbg_ptr,
+    ptr0,
+    len0,
+    ptr1,
+    len1
+  );
+  let v3;
+  if (ret[0] !== 0) {
+    v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+  }
+  return v3;
 }
 
-function _assertClass(instance, klass) {
-    if (!(instance instanceof klass)) {
-        throw new Error(`expected instance of ${klass.name}`);
-    }
-}
 /**
  * Encrypts data using AES-256-SIV authenticated encryption.
  *
@@ -191,70 +255,42 @@ function _assertClass(instance, klass) {
  * @returns {Uint8Array}
  */
 export function aead_encrypt(key, nonce, plaintext, aad) {
-    _assertClass(key, EncryptionKey);
-    _assertClass(nonce, Nonce);
-    const ptr0 = passArray8ToWasm0(plaintext, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(aad, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.aead_encrypt(key.__wbg_ptr, nonce.__wbg_ptr, ptr0, len0, ptr1, len1);
-    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v3;
+  _assertClass(key, EncryptionKey);
+  _assertClass(nonce, Nonce);
+  const ptr0 = passArray8ToWasm0(plaintext, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passArray8ToWasm0(aad, wasm.__wbindgen_malloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ret = wasm.aead_encrypt(
+    key.__wbg_ptr,
+    nonce.__wbg_ptr,
+    ptr0,
+    len0,
+    ptr1,
+    len1
+  );
+  var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+  wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+  return v3;
 }
 
 /**
- * Decrypts data using AES-256-SIV authenticated encryption.
- *
- * # Parameters
- *
- * - `key`: The encryption key (64 bytes, must match encryption key)
- * - `nonce`: The nonce (16 bytes, must match encryption nonce)
- * - `ciphertext`: The encrypted data with authentication tag
- * - `aad`: Additional authenticated data (must match encryption AAD)
- *
- * # Returns
- *
- * The decrypted plaintext, or `null` if authentication fails.
- *
- * # Security Notes
- *
- * - Returns `null` if:
- *   - The ciphertext has been tampered with
- *   - The wrong key or nonce is used
- *   - The AAD doesn't match
- * - Never ignore a decryption failure; it indicates tampering or corruption
- *
- * # Example
- *
- * ```javascript
- * const plaintext = aead_decrypt(key, nonce, ciphertext, aad);
- * if (plaintext) {
- *     console.log("Decrypted:", new TextDecoder().decode(plaintext));
- * } else {
- *     console.error("Decryption failed - data may be corrupted or tampered");
- * }
- * ```
- * @param {EncryptionKey} key
- * @param {Nonce} nonce
- * @param {Uint8Array} ciphertext
- * @param {Uint8Array} aad
- * @returns {Uint8Array | undefined}
+ * Generates user keys from a passphrase using password-based key derivation.
+ * @param {string} passphrase
+ * @returns {UserKeys}
  */
-export function aead_decrypt(key, nonce, ciphertext, aad) {
-    _assertClass(key, EncryptionKey);
-    _assertClass(nonce, Nonce);
-    const ptr0 = passArray8ToWasm0(ciphertext, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(aad, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.aead_decrypt(key.__wbg_ptr, nonce.__wbg_ptr, ptr0, len0, ptr1, len1);
-    let v3;
-    if (ret[0] !== 0) {
-        v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    }
-    return v3;
+export function generate_user_keys(passphrase) {
+  const ptr0 = passStringToWasm0(
+    passphrase,
+    wasm.__wbindgen_malloc,
+    wasm.__wbindgen_realloc
+  );
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.generate_user_keys(ptr0, len0);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return UserKeys.__wrap(ret[0]);
 }
 
 /**
@@ -262,159 +298,178 @@ export function aead_decrypt(key, nonce, ciphertext, aad) {
  * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6}
  */
 export const SessionStatus = Object.freeze({
-    Active: 0, "0": "Active",
-    UnknownPeer: 1, "1": "UnknownPeer",
-    NoSession: 2, "2": "NoSession",
-    PeerRequested: 3, "3": "PeerRequested",
-    SelfRequested: 4, "4": "SelfRequested",
-    Killed: 5, "5": "Killed",
-    Saturated: 6, "6": "Saturated",
+  Active: 0,
+  0: 'Active',
+  UnknownPeer: 1,
+  1: 'UnknownPeer',
+  NoSession: 2,
+  2: 'NoSession',
+  PeerRequested: 3,
+  3: 'PeerRequested',
+  SelfRequested: 4,
+  4: 'SelfRequested',
+  Killed: 5,
+  5: 'Killed',
+  Saturated: 6,
+  6: 'Saturated',
 });
 
-const AnnouncementResultFinalization = (typeof FinalizationRegistry === 'undefined')
+const AnnouncementResultFinalization =
+  typeof FinalizationRegistry === 'undefined'
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_announcementresult_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr =>
+        wasm.__wbg_announcementresult_free(ptr >>> 0, 1)
+      );
 /**
  * Result from feeding an incoming announcement.
  */
 export class AnnouncementResult {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(AnnouncementResult.prototype);
-        obj.__wbg_ptr = ptr;
-        AnnouncementResultFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        AnnouncementResultFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_announcementresult_free(ptr, 0);
-    }
-    /**
-     * Gets the announcer's public keys.
-     * @returns {UserPublicKeys}
-     */
-    get announcer_public_keys() {
-        const ret = wasm.announcementresult_announcer_public_keys(this.__wbg_ptr);
-        return UserPublicKeys.__wrap(ret);
-    }
-    /**
-     * Gets the announcement timestamp in milliseconds since Unix epoch.
-     * @returns {number}
-     */
-    get timestamp() {
-        const ret = wasm.announcementresult_timestamp(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Gets the user data embedded in the announcement.
-     * @returns {Uint8Array}
-     */
-    get user_data() {
-        const ret = wasm.announcementresult_user_data(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(AnnouncementResult.prototype);
+    obj.__wbg_ptr = ptr;
+    AnnouncementResultFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    AnnouncementResultFinalization.unregister(this);
+    return ptr;
+  }
+
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_announcementresult_free(ptr, 0);
+  }
+  /**
+   * Gets the announcer's public keys.
+   * @returns {UserPublicKeys}
+   */
+  get announcer_public_keys() {
+    const ret = wasm.announcementresult_announcer_public_keys(this.__wbg_ptr);
+    return UserPublicKeys.__wrap(ret);
+  }
+  /**
+   * Gets the announcement timestamp in milliseconds since Unix epoch.
+   * @returns {number}
+   */
+  get timestamp() {
+    const ret = wasm.announcementresult_timestamp(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * Gets the user data embedded in the announcement.
+   * @returns {Uint8Array}
+   */
+  get user_data() {
+    const ret = wasm.announcementresult_user_data(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
 }
-if (Symbol.dispose) AnnouncementResult.prototype[Symbol.dispose] = AnnouncementResult.prototype.free;
+if (Symbol.dispose)
+  AnnouncementResult.prototype[Symbol.dispose] =
+    AnnouncementResult.prototype.free;
 
-const EncryptionKeyFinalization = (typeof FinalizationRegistry === 'undefined')
+const EncryptionKeyFinalization =
+  typeof FinalizationRegistry === 'undefined'
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_encryptionkey_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr =>
+        wasm.__wbg_encryptionkey_free(ptr >>> 0, 1)
+      );
 /**
  * Encryption key for AEAD operations (AES-256-SIV).
  *
  * AES-256-SIV uses a 64-byte (512-bit) key: two 256-bit keys for encryption and MAC.
  */
 export class EncryptionKey {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(EncryptionKey.prototype);
-        obj.__wbg_ptr = ptr;
-        EncryptionKeyFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        EncryptionKeyFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_encryptionkey_free(ptr, 0);
-    }
-    /**
-     * Generates a new random encryption key (64 bytes).
-     * @returns {EncryptionKey}
-     */
-    static generate() {
-        const ret = wasm.encryptionkey_generate();
-        return EncryptionKey.__wrap(ret);
-    }
-    /**
-     * Generates a deterministic encryption key (64 bytes) from a seed and salt.
-     *
-     * Uses Argon2id via `crypto_password_kdf` to derive a 64-byte key suitable for
-     * AES-256-SIV (which requires 64 bytes: 2×256-bit keys).
-     *
-     * - `seed`: application-provided seed string (treat like a password)
-     * - `salt`: unique, random salt (minimum 8 bytes, recommended 16+ bytes)
-     * @param {string} seed
-     * @param {Uint8Array} salt
-     * @returns {EncryptionKey}
-     */
-    static from_seed(seed, salt) {
-        const ptr0 = passStringToWasm0(seed, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArray8ToWasm0(salt, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.encryptionkey_from_seed(ptr0, len0, ptr1, len1);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return EncryptionKey.__wrap(ret[0]);
-    }
-    /**
-     * Creates an encryption key from raw bytes (must be 64 bytes).
-     * @param {Uint8Array} bytes
-     * @returns {EncryptionKey}
-     */
-    static from_bytes(bytes) {
-        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.encryptionkey_from_bytes(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return EncryptionKey.__wrap(ret[0]);
-    }
-    /**
-     * Gets the raw bytes of the encryption key.
-     * @returns {Uint8Array}
-     */
-    to_bytes() {
-        const ret = wasm.encryptionkey_to_bytes(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(EncryptionKey.prototype);
+    obj.__wbg_ptr = ptr;
+    EncryptionKeyFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    EncryptionKeyFinalization.unregister(this);
+    return ptr;
+  }
+
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_encryptionkey_free(ptr, 0);
+  }
+  /**
+   * Creates an encryption key from raw bytes (must be 64 bytes).
+   * @param {Uint8Array} bytes
+   * @returns {EncryptionKey}
+   */
+  static from_bytes(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.encryptionkey_from_bytes(ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return EncryptionKey.__wrap(ret[0]);
+  }
+  /**
+   * Generates a new random encryption key (64 bytes).
+   * @returns {EncryptionKey}
+   */
+  static generate() {
+    const ret = wasm.encryptionkey_generate();
+    return EncryptionKey.__wrap(ret);
+  }
+  /**
+   * Gets the raw bytes of the encryption key.
+   * @returns {Uint8Array}
+   */
+  to_bytes() {
+    const ret = wasm.encryptionkey_to_bytes(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * Generates a deterministic encryption key (64 bytes) from a seed and salt.
+   *
+   * Uses Argon2id via `crypto_password_kdf` to derive a 64-byte key suitable for
+   * AES-256-SIV (which requires 64 bytes: 2×256-bit keys).
+   *
+   * - `seed`: application-provided seed string (treat like a password)
+   * - `salt`: unique, random salt (minimum 8 bytes, recommended 16+ bytes)
+   * @param {string} seed
+   * @param {Uint8Array} salt
+   * @returns {EncryptionKey}
+   */
+  static from_seed(seed, salt) {
+    const ptr0 = passStringToWasm0(
+      seed,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc
+    );
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(salt, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.encryptionkey_from_seed(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
     }
+    return EncryptionKey.__wrap(ret[0]);
+  }
 }
-if (Symbol.dispose) EncryptionKey.prototype[Symbol.dispose] = EncryptionKey.prototype.free;
+if (Symbol.dispose)
+  EncryptionKey.prototype[Symbol.dispose] = EncryptionKey.prototype.free;
 
-const NonceFinalization = (typeof FinalizationRegistry === 'undefined')
+const NonceFinalization =
+  typeof FinalizationRegistry === 'undefined'
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_nonce_free(ptr >>> 0, 1));
 /**
@@ -424,975 +479,1078 @@ const NonceFinalization = (typeof FinalizationRegistry === 'undefined')
  * per encryption for maximum security, though SIV mode is nonce-misuse resistant.
  */
 export class Nonce {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Nonce.prototype);
-        obj.__wbg_ptr = ptr;
-        NonceFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        NonceFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_nonce_free(ptr, 0);
-    }
-    /**
-     * Generates a new random nonce (16 bytes).
-     * @returns {Nonce}
-     */
-    static generate() {
-        const ret = wasm.nonce_generate();
-        return Nonce.__wrap(ret);
-    }
-    /**
-     * Creates a nonce from raw bytes (must be 16 bytes).
-     * @param {Uint8Array} bytes
-     * @returns {Nonce}
-     */
-    static from_bytes(bytes) {
-        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.nonce_from_bytes(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Nonce.__wrap(ret[0]);
-    }
-    /**
-     * Gets the raw bytes of the nonce.
-     * @returns {Uint8Array}
-     */
-    to_bytes() {
-        const ret = wasm.nonce_to_bytes(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(Nonce.prototype);
+    obj.__wbg_ptr = ptr;
+    NonceFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    NonceFinalization.unregister(this);
+    return ptr;
+  }
+
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_nonce_free(ptr, 0);
+  }
+  /**
+   * Creates a nonce from raw bytes (must be 16 bytes).
+   * @param {Uint8Array} bytes
+   * @returns {Nonce}
+   */
+  static from_bytes(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.nonce_from_bytes(ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return Nonce.__wrap(ret[0]);
+  }
+  /**
+   * Generates a new random nonce (16 bytes).
+   * @returns {Nonce}
+   */
+  static generate() {
+    const ret = wasm.nonce_generate();
+    return Nonce.__wrap(ret);
+  }
+  /**
+   * Gets the raw bytes of the nonce.
+   * @returns {Uint8Array}
+   */
+  to_bytes() {
+    const ret = wasm.nonce_to_bytes(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
 }
 if (Symbol.dispose) Nonce.prototype[Symbol.dispose] = Nonce.prototype.free;
 
-const ReceiveMessageOutputFinalization = (typeof FinalizationRegistry === 'undefined')
+const ReceiveMessageOutputFinalization =
+  typeof FinalizationRegistry === 'undefined'
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_receivemessageoutput_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr =>
+        wasm.__wbg_receivemessageoutput_free(ptr >>> 0, 1)
+      );
 /**
  * Output from receiving a message.
  */
 export class ReceiveMessageOutput {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(ReceiveMessageOutput.prototype);
-        obj.__wbg_ptr = ptr;
-        ReceiveMessageOutputFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        ReceiveMessageOutputFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_receivemessageoutput_free(ptr, 0);
-    }
-    /**
-     * Gets the received message contents.
-     * @returns {Uint8Array}
-     */
-    get message() {
-        const ret = wasm.receivemessageoutput_message(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-    /**
-     * Gets the message timestamp (milliseconds since Unix epoch).
-     * @returns {number}
-     */
-    get timestamp() {
-        const ret = wasm.receivemessageoutput_timestamp(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Gets the list of newly acknowledged seekers.
-     * @returns {Array<any>}
-     */
-    get acknowledged_seekers() {
-        const ret = wasm.receivemessageoutput_acknowledged_seekers(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Gets the sender's user id (32 bytes).
-     * @returns {Uint8Array}
-     */
-    get user_id() {
-        const ret = wasm.receivemessageoutput_user_id(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(ReceiveMessageOutput.prototype);
+    obj.__wbg_ptr = ptr;
+    ReceiveMessageOutputFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    ReceiveMessageOutputFinalization.unregister(this);
+    return ptr;
+  }
+
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_receivemessageoutput_free(ptr, 0);
+  }
+  /**
+   * Gets the list of newly acknowledged seekers.
+   * @returns {Array<any>}
+   */
+  get acknowledged_seekers() {
+    const ret = wasm.receivemessageoutput_acknowledged_seekers(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * Gets the received message contents.
+   * @returns {Uint8Array}
+   */
+  get message() {
+    const ret = wasm.receivemessageoutput_message(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * Gets the sender's user id (32 bytes).
+   * @returns {Uint8Array}
+   */
+  get user_id() {
+    const ret = wasm.receivemessageoutput_user_id(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * Gets the message timestamp (milliseconds since Unix epoch).
+   * @returns {number}
+   */
+  get timestamp() {
+    const ret = wasm.receivemessageoutput_timestamp(this.__wbg_ptr);
+    return ret;
+  }
 }
-if (Symbol.dispose) ReceiveMessageOutput.prototype[Symbol.dispose] = ReceiveMessageOutput.prototype.free;
+if (Symbol.dispose)
+  ReceiveMessageOutput.prototype[Symbol.dispose] =
+    ReceiveMessageOutput.prototype.free;
 
-const SendMessageOutputFinalization = (typeof FinalizationRegistry === 'undefined')
+const SendMessageOutputFinalization =
+  typeof FinalizationRegistry === 'undefined'
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_sendmessageoutput_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr =>
+        wasm.__wbg_sendmessageoutput_free(ptr >>> 0, 1)
+      );
 /**
  * Output from sending a message.
  */
 export class SendMessageOutput {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(SendMessageOutput.prototype);
-        obj.__wbg_ptr = ptr;
-        SendMessageOutputFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        SendMessageOutputFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_sendmessageoutput_free(ptr, 0);
-    }
-    /**
-     * Gets the seeker (identifier for message board lookup).
-     * @returns {Uint8Array}
-     */
-    get seeker() {
-        const ret = wasm.sendmessageoutput_seeker(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-    /**
-     * Gets the encrypted message data.
-     * @returns {Uint8Array}
-     */
-    get data() {
-        const ret = wasm.sendmessageoutput_data(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(SendMessageOutput.prototype);
+    obj.__wbg_ptr = ptr;
+    SendMessageOutputFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    SendMessageOutputFinalization.unregister(this);
+    return ptr;
+  }
+
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_sendmessageoutput_free(ptr, 0);
+  }
+  /**
+   * Gets the encrypted message data.
+   * @returns {Uint8Array}
+   */
+  get data() {
+    const ret = wasm.sendmessageoutput_data(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * Gets the seeker (identifier for message board lookup).
+   * @returns {Uint8Array}
+   */
+  get seeker() {
+    const ret = wasm.sendmessageoutput_seeker(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
 }
-if (Symbol.dispose) SendMessageOutput.prototype[Symbol.dispose] = SendMessageOutput.prototype.free;
+if (Symbol.dispose)
+  SendMessageOutput.prototype[Symbol.dispose] =
+    SendMessageOutput.prototype.free;
 
-const SessionConfigFinalization = (typeof FinalizationRegistry === 'undefined')
+const SessionConfigFinalization =
+  typeof FinalizationRegistry === 'undefined'
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_sessionconfig_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr =>
+        wasm.__wbg_sessionconfig_free(ptr >>> 0, 1)
+      );
 /**
  * Session manager configuration for controlling session behavior.
  */
 export class SessionConfig {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(SessionConfig.prototype);
-        obj.__wbg_ptr = ptr;
-        SessionConfigFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        SessionConfigFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_sessionconfig_free(ptr, 0);
-    }
-    /**
-     * Creates a new session configuration with the given parameters.
-     * @param {number} max_incoming_announcement_age_millis
-     * @param {number} max_incoming_announcement_future_millis
-     * @param {number} max_incoming_message_age_millis
-     * @param {number} max_incoming_message_future_millis
-     * @param {number} max_session_inactivity_millis
-     * @param {number} keep_alive_interval_millis
-     * @param {bigint} max_session_lag_length
-     */
-    constructor(max_incoming_announcement_age_millis, max_incoming_announcement_future_millis, max_incoming_message_age_millis, max_incoming_message_future_millis, max_session_inactivity_millis, keep_alive_interval_millis, max_session_lag_length) {
-        const ret = wasm.sessionconfig_new(max_incoming_announcement_age_millis, max_incoming_announcement_future_millis, max_incoming_message_age_millis, max_incoming_message_future_millis, max_session_inactivity_millis, keep_alive_interval_millis, max_session_lag_length);
-        this.__wbg_ptr = ret >>> 0;
-        SessionConfigFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * Creates a default configuration with sensible defaults:
-     * - Announcement age: 1 week
-     * - Announcement future: 1 minute
-     * - Message age: 1 week
-     * - Message future: 1 minute
-     * - Session inactivity: 1 week
-     * - Keep-alive interval: 1 day
-     * - Max lag: 10000 messages
-     * @returns {SessionConfig}
-     */
-    static new_default() {
-        const ret = wasm.sessionconfig_new_default();
-        return SessionConfig.__wrap(ret);
-    }
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(SessionConfig.prototype);
+    obj.__wbg_ptr = ptr;
+    SessionConfigFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    SessionConfigFinalization.unregister(this);
+    return ptr;
+  }
+
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_sessionconfig_free(ptr, 0);
+  }
+  /**
+   * Creates a default configuration with sensible defaults:
+   * - Announcement age: 1 week
+   * - Announcement future: 1 minute
+   * - Message age: 1 week
+   * - Message future: 1 minute
+   * - Session inactivity: 1 week
+   * - Keep-alive interval: 1 day
+   * - Max lag: 10000 messages
+   * @returns {SessionConfig}
+   */
+  static new_default() {
+    const ret = wasm.sessionconfig_new_default();
+    return SessionConfig.__wrap(ret);
+  }
+  /**
+   * Creates a new session configuration with the given parameters.
+   * @param {number} max_incoming_announcement_age_millis
+   * @param {number} max_incoming_announcement_future_millis
+   * @param {number} max_incoming_message_age_millis
+   * @param {number} max_incoming_message_future_millis
+   * @param {number} max_session_inactivity_millis
+   * @param {number} keep_alive_interval_millis
+   * @param {bigint} max_session_lag_length
+   */
+  constructor(
+    max_incoming_announcement_age_millis,
+    max_incoming_announcement_future_millis,
+    max_incoming_message_age_millis,
+    max_incoming_message_future_millis,
+    max_session_inactivity_millis,
+    keep_alive_interval_millis,
+    max_session_lag_length
+  ) {
+    const ret = wasm.sessionconfig_new(
+      max_incoming_announcement_age_millis,
+      max_incoming_announcement_future_millis,
+      max_incoming_message_age_millis,
+      max_incoming_message_future_millis,
+      max_session_inactivity_millis,
+      keep_alive_interval_millis,
+      max_session_lag_length
+    );
+    this.__wbg_ptr = ret >>> 0;
+    SessionConfigFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
 }
-if (Symbol.dispose) SessionConfig.prototype[Symbol.dispose] = SessionConfig.prototype.free;
+if (Symbol.dispose)
+  SessionConfig.prototype[Symbol.dispose] = SessionConfig.prototype.free;
 
-const SessionManagerWrapperFinalization = (typeof FinalizationRegistry === 'undefined')
+const SessionManagerWrapperFinalization =
+  typeof FinalizationRegistry === 'undefined'
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_sessionmanagerwrapper_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr =>
+        wasm.__wbg_sessionmanagerwrapper_free(ptr >>> 0, 1)
+      );
 /**
  * Session manager wrapper for WebAssembly.
  */
 export class SessionManagerWrapper {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(SessionManagerWrapper.prototype);
-        obj.__wbg_ptr = ptr;
-        SessionManagerWrapperFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        SessionManagerWrapperFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_sessionmanagerwrapper_free(ptr, 0);
-    }
-    /**
-     * Creates a new session manager with the given configuration.
-     * @param {SessionConfig} config
-     */
-    constructor(config) {
-        _assertClass(config, SessionConfig);
-        var ptr0 = config.__destroy_into_raw();
-        const ret = wasm.sessionmanagerwrapper_new(ptr0);
-        this.__wbg_ptr = ret >>> 0;
-        SessionManagerWrapperFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * Deserializes a session manager from an encrypted blob.
-     * @param {Uint8Array} encrypted_blob
-     * @param {EncryptionKey} key
-     * @returns {SessionManagerWrapper}
-     */
-    static from_encrypted_blob(encrypted_blob, key) {
-        const ptr0 = passArray8ToWasm0(encrypted_blob, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        _assertClass(key, EncryptionKey);
-        const ret = wasm.sessionmanagerwrapper_from_encrypted_blob(ptr0, len0, key.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return SessionManagerWrapper.__wrap(ret[0]);
-    }
-    /**
-     * Serializes and encrypts the session manager into a blob.
-     * @param {EncryptionKey} key
-     * @returns {Uint8Array}
-     */
-    to_encrypted_blob(key) {
-        _assertClass(key, EncryptionKey);
-        const ret = wasm.sessionmanagerwrapper_to_encrypted_blob(this.__wbg_ptr, key.__wbg_ptr);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-    /**
-     * Establishes an outgoing session with a peer.
-     *
-     * # Parameters
-     *
-     * - `peer_pk`: The peer's public keys
-     * - `our_pk`: Our public keys
-     * - `our_sk`: Our secret keys
-     * - `user_data`: Arbitrary user data to include in the announcement (can be empty)
-     *
-     * # Security Warning
-     *
-     * **The user_data in announcements has reduced security compared to regular messages:**
-     * - ✅ **Plausible deniability preserved**: The user_data is not cryptographically signed,
-     *   so you can deny having sent specific user_data content (though you cannot deny the
-     *   announcement itself).
-     * - ❌ **No post-compromise secrecy**: If your long-term keys are compromised in the
-     *   future, past announcements (including their user_data) can be decrypted.
-     *
-     * **Recommendation**: Avoid including highly sensitive information in user_data. Use it for
-     * metadata like protocol version, public display names, or capability flags. Send truly
-     * sensitive data through regular messages after the session is established.
-     *
-     * # Returns
-     *
-     * The announcement bytes to publish to the blockchain.
-     * @param {UserPublicKeys} peer_pk
-     * @param {UserPublicKeys} our_pk
-     * @param {UserSecretKeys} our_sk
-     * @param {Uint8Array} user_data
-     * @returns {Uint8Array}
-     */
-    establish_outgoing_session(peer_pk, our_pk, our_sk, user_data) {
-        _assertClass(peer_pk, UserPublicKeys);
-        _assertClass(our_pk, UserPublicKeys);
-        _assertClass(our_sk, UserSecretKeys);
-        const ptr0 = passArray8ToWasm0(user_data, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.sessionmanagerwrapper_establish_outgoing_session(this.__wbg_ptr, peer_pk.__wbg_ptr, our_pk.__wbg_ptr, our_sk.__wbg_ptr, ptr0, len0);
-        var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v2;
-    }
-    /**
-     * Feeds an incoming announcement from the blockchain.
-     *
-     * # Parameters
-     *
-     * - `announcement_bytes`: The raw announcement bytes received from the blockchain
-     * - `our_pk`: Our public keys
-     * - `our_sk`: Our secret keys
-     *
-     * # Returns
-     *
-     * If the announcement is valid, returns an `AnnouncementResult` containing:
-     * - The announcer's public keys
-     * - The timestamp when the announcement was created (milliseconds since Unix epoch)
-     * - The user data embedded in the announcement
-     *
-     * Returns `None` if the announcement is invalid or too old.
-     *
-     * # Security Warning
-     *
-     * **The user_data in announcements has reduced security compared to regular messages:**
-     * - ✅ **Plausible deniability preserved**: The user_data is not cryptographically signed,
-     *   so the sender can deny having sent specific user_data content (though they cannot deny
-     *   the announcement itself).
-     * - ❌ **No post-compromise secrecy**: If the sender's long-term keys are compromised
-     *   in the future, all past announcements (including their user_data) can be decrypted.
-     *
-     * **Recommendation**: Treat user_data as having limited confidentiality. Use it for
-     * metadata that is not highly sensitive. Send truly sensitive information through regular
-     * messages after the session is established.
-     * @param {Uint8Array} announcement_bytes
-     * @param {UserPublicKeys} our_pk
-     * @param {UserSecretKeys} our_sk
-     * @returns {AnnouncementResult | undefined}
-     */
-    feed_incoming_announcement(announcement_bytes, our_pk, our_sk) {
-        const ptr0 = passArray8ToWasm0(announcement_bytes, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        _assertClass(our_pk, UserPublicKeys);
-        _assertClass(our_sk, UserSecretKeys);
-        const ret = wasm.sessionmanagerwrapper_feed_incoming_announcement(this.__wbg_ptr, ptr0, len0, our_pk.__wbg_ptr, our_sk.__wbg_ptr);
-        return ret === 0 ? undefined : AnnouncementResult.__wrap(ret);
-    }
-    /**
-     * Gets the list of message board seekers to monitor.
-     * @returns {Array<any>}
-     */
-    get_message_board_read_keys() {
-        const ret = wasm.sessionmanagerwrapper_get_message_board_read_keys(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Sends a message to a peer.
-     * @param {Uint8Array} peer_id
-     * @param {Uint8Array} message_contents
-     * @returns {SendMessageOutput | undefined}
-     */
-    send_message(peer_id, message_contents) {
-        const ptr0 = passArray8ToWasm0(peer_id, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArray8ToWasm0(message_contents, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.sessionmanagerwrapper_send_message(this.__wbg_ptr, ptr0, len0, ptr1, len1);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0] === 0 ? undefined : SendMessageOutput.__wrap(ret[0]);
-    }
-    /**
-     * Processes an incoming message from the message board.
-     * @param {Uint8Array} seeker
-     * @param {Uint8Array} ciphertext
-     * @param {UserSecretKeys} our_sk
-     * @returns {ReceiveMessageOutput | undefined}
-     */
-    feed_incoming_message_board_read(seeker, ciphertext, our_sk) {
-        const ptr0 = passArray8ToWasm0(seeker, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArray8ToWasm0(ciphertext, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        _assertClass(our_sk, UserSecretKeys);
-        const ret = wasm.sessionmanagerwrapper_feed_incoming_message_board_read(this.__wbg_ptr, ptr0, len0, ptr1, len1, our_sk.__wbg_ptr);
-        return ret === 0 ? undefined : ReceiveMessageOutput.__wrap(ret);
-    }
-    /**
-     * Gets the list of all peer IDs.
-     * @returns {Array<any>}
-     */
-    peer_list() {
-        const ret = wasm.sessionmanagerwrapper_peer_list(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Gets the session status for a peer.
-     * @param {Uint8Array} peer_id
-     * @returns {SessionStatus}
-     */
-    peer_session_status(peer_id) {
-        const ptr0 = passArray8ToWasm0(peer_id, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.sessionmanagerwrapper_peer_session_status(this.__wbg_ptr, ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0];
-    }
-    /**
-     * Discards a peer and all associated session state.
-     * @param {Uint8Array} peer_id
-     */
-    peer_discard(peer_id) {
-        const ptr0 = passArray8ToWasm0(peer_id, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.sessionmanagerwrapper_peer_discard(this.__wbg_ptr, ptr0, len0);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
-    }
-    /**
-     * Refreshes sessions and returns peer IDs that need keep-alive messages.
-     * @returns {Array<any>}
-     */
-    refresh() {
-        const ret = wasm.sessionmanagerwrapper_refresh(this.__wbg_ptr);
-        return ret;
-    }
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(SessionManagerWrapper.prototype);
+    obj.__wbg_ptr = ptr;
+    SessionManagerWrapperFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    SessionManagerWrapperFinalization.unregister(this);
+    return ptr;
+  }
+
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_sessionmanagerwrapper_free(ptr, 0);
+  }
+  /**
+   * Discards a peer and all associated session state.
+   * @param {Uint8Array} peer_id
+   */
+  peer_discard(peer_id) {
+    const ptr0 = passArray8ToWasm0(peer_id, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.sessionmanagerwrapper_peer_discard(
+      this.__wbg_ptr,
+      ptr0,
+      len0
+    );
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * Sends a message to a peer.
+   * @param {Uint8Array} peer_id
+   * @param {Uint8Array} message_contents
+   * @returns {SendMessageOutput | undefined}
+   */
+  send_message(peer_id, message_contents) {
+    const ptr0 = passArray8ToWasm0(peer_id, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(message_contents, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.sessionmanagerwrapper_send_message(
+      this.__wbg_ptr,
+      ptr0,
+      len0,
+      ptr1,
+      len1
+    );
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0] === 0 ? undefined : SendMessageOutput.__wrap(ret[0]);
+  }
+  /**
+   * Serializes and encrypts the session manager into a blob.
+   * @param {EncryptionKey} key
+   * @returns {Uint8Array}
+   */
+  to_encrypted_blob(key) {
+    _assertClass(key, EncryptionKey);
+    const ret = wasm.sessionmanagerwrapper_to_encrypted_blob(
+      this.__wbg_ptr,
+      key.__wbg_ptr
+    );
+    if (ret[3]) {
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * Deserializes a session manager from an encrypted blob.
+   * @param {Uint8Array} encrypted_blob
+   * @param {EncryptionKey} key
+   * @returns {SessionManagerWrapper}
+   */
+  static from_encrypted_blob(encrypted_blob, key) {
+    const ptr0 = passArray8ToWasm0(encrypted_blob, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    _assertClass(key, EncryptionKey);
+    const ret = wasm.sessionmanagerwrapper_from_encrypted_blob(
+      ptr0,
+      len0,
+      key.__wbg_ptr
+    );
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return SessionManagerWrapper.__wrap(ret[0]);
+  }
+  /**
+   * Gets the session status for a peer.
+   * @param {Uint8Array} peer_id
+   * @returns {SessionStatus}
+   */
+  peer_session_status(peer_id) {
+    const ptr0 = passArray8ToWasm0(peer_id, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.sessionmanagerwrapper_peer_session_status(
+      this.__wbg_ptr,
+      ptr0,
+      len0
+    );
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0];
+  }
+  /**
+   * Establishes an outgoing session with a peer.
+   *
+   * # Parameters
+   *
+   * - `peer_pk`: The peer's public keys
+   * - `our_pk`: Our public keys
+   * - `our_sk`: Our secret keys
+   * - `user_data`: Arbitrary user data to include in the announcement (can be empty)
+   *
+   * # Security Warning
+   *
+   * **The user_data in announcements has reduced security compared to regular messages:**
+   * - ✅ **Plausible deniability preserved**: The user_data is not cryptographically signed,
+   *   so you can deny having sent specific user_data content (though you cannot deny the
+   *   announcement itself).
+   * - ❌ **No post-compromise secrecy**: If your long-term keys are compromised in the
+   *   future, past announcements (including their user_data) can be decrypted.
+   *
+   * **Recommendation**: Avoid including highly sensitive information in user_data. Use it for
+   * metadata like protocol version, public display names, or capability flags. Send truly
+   * sensitive data through regular messages after the session is established.
+   *
+   * # Returns
+   *
+   * The announcement bytes to publish to the blockchain.
+   * @param {UserPublicKeys} peer_pk
+   * @param {UserPublicKeys} our_pk
+   * @param {UserSecretKeys} our_sk
+   * @param {Uint8Array} user_data
+   * @returns {Uint8Array}
+   */
+  establish_outgoing_session(peer_pk, our_pk, our_sk, user_data) {
+    _assertClass(peer_pk, UserPublicKeys);
+    _assertClass(our_pk, UserPublicKeys);
+    _assertClass(our_sk, UserSecretKeys);
+    const ptr0 = passArray8ToWasm0(user_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.sessionmanagerwrapper_establish_outgoing_session(
+      this.__wbg_ptr,
+      peer_pk.__wbg_ptr,
+      our_pk.__wbg_ptr,
+      our_sk.__wbg_ptr,
+      ptr0,
+      len0
+    );
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+  }
+  /**
+   * Feeds an incoming announcement from the blockchain.
+   *
+   * # Parameters
+   *
+   * - `announcement_bytes`: The raw announcement bytes received from the blockchain
+   * - `our_pk`: Our public keys
+   * - `our_sk`: Our secret keys
+   *
+   * # Returns
+   *
+   * If the announcement is valid, returns an `AnnouncementResult` containing:
+   * - The announcer's public keys
+   * - The timestamp when the announcement was created (milliseconds since Unix epoch)
+   * - The user data embedded in the announcement
+   *
+   * Returns `None` if the announcement is invalid or too old.
+   *
+   * # Security Warning
+   *
+   * **The user_data in announcements has reduced security compared to regular messages:**
+   * - ✅ **Plausible deniability preserved**: The user_data is not cryptographically signed,
+   *   so the sender can deny having sent specific user_data content (though they cannot deny
+   *   the announcement itself).
+   * - ❌ **No post-compromise secrecy**: If the sender's long-term keys are compromised
+   *   in the future, all past announcements (including their user_data) can be decrypted.
+   *
+   * **Recommendation**: Treat user_data as having limited confidentiality. Use it for
+   * metadata that is not highly sensitive. Send truly sensitive information through regular
+   * messages after the session is established.
+   * @param {Uint8Array} announcement_bytes
+   * @param {UserPublicKeys} our_pk
+   * @param {UserSecretKeys} our_sk
+   * @returns {AnnouncementResult | undefined}
+   */
+  feed_incoming_announcement(announcement_bytes, our_pk, our_sk) {
+    const ptr0 = passArray8ToWasm0(announcement_bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    _assertClass(our_pk, UserPublicKeys);
+    _assertClass(our_sk, UserSecretKeys);
+    const ret = wasm.sessionmanagerwrapper_feed_incoming_announcement(
+      this.__wbg_ptr,
+      ptr0,
+      len0,
+      our_pk.__wbg_ptr,
+      our_sk.__wbg_ptr
+    );
+    return ret === 0 ? undefined : AnnouncementResult.__wrap(ret);
+  }
+  /**
+   * Gets the list of message board seekers to monitor.
+   * @returns {Array<any>}
+   */
+  get_message_board_read_keys() {
+    const ret = wasm.sessionmanagerwrapper_get_message_board_read_keys(
+      this.__wbg_ptr
+    );
+    return ret;
+  }
+  /**
+   * Processes an incoming message from the message board.
+   * @param {Uint8Array} seeker
+   * @param {Uint8Array} ciphertext
+   * @param {UserSecretKeys} our_sk
+   * @returns {ReceiveMessageOutput | undefined}
+   */
+  feed_incoming_message_board_read(seeker, ciphertext, our_sk) {
+    const ptr0 = passArray8ToWasm0(seeker, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(ciphertext, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    _assertClass(our_sk, UserSecretKeys);
+    const ret = wasm.sessionmanagerwrapper_feed_incoming_message_board_read(
+      this.__wbg_ptr,
+      ptr0,
+      len0,
+      ptr1,
+      len1,
+      our_sk.__wbg_ptr
+    );
+    return ret === 0 ? undefined : ReceiveMessageOutput.__wrap(ret);
+  }
+  /**
+   * Creates a new session manager with the given configuration.
+   * @param {SessionConfig} config
+   */
+  constructor(config) {
+    _assertClass(config, SessionConfig);
+    var ptr0 = config.__destroy_into_raw();
+    const ret = wasm.sessionmanagerwrapper_new(ptr0);
+    this.__wbg_ptr = ret >>> 0;
+    SessionManagerWrapperFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * Refreshes sessions and returns peer IDs that need keep-alive messages.
+   * @returns {Array<any>}
+   */
+  refresh() {
+    const ret = wasm.sessionmanagerwrapper_refresh(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * Gets the list of all peer IDs.
+   * @returns {Array<any>}
+   */
+  peer_list() {
+    const ret = wasm.sessionmanagerwrapper_peer_list(this.__wbg_ptr);
+    return ret;
+  }
 }
-if (Symbol.dispose) SessionManagerWrapper.prototype[Symbol.dispose] = SessionManagerWrapper.prototype.free;
+if (Symbol.dispose)
+  SessionManagerWrapper.prototype[Symbol.dispose] =
+    SessionManagerWrapper.prototype.free;
 
-const UserKeysFinalization = (typeof FinalizationRegistry === 'undefined')
+const UserKeysFinalization =
+  typeof FinalizationRegistry === 'undefined'
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_userkeys_free(ptr >>> 0, 1));
 /**
  * User keypair containing both public and secret keys.
  */
 export class UserKeys {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(UserKeys.prototype);
-        obj.__wbg_ptr = ptr;
-        UserKeysFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        UserKeysFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_userkeys_free(ptr, 0);
-    }
-    /**
-     * Gets the public keys.
-     * @returns {UserPublicKeys}
-     */
-    public_keys() {
-        const ret = wasm.userkeys_public_keys(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return UserPublicKeys.__wrap(ret[0]);
-    }
-    /**
-     * Gets the secret keys.
-     * @returns {UserSecretKeys}
-     */
-    secret_keys() {
-        const ret = wasm.userkeys_secret_keys(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return UserSecretKeys.__wrap(ret[0]);
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(UserKeys.prototype);
+    obj.__wbg_ptr = ptr;
+    UserKeysFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    UserKeysFinalization.unregister(this);
+    return ptr;
+  }
+
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_userkeys_free(ptr, 0);
+  }
+  /**
+   * Gets the public keys.
+   * @returns {UserPublicKeys}
+   */
+  public_keys() {
+    const ret = wasm.userkeys_public_keys(this.__wbg_ptr);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return UserPublicKeys.__wrap(ret[0]);
+  }
+  /**
+   * Gets the secret keys.
+   * @returns {UserSecretKeys}
+   */
+  secret_keys() {
+    const ret = wasm.userkeys_secret_keys(this.__wbg_ptr);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
     }
+    return UserSecretKeys.__wrap(ret[0]);
+  }
 }
-if (Symbol.dispose) UserKeys.prototype[Symbol.dispose] = UserKeys.prototype.free;
+if (Symbol.dispose)
+  UserKeys.prototype[Symbol.dispose] = UserKeys.prototype.free;
 
-const UserPublicKeysFinalization = (typeof FinalizationRegistry === 'undefined')
+const UserPublicKeysFinalization =
+  typeof FinalizationRegistry === 'undefined'
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_userpublickeys_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr =>
+        wasm.__wbg_userpublickeys_free(ptr >>> 0, 1)
+      );
 /**
  * User public keys for authentication and encryption.
  */
 export class UserPublicKeys {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(UserPublicKeys.prototype);
-        obj.__wbg_ptr = ptr;
-        UserPublicKeysFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        UserPublicKeysFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_userpublickeys_free(ptr, 0);
-    }
-    /**
-     * Derives a unique user ID from the public keys.
-     * @returns {Uint8Array}
-     */
-    derive_id() {
-        const ret = wasm.userpublickeys_derive_id(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-    /**
-     * Gets the DSA verification key bytes.
-     * @returns {Uint8Array}
-     */
-    get dsa_verification_key() {
-        const ret = wasm.userpublickeys_dsa_verification_key(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-    /**
-     * Gets the KEM public key bytes.
-     * @returns {Uint8Array}
-     */
-    get kem_public_key() {
-        const ret = wasm.userpublickeys_kem_public_key(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-    /**
-     * Gets the Massa public key bytes.
-     * @returns {Uint8Array}
-     */
-    get massa_public_key() {
-        const ret = wasm.userpublickeys_massa_public_key(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-    /**
-     * Serializes the public keys to bytes.
-     * @returns {Uint8Array}
-     */
-    to_bytes() {
-        const ret = wasm.userpublickeys_to_bytes(this.__wbg_ptr);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-    /**
-     * Deserializes public keys from bytes.
-     * @param {Uint8Array} bytes
-     * @returns {UserPublicKeys}
-     */
-    static from_bytes(bytes) {
-        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.userpublickeys_from_bytes(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return UserPublicKeys.__wrap(ret[0]);
-    }
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(UserPublicKeys.prototype);
+    obj.__wbg_ptr = ptr;
+    UserPublicKeysFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    UserPublicKeysFinalization.unregister(this);
+    return ptr;
+  }
+
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_userpublickeys_free(ptr, 0);
+  }
+  /**
+   * Deserializes public keys from bytes.
+   * @param {Uint8Array} bytes
+   * @returns {UserPublicKeys}
+   */
+  static from_bytes(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.userpublickeys_from_bytes(ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return UserPublicKeys.__wrap(ret[0]);
+  }
+  /**
+   * Gets the KEM public key bytes.
+   * @returns {Uint8Array}
+   */
+  get kem_public_key() {
+    const ret = wasm.userpublickeys_kem_public_key(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * Gets the Massa public key bytes.
+   * @returns {Uint8Array}
+   */
+  get massa_public_key() {
+    const ret = wasm.userpublickeys_massa_public_key(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * Gets the DSA verification key bytes.
+   * @returns {Uint8Array}
+   */
+  get dsa_verification_key() {
+    const ret = wasm.userpublickeys_dsa_verification_key(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * Serializes the public keys to bytes.
+   * @returns {Uint8Array}
+   */
+  to_bytes() {
+    const ret = wasm.userpublickeys_to_bytes(this.__wbg_ptr);
+    if (ret[3]) {
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * Derives a unique user ID from the public keys.
+   * @returns {Uint8Array}
+   */
+  derive_id() {
+    const ret = wasm.userpublickeys_derive_id(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
 }
-if (Symbol.dispose) UserPublicKeys.prototype[Symbol.dispose] = UserPublicKeys.prototype.free;
+if (Symbol.dispose)
+  UserPublicKeys.prototype[Symbol.dispose] = UserPublicKeys.prototype.free;
 
-const UserSecretKeysFinalization = (typeof FinalizationRegistry === 'undefined')
+const UserSecretKeysFinalization =
+  typeof FinalizationRegistry === 'undefined'
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_usersecretkeys_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr =>
+        wasm.__wbg_usersecretkeys_free(ptr >>> 0, 1)
+      );
 /**
  * User secret keys for signing and decryption.
  */
 export class UserSecretKeys {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(UserSecretKeys.prototype);
-        obj.__wbg_ptr = ptr;
-        UserSecretKeysFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        UserSecretKeysFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_usersecretkeys_free(ptr, 0);
-    }
-    /**
-     * Serializes the secret keys to bytes for secure storage.
-     * @returns {Uint8Array}
-     */
-    to_bytes() {
-        const ret = wasm.usersecretkeys_to_bytes(this.__wbg_ptr);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-    /**
-     * Deserializes secret keys from bytes.
-     * @param {Uint8Array} bytes
-     * @returns {UserSecretKeys}
-     */
-    static from_bytes(bytes) {
-        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.usersecretkeys_from_bytes(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return UserSecretKeys.__wrap(ret[0]);
-    }
-    /**
-     * Gets the DSA signing key bytes.
-     * @returns {Uint8Array}
-     */
-    get dsa_signing_key() {
-        const ret = wasm.usersecretkeys_dsa_signing_key(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-    /**
-     * Gets the KEM secret key bytes.
-     * @returns {Uint8Array}
-     */
-    get kem_secret_key() {
-        const ret = wasm.usersecretkeys_kem_secret_key(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-    /**
-     * Gets only the Massa secret key bytes
-     * @returns {Uint8Array}
-     */
-    get massa_secret_key() {
-        const ret = wasm.usersecretkeys_massa_secret_key(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(UserSecretKeys.prototype);
+    obj.__wbg_ptr = ptr;
+    UserSecretKeysFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    UserSecretKeysFinalization.unregister(this);
+    return ptr;
+  }
+
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_usersecretkeys_free(ptr, 0);
+  }
+  /**
+   * Deserializes secret keys from bytes.
+   * @param {Uint8Array} bytes
+   * @returns {UserSecretKeys}
+   */
+  static from_bytes(bytes) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.usersecretkeys_from_bytes(ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return UserSecretKeys.__wrap(ret[0]);
+  }
+  /**
+   * Gets the KEM secret key bytes.
+   * @returns {Uint8Array}
+   */
+  get kem_secret_key() {
+    const ret = wasm.usersecretkeys_kem_secret_key(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * Gets the DSA signing key bytes.
+   * @returns {Uint8Array}
+   */
+  get dsa_signing_key() {
+    const ret = wasm.usersecretkeys_dsa_signing_key(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * Gets only the Massa secret key bytes
+   * @returns {Uint8Array}
+   */
+  get massa_secret_key() {
+    const ret = wasm.usersecretkeys_massa_secret_key(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * Serializes the secret keys to bytes for secure storage.
+   * @returns {Uint8Array}
+   */
+  to_bytes() {
+    const ret = wasm.usersecretkeys_to_bytes(this.__wbg_ptr);
+    if (ret[3]) {
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
 }
-if (Symbol.dispose) UserSecretKeys.prototype[Symbol.dispose] = UserSecretKeys.prototype.free;
+if (Symbol.dispose)
+  UserSecretKeys.prototype[Symbol.dispose] = UserSecretKeys.prototype.free;
 
 const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
 
 async function __wbg_load(module, imports) {
-    if (typeof Response === 'function' && module instanceof Response) {
-        if (typeof WebAssembly.instantiateStreaming === 'function') {
-            try {
-                return await WebAssembly.instantiateStreaming(module, imports);
-
-            } catch (e) {
-                const validResponse = module.ok && EXPECTED_RESPONSE_TYPES.has(module.type);
-
-                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
-                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
-
-                } else {
-                    throw e;
-                }
-            }
+  if (typeof Response === 'function' && module instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === 'function') {
+      try {
+        return await WebAssembly.instantiateStreaming(module, imports);
+      } catch (e) {
+        const validResponse =
+          module.ok && EXPECTED_RESPONSE_TYPES.has(module.type);
+
+        if (
+          validResponse &&
+          module.headers.get('Content-Type') !== 'application/wasm'
+        ) {
+          console.warn(
+            '`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n',
+            e
+          );
+        } else {
+          throw e;
         }
+      }
+    }
 
-        const bytes = await module.arrayBuffer();
-        return await WebAssembly.instantiate(bytes, imports);
+    const bytes = await module.arrayBuffer();
+    return await WebAssembly.instantiate(bytes, imports);
+  } else {
+    const instance = await WebAssembly.instantiate(module, imports);
 
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module };
     } else {
-        const instance = await WebAssembly.instantiate(module, imports);
-
-        if (instance instanceof WebAssembly.Instance) {
-            return { instance, module };
-
-        } else {
-            return instance;
-        }
+      return instance;
     }
+  }
 }
 
 function __wbg_get_imports() {
-    const imports = {};
-    imports.wbg = {};
-    imports.wbg.__wbg_call_13410aac570ffff7 = function() { return handleError(function (arg0, arg1) {
-        const ret = arg0.call(arg1);
-        return ret;
-    }, arguments) };
-    imports.wbg.__wbg_call_a5400b25a865cfd8 = function() { return handleError(function (arg0, arg1, arg2) {
-        const ret = arg0.call(arg1, arg2);
-        return ret;
-    }, arguments) };
-    imports.wbg.__wbg_crypto_574e78ad8b13b65f = function(arg0) {
-        const ret = arg0.crypto;
-        return ret;
-    };
-    imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
-        let deferred0_0;
-        let deferred0_1;
-        try {
-            deferred0_0 = arg0;
-            deferred0_1 = arg1;
-            console.error(getStringFromWasm0(arg0, arg1));
-        } finally {
-            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
-        }
-    };
-    imports.wbg.__wbg_getRandomValues_b8f5dbd5f3995a9e = function() { return handleError(function (arg0, arg1) {
-        arg0.getRandomValues(arg1);
-    }, arguments) };
-    imports.wbg.__wbg_length_6bb7e81f9d7713e4 = function(arg0) {
-        const ret = arg0.length;
-        return ret;
-    };
-    imports.wbg.__wbg_msCrypto_a61aeb35a24c1329 = function(arg0) {
-        const ret = arg0.msCrypto;
-        return ret;
-    };
-    imports.wbg.__wbg_new_1f3a344cf3123716 = function() {
-        const ret = new Array();
-        return ret;
-    };
-    imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
-        const ret = new Error();
-        return ret;
-    };
-    imports.wbg.__wbg_newfromslice_074c56947bd43469 = function(arg0, arg1) {
-        const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
-        return ret;
-    };
-    imports.wbg.__wbg_newnoargs_254190557c45b4ec = function(arg0, arg1) {
-        const ret = new Function(getStringFromWasm0(arg0, arg1));
-        return ret;
-    };
-    imports.wbg.__wbg_newwithlength_a167dcc7aaa3ba77 = function(arg0) {
-        const ret = new Uint8Array(arg0 >>> 0);
-        return ret;
-    };
-    imports.wbg.__wbg_node_905d3e251edff8a2 = function(arg0) {
-        const ret = arg0.node;
-        return ret;
-    };
-    imports.wbg.__wbg_now_1e80617bcee43265 = function() {
-        const ret = Date.now();
-        return ret;
-    };
-    imports.wbg.__wbg_process_dc0fbacc7c1c06f7 = function(arg0) {
-        const ret = arg0.process;
-        return ret;
-    };
-    imports.wbg.__wbg_prototypesetcall_3d4a26c1ed734349 = function(arg0, arg1, arg2) {
-        Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
-    };
-    imports.wbg.__wbg_push_330b2eb93e4e1212 = function(arg0, arg1) {
-        const ret = arg0.push(arg1);
-        return ret;
-    };
-    imports.wbg.__wbg_randomFillSync_ac0988aba3254290 = function() { return handleError(function (arg0, arg1) {
-        arg0.randomFillSync(arg1);
-    }, arguments) };
-    imports.wbg.__wbg_require_60cc747a6bc5215a = function() { return handleError(function () {
-        const ret = module.require;
-        return ret;
-    }, arguments) };
-    imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
-        const ret = arg1.stack;
-        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-    };
-    imports.wbg.__wbg_static_accessor_GLOBAL_8921f820c2ce3f12 = function() {
-        const ret = typeof global === 'undefined' ? null : global;
-        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-    };
-    imports.wbg.__wbg_static_accessor_GLOBAL_THIS_f0a4409105898184 = function() {
-        const ret = typeof globalThis === 'undefined' ? null : globalThis;
-        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-    };
-    imports.wbg.__wbg_static_accessor_SELF_995b214ae681ff99 = function() {
-        const ret = typeof self === 'undefined' ? null : self;
-        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-    };
-    imports.wbg.__wbg_static_accessor_WINDOW_cde3890479c675ea = function() {
-        const ret = typeof window === 'undefined' ? null : window;
-        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-    };
-    imports.wbg.__wbg_subarray_70fd07feefe14294 = function(arg0, arg1, arg2) {
-        const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
-        return ret;
-    };
-    imports.wbg.__wbg_versions_c01dfd4722a88165 = function(arg0) {
-        const ret = arg0.versions;
-        return ret;
-    };
-    imports.wbg.__wbg_wbindgenisfunction_8cee7dce3725ae74 = function(arg0) {
-        const ret = typeof(arg0) === 'function';
-        return ret;
-    };
-    imports.wbg.__wbg_wbindgenisobject_307a53c6bd97fbf8 = function(arg0) {
-        const val = arg0;
-        const ret = typeof(val) === 'object' && val !== null;
-        return ret;
-    };
-    imports.wbg.__wbg_wbindgenisstring_d4fa939789f003b0 = function(arg0) {
-        const ret = typeof(arg0) === 'string';
-        return ret;
-    };
-    imports.wbg.__wbg_wbindgenisundefined_c4b71d073b92f3c5 = function(arg0) {
-        const ret = arg0 === undefined;
-        return ret;
-    };
-    imports.wbg.__wbg_wbindgenthrow_451ec1a8469d7eb6 = function(arg0, arg1) {
-        throw new Error(getStringFromWasm0(arg0, arg1));
-    };
-    imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
-        // Cast intrinsic for `Ref(String) -> Externref`.
-        const ret = getStringFromWasm0(arg0, arg1);
-        return ret;
-    };
-    imports.wbg.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
-        // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
-        const ret = getArrayU8FromWasm0(arg0, arg1);
-        return ret;
-    };
-    imports.wbg.__wbindgen_init_externref_table = function() {
-        const table = wasm.__wbindgen_export_2;
-        const offset = table.grow(4);
-        table.set(0, undefined);
-        table.set(offset + 0, undefined);
-        table.set(offset + 1, null);
-        table.set(offset + 2, true);
-        table.set(offset + 3, false);
-        ;
-    };
-
-    return imports;
+  const imports = {};
+  imports.wbg = {};
+  imports.wbg.__wbg_call_13410aac570ffff7 = function () {
+    return handleError(function (arg0, arg1) {
+      const ret = arg0.call(arg1);
+      return ret;
+    }, arguments);
+  };
+  imports.wbg.__wbg_call_a5400b25a865cfd8 = function () {
+    return handleError(function (arg0, arg1, arg2) {
+      const ret = arg0.call(arg1, arg2);
+      return ret;
+    }, arguments);
+  };
+  imports.wbg.__wbg_crypto_574e78ad8b13b65f = function (arg0) {
+    const ret = arg0.crypto;
+    return ret;
+  };
+  imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function (arg0, arg1) {
+    let deferred0_0;
+    let deferred0_1;
+    try {
+      deferred0_0 = arg0;
+      deferred0_1 = arg1;
+      console.error(getStringFromWasm0(arg0, arg1));
+    } finally {
+      wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+    }
+  };
+  imports.wbg.__wbg_getRandomValues_b8f5dbd5f3995a9e = function () {
+    return handleError(function (arg0, arg1) {
+      arg0.getRandomValues(arg1);
+    }, arguments);
+  };
+  imports.wbg.__wbg_length_6bb7e81f9d7713e4 = function (arg0) {
+    const ret = arg0.length;
+    return ret;
+  };
+  imports.wbg.__wbg_msCrypto_a61aeb35a24c1329 = function (arg0) {
+    const ret = arg0.msCrypto;
+    return ret;
+  };
+  imports.wbg.__wbg_new_1f3a344cf3123716 = function () {
+    const ret = new Array();
+    return ret;
+  };
+  imports.wbg.__wbg_new_8a6f238a6ece86ea = function () {
+    const ret = new Error();
+    return ret;
+  };
+  imports.wbg.__wbg_newfromslice_074c56947bd43469 = function (arg0, arg1) {
+    const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+    return ret;
+  };
+  imports.wbg.__wbg_newnoargs_254190557c45b4ec = function (arg0, arg1) {
+    const ret = new Function(getStringFromWasm0(arg0, arg1));
+    return ret;
+  };
+  imports.wbg.__wbg_newwithlength_a167dcc7aaa3ba77 = function (arg0) {
+    const ret = new Uint8Array(arg0 >>> 0);
+    return ret;
+  };
+  imports.wbg.__wbg_node_905d3e251edff8a2 = function (arg0) {
+    const ret = arg0.node;
+    return ret;
+  };
+  imports.wbg.__wbg_now_1e80617bcee43265 = function () {
+    const ret = Date.now();
+    return ret;
+  };
+  imports.wbg.__wbg_process_dc0fbacc7c1c06f7 = function (arg0) {
+    const ret = arg0.process;
+    return ret;
+  };
+  imports.wbg.__wbg_prototypesetcall_3d4a26c1ed734349 = function (
+    arg0,
+    arg1,
+    arg2
+  ) {
+    Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+  };
+  imports.wbg.__wbg_push_330b2eb93e4e1212 = function (arg0, arg1) {
+    const ret = arg0.push(arg1);
+    return ret;
+  };
+  imports.wbg.__wbg_randomFillSync_ac0988aba3254290 = function () {
+    return handleError(function (arg0, arg1) {
+      arg0.randomFillSync(arg1);
+    }, arguments);
+  };
+  imports.wbg.__wbg_require_60cc747a6bc5215a = function () {
+    return handleError(function () {
+      const ret = module.require;
+      return ret;
+    }, arguments);
+  };
+  imports.wbg.__wbg_stack_0ed75d68575b0f3c = function (arg0, arg1) {
+    const ret = arg1.stack;
+    const ptr1 = passStringToWasm0(
+      ret,
+      wasm.__wbindgen_malloc,
+      wasm.__wbindgen_realloc
+    );
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+  };
+  imports.wbg.__wbg_static_accessor_GLOBAL_8921f820c2ce3f12 = function () {
+    const ret = typeof global === 'undefined' ? null : global;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+  };
+  imports.wbg.__wbg_static_accessor_GLOBAL_THIS_f0a4409105898184 = function () {
+    const ret = typeof globalThis === 'undefined' ? null : globalThis;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+  };
+  imports.wbg.__wbg_static_accessor_SELF_995b214ae681ff99 = function () {
+    const ret = typeof self === 'undefined' ? null : self;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+  };
+  imports.wbg.__wbg_static_accessor_WINDOW_cde3890479c675ea = function () {
+    const ret = typeof window === 'undefined' ? null : window;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+  };
+  imports.wbg.__wbg_subarray_70fd07feefe14294 = function (arg0, arg1, arg2) {
+    const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+    return ret;
+  };
+  imports.wbg.__wbg_versions_c01dfd4722a88165 = function (arg0) {
+    const ret = arg0.versions;
+    return ret;
+  };
+  imports.wbg.__wbg_wbindgenisfunction_8cee7dce3725ae74 = function (arg0) {
+    const ret = typeof arg0 === 'function';
+    return ret;
+  };
+  imports.wbg.__wbg_wbindgenisobject_307a53c6bd97fbf8 = function (arg0) {
+    const val = arg0;
+    const ret = typeof val === 'object' && val !== null;
+    return ret;
+  };
+  imports.wbg.__wbg_wbindgenisstring_d4fa939789f003b0 = function (arg0) {
+    const ret = typeof arg0 === 'string';
+    return ret;
+  };
+  imports.wbg.__wbg_wbindgenisundefined_c4b71d073b92f3c5 = function (arg0) {
+    const ret = arg0 === undefined;
+    return ret;
+  };
+  imports.wbg.__wbg_wbindgenthrow_451ec1a8469d7eb6 = function (arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+  };
+  imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function (arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+  };
+  imports.wbg.__wbindgen_cast_cb9088102bce6b30 = function (arg0, arg1) {
+    // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+    const ret = getArrayU8FromWasm0(arg0, arg1);
+    return ret;
+  };
+  imports.wbg.__wbindgen_init_externref_table = function () {
+    const table = wasm.__wbindgen_export_2;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+  };
+
+  return imports;
 }
 
-function __wbg_init_memory(imports, memory) {
-
-}
+function __wbg_init_memory(imports, memory) {}
 
 function __wbg_finalize_init(instance, module) {
-    wasm = instance.exports;
-    __wbg_init.__wbindgen_wasm_module = module;
-    cachedDataViewMemory0 = null;
-    cachedUint8ArrayMemory0 = null;
-
+  wasm = instance.exports;
+  __wbg_init.__wbindgen_wasm_module = module;
+  cachedDataViewMemory0 = null;
+  cachedUint8ArrayMemory0 = null;
 
-    wasm.__wbindgen_start();
-    return wasm;
+  wasm.__wbindgen_start();
+  return wasm;
 }
 
 function initSync(module) {
-    if (wasm !== undefined) return wasm;
+  if (wasm !== undefined) return wasm;
 
-
-    if (typeof module !== 'undefined') {
-        if (Object.getPrototypeOf(module) === Object.prototype) {
-            ({module} = module)
-        } else {
-            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
-        }
+  if (typeof module !== 'undefined') {
+    if (Object.getPrototypeOf(module) === Object.prototype) {
+      ({ module } = module);
+    } else {
+      console.warn(
+        'using deprecated parameters for `initSync()`; pass a single object instead'
+      );
     }
+  }
 
-    const imports = __wbg_get_imports();
+  const imports = __wbg_get_imports();
 
-    __wbg_init_memory(imports);
+  __wbg_init_memory(imports);
 
-    if (!(module instanceof WebAssembly.Module)) {
-        module = new WebAssembly.Module(module);
-    }
+  if (!(module instanceof WebAssembly.Module)) {
+    module = new WebAssembly.Module(module);
+  }
 
-    const instance = new WebAssembly.Instance(module, imports);
+  const instance = new WebAssembly.Instance(module, imports);
 
-    return __wbg_finalize_init(instance, module);
+  return __wbg_finalize_init(instance, module);
 }
 
 async function __wbg_init(module_or_path) {
-    if (wasm !== undefined) return wasm;
-
+  if (wasm !== undefined) return wasm;
 
-    if (typeof module_or_path !== 'undefined') {
-        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
-            ({module_or_path} = module_or_path)
-        } else {
-            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
-        }
+  if (typeof module_or_path !== 'undefined') {
+    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+      ({ module_or_path } = module_or_path);
+    } else {
+      console.warn(
+        'using deprecated parameters for the initialization function; pass a single object instead'
+      );
     }
+  }
 
-    if (typeof module_or_path === 'undefined') {
-        module_or_path = new URL('gossip_wasm_bg.wasm', import.meta.url);
-    }
-    const imports = __wbg_get_imports();
+  if (typeof module_or_path === 'undefined') {
+    module_or_path = new URL('gossip_wasm_bg.wasm', import.meta.url);
+  }
+  const imports = __wbg_get_imports();
 
-    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
-        module_or_path = fetch(module_or_path);
-    }
+  if (
+    typeof module_or_path === 'string' ||
+    (typeof Request === 'function' && module_or_path instanceof Request) ||
+    (typeof URL === 'function' && module_or_path instanceof URL)
+  ) {
+    module_or_path = fetch(module_or_path);
+  }
 
-    __wbg_init_memory(imports);
+  __wbg_init_memory(imports);
 
-    const { instance, module } = await __wbg_load(await module_or_path, imports);
+  const { instance, module } = await __wbg_load(await module_or_path, imports);
 
-    return __wbg_finalize_init(instance, module);
+  return __wbg_finalize_init(instance, module);
 }
 
 export { initSync };