zexus 1.7.2 → 1.8.1

package/src/zexus/blockchain/contract_vm.py

@@ -58,6 +58,22 @@ except ImportError:
     GasCost = None  # type: ignore
     OutOfGasError = None  # type: ignore
 
+# Rust VM (Phase 3 — adaptive contract execution)
+try:
+    from zexus_core import RustVMExecutor as _RustVMExecutor
+    _RUST_VM_AVAILABLE = True
+except Exception:
+    _RUST_VM_AVAILABLE = False
+    _RustVMExecutor = None  # type: ignore
+
+# Rust ContractVM orchestrator (Phase 4)
+try:
+    from zexus_core import RustContractVM as _RustContractVM
+    _RUST_CONTRACT_VM_AVAILABLE = True
+except Exception:
+    _RUST_CONTRACT_VM_AVAILABLE = False
+    _RustContractVM = None  # type: ignore
+
 # SmartContract from security module
 try:
     from ..security import SmartContract
@@ -196,8 +212,31 @@ class ContractVM:
             "bytecode_executions": 0,
             "bytecode_fallbacks": 0,
             "treewalk_executions": 0,
+            "rust_executions": 0,
+            "rust_fallbacks": 0,
         }
 
+        # Rust VM executor (Phase 3 + Phase 6 — Rust-first execution)
+        self._rust_vm_executor = _RustVMExecutor() if _RUST_VM_AVAILABLE else None
+        self._rust_vm_threshold = 0  # Phase 6: route ALL contracts through Rust by default
+        try:
+            _env_thresh = os.environ.get("ZEXUS_RUST_VM_THRESHOLD")
+            if _env_thresh is not None:
+                self._rust_vm_threshold = int(_env_thresh)
+        except (ValueError, TypeError):
+            pass
+
+        # Rust ContractVM orchestrator (Phase 4)
+        self._rust_contract_vm = (
+            _RustContractVM(
+                gas_discount=0.6,
+                default_gas_limit=gas_limit,
+                max_call_depth=self._max_call_depth,
+            )
+            if _RUST_CONTRACT_VM_AVAILABLE
+            else None
+        )
+
     # ------------------------------------------------------------------
     # Contract lifecycle
     # ------------------------------------------------------------------
@@ -334,7 +373,20 @@ class ContractVM:
         env = self._build_env(state_adapter, tx_ctx, contract, args or {})
         builtins = self._build_builtins(tx_ctx, contract_address, logs)
 
-        # 4. Execute
+        # ── Phase 4: Rust ContractVM orchestration ──
+        # Try to handle the entire execution lifecycle in Rust.
+        # If Rust signals needs_fallback we fall through to Python.
+        if (self._rust_contract_vm is not None
+                and self._use_bytecode_vm
+                and hasattr(action_obj, 'body')):
+            rust_receipt = self._try_rust_contract_vm(
+                contract_address, action_obj, state_adapter,
+                snapshot, env, args or {}, gas_limit, caller, logs,
+            )
+            if rust_receipt is not None:
+                return rust_receipt
+
+        # 4. Execute (Python path — Phase 3/0/tree-walk)
         try:
             vm = ZexusVM(
                 env=env,
@@ -717,6 +769,16 @@ class ContractVM:
                 except Exception:
                     pass
 
+        # --- Phase 3: Rust VM execution for large contracts ---
+        if (self._rust_vm_executor is not None
+                and self._use_bytecode_vm
+                and hasattr(action_obj, 'body')):
+            rust_result = self._try_rust_vm_execution(
+                action_obj, env, args, vm, cached_bc
+            )
+            if rust_result is not None:
+                used_bytecode, result = rust_result
+
         # --- Phase 0: bytecoded execution with fallback ---
         if self._use_bytecode_vm and hasattr(action_obj, 'body'):
             try:
@@ -811,9 +873,342 @@ class ContractVM:
 
         return result
 
+    def _try_rust_vm_execution(
+        self,
+        action_obj: Any,
+        env: Dict[str, Any],
+        args: Dict[str, Any],
+        vm: "ZexusVM",
+        cached_bc: Any,
+    ) -> Optional[Tuple[bool, Any]]:
+        """Attempt to run an action through the Rust VM.
+
+        Returns ``(True, result)`` on success, ``None`` if the Rust VM
+        is unavailable or signals a fallback.  The caller should fall
+        through to Phase 0 / tree-walk when ``None`` is returned.
+        """
+        try:
+            from ..vm.binary_bytecode import serialize as _serialize_zxc
+
+            # We need serializable bytecode — either from the .zxc cache
+            # or by compiling now.
+            zxc_data = None
+            bc = cached_bc
+            if bc is None:
+                # Try to compile to bytecode so we can check instruction count
+                from ..evaluator.core import Evaluator
+                evaluator = Evaluator(use_vm=True)
+                try:
+                    bc = evaluator.compile_to_bytecode(action_obj.body)
+                except Exception:
+                    return None
+
+            # Check threshold
+            instr_count = len(getattr(bc, "instructions", []))
+            if instr_count < self._rust_vm_threshold:
+                return None  # Too small — let Python handle it
+
+            # Serialize
+            zxc_data = _serialize_zxc(bc, include_checksum=True)
+
+            # Build state dict from ContractStateAdapter
+            state_adapter = env.get("_blockchain_state")
+            rust_state = {}
+            if state_adapter and isinstance(state_adapter, dict):
+                for k, v in state_adapter.items():
+                    if isinstance(v, (int, float, str, bool, type(None))):
+                        rust_state[k] = v
+
+            # Build env dict (simple values only)
+            from ..object import (
+                Integer as ZInteger, Float as ZFloat,
+                Boolean as ZBoolean, String as ZString, Null as ZNull,
+            )
+            rust_env = {}
+            for k, v in env.items():
+                if isinstance(v, (int, float, str, bool, type(None))):
+                    rust_env[k] = v
+                elif isinstance(v, ZInteger):
+                    rust_env[k] = v.value
+                elif isinstance(v, ZFloat):
+                    rust_env[k] = v.value
+                elif isinstance(v, ZString):
+                    rust_env[k] = v.value
+                elif isinstance(v, ZBoolean):
+                    rust_env[k] = v.value
+                elif isinstance(v, ZNull):
+                    rust_env[k] = None
+
+            # Add action parameters
+            if hasattr(action_obj, 'parameters') and action_obj.parameters:
+                for param in action_obj.parameters:
+                    param_name = param.value if hasattr(param, 'value') else str(param)
+                    if param_name in args:
+                        v = args[param_name]
+                        if isinstance(v, (int, float, str, bool, type(None))):
+                            rust_env[param_name] = v
+
+            # Gas limit
+            gas_limit = 0
+            if vm.gas_metering:
+                remaining_fn = getattr(vm.gas_metering, "remaining", None)
+                if callable(remaining_fn):
+                    try:
+                        rem = remaining_fn()
+                        if isinstance(rem, (int, float)) and rem > 0:
+                            gas_limit = int(rem)
+                    except Exception:
+                        pass
+                if gas_limit == 0:
+                    gl = getattr(vm.gas_metering, "gas_limit", 0) or 0
+                    gu = getattr(vm.gas_metering, "gas_used", 0) or 0
+                    if isinstance(gl, (int, float)) and isinstance(gu, (int, float)):
+                        if gl > gu:
+                            gas_limit = int(gl - gu)
+
+            # Execute
+            result_dict = self._rust_vm_executor.execute(
+                zxc_data,
+                env=rust_env or None,
+                state=rust_state or None,
+                gas_limit=gas_limit,
+            )
+
+            # Fallback?
+            if result_dict.get("needs_fallback", False):
+                self._vm_stats["rust_fallbacks"] += 1
+                return None
+
+            # Error?
+            error = result_dict.get("error")
+            if error:
+                if "OutOfGas" in str(error):
+                    raise RuntimeError(str(error))
+                if "RequireFailed" in str(error):
+                    raise RuntimeError(str(error))
+                # Other errors — fall back
+                self._vm_stats["rust_fallbacks"] += 1
+                return None
+
+            # Success — bridge gas back
+            if vm.gas_metering:
+                rust_gas = result_dict.get("gas_used", 0)
+                if rust_gas > 0:
+                    current_used = getattr(vm.gas_metering, "gas_used", None)
+                    if current_used is not None:
+                        vm.gas_metering.gas_used = current_used + rust_gas
+                    add_fn = getattr(vm.gas_metering, "add_gas", None)
+                    if add_fn:
+                        add_fn(rust_gas)
+
+            # Merge state back into ContractStateAdapter
+            rust_state_out = result_dict.get("state", {})
+            if rust_state_out and state_adapter is not None:
+                for k, v in rust_state_out.items():
+                    state_adapter[k] = v
+
+            self._vm_stats["rust_executions"] += 1
+            if self._debug:
+                logger.debug(
+                    "Rust VM execution: ops=%d gas=%d",
+                    result_dict.get("instructions_executed", 0),
+                    result_dict.get("gas_used", 0),
+                )
+
+            return (True, result_dict.get("result"))
+
+        except Exception as e:
+            self._vm_stats["rust_fallbacks"] += 1
+            logger.debug("Rust VM execution failed, falling back: %s", e)
+            return None
+
+    def _try_rust_contract_vm(
+        self,
+        contract_address: str,
+        action_obj: Any,
+        state_adapter: ContractStateAdapter,
+        snapshot: Dict[str, Any],
+        env: Dict[str, Any],
+        args: Dict[str, Any],
+        gas_limit: int,
+        caller: str,
+        logs: List[Dict[str, Any]],
+    ) -> Optional[ContractExecutionReceipt]:
+        """Phase 4: Attempt full contract execution via Rust ContractVM.
+
+        Returns a ``ContractExecutionReceipt`` on success, or ``None``
+        if Rust can't handle it (falls back to Python).
+        """
+        try:
+            from ..vm.binary_bytecode import serialize as _serialize_zxc
+
+            # Compile to bytecode
+            bc = getattr(action_obj, '_cached_bytecode', None)
+            if bc is None:
+                from ..evaluator.core import Evaluator
+                evaluator = Evaluator(use_vm=True)
+                try:
+                    bc = evaluator.compile_to_bytecode(action_obj.body)
+                except Exception:
+                    return None  # Can't compile — fall back
+
+            # Serialize to .zxc
+            zxc_data = _serialize_zxc(bc, include_checksum=True)
+
+            # Build state dict (simple values)
+            rust_state = {}
+            for k, v in state_adapter.items():
+                if isinstance(v, (int, float, str, bool, type(None))):
+                    rust_state[k] = v
+
+            # Build env dict (simple values)
+            from ..object import (
+                Integer as ZInteger, Float as ZFloat,
+                Boolean as ZBoolean, String as ZString, Null as ZNull,
+            )
+            rust_env = {}
+            for k, v in env.items():
+                if isinstance(v, (int, float, str, bool, type(None))):
+                    rust_env[k] = v
+                elif isinstance(v, ZInteger):
+                    rust_env[k] = v.value
+                elif isinstance(v, ZFloat):
+                    rust_env[k] = v.value
+                elif isinstance(v, ZString):
+                    rust_env[k] = v.value
+                elif isinstance(v, ZBoolean):
+                    rust_env[k] = v.value
+                elif isinstance(v, ZNull):
+                    rust_env[k] = None
+
+            # Phase 6: Inject chain info for Rust builtins
+            if "_block_number" not in rust_env:
+                try:
+                    rust_env["_block_number"] = self._chain.height
+                except Exception:
+                    rust_env["_block_number"] = 0
+            if "_block_timestamp" not in rust_env:
+                try:
+                    tip = self._chain.tip
+                    rust_env["_block_timestamp"] = (
+                        tip.header.timestamp if tip else 0.0
+                    )
+                except Exception:
+                    rust_env["_block_timestamp"] = 0.0
+
+            # Build args dict (simple values)
+            rust_args = {}
+            for k, v in args.items():
+                if isinstance(v, (int, float, str, bool, type(None))):
+                    rust_args[k] = v
+
+            # Execute via Rust ContractVM
+            result_dict = self._rust_contract_vm.execute_contract(
+                contract_address=contract_address,
+                action_bytecode=zxc_data,
+                state=rust_state or None,
+                env=rust_env or None,
+                args=rust_args or None,
+                gas_limit=gas_limit,
+                caller=caller,
+            )
+
+            # Check for fallback
+            if result_dict.get("needs_fallback", False):
+                self._vm_stats["rust_fallbacks"] += 1
+                if self._debug:
+                    logger.debug("Rust ContractVM needs fallback: %s",
+                                 result_dict.get("error", ""))
+                return None
+
+            # Build receipt
+            success = result_dict.get("success", False)
+            gas_used = result_dict.get("gas_used", 0)
+
+            if success:
+                # Merge new state back to ContractStateAdapter
+                new_state = result_dict.get("new_state", {})
+                if new_state:
+                    state_adapter.clear()
+                    state_adapter.update(new_state)
+                state_adapter.commit()
+
+                # Phase 6: Collect events emitted by Rust builtins
+                rust_events = result_dict.get("events", [])
+                import time as _time
+                for ev in rust_events:
+                    ev_name = ev.get("event", "") if isinstance(ev, dict) else str(ev)
+                    ev_data = ev.get("data", None) if isinstance(ev, dict) else None
+                    logs.append({
+                        "event": ev_name,
+                        "data": ev_data,
+                        "timestamp": _time.time(),
+                        "contract": contract_address,
+                    })
+
+                self._vm_stats["rust_executions"] += 1
+
+                return ContractExecutionReceipt(
+                    success=True,
+                    return_value=result_dict.get("result"),
+                    gas_used=gas_used,
+                    gas_limit=gas_limit,
+                    logs=list(logs),
+                    state_changes=result_dict.get("state_changes", {}),
+                )
+            else:
+                # Error — rollback
+                state_adapter.rollback(snapshot)
+                error = result_dict.get("error", "UnknownError")
+
+                if error == "OutOfGas":
+                    self._vm_stats["rust_fallbacks"] += 1
+                    return ContractExecutionReceipt(
+                        success=False,
+                        gas_used=gas_limit,
+                        gas_limit=gas_limit,
+                        error="OutOfGas",
+                        revert_reason=result_dict.get("revert_reason", ""),
+                    )
+                elif error == "ReentrancyGuard":
+                    return ContractExecutionReceipt(
+                        success=False,
+                        error="ReentrancyGuard",
+                        revert_reason=result_dict.get("revert_reason", ""),
+                        gas_limit=gas_limit,
+                    )
+                else:
+                    self._vm_stats["rust_fallbacks"] += 1
+                    return ContractExecutionReceipt(
+                        success=False,
+                        gas_used=gas_used,
+                        gas_limit=gas_limit,
+                        error=error,
+                        revert_reason=result_dict.get("revert_reason", ""),
+                        logs=list(logs),
+                    )
+
+        except Exception as e:
+            self._vm_stats["rust_fallbacks"] += 1
+            logger.debug("Rust ContractVM failed, falling back: %s", e)
+            return None
+
     def get_vm_execution_stats(self) -> Dict[str, Any]:
-        """Return Phase 0 execution statistics."""
-        total = sum(self._vm_stats.values())
+        """Return Phase 0-3 execution statistics."""
+        total = (
+            self._vm_stats["bytecode_executions"]
+            + self._vm_stats["bytecode_fallbacks"]
+            + self._vm_stats["treewalk_executions"]
+            + self._vm_stats["rust_executions"]
+        )
+        # Phase 4 stats from Rust ContractVM
+        rust_cvm_stats = {}
+        if self._rust_contract_vm is not None:
+            try:
+                rust_cvm_stats = self._rust_contract_vm.get_stats()
+            except Exception:
+                pass
+
         return {
             **self._vm_stats,
             "total_executions": total,
@@ -821,7 +1216,15 @@ class ContractVM:
                 self._vm_stats["bytecode_executions"] / total * 100
                 if total > 0 else 0.0
             ),
+            "rust_rate": (
+                self._vm_stats["rust_executions"] / total * 100
+                if total > 0 else 0.0
+            ),
             "use_bytecode_vm": self._use_bytecode_vm,
+            "rust_vm_available": self._rust_vm_executor is not None,
+            "rust_vm_threshold": self._rust_vm_threshold,
+            "rust_contract_vm_available": self._rust_contract_vm is not None,
+            "rust_contract_vm_stats": rust_cvm_stats,
         }
 
     # ------------------------------------------------------------------
@@ -940,6 +1343,9 @@ class ContractVM:
                 gas_limit=gas_limit,
                 debug=self._debug,
             )
+            # Static calls use light gas metering (flat 1/op) since
+            # they don't consume chain resources — read-only.
+            vm.enable_gas_light = True
             result = self._execute_action(vm, action_obj, env, args or {})
             gas_used = vm.gas_metering.gas_used if vm.gas_metering else 0
 

package/src/zexus/blockchain/rust_bridge.py

@@ -327,6 +327,48 @@ def _execute_batch_py(
     return result
 
 
+# ── Phase 5: GIL-free Native Batch Execution ──────────────────────────
+
+def execute_batch_native(
+    transactions: List[Dict[str, Any]],
+    max_workers: int = 0,
+    gas_discount: float = 0.6,
+    default_gas_limit: int = 10_000_000,
+) -> Optional[Dict[str, Any]]:
+    """Execute a batch of pre-compiled .zxc transactions entirely in Rust.
+
+    **Zero GIL acquisitions during execution.**  Requires Rust core.
+
+    Parameters
+    ----------
+    transactions : list of dict
+        Each dict must contain ``bytecode`` (bytes), ``contract_address`` (str),
+        ``caller`` (str).  Optional: ``gas_limit``, ``state``, ``gas_discount``.
+    max_workers : int
+        Rayon thread count (0 = auto-detect CPU cores).
+    gas_discount : float
+        Default gas discount for Rust execution (0.6 = 40% cheaper).
+    default_gas_limit : int
+        Default gas limit if not specified per-transaction.
+
+    Returns
+    -------
+    dict or None
+        Dict with keys: total, succeeded, failed, gas_used, gas_saved,
+        throughput, receipts, state_changes, mode='native_gil_free'.
+        Returns None if Rust core is not available.
+    """
+    if not _RUST_AVAILABLE:
+        return None
+
+    executor = _zexus_core.RustBatchExecutor(
+        max_workers=max_workers,
+        gas_discount=gas_discount,
+        default_gas_limit=default_gas_limit,
+    )
+    return executor.execute_batch_native(transactions)
+
+
 # ── Block Validation ───────────────────────────────────────────────────
 
 def validate_chain_headers(
@@ -416,6 +458,28 @@ class RustCoreBridge:
             transactions, vm_callback, max_workers=self._max_workers
         )
 
+    def execute_batch_native(
+        self,
+        transactions: List[Dict[str, Any]],
+    ) -> Optional[Dict[str, Any]]:
+        """Execute a batch of pre-compiled .zxc transactions — zero GIL.
+
+        Each transaction dict must contain:
+          - ``bytecode``: bytes — .zxc serialized bytecode
+          - ``contract_address``: str
+          - ``caller``: str
+          - ``gas_limit``: int (optional)
+          - ``state``: dict (optional)
+          - ``gas_discount``: float (optional)
+
+        Returns a dict with keys: total, succeeded, failed, gas_used,
+        gas_saved, throughput, receipts, state_changes, mode='native_gil_free'.
+        Returns None if Rust is not available.
+        """
+        return execute_batch_native(
+            transactions, max_workers=self._max_workers
+        )
+
     # Validation
     validate_chain = staticmethod(validate_chain_headers)
     check_pow = staticmethod(check_pow_difficulty)

package/src/zexus/cli/main.py

@@ -156,7 +156,7 @@ def show_all_commands():
     console.print("\n[bold green]💡 Tip:[/bold green] Use 'zx <command> --help' for detailed command options\n")
 
 @click.group(invoke_without_command=True)
-@click.version_option(version="1.7.2", prog_name="Zexus")
+@click.version_option(version="1.8.1", prog_name="Zexus")
 @click.option('--syntax-style', type=click.Choice(['universal', 'tolerable', 'auto']),
               default='auto', help='Syntax style to use (universal=strict, tolerable=flexible)')
 @click.option('--advanced-parsing', is_flag=True, default=True,

package/src/zexus/cli/zpm.py

@@ -18,7 +18,7 @@ console = Console()
 
 
 @click.group()
-@click.version_option(version="1.7.2", prog_name="ZPM")
+@click.version_option(version="1.8.1", prog_name="ZPM")
 def cli():
     """ZPM - Zexus Package Manager