feat: update dependencies, optimize WASM performance, and improve memory allocation

Author: jlucaso1

.cargo/config.toml

@@ -1,5 +1,5 @@
 [target.wasm32-unknown-unknown]
-rustflags = ["-C", "target-feature=+simd128"]
+rustflags = ["-C", "target-feature=+simd128", "--cfg", "getrandom_backend=\"wasm_js\""]
 
 [build]
 target = "wasm32-unknown-unknown"

Cargo.lock

@@ -56,7 +56,7 @@ image = { version = "0.25.5", default-features = false, features = [
 ], optional = true }
 
 img-parts = { version = "0.4", default-features = false, optional = true }
-js-sys = "0.3"
+js-sys = "0.3.85"
 log = "0.4"
 md-5 = "0.10"
 prost = { version = "0.14.1", default-features = false }
@@ -75,14 +75,15 @@ sha2 = "0.10"
 simd-adler32 = { version = "0.3.7", default-features = false, features = [
   "std",
 ] }
-symphonia = { version = "0.5.4", default-features = false, features = [
+symphonia = { version = "0.5.5", default-features = false, features = [
   "mp3",
   "aac",
   "isomp4",
   "ogg",
 ], optional = true }
+talc = "4.4.3"
 tsify-next = { version = "0.5", default-features = false, features = ["js"] }
-uuid = { version = "1.18.1", default-features = false, features = ["v4", "js"] }
+uuid = { version = "1.20.0", default-features = false, features = ["v4", "js"] }
 
 wacore-appstate = { git = "https://github.com/jlucaso1/whatsapp-rust.git", branch = "main", package = "wacore-appstate" }
 wacore-binary = { git = "https://github.com/jlucaso1/whatsapp-rust.git", branch = "main", features = [
@@ -91,8 +92,8 @@ wacore-binary = { git = "https://github.com/jlucaso1/whatsapp-rust.git", branch
 wacore-libsignal = { git = "https://github.com/jlucaso1/whatsapp-rust.git", branch = "main", package = "wacore-libsignal" }
 wacore-noise = { git = "https://github.com/jlucaso1/whatsapp-rust.git", branch = "main", package = "wacore-noise" }
 waproto = { git = "https://github.com/jlucaso1/whatsapp-rust.git", branch = "main", package = "waproto" }
-wasm-bindgen = "0.2.100"
-wasm-bindgen-futures = "0.4.55"
+wasm-bindgen = { version = "0.2.108", features = ["enable-interning"] }
+wasm-bindgen-futures = "0.4"
 web-sys = { version = "0.3", features = [
   "ReadableStream",
   "ReadableStreamDefaultReader",

Cargo.toml

@@ -123,15 +123,23 @@ impl InternalBinaryNode {
 
     #[inline]
     fn convert_attrs(attrs: &[(Cow<'_, str>, ValueRef<'_>)]) -> Attrs {
-        let obj = Object::new();
-        for (k, v) in attrs.iter() {
-            let js_value = match v.as_str() {
-                Some(s) => JsValue::from_str(s),
-                None => JsValue::from_str(&v.to_string()),
-            };
-            let _ = js_sys::Reflect::set(&obj, &JsValue::from_str(k), &js_value);
+        // Use Object.from_entries() which is faster than multiple Reflect.set() calls
+        let entries = Array::new_with_length(attrs.len() as u32);
+        for (i, (k, v)) in attrs.iter().enumerate() {
+            let pair = Array::new_with_length(2);
+            pair.set(0, JsValue::from_str(k));
+            pair.set(
+                1,
+                match v.as_str() {
+                    Some(s) => JsValue::from_str(s),
+                    None => JsValue::from_str(&v.to_string()),
+                },
+            );
+            entries.set(i as u32, pair.into());
         }
-        obj.unchecked_into()
+        Object::from_entries(&entries)
+            .unwrap_or_else(|_| Object::new())
+            .unchecked_into()
     }
 }
 
@@ -146,12 +154,17 @@ impl InternalBinaryNode {
     pub fn to_json(&self) -> JsValue {
         let obj = Object::new();
 
+        // Use interned strings for frequently used keys
         let _ = js_sys::Reflect::set(
             &obj,
-            &JsValue::from_str("tag"),
+            &wasm_bindgen::intern("tag").into(),
             &JsValue::from_str(&self.node_ref().tag),
         );
-        let _ = js_sys::Reflect::set(&obj, &JsValue::from_str("attrs"), &self.attrs().into());
+        let _ = js_sys::Reflect::set(
+            &obj,
+            &wasm_bindgen::intern("attrs").into(),
+            &self.attrs().into(),
+        );
 
         if let Some(content) = self.content() {
             let content_js: JsValue = content.into();
@@ -160,7 +173,11 @@ impl InternalBinaryNode {
             } else {
                 content_js
             };
-            let _ = js_sys::Reflect::set(&obj, &JsValue::from_str("content"), &content_value);
+            let _ = js_sys::Reflect::set(
+                &obj,
+                &wasm_bindgen::intern("content").into(),
+                &content_value,
+            );
         }
 
         obj.into()
@@ -169,7 +186,8 @@ impl InternalBinaryNode {
     fn serialize_child_nodes(&self, content_js: &JsValue) -> JsValue {
         let arr = Array::from(content_js);
         let json_arr = Array::new_with_length(arr.length());
-        let to_json_key = JsValue::from_str("toJSON");
+        // Use interned string for toJSON key - called repeatedly
+        let to_json_key: JsValue = wasm_bindgen::intern("toJSON").into();
 
         for i in 0..arr.length() {
             let item = arr.get(i);

src/binary.rs

@@ -83,7 +83,7 @@ pub fn calculate_agreement(
     let pub_key = parse_public_key(public_key_bytes)?;
     let secret = priv_key.calculate_agreement(&pub_key).map_err(map_err)?;
 
-    let result = Uint8Array::new_with_length(secret.len() as u32);
+    let result = Uint8Array::new_with_length(32);
     result.copy_from(secret.as_ref());
     Ok(result)
 }
@@ -106,7 +106,7 @@ pub fn calculate_signature(
         .calculate_signature(message, &mut OsRng.unwrap_err())
         .map_err(map_err)?;
 
-    let result = Uint8Array::new_with_length(signature.len() as u32);
+    let result = Uint8Array::new_with_length(64);
     result.copy_from(signature.as_ref());
     Ok(result)
 }

src/curve.rs

@@ -1,3 +1,10 @@
+// Use Talc allocator for better WASM performance
+// WasmHandler integrates with WebAssembly's memory.grow for dynamic allocation
+#[cfg(target_arch = "wasm32")]
+#[global_allocator]
+static ALLOCATOR: talc::Talck<talc::locking::AssumeUnlockable, talc::WasmHandler> =
+    unsafe { talc::Talc::new(talc::WasmHandler::new()).lock() };
+
 pub mod appstate;
 #[cfg(feature = "audio")]
 pub mod audio;

src/lib.rs

@@ -46,7 +46,7 @@ impl NoiseSession {
             is_finished: false,
             intro_header: Some(intro_header),
             frame_decoder: FrameDecoder::new(),
-            encode_scratch: Vec::with_capacity(4096),
+            encode_scratch: Vec::new(), // Lazy allocation - grows on demand
         })
     }
 
@@ -221,7 +221,7 @@ impl NoiseSession {
     pub fn get_hash(&self) -> Uint8Array {
         if let Some(ref handshake) = self.handshake {
             let hash = handshake.hash();
-            let result = Uint8Array::new_with_length(hash.len() as u32);
+            let result = Uint8Array::new_with_length(32);
             result.copy_from(hash);
             result
         } else {

src/noise_session.rs

@@ -1,6 +1,5 @@
 use js_sys::{Object, Reflect, Uint8Array};
 use rand::{TryRngCore, rngs::OsRng};
-use std::cell::RefCell;
 use wasm_bindgen::prelude::*;
 
 use crate::{
@@ -11,9 +10,20 @@ use wacore_libsignal::protocol::{self as libsignal, SessionStore, UsePQRatchet};
 
 #[inline]
 fn bytes_to_uint8array(bytes: &[u8]) -> Uint8Array {
-    let result = Uint8Array::new_with_length(bytes.len() as u32);
-    result.copy_from(bytes);
-    result
+    Uint8Array::from(bytes)
+}
+
+// Interned keys for encrypt result - avoids repeated string allocation
+#[inline]
+fn create_encrypt_result(type_id: u8, body: Uint8Array) -> Result<EncryptResult, JsValue> {
+    let obj = Object::new();
+    let _ = Reflect::set(
+        &obj,
+        &wasm_bindgen::intern("type").into(),
+        &(type_id as u32).into(),
+    );
+    let _ = Reflect::set(&obj, &wasm_bindgen::intern("body").into(), &body.into());
+    Ok(obj.unchecked_into())
 }
 
 #[wasm_bindgen]
@@ -22,11 +32,6 @@ extern "C" {
     pub type EncryptResult;
 }
 
-thread_local! {
-    static TYPE_KEY: RefCell<JsValue> = RefCell::new(JsValue::from_str("type"));
-    static BODY_KEY: RefCell<JsValue> = RefCell::new(JsValue::from_str("body"));
-}
-
 #[wasm_bindgen(js_name = SessionCipher)]
 pub struct SessionCipher {
     storage_adapter: JsStorageAdapter,
@@ -62,11 +67,7 @@ impl SessionCipher {
         let body_array = bytes_to_uint8array(ciphertext_message.serialize());
         let type_id = ciphertext_message.message_type() as u8;
 
-        let result = Object::new();
-        TYPE_KEY.with(|k| Reflect::set(&result, &k.borrow(), &(type_id as u32).into()))?;
-        BODY_KEY.with(|k| Reflect::set(&result, &k.borrow(), &body_array.into()))?;
-
-        Ok(result.unchecked_into())
+        create_encrypt_result(type_id, body_array)
     }
 
     #[wasm_bindgen(js_name = decryptPreKeyWhisperMessage)]

src/session_cipher.rs

@@ -33,12 +33,12 @@ impl SessionRecord {
 
         // 3. Legacy libsignal-node JSON format (has "_sessions" key)
         // Returns empty record to trigger safe re-negotiation
-        if Reflect::has(&val, &JsValue::from_str(SESSIONS_KEY)).unwrap_or(false) {
+        if Reflect::has(&val, &wasm_bindgen::intern(SESSIONS_KEY).into()).unwrap_or(false) {
             return create_empty_session_record();
         }
 
         // 4. Buffer-like objects { type: 'Buffer', data: [...] }
-        if let Ok(data) = Reflect::get(&val, &JsValue::from_str(DATA_KEY))
+        if let Ok(data) = Reflect::get(&val, &wasm_bindgen::intern(DATA_KEY).into())
             && Array::is_array(&data)
         {
             return Ok(SessionRecord::new(js_array_to_vec(&Array::from(&data))));