Refactor ChronoSeal daemon for dynamic configurations, connection pooling, custom error handling, and complete tests (v0.5.0)

wasm/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "chronoseal-wasm"
-version = "0.2.0"
+version = "0.5.0"
 edition = "2021"
 
 [lib]
-crate-type = ["cdylib"]
+crate-type = ["cdylib", "rlib"]
 
 [dependencies]
 shared = { path = "../shared" }

wasm/src/anti_debug.rs

@@ -1,2 +1,2 @@
 // Example: break debugger detection, console clearing, etc.
-// Currently empty.
+// Currently empty.

wasm/src/crypto.rs

@@ -3,7 +3,7 @@ use std::cell::RefCell;
 use wasm_bindgen::prelude::*;
 
 thread_local! {
-    static KEYPAIR: RefCell<Option<SigningKey>> = RefCell::new(None);
+    static KEYPAIR: RefCell<Option<SigningKey>> = const { RefCell::new(None) };
 }
 
 #[wasm_bindgen]
@@ -51,10 +51,8 @@ pub fn compute_next_hash(
 ) -> String {
     let prev = hex::decode(prev_hash_hex).unwrap_or_default();
     let salt = hex::decode(salt_hex).unwrap_or_default();
-    let entropy =
-        serde_json::from_str::<shared::protocol::EntropyData>(entropy_data_json).unwrap();
-    let stack =
-        serde_json::from_str::<shared::protocol::StackState>(stack_state_json).unwrap();
+    let entropy = serde_json::from_str::<shared::protocol::EntropyData>(entropy_data_json).unwrap();
+    let stack = serde_json::from_str::<shared::protocol::StackState>(stack_state_json).unwrap();
     let new = shared::hashing::next_chain_hash(&prev, timestamp, &entropy, &stack, &salt);
     hex::encode(new)
-}
+}

wasm/src/entropy.rs

@@ -1,2 +1,2 @@
 // This module is handled on the JS side; WASM only receives the prepared entropy data.
-// Could be used to add extra entropy sources (e.g., from JS via import).
+// Could be used to add extra entropy sources (e.g., from JS via import).

wasm/src/fingerprint.rs

@@ -1 +1 @@
-// Fingerprint collection is done in JS, this module is a placeholder.
+// Fingerprint collection is done in JS, this module is a placeholder.

wasm/src/lib.rs

@@ -3,4 +3,4 @@ pub mod crypto;
 pub mod entropy;
 pub mod fingerprint;
 pub mod transport;
-pub mod vm;
+pub mod vm;

wasm/src/transport.rs

@@ -1 +1 @@
-// Could contain WebTransport related code if needed later.
+// Could contain WebTransport related code if needed later.

wasm/src/vm.rs

@@ -1,10 +1,12 @@
-use wasm_bindgen::prelude::*;
 use shared::protocol::StackState;
+use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen]
 pub fn run_program(program_b64: &str) -> JsValue {
     use base64::Engine;
-    let bytes = base64::engine::general_purpose::STANDARD.decode(program_b64).unwrap();
+    let bytes = base64::engine::general_purpose::STANDARD
+        .decode(program_b64)
+        .unwrap();
     let state = execute(&bytes);
     serde_wasm_bindgen::to_value(&state).unwrap()
 }
@@ -17,13 +19,22 @@ fn execute(program: &[u8]) -> StackState {
         ip += 1;
         match op {
             0x00 => {
-                if ip + 4 > program.len() { break; }
-                let val = u32::from_le_bytes([program[ip], program[ip+1], program[ip+2], program[ip+3]]);
+                if ip + 4 > program.len() {
+                    break;
+                }
+                let val = u32::from_le_bytes([
+                    program[ip],
+                    program[ip + 1],
+                    program[ip + 2],
+                    program[ip + 3],
+                ]);
                 ip += 4;
                 stack.push(val);
             }
             0x01..=0x07 => {
-                if stack.len() < 2 { break; }
+                if stack.len() < 2 {
+                    break;
+                }
                 let b = stack.pop().unwrap();
                 let a = stack.pop().unwrap();
                 let r = match op {
@@ -39,7 +50,9 @@ fn execute(program: &[u8]) -> StackState {
                 stack.push(r);
             }
             0x08 => {
-                if stack.is_empty() { break; }
+                if stack.is_empty() {
+                    break;
+                }
                 let a = stack.pop().unwrap();
                 stack.push(!a);
             }
@@ -51,5 +64,140 @@ fn execute(program: &[u8]) -> StackState {
             _ => break,
         }
     }
-    StackState { stack, ip: ip as u16 }
-}
+    StackState {
+        stack,
+        ip: ip as u16,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_push() {
+        // PUSH 42, PUSH 100
+        let program = vec![0x00, 42, 0, 0, 0, 0x00, 100, 0, 0, 0];
+        let state = execute(&program);
+        assert_eq!(state.stack, vec![42, 100]);
+        assert_eq!(state.ip, 10);
+    }
+
+    #[test]
+    fn test_add() {
+        // PUSH 5, PUSH 10, ADD
+        let program = vec![0x00, 5, 0, 0, 0, 0x00, 10, 0, 0, 0, 0x01];
+        let state = execute(&program);
+        assert_eq!(state.stack, vec![15]);
+    }
+
+    #[test]
+    fn test_add_wrapping() {
+        // PUSH u32::MAX, PUSH 1, ADD
+        let program = vec![0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 1, 0, 0, 0, 0x01];
+        let state = execute(&program);
+        assert_eq!(state.stack, vec![0]);
+    }
+
+    #[test]
+    fn test_sub() {
+        // PUSH 20, PUSH 7, SUB
+        let program = vec![0x00, 20, 0, 0, 0, 0x00, 7, 0, 0, 0, 0x02];
+        let state = execute(&program);
+        assert_eq!(state.stack, vec![13]);
+    }
+
+    #[test]
+    fn test_sub_wrapping() {
+        // PUSH 0, PUSH 1, SUB
+        let program = vec![0x00, 0, 0, 0, 0, 0x00, 1, 0, 0, 0, 0x02];
+        let state = execute(&program);
+        assert_eq!(state.stack, vec![u32::MAX]);
+    }
+
+    #[test]
+    fn test_mul() {
+        // PUSH 6, PUSH 7, MUL
+        let program = vec![0x00, 6, 0, 0, 0, 0x00, 7, 0, 0, 0, 0x03];
+        let state = execute(&program);
+        assert_eq!(state.stack, vec![42]);
+    }
+
+    #[test]
+    fn test_xor() {
+        // PUSH 0b1010, PUSH 0b1100, XOR
+        let program = vec![0x00, 0b1010, 0, 0, 0, 0x00, 0b1100, 0, 0, 0, 0x04];
+        let state = execute(&program);
+        assert_eq!(state.stack, vec![0b0110]);
+    }
+
+    #[test]
+    fn test_and() {
+        // PUSH 0b1010, PUSH 0b1100, AND
+        let program = vec![0x00, 0b1010, 0, 0, 0, 0x00, 0b1100, 0, 0, 0, 0x05];
+        let state = execute(&program);
+        assert_eq!(state.stack, vec![0b1000]);
+    }
+
+    #[test]
+    fn test_or() {
+        // PUSH 0b1010, PUSH 0b1100, OR
+        let program = vec![0x00, 0b1010, 0, 0, 0, 0x00, 0b1100, 0, 0, 0, 0x06];
+        let state = execute(&program);
+        assert_eq!(state.stack, vec![0b1110]);
+    }
+
+    #[test]
+    fn test_rot() {
+        // PUSH 1, PUSH 4, ROT
+        let program = vec![0x00, 1, 0, 0, 0, 0x00, 4, 0, 0, 0, 0x07];
+        let state = execute(&program);
+        assert_eq!(state.stack, vec![16]);
+    }
+
+    #[test]
+    fn test_not() {
+        // PUSH 0, NOT
+        let program = vec![0x00, 0, 0, 0, 0, 0x08];
+        let state = execute(&program);
+        assert_eq!(state.stack, vec![u32::MAX]);
+    }
+
+    #[test]
+    fn test_hash() {
+        // PUSH 10, PUSH 20, HASH
+        let program = vec![0x00, 10, 0, 0, 0, 0x00, 20, 0, 0, 0, 0x09];
+        let state = execute(&program);
+        assert_eq!(state.stack.len(), 1);
+        let expected_hash = shared::hashing::hash_stack(&[10, 20]);
+        assert_eq!(state.stack[0], expected_hash);
+    }
+
+    #[test]
+    fn test_underflow_binary() {
+        // PUSH 42, ADD (needs 2 values, only 1 on stack)
+        let program = vec![0x00, 42, 0, 0, 0, 0x01];
+        let state = execute(&program);
+        // ADD breaks when stack.len() < 2, stack has 42 left, ip is at the opcode ADD (6)
+        assert_eq!(state.stack, vec![42]);
+        assert_eq!(state.ip, 6);
+    }
+
+    #[test]
+    fn test_underflow_unary() {
+        // NOT (needs 1 value, empty stack)
+        let program = vec![0x08];
+        let state = execute(&program);
+        assert_eq!(state.stack, Vec::<u32>::new());
+        assert_eq!(state.ip, 1);
+    }
+
+    #[test]
+    fn test_incomplete_push() {
+        // PUSH opcode, but only 2 bytes instead of 4
+        let program = vec![0x00, 42, 0];
+        let state = execute(&program);
+        assert_eq!(state.stack, Vec::<u32>::new());
+        assert_eq!(state.ip, 1); // execution stopped at op 0x00 because ip + 4 > program.len()
+    }
+}