zexus 1.8.0 → 1.8.2

package/rust_core/src/signature.rs

@@ -0,0 +1,79 @@
+// ─────────────────────────────────────────────────────────────────────
+// ECDSA-secp256k1 Signature Verification  (batch-parallel)
+// ─────────────────────────────────────────────────────────────────────
+
+use k256::ecdsa::{
+    signature::Verifier, Signature, VerifyingKey,
+};
+use pyo3::prelude::*;
+use rayon::prelude::*;
+use sha2::{Digest, Sha256};
+
+#[pyclass]
+pub struct RustSignature;
+
+#[pymethods]
+impl RustSignature {
+    #[new]
+    fn new() -> Self {
+        RustSignature
+    }
+
+    /// Verify a single ECDSA-secp256k1 signature.
+    ///
+    /// * `message`   — the raw message bytes that were signed
+    /// * `signature` — 64-byte DER or compact signature
+    /// * `public_key`— 33-byte (compressed) or 65-byte (uncompressed) public key
+    ///
+    /// Returns `true` if the signature is valid.
+    #[staticmethod]
+    fn verify(message: Vec<u8>, signature: Vec<u8>, public_key: Vec<u8>) -> bool {
+        Self::_verify_inner(&message, &signature, &public_key)
+    }
+
+    /// Batch-verify multiple signatures in parallel.
+    ///
+    /// Each item is a tuple `(message_bytes, signature_bytes, pubkey_bytes)`.
+    /// Returns a list of booleans (one per signature).
+    #[staticmethod]
+    fn verify_batch(
+        py: Python<'_>,
+        items: Vec<(Vec<u8>, Vec<u8>, Vec<u8>)>,
+    ) -> Vec<bool> {
+        py.allow_threads(|| {
+            items
+                .par_iter()
+                .map(|(msg, sig, pk)| Self::_verify_inner(msg, sig, pk))
+                .collect()
+        })
+    }
+
+    /// Hash a message with SHA-256 then verify the signature against the
+    /// hash.  This matches the common blockchain pattern of sign(sha256(msg)).
+    #[staticmethod]
+    fn verify_hashed(message: Vec<u8>, signature: Vec<u8>, public_key: Vec<u8>) -> bool {
+        let hash = Sha256::digest(&message);
+        Self::_verify_inner(&hash, &signature, &public_key)
+    }
+}
+
+impl RustSignature {
+    fn _verify_inner(message: &[u8], signature: &[u8], public_key: &[u8]) -> bool {
+        verify_single(message, signature, public_key)
+    }
+}
+
+/// Public helper so other modules (validator) can call it directly.
+pub fn verify_single(message: &[u8], signature: &[u8], public_key: &[u8]) -> bool {
+    let vk = match VerifyingKey::from_sec1_bytes(public_key) {
+        Ok(vk) => vk,
+        Err(_) => return false,
+    };
+
+    let sig = match Signature::from_slice(signature) {
+        Ok(s) => s,
+        Err(_) => return false,
+    };
+
+    vk.verify(message, &sig).is_ok()
+}

package/rust_core/src/state_adapter.rs

@@ -0,0 +1,281 @@
+// ─────────────────────────────────────────────────────────────────────
+// Zexus Blockchain — Rust State Adapter (Phase 3)
+// ─────────────────────────────────────────────────────────────────────
+//
+// In-memory state cache that batches reads/writes in Rust to minimise
+// GIL crossings when the Rust VM operates on blockchain state.
+//
+// Architecture:
+//
+//   1.  Pre-load state from Python dict → Rust HashMap ("warm cache")
+//   2.  STATE_READ/STATE_WRITE hit the Rust cache — zero Python calls
+//   3.  After execution, flush dirty keys back to Python in one batch
+//   4.  TX_BEGIN/TX_COMMIT/TX_REVERT use Rust-side snapshots
+//
+// This avoids per-opcode GIL acquisition for state operations,
+// delivering ~50x speedup on state-heavy contracts.
+
+use pyo3::prelude::*;
+use pyo3::types::{PyDict, PyList};
+use pyo3::ToPyObject;
+use std::collections::{HashMap, HashSet};
+
+/// A single value in the state cache.
+#[derive(Debug, Clone)]
+pub enum StateValue {
+    Null,
+    Bool(bool),
+    Int(i64),
+    Float(f64),
+    Str(String),
+    Bytes(Vec<u8>),
+    List(Vec<StateValue>),
+    Map(Vec<(String, StateValue)>),
+}
+
+impl StateValue {
+    /// Convert a Python object to a StateValue.
+    pub fn from_py(py: Python<'_>, obj: &PyObject) -> Self {
+        let bound = obj.bind(py);
+        if bound.is_none() {
+            return StateValue::Null;
+        }
+        if let Ok(b) = bound.extract::<bool>() {
+            return StateValue::Bool(b);
+        }
+        if let Ok(i) = bound.extract::<i64>() {
+            return StateValue::Int(i);
+        }
+        if let Ok(f) = bound.extract::<f64>() {
+            return StateValue::Float(f);
+        }
+        if let Ok(s) = bound.extract::<String>() {
+            return StateValue::Str(s);
+        }
+        if let Ok(list) = bound.downcast::<PyList>() {
+            let items: Vec<StateValue> = list
+                .iter()
+                .map(|item| StateValue::from_py(py, &item.to_object(py)))
+                .collect();
+            return StateValue::List(items);
+        }
+        if let Ok(dict) = bound.downcast::<PyDict>() {
+            let items: Vec<(String, StateValue)> = dict
+                .iter()
+                .filter_map(|(k, v)| {
+                    k.extract::<String>()
+                        .ok()
+                        .map(|key| (key, StateValue::from_py(py, &v.to_object(py))))
+                })
+                .collect();
+            return StateValue::Map(items);
+        }
+        // Fallback: try string representation
+        if let Ok(s) = bound.str().and_then(|s| s.extract::<String>()) {
+            return StateValue::Str(s);
+        }
+        StateValue::Null
+    }
+
+    /// Convert to a Python object.
+    pub fn to_py(&self, py: Python<'_>) -> PyObject {
+        match self {
+            StateValue::Null => py.None(),
+            StateValue::Bool(b) => b.to_object(py),
+            StateValue::Int(i) => i.to_object(py),
+            StateValue::Float(f) => f.to_object(py),
+            StateValue::Str(s) => s.to_object(py),
+            StateValue::Bytes(b) => {
+                pyo3::types::PyBytes::new_bound(py, b).to_object(py)
+            }
+            StateValue::List(items) => {
+                let py_list = PyList::empty_bound(py);
+                for item in items {
+                    let _ = py_list.append(item.to_py(py));
+                }
+                py_list.to_object(py)
+            }
+            StateValue::Map(items) => {
+                let py_dict = PyDict::new_bound(py);
+                for (k, v) in items {
+                    let _ = py_dict.set_item(k, v.to_py(py));
+                }
+                py_dict.to_object(py)
+            }
+        }
+    }
+}
+
+/// Transaction snapshot for nested transaction support.
+struct TxSnapshot {
+    cache: HashMap<String, StateValue>,
+    dirty: HashSet<String>,
+}
+
+/// Rust-side state cache with batch flush capability.
+///
+/// Usage from Python:
+/// ```python
+/// from zexus_core import RustStateAdapter
+/// adapter = RustStateAdapter()
+/// adapter.load_from_dict({"key": "value", "counter": 42})
+/// adapter.set("counter", 43)
+/// val = adapter.get("counter")
+/// dirty = adapter.flush_dirty()   # returns dict of changed keys
+/// ```
+#[pyclass]
+pub struct RustStateAdapter {
+    /// In-memory state cache (key → value).
+    cache: HashMap<String, StateValue>,
+
+    /// Set of keys that have been written (dirty) since last flush.
+    dirty: HashSet<String>,
+
+    /// Transaction snapshot stack for TX_BEGIN/TX_COMMIT/TX_REVERT.
+    tx_stack: Vec<TxSnapshot>,
+
+    /// Total reads served from cache (no Python call).
+    cache_hits: u64,
+
+    /// Total writes batched (no Python call until flush).
+    cache_writes: u64,
+}
+
+#[pymethods]
+impl RustStateAdapter {
+    #[new]
+    fn new() -> Self {
+        RustStateAdapter {
+            cache: HashMap::new(),
+            dirty: HashSet::new(),
+            tx_stack: Vec::new(),
+            cache_hits: 0,
+            cache_writes: 0,
+        }
+    }
+
+    /// Bulk-load state from a Python dict into the Rust cache.
+    /// This is the "warm-up" step — called once before Rust VM execution.
+    fn load_from_dict(&mut self, py: Python<'_>, data: &Bound<'_, PyDict>) -> PyResult<u64> {
+        let mut count: u64 = 0;
+        for (k, v) in data.iter() {
+            let key = k.extract::<String>()?;
+            let val = StateValue::from_py(py, &v.to_object(py));
+            self.cache.insert(key, val);
+            count += 1;
+        }
+        Ok(count)
+    }
+
+    /// Read a value from the cache.
+    fn get(&mut self, py: Python<'_>, key: &str) -> PyObject {
+        self.cache_hits += 1;
+        match self.cache.get(key) {
+            Some(val) => val.to_py(py),
+            None => py.None(),
+        }
+    }
+
+    /// Write a value to the cache and mark it dirty.
+    fn set(&mut self, py: Python<'_>, key: String, value: PyObject) {
+        let sv = StateValue::from_py(py, &value);
+        self.cache.insert(key.clone(), sv);
+        self.dirty.insert(key);
+        self.cache_writes += 1;
+    }
+
+    /// Check if a key exists in the cache.
+    fn contains(&self, key: &str) -> bool {
+        self.cache.contains_key(key)
+    }
+
+    /// Delete a key from the cache and mark it dirty (sets to Null).
+    fn delete(&mut self, key: &str) {
+        self.cache.insert(key.to_string(), StateValue::Null);
+        self.dirty.insert(key.to_string());
+        self.cache_writes += 1;
+    }
+
+    /// Return all dirty (modified) keys as a Python dict.
+    /// Clears the dirty set after flushing.
+    fn flush_dirty(&mut self, py: Python<'_>) -> PyResult<PyObject> {
+        let result = PyDict::new_bound(py);
+        for key in self.dirty.drain() {
+            if let Some(val) = self.cache.get(&key) {
+                result.set_item(&key, val.to_py(py))?;
+            }
+        }
+        Ok(result.to_object(py))
+    }
+
+    /// Return the full cache as a Python dict.
+    fn to_dict(&self, py: Python<'_>) -> PyResult<PyObject> {
+        let result = PyDict::new_bound(py);
+        for (k, v) in &self.cache {
+            result.set_item(k, v.to_py(py))?;
+        }
+        Ok(result.to_object(py))
+    }
+
+    /// Get the number of keys in the cache.
+    fn len(&self) -> usize {
+        self.cache.len()
+    }
+
+    /// Get the number of dirty keys pending flush.
+    fn dirty_count(&self) -> usize {
+        self.dirty.len()
+    }
+
+    /// Begin a transaction — snapshot current state.
+    fn tx_begin(&mut self) {
+        let snapshot = TxSnapshot {
+            cache: self.cache.clone(),
+            dirty: self.dirty.clone(),
+        };
+        self.tx_stack.push(snapshot);
+    }
+
+    /// Commit a transaction — discard the snapshot, keep changes.
+    fn tx_commit(&mut self) -> bool {
+        if self.tx_stack.is_empty() {
+            return false;
+        }
+        // Pop snapshot but keep current state — changes are committed
+        let _snapshot = self.tx_stack.pop().unwrap();
+        // Merge dirty keys from this transaction into the parent
+        // (dirty set already contains all writes — nothing extra needed)
+        true
+    }
+
+    /// Revert a transaction — restore the snapshot.
+    fn tx_revert(&mut self) -> bool {
+        if let Some(snapshot) = self.tx_stack.pop() {
+            self.cache = snapshot.cache;
+            self.dirty = snapshot.dirty;
+            true
+        } else {
+            false
+        }
+    }
+
+    /// Return cache statistics.
+    fn stats(&self, py: Python<'_>) -> PyResult<PyObject> {
+        let result = PyDict::new_bound(py);
+        result.set_item("cache_size", self.cache.len())?;
+        result.set_item("dirty_count", self.dirty.len())?;
+        result.set_item("cache_hits", self.cache_hits)?;
+        result.set_item("cache_writes", self.cache_writes)?;
+        result.set_item("tx_depth", self.tx_stack.len())?;
+        Ok(result.to_object(py))
+    }
+
+    /// Reset the adapter.
+    fn clear(&mut self) {
+        self.cache.clear();
+        self.dirty.clear();
+        self.tx_stack.clear();
+        self.cache_hits = 0;
+        self.cache_writes = 0;
+    }
+}

package/rust_core/src/validator.rs

@@ -0,0 +1,116 @@
+// ─────────────────────────────────────────────────────────────────────
+// Block Validation — fast parallel checks
+// ─────────────────────────────────────────────────────────────────────
+
+use pyo3::prelude::*;
+use rayon::prelude::*;
+use sha2::{Digest, Sha256};
+use std::collections::HashMap;
+
+/// Validates block header integrity at native speed.
+#[pyclass]
+pub struct RustBlockValidator;
+
+#[pymethods]
+impl RustBlockValidator {
+    #[new]
+    fn new() -> Self {
+        RustBlockValidator
+    }
+
+    /// Verify a block hash matches its header contents.
+    ///
+    /// `header_json` — JSON-encoded block header
+    /// `expected_hash` — the hash claimed by the block
+    ///
+    /// Returns `true` if SHA-256(header_json) == expected_hash.
+    #[staticmethod]
+    fn verify_block_hash(header_json: &str, expected_hash: &str) -> bool {
+        let hash = Sha256::digest(header_json.as_bytes());
+        hex::encode(hash) == expected_hash
+    }
+
+    /// Validate a chain of block hashes in parallel.
+    ///
+    /// `blocks` — list of (header_json, claimed_hash, prev_hash) tuples.
+    /// Returns a list of booleans — one per block.
+    ///
+    /// Checks:
+    ///   1. SHA-256(header) == claimed_hash
+    ///   2. prev_hash links correctly (sequential check)
+    #[staticmethod]
+    fn validate_chain(
+        py: Python<'_>,
+        blocks: Vec<(String, String, String)>,
+    ) -> Vec<bool> {
+        if blocks.is_empty() {
+            return vec![];
+        }
+
+        // Step 1: verify hashes in parallel
+        let hash_checks: Vec<bool> = py.allow_threads(|| {
+            blocks
+                .par_iter()
+                .map(|(header, claimed, _)| {
+                    let hash = Sha256::digest(header.as_bytes());
+                    hex::encode(hash) == *claimed
+                })
+                .collect()
+        });
+
+        // Step 2: verify chain linkage (sequential — inherently ordered)
+        let mut results = hash_checks;
+        for i in 1..blocks.len() {
+            let expected_prev = &blocks[i - 1].1; // previous block's hash
+            let actual_prev = &blocks[i].2; // this block's prev_hash
+            if expected_prev != actual_prev {
+                results[i] = false;
+            }
+        }
+
+        results
+    }
+
+    /// Check Proof-of-Work difficulty: does the block hash have the
+    /// required number of leading zero bits?
+    #[staticmethod]
+    fn check_pow_difficulty(block_hash: &str, difficulty: u32) -> bool {
+        let bytes = match hex::decode(block_hash) {
+            Ok(b) => b,
+            Err(_) => return false,
+        };
+
+        let mut leading_zeros = 0u32;
+        for byte in &bytes {
+            if *byte == 0 {
+                leading_zeros += 8;
+            } else {
+                leading_zeros += byte.leading_zeros();
+                break;
+            }
+        }
+
+        leading_zeros >= difficulty
+    }
+
+    /// Batch-validate transaction signatures within a block.
+    ///
+    /// `tx_data` — list of (message_bytes, signature_bytes, pubkey_bytes).
+    /// Returns the number of valid signatures.
+    #[staticmethod]
+    fn validate_tx_signatures(
+        py: Python<'_>,
+        tx_data: Vec<(Vec<u8>, Vec<u8>, Vec<u8>)>,
+    ) -> usize {
+        let results: Vec<bool> = py.allow_threads(|| {
+            use rayon::prelude::*;
+            tx_data
+                .par_iter()
+                .map(|(msg, sig, pk)| {
+                    crate::signature::verify_single(msg, sig, pk)
+                })
+                .collect()
+        });
+        results.iter().filter(|&&v| v).count()
+    }
+}