Modular Core Implementation & Smart Contracts and contract tests

conftest.py

@@ -0,0 +1,4 @@
+import sys
+import os
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

consensus/__init__.py

@@ -0,0 +1,3 @@
+from .pow import mine_block, calculate_hash, MiningExceededError
+
+__all__ = ["mine_block", "calculate_hash", "MiningExceededError"]

consensus/pow.py

@@ -0,0 +1,73 @@
+import json
+import time
+from nacl.hash import sha256
+from nacl.encoding import HexEncoder
+
+
+class MiningExceededError(Exception):
+    """Raised when max_nonce, timeout, or cancellation is exceeded during mining."""
+
+
+def calculate_hash(block_dict):
+    """Calculates SHA256 hash of a block header."""
+    block_string = json.dumps(block_dict, sort_keys=True).encode("utf-8")
+    return sha256(block_string, encoder=HexEncoder).decode("utf-8")
+
+
+def mine_block(
+    block,
+    difficulty=4,
+    max_nonce=10_000_000,
+    timeout_seconds=None,
+    logger=None,
+    progress_callback=None
+):
+    """Mines a block using Proof-of-Work without mutating input block until success."""
+
+    target = "0" * difficulty
+    local_nonce = 0
+    start_time = time.time()
+
+    if logger:
+        logger.info(
+            "Mining block %s (Difficulty: %s)",
+            block.index,
+            difficulty,
+        )
+
+    while True:
+
+        # Enforce max_nonce limit before hashing
+        if local_nonce >= max_nonce:
+            if logger:
+                logger.warning("Max nonce exceeded during mining.")
+            raise MiningExceededError("Mining failed: max_nonce exceeded")
+
+        # Enforce timeout if specified
+        if timeout_seconds is not None and (time.time() - start_time) > timeout_seconds:
+            if logger:
+                logger.warning("Mining timeout exceeded.")
+            raise MiningExceededError("Mining failed: timeout exceeded")
+
+        # Temporarily set nonce for hashing only
+        block.nonce = local_nonce
+        block_hash = calculate_hash(block.to_header_dict())
+
+        # Allow cancellation via progress callback (pass nonce explicitly)
+        if progress_callback:
+            should_continue = progress_callback(local_nonce, block_hash)
+            if should_continue is False:
+                if logger:
+                    logger.info("Mining cancelled via progress_callback.")
+                raise MiningExceededError("Mining cancelled")
+
+        # Check difficulty target
+        if block_hash.startswith(target):
+            block.nonce = local_nonce
+            block.hash = block_hash
+            if logger:
+                logger.info("Success! Hash: %s", block_hash)
+            return block
+
+        # Increment nonce after attempt
+        local_nonce += 1

core/__init__.py

@@ -0,0 +1,13 @@
+from .block import Block
+from .chain import Blockchain
+from .transaction import Transaction
+from .state import State
+from .contract import ContractMachine
+
+__all__ = [
+    "Block",
+    "Blockchain",
+    "Transaction",
+    "State",
+    "ContractMachine",
+]

core/block.py

@@ -0,0 +1,34 @@
+import time
+
+class Block:
+    def __init__(self, index, previous_hash, transactions, timestamp=None, difficulty=None):
+        self.index = index
+        self.previous_hash = previous_hash
+        self.transactions = transactions
+        self.timestamp = time.time() if timestamp is None else timestamp
+        self.nonce = 0
+        self.hash = None
+        self.difficulty = difficulty
+
+    def to_dict(self):
+        """Full block data for serialization/transport."""
+        return {
+            "index": self.index,
+            "previous_hash": self.previous_hash,
+            "transactions": [tx.to_dict() for tx in self.transactions],
+            "timestamp": self.timestamp,
+            "difficulty": self.difficulty,
+            "nonce": self.nonce,
+            "hash": self.hash
+        }
+
+    def to_header_dict(self):
+        """Data used for mining (consensus)."""
+        return {
+            "index": self.index,
+            "previous_hash": self.previous_hash,
+            "transactions": [tx.to_dict() for tx in self.transactions],
+            "timestamp": self.timestamp,
+            "difficulty": self.difficulty,
+            "nonce": self.nonce
+        }

core/chain.py

@@ -0,0 +1,73 @@
+from core.block import Block
+from core.state import State
+from consensus import calculate_hash
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class Blockchain:
+    """
+    Manages the blockchain, validates blocks, and commits state transitions.
+    """
+
+    def __init__(self):
+        self.chain = []
+        self.state = State()
+        self._create_genesis_block()
+
+    def _create_genesis_block(self):
+        """
+        Creates the genesis block with a fixed hash.
+        """
+        genesis_block = Block(
+            index=0,
+            previous_hash="0",
+            transactions=[]
+        )
+        genesis_block.hash = "0" * 64
+        self.chain.append(genesis_block)
+
+    @property
+    def last_block(self):
+        """
+        Returns the most recent block in the chain.
+        """
+        return self.chain[-1]
+
+    def add_block(self, block):
+        """
+        Validates and adds a block to the chain if all transactions succeed.
+        Uses a copied State to ensure atomic validation.
+        """
+
+        # Check previous hash linkage
+        if block.previous_hash != self.last_block.hash:
+            logger.warning("Block %s rejected: Invalid previous hash %s != %s", block.index, block.previous_hash, self.last_block.hash)
+            return False
+
+        # Check index linkage
+        if block.index != self.last_block.index + 1:
+            logger.warning("Block %s rejected: Invalid index %s != %s", block.index, block.index, self.last_block.index + 1)
+            return False
+
+        # Verify block hash
+        if block.hash != calculate_hash(block.to_dict()):
+            logger.warning("Block %s rejected: Invalid hash %s", block.index, block.hash)
+            return False
+
+        # Validate transactions on a temporary state copy
+        temp_state = self.state.copy()
+
+        for tx in block.transactions:
+            result = temp_state.validate_and_apply(tx)
+
+            # Reject block if any transaction fails
+            if result is False or result is None:
+                logger.warning("Block %s rejected: Transaction failed validation", block.index)
+                return False
+
+        # All transactions valid → commit state and append block
+        self.state = temp_state
+        self.chain.append(block)
+        return True

core/contract.py

@@ -0,0 +1,135 @@
+import logging
+import multiprocessing
+import ast
+import sys
+
+logger = logging.getLogger(__name__)
+
+def _safe_exec_worker(code, globals_dict, context_dict, result_queue):
+    """
+    Worker function to execute contract code in a separate process.
+    """
+    try:
+        # Attempt to set resource limits (Unix only)
+        try:
+            import resource
+            # Limit CPU time (seconds) and memory (bytes) - example values
+            resource.setrlimit(resource.RLIMIT_CPU, (1, 1))
+            # resource.setrlimit(resource.RLIMIT_AS, (100 * 1024 * 1024, 100 * 1024 * 1024))
+        except ImportError as e:
+            logger.error(f"Resource limits not enforced: {e}")
+            raise RuntimeError(f"Resource limits not enforced: {e}")
+
+        exec(code, globals_dict, context_dict)
+        # Return the updated storage
+        result_queue.put({"status": "success", "storage": context_dict.get("storage")})
+    except Exception as e:
+        result_queue.put({"status": "error", "error": str(e)})
+
+class ContractMachine:
+    """
+    A minimal execution environment for Python-based smart contracts.
+    WARNING: Still not production-safe. For educational use only.
+    """
+
+    def __init__(self, state):
+        self.state = state
+
+    def execute(self, contract_address, sender_address, payload, amount):
+        """
+        Executes the contract code associated with the contract_address.
+        """
+
+        account = self.state.get_account(contract_address)
+        if not account:
+            return False
+
+        code = account.get("code")
+
+        # Defensive copy of storage to prevent direct mutation
+        storage = dict(account.get("storage", {}))
+
+        if not code:
+            return False
+
+        # AST Validation to prevent introspection
+        if not self._validate_code_ast(code):
+            return False
+
+        # Restricted builtins (explicit allowlist)
+        safe_builtins = {
+            "True": True,
+            "False": False,
+            "None": None,
+            "range": range,
+            "len": len,
+            "min": min,
+            "max": max,
+            "abs": abs,
+        }
+
+        globals_for_exec = {
+            "__builtins__": safe_builtins
+        }
+
+        # Execution context (locals)
+        context = {
+            "storage": storage,
+            "msg": {
+                "sender": sender_address,
+                "value": amount,
+                "data": payload,
+            },
+            "print": print,  # Explicitly allowed for debugging
+        }
+
+        try:
+            # Execute in a subprocess with timeout
+            queue = multiprocessing.Queue()
+            p = multiprocessing.Process(
+                target=_safe_exec_worker,
+                args=(code, globals_for_exec, context, queue)
+            )
+            p.start()
+            p.join(timeout=2)  # 2 second timeout
+
+            if p.is_alive():
+                p.kill()
+                logger.error("Contract execution timed out")
+                return False
+
+            if queue.empty():
+                logger.error("Contract execution crashed without result")
+                return False
+
+            result = queue.get()
+            if result["status"] != "success":
+                logger.error(f"Contract Execution Failed: {result.get('error')}")
+                return False
+
+            # Commit updated storage only after successful execution
+            self.state.update_contract_storage(
+                contract_address,
+                result["storage"]
+            )
+
+            return True
+
+        except Exception as e:
+            logger.error("Contract Execution Failed", exc_info=True)
+            return False
+
+    def _validate_code_ast(self, code):
+        """Reject code that uses double underscores or introspection."""
+        try:
+            tree = ast.parse(code)
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Attribute) and node.attr.startswith("__"):
+                    logger.warning("Rejected contract code with double-underscore attribute access.")
+                    return False
+                if isinstance(node, ast.Name) and node.id.startswith("__"):
+                    logger.warning("Rejected contract code with double-underscore name.")
+                    return False
+            return True
+        except SyntaxError:
+            return False