zexus 1.7.2 → 1.8.0

package/src/zexus/vm/gas_metering.py

@@ -59,7 +59,7 @@ class GasCost(IntEnum):
     CALL_TOP = 10
     CALL_METHOD = 10
     CALL_BUILTIN = 8
-    STORE_FUNC = 5
+    STORE_FUNC = 3       # Aligned with Rust — function storage is a cheap memory op
     BUILD_LAMBDA = 5
     
     # Async operations
@@ -71,7 +71,7 @@ class GasCost(IntEnum):
     VERIFY_SIGNATURE = 100
     MERKLE_ROOT = 30  # Base cost, + per leaf
     STATE_READ = 20
-    STATE_WRITE = 50
+    STATE_WRITE = 30       # Reduced: RustStateAdapter caching makes writes memory-local
     TX_BEGIN = 20
     TX_COMMIT = 30
     TX_REVERT = 20

package/src/zexus/vm/vm.py

@@ -136,6 +136,17 @@ except Exception:
     _FASTOPS_AVAILABLE = False
     _fastops = None
 
+# Rust VM (Phase 3 — adaptive execution)
+try:
+    from zexus_core import RustVMExecutor as _RustVMExecutor
+    _RUST_VM_AVAILABLE = True
+except Exception:
+    _RUST_VM_AVAILABLE = False
+    _RustVMExecutor = None
+
+# Sentinel returned when Rust VM signals needs_fallback
+_RUST_VM_FALLBACK_SENTINEL = object()
+
 # Async Optimizer (Phase 8)
 try:
     from .async_optimizer import AsyncOptimizer, AsyncOptimizationLevel
@@ -425,6 +436,25 @@ class VM:
         self._in_execution = 0
         self._native_jit_auto_enabled = False
         self._native_jit_auto_threshold = 700
+
+        # --- Rust VM Adaptive Routing (Phase 3 + Phase 6) ---
+        self._rust_vm_available = _RUST_VM_AVAILABLE
+        self._rust_vm_executor = _RustVMExecutor() if _RUST_VM_AVAILABLE else None
+        self._rust_vm_threshold = 0  # Phase 6: route ALL programs 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
+        self._rust_vm_enabled = self._rust_vm_available  # Can be disabled at runtime
+        self._rust_vm_stats = {
+            "rust_executions": 0,
+            "rust_fallbacks": 0,
+            "python_executions": 0,
+            "total_rust_ops": 0,
+        }
+
         self._env_version = 0
         self._name_cache: Dict[str, Tuple[Any, int]] = {}
         self._method_cache: Dict[Tuple[type, str], Any] = {}
@@ -1704,6 +1734,126 @@ class VM:
         if tag == "LIST": return [self._eval_hl_op(e) for e in op[1]]
         return None
 
+    # ==================== Rust VM Adaptive Routing (Phase 3) ====================
+
+    def _execute_via_rust_vm(self, bytecode, debug=False):
+        """Serialize bytecode to .zxc and execute via the Rust VM.
+
+        Returns the result value on success, or ``_RUST_VM_FALLBACK_SENTINEL``
+        if the Rust VM signals it needs a Python fallback (e.g. for
+        CALL_NAME / CALL_METHOD that need Python interop).
+        """
+        from .binary_bytecode import serialize as _serialize_zxc
+
+        # Serialize bytecode → .zxc binary
+        zxc_data = _serialize_zxc(bytecode, include_checksum=True)
+
+        # Build env dict for Rust (only simple serializable values)
+        rust_env = {}
+        for k, v in self.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, type(None))):
+                rust_env[k] = None
+            # Skip non-serializable values (callables, AST nodes, etc.)
+
+        # Build state dict (if blockchain state exists)
+        rust_state = {}
+        bc_state = self.env.get("_blockchain_state")
+        if bc_state and isinstance(bc_state, dict):
+            for k, v in bc_state.items():
+                if isinstance(v, (int, float, str, bool, type(None))):
+                    rust_state[k] = v
+
+        # Gas limit
+        gas_limit = 0
+        if self.gas_metering:
+            remaining_fn = getattr(self.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:
+                gas_limit_val = getattr(self.gas_metering, "gas_limit", 0) or 0
+                gas_used_val = getattr(self.gas_metering, "gas_used", 0) or 0
+                if isinstance(gas_limit_val, (int, float)) and isinstance(gas_used_val, (int, float)):
+                    if gas_limit_val > gas_used_val:
+                        gas_limit = int(gas_limit_val - gas_used_val)
+
+        # Execute via Rust VM
+        result_dict = self._rust_vm_executor.execute(
+            zxc_data,
+            env=rust_env or None,
+            state=rust_state or None,
+            gas_limit=gas_limit,
+        )
+
+        # Check for fallback
+        if result_dict.get("needs_fallback", False):
+            self._rust_vm_stats["rust_fallbacks"] += 1
+            if debug:
+                print("[VM] Rust VM needs Python fallback — delegating to Python VM")
+            return _RUST_VM_FALLBACK_SENTINEL
+
+        # Check for errors
+        error = result_dict.get("error")
+        if error:
+            if "OutOfGas" in str(error):
+                if self.gas_metering:
+                    raise OutOfGasError(str(error))
+                raise RuntimeError(str(error))
+            if "RequireFailed" in str(error):
+                raise RuntimeError(str(error))
+            raise RuntimeError(f"Rust VM error: {error}")
+
+        # Success — update stats
+        self._rust_vm_stats["rust_executions"] += 1
+        self._rust_vm_stats["total_rust_ops"] += result_dict.get("instructions_executed", 0)
+
+        # Bridge gas usage back to Python metering
+        if self.gas_metering:
+            rust_gas = result_dict.get("gas_used", 0)
+            if rust_gas > 0:
+                gas_used_attr = getattr(self.gas_metering, "gas_used", None)
+                if gas_used_attr is not None:
+                    self.gas_metering.gas_used = gas_used_attr + rust_gas
+                add_gas = getattr(self.gas_metering, "add_gas", None)
+                if add_gas:
+                    add_gas(rust_gas)
+
+        # Merge Rust env back into Python env
+        rust_env_out = result_dict.get("env", {})
+        if rust_env_out:
+            for k, v in rust_env_out.items():
+                self.env[k] = v
+
+        # Merge blockchain state back
+        rust_state_out = result_dict.get("state", {})
+        if rust_state_out and bc_state is not None:
+            for k, v in rust_state_out.items():
+                bc_state[k] = v
+
+        if debug:
+            print(f"[VM] Rust VM executed: ops={result_dict.get('instructions_executed', 0)} "
+                  f"gas={result_dict.get('gas_used', 0)}")
+
+        return result_dict.get("result")
+
+    def get_rust_vm_stats(self):
+        """Return statistics about Rust VM usage."""
+        return dict(self._rust_vm_stats)
+
     # ==================== Fast Synchronous Dispatch (Performance Mode) ====================
 
     def _run_stack_bytecode_sync(self, bytecode, debug=False):
@@ -1736,6 +1886,19 @@ class VM:
             except Exception:
                 pass
         
+        # Rust VM adaptive routing (Phase 3) — delegate to Rust when
+        # the program is large enough to amortise serialisation overhead.
+        if (self._rust_vm_enabled
+                and self._rust_vm_executor is not None
+                and len(instrs) >= self._rust_vm_threshold):
+            try:
+                rust_result = self._execute_via_rust_vm(bytecode, debug)
+                if rust_result is not _RUST_VM_FALLBACK_SENTINEL:
+                    return rust_result
+                # Rust signalled needs_fallback — continue to Python VM
+            except Exception:
+                self._rust_vm_stats["rust_fallbacks"] += 1
+        
         # Fast stack implementation
         stack: List[Any] = []
         stack_append = stack.append

package/src/zexus/zpm/package_manager.py

@@ -23,7 +23,7 @@ class PackageManager:
         self.installer = PackageInstaller(self.zpm_dir)
         self.publisher = PackagePublisher(self.registry)
         
-    def init(self, name: str = None, version: str = "1.7.2") -> Dict:
+    def init(self, name: str = None, version: str = "1.8.0") -> Dict:
         """Initialize a new Zexus project with package.json"""
         if self.config_file.exists():
             print(f"⚠️  {self.config_file} already exists")

package/src/zexus.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zexus
-Version: 1.7.2
+Version: 1.8.0
 Summary: A modern, security-first programming language with blockchain support
 Home-page: https://github.com/Zaidux/zexus-interpreter
 Author: Zaidux
@@ -53,7 +53,7 @@ Dynamic: requires-python
 
 <div align="center">
 
-![Zexus Logo](https://img.shields.io/badge/Zexus-v1.7.2-FF6B35?style=for-the-badge)
+![Zexus Logo](https://img.shields.io/badge/Zexus-v1.8.0-FF6B35?style=for-the-badge)
 [![License](https://img.shields.io/badge/License-MIT-blue.svg?style=for-the-badge)](LICENSE)
 [![Python](https://img.shields.io/badge/Python-3.8+-3776AB?style=for-the-badge&logo=python)](https://python.org)
 [![GitHub](https://img.shields.io/badge/GitHub-Zaidux/zexus--interpreter-181717?style=for-the-badge&logo=github)](https://github.com/Zaidux/zexus-interpreter)
@@ -118,9 +118,9 @@ Zexus is a next-generation, general-purpose programming language designed for se
 
 ---
 
-## 🎉 What's New in v1.7.2
+## 🎉 What's New in v1.8.0
 
-### Latest Features (v1.7.2)
+### Latest Features (v1.8.0)
 
 ✅ **FIND Keyword** - Declarative project search that resolves exact module paths with scope filtering and smart suggestions  
 ✅ **LOAD Keyword & Manager** - Provider-aware configuration loader with built-in ENV, JSON, and YAML support plus caching  
@@ -2643,6 +2643,29 @@ See [Ecosystem Strategy](docs/ECOSYSTEM_STRATEGY.md) for detailed roadmap.
 - Consider using `native` keyword for C/C++ FFI
 - Profile with `memory_stats()` to check for leaks
 
+#### PyPI upload fails on Termux with: "unsupported platform tag 'linux_aarch64'"
+- PyPI rejects wheels with generic `linux_*` platform tags (common when building on Termux).
+- **Fix**: upload an sdist (source distribution) and/or a pure-Python wheel:
+  - `python -m pip install --upgrade build twine`
+  - `python -m build`  # creates `dist/*.tar.gz` and (by default) a `py3-none-any.whl`
+  - `python -m twine upload dist/*.tar.gz dist/*-py3-none-any.whl`
+- `ZEXUS_BUILD_EXTENSIONS=1 python -m build` means: **build the optional native extensions** (Cython/C/C++) *in addition* to the Python code (it does not skip Python). This produces a **platform-specific** wheel.
+- If you want “everything compiled” locally, use:
+  - `ZEXUS_BUILD_EXTENSIONS=1 python -m build`
+  - or `ZEXUS_BUILD_EXTENSIONS=1 python -m pip install .`
+- For publishing native wheels to PyPI, build them in a manylinux environment (e.g. GitHub Actions + cibuildwheel). Wheels built on Termux are usually **not** PyPI-uploadable.
+  - This repo includes a workflow you can run: `.github/workflows/wheels.yml` (builds manylinux `aarch64` + `x86_64`, plus macOS/Windows wheels).
+  - To publish from GitHub Actions without API tokens, use **PyPI Trusted Publishing**:
+    - PyPI → your project → **Settings** → **Publishing** → **Trusted publishers** → **Add a new trusted publisher**
+    - Provider: **GitHub Actions**
+    - Owner: `Zaidux` (or your GitHub org/user)
+    - Repository: `zexus-interpreter`
+    - Workflow: `.github/workflows/wheels.yml`
+    - Environment: `pypi` (and optionally also add another trusted publisher entry for `testpypi`)
+    - Then either:
+      - Run **Actions → “Build wheels (cibuildwheel)” → Run workflow** and choose `testpypi` first, or
+      - Push a release tag like `v1.7.3` to auto-build + publish
+
 #### Blockchain/Contract issues
 - Remember `TX` is a global context object (uppercase)
 - Use `persistent storage` for contract state

package/src/zexus.egg-info/SOURCES.txt

@@ -28,6 +28,13 @@ VULNERABILITY_FINDINGS.md
 VULNERABILITY_TEST_RESULTS.md
 ZEXUS_BLOCKCHAIN_REFERENCE.md
 any.zx
+bench_compare.py
+bench_gas_stress.py
+bench_phase3.py
+bench_phase6.py
+bench_quick.py
+bench_vs.py
+benchmark_rust_vm.py
 check_action_tokens.py
 check_tokens.py
 check_verify_ast.py
@@ -73,6 +80,7 @@ zx-dev
 zx-run
 zx.bin
 .github/linguist.yml
+.github/workflows/wheels.yml
 .vscode/extensions.json
 .vscode/settings.json
 .vscode/extensions/zexus-language/README.md
@@ -264,6 +272,7 @@ docs/PERFORMANCE_FEATURES.md
 docs/PHILOSOPHY.md
 docs/PLUGIN_QUICK_REFERENCE.md
 docs/PLUGIN_SYSTEM.md
+docs/PYPI_TRUSTED_PUBLISHING.md
 docs/QUICK_REFERENCE.md
 docs/QUICK_START.md
 docs/README.md
@@ -477,11 +486,14 @@ linguist-submission/samples/security.zx
 rust_core/Cargo.lock
 rust_core/Cargo.toml
 rust_core/src/binary_bytecode.rs
+rust_core/src/contract_vm.rs
 rust_core/src/executor.rs
 rust_core/src/hasher.rs
 rust_core/src/lib.rs
 rust_core/src/merkle.rs
+rust_core/src/rust_vm.rs
 rust_core/src/signature.rs
+rust_core/src/state_adapter.rs
 rust_core/src/validator.rs
 samples/basic.zx
 samples/blockchain.zx
@@ -1088,9 +1100,14 @@ tests/vm/test_memory_pool.py
 tests/vm/test_optimizer.py
 tests/vm/test_parallel_vm.py
 tests/vm/test_peephole_optimizer.py
+tests/vm/test_phase3_adaptive.py
+tests/vm/test_phase4_contract_vm.py
+tests/vm/test_phase5_gil_free.py
+tests/vm/test_phase6_builtins.py
 tests/vm/test_profiler.py
 tests/vm/test_register_allocator.py
 tests/vm/test_register_vm.py
+tests/vm/test_rust_vm.py
 tests/vm/test_ssa_converter.py
 tests/vm/test_vm_async_integration.py
 tests/vm/test_vm_memory_pool_integration.py