@massalabs/gossip-sdk 0.0.2-dev.20260429061149 → 0.0.2-dev.20260506131227

package/dist/assets/generated/wasm/gossip_wasm.d.ts

@@ -1,5 +1,40 @@
 /* tslint:disable */
 /* eslint-disable */
+/**
+ * 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");
+ * }
+ * ```
+ */
+export function aead_decrypt(key: EncryptionKey, nonce: Nonce, ciphertext: Uint8Array, aad: Uint8Array): Uint8Array | undefined;
+export function start(): void;
 /**
  * Encrypts data using AES-256-SIV authenticated encryption.
  *
@@ -40,41 +75,6 @@ export function aead_encrypt(key: EncryptionKey, nonce: Nonce, plaintext: Uint8A
  * the passphrase crosses the JS boundary only once.
  */
 export function generate_user_keys(passphrase: string): UserKeys;
-export function start(): void;
-/**
- * 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");
- * }
- * ```
- */
-export function aead_decrypt(key: EncryptionKey, nonce: Nonce, ciphertext: Uint8Array, aad: Uint8Array): Uint8Array | undefined;
 /**
  * Session status indicating the state of a peer session.
  */
@@ -313,10 +313,24 @@ export class SessionManagerWrapper {
   feed_incoming_announcement(announcement_bytes: Uint8Array, our_pk: UserPublicKeys, our_sk: UserSecretKeys): AnnouncementResult | undefined;
   /**
    * Gets the list of message board seekers to monitor.
+   *
+   * Each seeker is materialised as a JS-owned Uint8Array via
+   * `new_with_length` + `copy_from`. `Uint8Array::from(&[u8])` in older
+   * js-sys returns an array whose buffer view sits over wasm linear
+   * memory; subsequent wasm calls that grow the heap detach those
+   * views, and the JS-side `SEEKERS_UPDATED` listener crashes with
+   * "Cannot perform values on a detached ArrayBuffer". The
+   * new-with-length path allocates a JS-side ArrayBuffer up front,
+   * then copies — the result is decoupled from wasm memory.
    */
   get_message_board_read_keys(): Array<any>;
   /**
    * Processes an incoming message from the message board.
+   *
+   * Each acknowledged seeker is materialised as a JS-owned Uint8Array
+   * (see `get_message_board_read_keys` for the rationale — same risk
+   * of detached views over wasm linear memory if the heap grows
+   * before the JS side reads the buffer).
    */
   feed_incoming_message_board_read(seeker: Uint8Array, ciphertext: Uint8Array, our_sk: UserSecretKeys): ReceiveMessageOutput | undefined;
   /**
@@ -325,10 +339,16 @@ export class SessionManagerWrapper {
   constructor(config: SessionConfig);
   /**
    * Refreshes sessions and returns peer IDs that need keep-alive messages.
+   *
+   * JS-owned Uint8Arrays — same detached-view rationale as
+   * `get_message_board_read_keys`.
    */
   refresh(): Array<any>;
   /**
    * Gets the list of all peer IDs.
+   *
+   * JS-owned Uint8Arrays — same detached-view rationale as
+   * `get_message_board_read_keys`.
    */
   peer_list(): Array<any>;
 }

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

@@ -135,6 +135,64 @@ function _assertClass(instance, 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;
+}
+
+export function start() {
+    wasm.start();
+}
+
 /**
  * Encrypts data using AES-256-SIV authenticated encryption.
  *
@@ -203,64 +261,6 @@ export function generate_user_keys(passphrase) {
     return UserKeys.__wrap(ret[0]);
 }
 
-export function start() {
-    wasm.start();
-}
-
-/**
- * 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;
-}
-
 /**
  * Session status indicating the state of a peer session.
  * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6}
@@ -851,6 +851,15 @@ export class SessionManagerWrapper {
     }
     /**
      * Gets the list of message board seekers to monitor.
+     *
+     * Each seeker is materialised as a JS-owned Uint8Array via
+     * `new_with_length` + `copy_from`. `Uint8Array::from(&[u8])` in older
+     * js-sys returns an array whose buffer view sits over wasm linear
+     * memory; subsequent wasm calls that grow the heap detach those
+     * views, and the JS-side `SEEKERS_UPDATED` listener crashes with
+     * "Cannot perform values on a detached ArrayBuffer". The
+     * new-with-length path allocates a JS-side ArrayBuffer up front,
+     * then copies — the result is decoupled from wasm memory.
      * @returns {Array<any>}
      */
     get_message_board_read_keys() {
@@ -859,6 +868,11 @@ export class SessionManagerWrapper {
     }
     /**
      * Processes an incoming message from the message board.
+     *
+     * Each acknowledged seeker is materialised as a JS-owned Uint8Array
+     * (see `get_message_board_read_keys` for the rationale — same risk
+     * of detached views over wasm linear memory if the heap grows
+     * before the JS side reads the buffer).
      * @param {Uint8Array} seeker
      * @param {Uint8Array} ciphertext
      * @param {UserSecretKeys} our_sk
@@ -887,6 +901,9 @@ export class SessionManagerWrapper {
     }
     /**
      * Refreshes sessions and returns peer IDs that need keep-alive messages.
+     *
+     * JS-owned Uint8Arrays — same detached-view rationale as
+     * `get_message_board_read_keys`.
      * @returns {Array<any>}
      */
     refresh() {
@@ -895,6 +912,9 @@ export class SessionManagerWrapper {
     }
     /**
      * Gets the list of all peer IDs.
+     *
+     * JS-owned Uint8Arrays — same detached-view rationale as
+     * `get_message_board_read_keys`.
      * @returns {Array<any>}
      */
     peer_list() {
@@ -1272,10 +1292,6 @@ function __wbg_get_imports() {
         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;
@@ -1310,6 +1326,9 @@ function __wbg_get_imports() {
         const ret = module.require;
         return ret;
     }, arguments) };
+    imports.wbg.__wbg_set_1353b2a5e96bc48c = function(arg0, arg1, arg2) {
+        arg0.set(getArrayU8FromWasm0(arg1, arg2));
+    };
     imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
         const ret = arg1.stack;
         const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);

package/dist/assets/generated/wasm-secureStorage/index.js

@@ -0,0 +1,2 @@
+export * from "./secureStorage.js";
+export { default } from "./secureStorage.js";

package/dist/assets/generated/wasm-secureStorage/secureStorage.d.ts

@@ -0,0 +1,143 @@
+/* tslint:disable */
+/* eslint-disable */
+export function initSecureStorage(domain: string, backend: string): Promise<void>;
+export function idbHasData(): Promise<boolean>;
+export function provisionStorage(): void;
+export function allocateSession(slot: number, password: Uint8Array): void;
+export function flushEncrypted(): Promise<void>;
+export function openDatabase(): void;
+export function closeDatabase(): void;
+/**
+ * Run a SQL statement with bound parameters.
+ *
+ * `params` is a JS array of values; supported types are number, string,
+ * Uint8Array, null, and bigint. Returns rows as a JS array of arrays
+ * (positional column values), matching the Drizzle sqlite-proxy contract.
+ */
+export function execSql(sql: string, params: Array<any>): ExecResult;
+export function unlockSession(password: Uint8Array): boolean;
+export function lockSession(): void;
+/**
+ * Permanently destroy the data of the currently unlocked slot.
+ *
+ * The actual writes (new dummy keypair + cover blocks) land in
+ * IdbBlockStorage's in-memory pending state. Durability comes from
+ * the caller's subsequent `flushEncrypted()` await — same pattern
+ * the worker uses for `lockSession`. A process crash before that
+ * flush rolls everything back: the IDB on-disk state is unchanged,
+ * the slot is left exactly as it was.
+ *
+ * **The caller must `closeDatabase()` first** so SQLite's xWrite
+ * flush on close lands in the buffer before destroy_session truncates
+ * the namespace. Mirrors `lockSession`'s contract.
+ */
+export function destroySession(namespaces: Uint8Array): void;
+export function coverTrafficTick(namespace: number): void;
+export function writeNamespaceData(namespace: number, offset: number, data: Uint8Array): void;
+export function readNamespaceData(namespace: number, offset: number, len: number): Uint8Array;
+export function namespaceDataLength(namespace: number): number;
+export function clearNamespace(namespace: number): void;
+export function initThreadPool(num_threads: number): Promise<any>;
+export function wbg_rayon_start_worker(receiver: number): void;
+/**
+ * Result of an `execSql` call.
+ *
+ * `last_insert_rowid` is `f64` (not `i64`) because it crosses the JS bridge
+ * and JS has no native i64 — its `Number` type is f64. SQLite rowids are
+ * sequential and stay within JS's safe integer range (2^53) in practice,
+ * so the conversion is lossless.
+ */
+export class ExecResult {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  readonly lastInsertRowId: number;
+  readonly rows: Array<any>;
+}
+export class wbg_rayon_PoolBuilder {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  numThreads(): number;
+  build(): void;
+  receiver(): number;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly __wbg_execresult_free: (a: number, b: number) => void;
+  readonly allocateSession: (a: number, b: number, c: number) => [number, number];
+  readonly clearNamespace: (a: number) => [number, number];
+  readonly closeDatabase: () => [number, number];
+  readonly coverTrafficTick: (a: number) => [number, number];
+  readonly destroySession: (a: number, b: number) => [number, number];
+  readonly execSql: (a: number, b: number, c: any) => [number, number, number];
+  readonly execresult_lastInsertRowId: (a: number) => number;
+  readonly execresult_rows: (a: number) => any;
+  readonly flushEncrypted: () => any;
+  readonly idbHasData: () => any;
+  readonly initSecureStorage: (a: number, b: number, c: number, d: number) => any;
+  readonly lockSession: () => [number, number];
+  readonly namespaceDataLength: (a: number) => [number, number, number];
+  readonly openDatabase: () => [number, number];
+  readonly provisionStorage: () => [number, number];
+  readonly readNamespaceData: (a: number, b: number, c: number) => [number, number, number, number];
+  readonly unlockSession: (a: number, b: number) => [number, number, number];
+  readonly writeNamespaceData: (a: number, b: number, c: number, d: number) => [number, number];
+  readonly __wbg_wbg_rayon_poolbuilder_free: (a: number, b: number) => void;
+  readonly initThreadPool: (a: number) => any;
+  readonly wbg_rayon_poolbuilder_build: (a: number) => void;
+  readonly wbg_rayon_poolbuilder_numThreads: (a: number) => number;
+  readonly wbg_rayon_poolbuilder_receiver: (a: number) => number;
+  readonly wbg_rayon_start_worker: (a: number) => void;
+  readonly rust_sqlite_wasm_abort: () => void;
+  readonly rust_sqlite_wasm_assert_fail: (a: number, b: number, c: number, d: number) => void;
+  readonly rust_sqlite_wasm_calloc: (a: number, b: number) => number;
+  readonly rust_sqlite_wasm_free: (a: number) => void;
+  readonly rust_sqlite_wasm_getentropy: (a: number, b: number) => number;
+  readonly rust_sqlite_wasm_localtime: (a: number) => number;
+  readonly rust_sqlite_wasm_malloc: (a: number) => number;
+  readonly rust_sqlite_wasm_realloc: (a: number, b: number) => number;
+  readonly sqlite3_os_end: () => number;
+  readonly sqlite3_os_init: () => number;
+  readonly __wbindgen_exn_store: (a: number) => void;
+  readonly __externref_table_alloc: () => number;
+  readonly __wbindgen_export_2: WebAssembly.Table;
+  readonly memory: WebAssembly.Memory;
+  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_export_7: WebAssembly.Table;
+  readonly __externref_table_dealloc: (a: number) => void;
+  readonly closure97_externref_shim: (a: number, b: number, c: any) => void;
+  readonly wasm_bindgen_b3ea05ef1784c7d3___convert__closures_____invoke______: (a: number, b: number) => void;
+  readonly closure662_externref_shim: (a: number, b: number, c: any) => void;
+  readonly closure89_externref_shim_multivalue_shim: (a: number, b: number, c: any) => [number, number];
+  readonly closure718_externref_shim: (a: number, b: number, c: any, d: any) => void;
+  readonly __wbindgen_thread_destroy: (a?: number, b?: number, c?: number) => void;
+  readonly __wbindgen_start: (a: number) => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {{ module: SyncInitInput, memory?: WebAssembly.Memory, thread_stack_size?: number }} module - Passing `SyncInitInput` directly is deprecated.
+* @param {WebAssembly.Memory} memory - Deprecated.
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: { module: SyncInitInput, memory?: WebAssembly.Memory, thread_stack_size?: number } | SyncInitInput, memory?: WebAssembly.Memory): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {{ module_or_path: InitInput | Promise<InitInput>, memory?: WebAssembly.Memory, thread_stack_size?: number }} module_or_path - Passing `InitInput` directly is deprecated.
+* @param {WebAssembly.Memory} memory - Deprecated.
+*
+* @returns {Promise<InitOutput>}
+*/
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput>, memory?: WebAssembly.Memory, thread_stack_size?: number } | InitInput | Promise<InitInput>, memory?: WebAssembly.Memory): Promise<InitOutput>;