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

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

@@ -0,0 +1,1557 @@
+let wasm;
+
+function addToExternrefTable0(obj) {
+  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);
+  }
+}
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+  if (
+    cachedUint8ArrayMemory0 === null ||
+    cachedUint8ArrayMemory0.byteLength === 0
+  ) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+
+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)
+  );
+}
+
+function getStringFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return decodeText(ptr, len);
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+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,
+    };
+  };
+}
+
+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;
+  }
+
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+
+  const mem = getUint8ArrayMemory0();
+
+  let offset = 0;
+
+  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);
+
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+
+  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;
+}
+
+function isLikeNone(x) {
+  return x === undefined || x === null;
+}
+
+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;
+}
+
+export function start() {
+  wasm.start();
+}
+
+function _assertClass(instance, klass) {
+  if (!(instance instanceof klass)) {
+    throw new Error(`expected instance of ${klass.name}`);
+  }
+}
+/**
+ * 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 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;
+}
+
+/**
+ * Encrypts data using AES-256-SIV authenticated encryption.
+ *
+ * # Parameters
+ *
+ * - `key`: The encryption key (64 bytes)
+ * - `nonce`: The nonce (16 bytes, should be unique per encryption)
+ * - `plaintext`: The data to encrypt
+ * - `aad`: Additional authenticated data (not encrypted, but authenticated)
+ *
+ * # Returns
+ *
+ * The ciphertext with authentication tag appended.
+ *
+ * # Security Notes
+ *
+ * - The nonce should be unique for each encryption operation
+ * - AES-SIV is nonce-misuse resistant: reusing nonces only leaks if plaintexts are identical
+ * - AAD is authenticated but not encrypted; it must be transmitted separately
+ * - The same AAD must be provided during decryption
+ *
+ * # Example
+ *
+ * ```javascript
+ * const key = EncryptionKey.generate();
+ * const nonce = Nonce.generate();
+ * const plaintext = new TextEncoder().encode("Secret message");
+ * const aad = new TextEncoder().encode("context info");
+ *
+ * const ciphertext = aead_encrypt(key, nonce, plaintext, aad);
+ * ```
+ * @param {EncryptionKey} key
+ * @param {Nonce} nonce
+ * @param {Uint8Array} plaintext
+ * @param {Uint8Array} aad
+ * @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;
+}
+
+/**
+ * Generates user keys from a passphrase using password-based key derivation.
+ * @param {string} passphrase
+ * @returns {UserKeys}
+ */
+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]);
+}
+
+/**
+ * Session status indicating the state of a peer session.
+ * @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',
+});
+
+const AnnouncementResultFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : 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;
+  }
+}
+if (Symbol.dispose)
+  AnnouncementResult.prototype[Symbol.dispose] =
+    AnnouncementResult.prototype.free;
+
+const EncryptionKeyFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : 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);
+  }
+  /**
+   * 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;
+
+const NonceFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_nonce_free(ptr >>> 0, 1));
+/**
+ * Nonce for AEAD operations (AES-256-SIV).
+ *
+ * AES-256-SIV uses a 16-byte (128-bit) nonce. The nonce should be unique
+ * 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);
+  }
+  /**
+   * 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'
+    ? { register: () => {}, unregister: () => {} }
+    : 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 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;
+
+const SendMessageOutputFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : 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 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;
+
+const SessionConfigFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : 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 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;
+
+const SessionManagerWrapperFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : 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);
+  }
+  /**
+   * 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;
+
+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]);
+  }
+}
+if (Symbol.dispose)
+  UserKeys.prototype[Symbol.dispose] = UserKeys.prototype.free;
+
+const UserPublicKeysFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : 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);
+  }
+  /**
+   * 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;
+
+const UserSecretKeysFinalization =
+  typeof FinalizationRegistry === 'undefined'
+    ? { register: () => {}, unregister: () => {} }
+    : 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);
+  }
+  /**
+   * 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;
+
+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;
+        }
+      }
+    }
+
+    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 {
+      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;
+}
+
+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.__wbindgen_start();
+  return wasm;
+}
+
+function initSync(module) {
+  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'
+      );
+    }
+  }
+
+  const imports = __wbg_get_imports();
+
+  __wbg_init_memory(imports);
+
+  if (!(module instanceof WebAssembly.Module)) {
+    module = new WebAssembly.Module(module);
+  }
+
+  const instance = new WebAssembly.Instance(module, imports);
+
+  return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+  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') {
+    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);
+  }
+
+  __wbg_init_memory(imports);
+
+  const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+  return __wbg_finalize_init(instance, module);
+}
+
+export { initSync };
+export default __wbg_init;