zexus 1.8.2 → 1.8.3

package/src/zexus/stdlib/blockchain.py

@@ -319,6 +319,90 @@ class BlockchainModule:
         
         return True
 
+    @staticmethod
+    def create_chain(name: str = "default", config: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Create a new blockchain initialized with a genesis block.
+
+        Args:
+            name: Name/identifier for this chain (default: "default")
+            config: Optional configuration dict. Supported keys:
+                - difficulty (int): Mining difficulty (default: 4)
+                - mining_reward (float): Block reward (default: 50.0)
+                - max_supply (float): Maximum token supply (default: 21_000_000.0)
+
+        Returns:
+            A chain dict with keys: name, config, blocks (list starting with
+            genesis), pending_transactions, height, and created_at.
+        """
+        cfg = {
+            "difficulty": 4,
+            "mining_reward": 50.0,
+            "max_supply": 21_000_000.0,
+        }
+        if config:
+            cfg.update(config)
+
+        genesis = BlockchainModule.create_genesis_block()
+
+        return {
+            "name": name,
+            "config": cfg,
+            "blocks": [genesis],
+            "pending_transactions": [],
+            "height": 1,
+            "created_at": genesis["timestamp"],
+        }
+
+    @staticmethod
+    def add_block(chain: Dict[str, Any], data: Any) -> Dict[str, Any]:
+        """Add a new block to an existing chain.
+
+        Args:
+            chain: Chain dict returned by create_chain()
+            data: Data/transactions to include in the block
+
+        Returns:
+            The newly created block (also appended to chain["blocks"]).
+        """
+        blocks = chain.get("blocks", [])
+        last_block = blocks[-1] if blocks else None
+        prev_hash = last_block["hash"] if last_block else "0" * 64
+        index = len(blocks)
+
+        new_block = BlockchainModule.create_block(
+            index=index,
+            timestamp=time.time(),
+            data=data,
+            previous_hash=prev_hash,
+            nonce=0,
+        )
+        blocks.append(new_block)
+        chain["blocks"] = blocks
+        chain["height"] = len(blocks)
+        return new_block
+
+    @staticmethod
+    def get_chain_info(chain: Dict[str, Any]) -> Dict[str, Any]:
+        """Return summary information about a chain.
+
+        Args:
+            chain: Chain dict returned by create_chain()
+
+        Returns:
+            Dict with name, height, difficulty, mining_reward, created_at,
+            latest_hash.
+        """
+        blocks = chain.get("blocks", [])
+        cfg = chain.get("config", {})
+        return {
+            "name": chain.get("name", "unknown"),
+            "height": chain.get("height", len(blocks)),
+            "difficulty": cfg.get("difficulty", 4),
+            "mining_reward": cfg.get("mining_reward", 50.0),
+            "created_at": chain.get("created_at", 0),
+            "latest_hash": blocks[-1]["hash"] if blocks else "",
+        }
+
 
 # Export functions for easy access
 create_address = BlockchainModule.create_address

package/src/zexus/stdlib/http_server.py

@@ -201,7 +201,7 @@ class HTTPServer:
         finally:
             try:
                 client_socket.close()
-            except:
+            except OSError:
                 pass
     
     def listen(self):
@@ -244,5 +244,5 @@ class HTTPServer:
         if self.socket:
             try:
                 self.socket.close()
-            except:
+            except OSError:
                 pass

package/src/zexus/stdlib/math.py

@@ -1,9 +1,17 @@
 """Math module for Zexus standard library."""
 
 import math
-import random
+import random as _random_module
 from typing import List
 
+# Save builtin references before module-level exports shadow them
+_builtin_min = min
+_builtin_max = max
+_builtin_sum = sum
+_builtin_abs = abs
+_builtin_round = round
+_builtin_pow = pow
+
 
 class MathModule:
     """Provides advanced mathematical operations."""
@@ -121,7 +129,7 @@ class MathModule:
     @staticmethod
     def cbrt(x: float) -> float:
         """Cube root."""
-        return math.copysign(1, x) * abs(x) ** (1/3)
+        return math.copysign(1, x) * _builtin_abs(x) ** (1/3)
 
     # Rounding and absolute functions
     @staticmethod
@@ -142,12 +150,12 @@ class MathModule:
     @staticmethod
     def round(x: float, ndigits: int = 0) -> float:
         """Round to n digits."""
-        return round(x, ndigits)
+        return _builtin_round(x, ndigits)
 
     @staticmethod
     def abs(x: float) -> float:
         """Absolute value."""
-        return abs(x)
+        return _builtin_abs(x)
 
     # Other functions
     @staticmethod
@@ -163,7 +171,7 @@ class MathModule:
     @staticmethod
     def lcm(a: int, b: int) -> int:
         """Least common multiple."""
-        return abs(a * b) // math.gcd(a, b) if a and b else 0
+        return _builtin_abs(a * b) // math.gcd(a, b) if a and b else 0
 
     @staticmethod
     def degrees(x: float) -> float:
@@ -209,12 +217,12 @@ class MathModule:
     @staticmethod
     def sum(numbers: List[float]) -> float:
         """Sum of numbers."""
-        return sum(numbers)
+        return _builtin_sum(numbers)
 
     @staticmethod
     def mean(numbers: List[float]) -> float:
         """Arithmetic mean."""
-        return sum(numbers) / len(numbers) if numbers else 0
+        return _builtin_sum(numbers) / len(numbers) if numbers else 0
 
     @staticmethod
     def median(numbers: List[float]) -> float:
@@ -242,7 +250,7 @@ class MathModule:
         if not numbers:
             return 0
         m = MathModule.mean(numbers)
-        return sum((x - m) ** 2 for x in numbers) / len(numbers)
+        return _builtin_sum((x - m) ** 2 for x in numbers) / len(numbers)
 
     @staticmethod
     def stdev(numbers: List[float]) -> float:
@@ -252,17 +260,17 @@ class MathModule:
     @staticmethod
     def min(numbers: List[float]) -> float:
         """Minimum value."""
-        return min(numbers) if numbers else 0
+        return _builtin_min(numbers) if numbers else 0
 
     @staticmethod
     def max(numbers: List[float]) -> float:
         """Maximum value."""
-        return max(numbers) if numbers else 0
+        return _builtin_max(numbers) if numbers else 0
 
     @staticmethod
     def clamp(x: float, min_val: float, max_val: float) -> float:
         """Clamp x between min and max."""
-        return max(min_val, min(max_val, x))
+        return _builtin_max(min_val, _builtin_min(max_val, x))
 
     @staticmethod
     def lerp(a: float, b: float, t: float) -> float:
@@ -273,30 +281,30 @@ class MathModule:
     @staticmethod
     def random() -> float:
         """Random float in [0, 1)."""
-        return random.random()
+        return _random_module.random()
 
     @staticmethod
     def randint(a: int, b: int) -> int:
         """Random integer in [a, b]."""
-        return random.randint(a, b)
+        return _random_module.randint(a, b)
 
     @staticmethod
     def randrange(start: int, stop: int = None, step: int = 1) -> int:
         """Random integer from range."""
         if stop is None:
-            return random.randrange(start)
-        return random.randrange(start, stop, step)
+            return _random_module.randrange(start)
+        return _random_module.randrange(start, stop, step)
 
     @staticmethod
     def choice(seq: List) -> any:
         """Random element from sequence."""
-        return random.choice(seq) if seq else None
+        return _random_module.choice(seq) if seq else None
 
     @staticmethod
     def shuffle(seq: List) -> List:
         """Shuffle sequence (returns new list)."""
         result = seq.copy()
-        random.shuffle(result)
+        _random_module.shuffle(result)
         return result
 
 

package/src/zexus/stdlib_integration.py

@@ -3,7 +3,7 @@ Standard Library Integration for Zexus
 Provides integration between Python stdlib modules and Zexus evaluator.
 """
 
-from .object import Environment, Builtin, String, Integer, Float, Boolean, Map, List as ListObj, EvaluationError
+from .object import Environment, Builtin, String, Integer, Float, Boolean, Null, Map, List as ListObj, EvaluationError
 
 
 def create_stdlib_module(module_name, evaluator=None):
@@ -595,6 +595,54 @@ def create_stdlib_module(module_name, evaluator=None):
             except Exception as e:
                 return EvaluationError(f"validate_chain error: {str(e)}")
 
+        def _blockchain_create_chain(*args):
+            name = "default"
+            config = None
+            if len(args) >= 1 and hasattr(args[0], 'value'):
+                name = str(args[0].value)
+            if len(args) >= 2 and isinstance(args[1], Map):
+                config = {}
+                for k, v in args[1].pairs.items():
+                    key = k.value if hasattr(k, 'value') else str(k)
+                    val = v.value if hasattr(v, 'value') else v
+                    config[key] = val
+            try:
+                result = BlockchainModule.create_chain(name, config)
+                return _python_to_zexus(result)
+            except Exception as e:
+                return EvaluationError(f"create_chain error: {str(e)}")
+
+        def _blockchain_add_block(*args):
+            if len(args) < 2:
+                return EvaluationError("add_block() requires 2 args: chain, data")
+            chain_obj = args[0]
+            if not isinstance(chain_obj, Map):
+                return EvaluationError("add_block() first argument must be a chain map")
+            chain = _zexus_to_python(chain_obj)
+            data = args[1].value if hasattr(args[1], 'value') else str(args[1])
+            try:
+                new_block = BlockchainModule.add_block(chain, data)
+                # Update the original map in-place so the caller sees changes
+                updated = _python_to_zexus(chain)
+                if isinstance(updated, Map):
+                    chain_obj.pairs = updated.pairs
+                return _python_to_zexus(new_block)
+            except Exception as e:
+                return EvaluationError(f"add_block error: {str(e)}")
+
+        def _blockchain_get_chain_info(*args):
+            if len(args) < 1:
+                return EvaluationError("get_chain_info() requires 1 argument: chain")
+            chain_obj = args[0]
+            if not isinstance(chain_obj, Map):
+                return EvaluationError("get_chain_info() expects a chain map")
+            chain = _zexus_to_python(chain_obj)
+            try:
+                result = BlockchainModule.get_chain_info(chain)
+                return _python_to_zexus(result)
+            except Exception as e:
+                return EvaluationError(f"get_chain_info error: {str(e)}")
+
         env.set("create_address", Builtin(_blockchain_create_address))
         env.set("validate_address", Builtin(_blockchain_validate_address))
         env.set("calculate_merkle_root", Builtin(_blockchain_calculate_merkle_root))
@@ -606,6 +654,24 @@ def create_stdlib_module(module_name, evaluator=None):
         env.set("create_transaction", Builtin(_blockchain_create_transaction))
         env.set("hash_transaction", Builtin(_blockchain_hash_transaction))
         env.set("validate_chain", Builtin(_blockchain_validate_chain))
+        env.set("create_chain", Builtin(_blockchain_create_chain))
+        env.set("add_block", Builtin(_blockchain_add_block))
+        env.set("get_chain_info", Builtin(_blockchain_get_chain_info))
+        # camelCase aliases for blockchain functions
+        env.set("createChain", Builtin(_blockchain_create_chain))
+        env.set("addBlock", Builtin(_blockchain_add_block))
+        env.set("getChainInfo", Builtin(_blockchain_get_chain_info))
+        env.set("createAddress", Builtin(_blockchain_create_address))
+        env.set("validateAddress", Builtin(_blockchain_validate_address))
+        env.set("calculateMerkleRoot", Builtin(_blockchain_calculate_merkle_root))
+        env.set("createGenesisBlock", Builtin(_blockchain_create_genesis_block))
+        env.set("createBlock", Builtin(_blockchain_create_block))
+        env.set("hashBlock", Builtin(_blockchain_hash_block))
+        env.set("validateBlock", Builtin(_blockchain_validate_block))
+        env.set("proofOfWork", Builtin(_blockchain_proof_of_work))
+        env.set("createTransaction", Builtin(_blockchain_create_transaction))
+        env.set("hashTransaction", Builtin(_blockchain_hash_transaction))
+        env.set("validateChain", Builtin(_blockchain_validate_chain))
 
     elif module_name == "websocket" or module_name == "stdlib/websocket":
         try:
@@ -655,6 +721,57 @@ def create_stdlib_module(module_name, evaluator=None):
         env.set("create_server", Builtin(_ws_create_server))
         env.set("connect", Builtin(_ws_connect))
 
+    elif module_name == "kernel" or module_name == "stdlib/kernel":
+        # Expose the kernel extension layer to Zexus scripts
+        try:
+            from .kernel import get_kernel
+
+            kernel = get_kernel()
+            if not kernel.is_booted:
+                kernel.boot()
+
+            def _kernel_status(*args):
+                return _python_to_zexus(kernel.status())
+
+            def _kernel_domains(*args):
+                domains = kernel.registry.list_domains()
+                return _python_to_zexus([
+                    {"name": d.name, "version": d.version, "opcodes": len(d.opcodes)}
+                    for d in domains
+                ])
+
+            def _kernel_get_domain(*args):
+                if len(args) < 1:
+                    return EvaluationError("get_domain() requires 1 argument: name")
+                name = args[0].value if hasattr(args[0], 'value') else str(args[0])
+                d = kernel.registry.get_domain(name)
+                if d is None:
+                    return Null()
+                return _python_to_zexus({
+                    "name": d.name,
+                    "version": d.version,
+                    "description": d.description,
+                    "opcodes": d.opcodes,
+                })
+
+            def _kernel_resolve_opcode(*args):
+                if len(args) < 1:
+                    return EvaluationError("resolve_opcode() requires 1 argument: opcode (int)")
+                op = int(args[0].value) if hasattr(args[0], 'value') else int(args[0])
+                owner = kernel.resolve_opcode_domain(op)
+                return String(owner) if owner else Null()
+
+            def _kernel_is_booted(*args):
+                return Boolean(kernel.is_booted)
+
+            env.set("status", Builtin(_kernel_status))
+            env.set("domains", Builtin(_kernel_domains))
+            env.set("get_domain", Builtin(_kernel_get_domain))
+            env.set("resolve_opcode", Builtin(_kernel_resolve_opcode))
+            env.set("is_booted", Builtin(_kernel_is_booted))
+        except Exception:
+            pass  # Kernel not available — module is empty but doesn't crash
+
     return env
 
 
@@ -690,7 +807,7 @@ def _zexus_to_python(obj):
 
 def is_stdlib_module(module_name):
     """Check if a module name refers to a stdlib module."""
-    stdlib_modules = ['fs', 'http', 'json', 'datetime', 'crypto', 'blockchain', 'perf', 'websocket']
+    stdlib_modules = ['fs', 'http', 'json', 'datetime', 'crypto', 'blockchain', 'perf', 'websocket', 'kernel']
     
     # Handle both "fs" and "stdlib/fs" formats
     if module_name in stdlib_modules:

package/src/zexus/type_checker.py

@@ -431,18 +431,23 @@ class StaticTypeChecker:
                 )
 
         # Per-argument type check
-        for i, (pname, pts) in enumerate(params):
-            if i >= len(args):
-                break
-            if pts is None:
-                continue
-            actual = _infer_expr_type(args[i], self._scope)
-            if actual and not _is_compatible(pts, actual):
-                self._error(
-                    f"Argument '{pname}' of '{fn_name}' expects "
-                    f"{pts.base_type.value} but got {actual.base_type.value}",
-                    call,
-                )
+        # Skip for entity constructors using {field: value} syntax —
+        # the single MapLiteral arg doesn't match positional param types.
+        if is_entity and len(args) == 1 and isinstance(args[0], ast.MapLiteral):
+            pass
+        else:
+            for i, (pname, pts) in enumerate(params):
+                if i >= len(args):
+                    break
+                if pts is None:
+                    continue
+                actual = _infer_expr_type(args[i], self._scope)
+                if actual and not _is_compatible(pts, actual):
+                    self._error(
+                        f"Argument '{pname}' of '{fn_name}' expects "
+                        f"{pts.base_type.value} but got {actual.base_type.value}",
+                        call,
+                    )
 
     def _check_infix_types(self, expr: ast.InfixExpression):
         """Warn on obviously wrong infix operations."""

package/src/zexus/vm/compiler.py

@@ -542,13 +542,27 @@ class BytecodeCompiler:
         exit_jump_idx = len(self.instructions)
         self._emit(Opcode.JUMP_IF_FALSE, None)               # jump to end if false
 
-        # --- Extract item: item = iterable[index] ---
-        self._emit(Opcode.LOAD_NAME, iter_const)            # push iterable
-        self._emit(Opcode.LOAD_NAME, index_const)           # push index
-        self._emit(Opcode.INDEX)                             # iterable[index]
+        # --- Extract item (and optional index/key) ---
         item_name = node.item.value if hasattr(node.item, 'value') else str(node.item)
         item_const = self._add_constant(item_name)
-        self._emit(Opcode.STORE_NAME, item_const)           # store as loop variable
+
+        if node.index:
+            # Two-variable for-each: for key, value in map OR for i, item in list
+            # Use FOR_ITER 2: pushes (index_or_key, item_or_value) onto stack
+            user_index_name = node.index.value if hasattr(node.index, 'value') else str(node.index)
+            user_index_const = self._add_constant(user_index_name)
+            self._emit(Opcode.LOAD_NAME, iter_const)        # push iterable
+            self._emit(Opcode.LOAD_NAME, index_const)       # push counter
+            self._emit(Opcode.FOR_ITER, 2)                   # push key/index, then value/item
+            self._emit(Opcode.STORE_NAME, item_const)        # store item/value (top)
+            self._emit(Opcode.STORE_NAME, user_index_const)  # store index/key (below)
+        else:
+            # Single variable: for item in list OR for key in map
+            # Use FOR_ITER 1: pushes single value (element for list, key for dict)
+            self._emit(Opcode.LOAD_NAME, iter_const)        # push iterable
+            self._emit(Opcode.LOAD_NAME, index_const)       # push counter
+            self._emit(Opcode.FOR_ITER, 1)                   # push item or key
+            self._emit(Opcode.STORE_NAME, item_const)        # store as loop variable
 
         # --- Body ---
         self._compile_node(node.body)
@@ -633,7 +647,16 @@ class BytecodeCompiler:
             count = len(pairs)
 
         for key, value in iterable:
-            self._compile_node(key)
+            # Map literal keys that are Identifiers should be treated as
+            # string constants (field names), NOT as variable lookups.
+            if hasattr(key, '__class__') and key.__class__.__name__ == 'Identifier':
+                const_idx = self._add_constant(key.value)
+                self._emit(Opcode.LOAD_CONST, const_idx)
+            elif isinstance(key, str):
+                const_idx = self._add_constant(key)
+                self._emit(Opcode.LOAD_CONST, const_idx)
+            else:
+                self._compile_node(key)
             self._compile_node(value)
         
         # Build map
@@ -1104,6 +1127,34 @@ class BytecodeCompiler:
         self._emit(Opcode.DEFINE_ENTITY, member_count)
         self._emit(Opcode.STORE_NAME, name_idx)
 
+    def _compile_StateStatement(self, node):
+        """Compile a standalone state declaration.
+
+        Inside a contract, state vars are handled by _compile_ContractStatement
+        which pushes (name, value) pairs for DEFINE_CONTRACT.  When a
+        StateStatement appears at the top level or outside contracts, we
+        compile it as a STATE_WRITE + STORE_NAME so the variable is available
+        in the local environment AND in the blockchain state dict.
+        """
+        var_name = node.name.value if hasattr(node.name, 'value') else str(node.name)
+        name_idx = self._add_constant(var_name)
+
+        # Compile the initial value expression (or None)
+        if getattr(node, 'initial_value', None):
+            self._compile_node(node.initial_value)
+        else:
+            self._emit(Opcode.LOAD_CONST, self._add_constant(None))
+
+        # Write to blockchain state dict
+        self._emit(Opcode.STATE_WRITE, name_idx)
+
+        # Also store in local environment so it's accessible as a normal variable
+        if getattr(node, 'initial_value', None):
+            self._compile_node(node.initial_value)
+        else:
+            self._emit(Opcode.LOAD_CONST, self._add_constant(None))
+        self._emit(Opcode.STORE_NAME, name_idx)
+
     def _compile_ExportStatement(self, node):
         """Compile export statement - marks names for module export.