zexus 1.8.0 → 1.8.2

package/rust_core/src/hasher.rs

@@ -0,0 +1,90 @@
+// ─────────────────────────────────────────────────────────────────────
+// Cryptographic Hashing — SHA-256 & Keccak-256
+// ─────────────────────────────────────────────────────────────────────
+
+use pyo3::prelude::*;
+use sha2::{Digest, Sha256};
+use tiny_keccak::{Hasher as TinyHasher, Keccak};
+
+#[pyclass]
+pub struct RustHasher;
+
+#[pymethods]
+impl RustHasher {
+    #[new]
+    fn new() -> Self {
+        RustHasher
+    }
+
+    /// SHA-256 of raw bytes → hex string.
+    #[staticmethod]
+    fn sha256(data: Vec<u8>) -> String {
+        let hash = Sha256::digest(&data);
+        hex::encode(hash)
+    }
+
+    /// SHA-256 of a UTF-8 string → hex string.
+    #[staticmethod]
+    fn sha256_str(text: &str) -> String {
+        let hash = Sha256::digest(text.as_bytes());
+        hex::encode(hash)
+    }
+
+    /// Double SHA-256 (Bitcoin-style) → hex string.
+    #[staticmethod]
+    fn sha256d(data: Vec<u8>) -> String {
+        let first = Sha256::digest(&data);
+        let second = Sha256::digest(&first);
+        hex::encode(second)
+    }
+
+    /// Keccak-256 (Ethereum-style) → hex string.
+    #[staticmethod]
+    fn keccak256(data: Vec<u8>) -> String {
+        let mut hasher = Keccak::v256();
+        let mut output = [0u8; 32];
+        hasher.update(&data);
+        hasher.finalize(&mut output);
+        hex::encode(output)
+    }
+
+    /// Keccak-256 of a UTF-8 string → hex string.
+    #[staticmethod]
+    fn keccak256_str(text: &str) -> String {
+        let mut hasher = Keccak::v256();
+        let mut output = [0u8; 32];
+        hasher.update(text.as_bytes());
+        hasher.finalize(&mut output);
+        hex::encode(output)
+    }
+
+    /// Batch SHA-256: hash many byte-arrays in parallel → list of hex strings.
+    #[staticmethod]
+    fn sha256_batch(py: Python<'_>, items: Vec<Vec<u8>>) -> Vec<String> {
+        use rayon::prelude::*;
+        py.allow_threads(|| {
+            items
+                .par_iter()
+                .map(|d| hex::encode(Sha256::digest(d)))
+                .collect()
+        })
+    }
+
+    /// Batch Keccak-256 in parallel.
+    #[staticmethod]
+    fn keccak256_batch(py: Python<'_>, items: Vec<Vec<u8>>) -> Vec<String> {
+        use rayon::prelude::*;
+        py.allow_threads(|| {
+            items
+                .par_iter()
+                .map(|d| {
+                    let mut h = Keccak::v256();
+                    let mut out = [0u8; 32];
+                    h.update(d);
+                    h.finalize(&mut out);
+                    hex::encode(out)
+                })
+                .collect()
+        })
+    }
+}

package/rust_core/src/lib.rs

@@ -0,0 +1,71 @@
+// ─────────────────────────────────────────────────────────────────────
+// Zexus Blockchain — Rust Execution Core
+// ─────────────────────────────────────────────────────────────────────
+//
+// High-performance native execution engine exposed to Python via PyO3.
+//
+// Hot paths moved to Rust:
+//   • Batch transaction execution (parallel via Rayon)
+//   • SHA-256 / Keccak-256 hashing
+//   • ECDSA-secp256k1 signature verification
+//   • Merkle root computation
+//   • Block header validation
+//
+// The Python `ExecutionAccelerator` detects this extension at import
+// time and delegates to it automatically.  When the extension is not
+// compiled the system falls back to the pure-Python implementation
+// with zero breakage.
+
+use pyo3::prelude::*;
+use pyo3::types::{PyDict, PyList};
+use std::collections::HashMap;
+
+mod binary_bytecode;
+mod contract_vm;
+mod executor;
+mod hasher;
+mod merkle;
+mod rust_vm;
+mod signature;
+mod state_adapter;
+mod validator;
+
+use binary_bytecode::RustBytecodeReader;
+use contract_vm::RustContractVM;
+use executor::{RustBatchExecutor, TxBatchResult as RustTxBatchResult};
+use rust_vm::RustVMExecutor;
+use hasher::RustHasher;
+use merkle::RustMerkle;
+use signature::RustSignature;
+use state_adapter::RustStateAdapter;
+use validator::RustBlockValidator;
+
+// ── Python module definition ──────────────────────────────────────────
+
+/// The native Zexus execution core.
+#[pymodule]
+fn zexus_core(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_class::<RustBatchExecutor>()?;
+    m.add_class::<RustTxBatchResult>()?;
+    m.add_class::<RustHasher>()?;
+    m.add_class::<RustMerkle>()?;
+    m.add_class::<RustSignature>()?;
+    m.add_class::<RustBlockValidator>()?;
+    m.add_class::<RustBytecodeReader>()?;
+    m.add_class::<RustVMExecutor>()?;
+    m.add_class::<RustStateAdapter>()?;
+    m.add_class::<RustContractVM>()?;
+
+    // Convenience — quick check from Python:  `zexus_core.is_available()`
+    #[pyfn(m)]
+    fn is_available() -> bool {
+        true
+    }
+
+    #[pyfn(m)]
+    fn version() -> &'static str {
+        env!("CARGO_PKG_VERSION")
+    }
+
+    Ok(())
+}

package/rust_core/src/merkle.rs

@@ -0,0 +1,128 @@
+// ─────────────────────────────────────────────────────────────────────
+// Merkle Root Computation — parallelised
+// ─────────────────────────────────────────────────────────────────────
+
+use pyo3::prelude::*;
+use rayon::prelude::*;
+use sha2::{Digest, Sha256};
+
+#[pyclass]
+pub struct RustMerkle;
+
+#[pymethods]
+impl RustMerkle {
+    #[new]
+    fn new() -> Self {
+        RustMerkle
+    }
+
+    /// Compute the Merkle root of a list of hex-encoded leaf hashes.
+    ///
+    /// Uses a standard binary Merkle tree (duplicate last leaf if odd).
+    /// The hashing combines pairs with SHA-256(left || right).
+    ///
+    /// Returns the root as a hex string.
+    #[staticmethod]
+    fn compute_root(py: Python<'_>, leaves: Vec<String>) -> String {
+        if leaves.is_empty() {
+            return "0".repeat(64);
+        }
+        if leaves.len() == 1 {
+            return leaves[0].clone();
+        }
+
+        // Decode hex leaves to raw bytes
+        let mut current: Vec<[u8; 32]> = leaves
+            .iter()
+            .map(|h| {
+                let bytes = hex::decode(h).unwrap_or_else(|_| {
+                    // If not valid hex, hash the raw string
+                    Sha256::digest(h.as_bytes()).to_vec()
+                });
+                let mut arr = [0u8; 32];
+                let len = bytes.len().min(32);
+                arr[..len].copy_from_slice(&bytes[..len]);
+                arr
+            })
+            .collect();
+
+        py.allow_threads(|| {
+            while current.len() > 1 {
+                // Duplicate last if odd
+                if current.len() % 2 != 0 {
+                    current.push(*current.last().unwrap());
+                }
+
+                // Pair and hash in parallel
+                let pairs: Vec<([u8; 32], [u8; 32])> = current
+                    .chunks(2)
+                    .map(|c| (c[0], c[1]))
+                    .collect();
+
+                current = pairs
+                    .par_iter()
+                    .map(|(left, right)| {
+                        let mut combined = Vec::with_capacity(64);
+                        combined.extend_from_slice(left);
+                        combined.extend_from_slice(right);
+                        let hash = Sha256::digest(&combined);
+                        let mut arr = [0u8; 32];
+                        arr.copy_from_slice(&hash);
+                        arr
+                    })
+                    .collect();
+            }
+
+            hex::encode(current[0])
+        })
+    }
+
+    /// Compute Merkle root from raw transaction data (list of byte arrays).
+    /// Each item is SHA-256 hashed first to produce the leaf, then the
+    /// tree is built.
+    #[staticmethod]
+    fn compute_root_from_data(py: Python<'_>, data: Vec<Vec<u8>>) -> String {
+        let leaves: Vec<String> = py.allow_threads(|| {
+            data.par_iter()
+                .map(|d| hex::encode(Sha256::digest(d)))
+                .collect()
+        });
+        // Re-acquire GIL for the tree computation call
+        RustMerkle::compute_root(py, leaves)
+    }
+
+    /// Verify a Merkle proof.
+    ///
+    /// `leaf_hash` — the hex hash of the item to verify  
+    /// `proof`     — list of (hex_hash, "left"|"right") pairs  
+    /// `root`      — expected root hex  
+    #[staticmethod]
+    fn verify_proof(
+        leaf_hash: &str,
+        proof: Vec<(String, String)>,
+        root: &str,
+    ) -> bool {
+        let mut current = hex::decode(leaf_hash).unwrap_or_default();
+        if current.len() != 32 {
+            return false;
+        }
+
+        for (sibling_hex, direction) in &proof {
+            let sibling = hex::decode(sibling_hex).unwrap_or_default();
+            if sibling.len() != 32 {
+                return false;
+            }
+            let mut combined = Vec::with_capacity(64);
+            if direction == "left" {
+                combined.extend_from_slice(&sibling);
+                combined.extend_from_slice(&current);
+            } else {
+                combined.extend_from_slice(&current);
+                combined.extend_from_slice(&sibling);
+            }
+            current = Sha256::digest(&combined).to_vec();
+        }
+
+        hex::encode(&current) == root
+    }
+}