refactor: flatten directory structure to single minichain package

.gitignore

@@ -324,3 +324,9 @@ TSWLatexianTemp*
 # option is specified. Footnotes are the stored in a file with suffix Notes.bib.
 # Uncomment the next line to have this generated file ignored.
 #*Notes.bib
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so

main.py

@@ -4,10 +4,7 @@
 from nacl.signing import SigningKey
 from nacl.encoding import HexEncoder
 
-from core import Transaction, Blockchain, Block, State
-from node import Mempool
-from network import P2PNetwork
-from consensus import mine_block
+from minichain import Transaction, Blockchain, Block, State, Mempool, P2PNetwork, mine_block
 
 
 logger = logging.getLogger(__name__)
@@ -80,21 +77,20 @@ def sync_nonce(state, pending_nonce_map, address):
 async def node_loop():
     logger.info("Starting MiniChain Node with Smart Contracts")
 
-    state = State()
-    chain = Blockchain(state)
+    chain = Blockchain()
     mempool = Mempool()
 
     pending_nonce_map = {}
 
-    def claim_nonce(address):
-        account = state.get_account(address)
+    def claim_nonce(address) -> int:
+        account = chain.state.get_account(address)
         account_nonce = account.get("nonce", 0) if account else 0
         local_nonce = pending_nonce_map.get(address, account_nonce)
         next_nonce = max(account_nonce, local_nonce)
         pending_nonce_map[address] = next_nonce + 1
         return next_nonce
 
-    network = P2PNetwork(None)
+    network = P2PNetwork()
 
     async def _handle_network_data(data):
         logger.info("Received network data: %s", data)
@@ -127,10 +123,10 @@ async def _handle_network_data(data):
         except Exception:
             logger.exception("Error processing network data: %s", data)
 
-    network.handler_callback = _handle_network_data
+    network.register_handler(_handle_network_data)
 
     try:
-        await _run_node(network, state, chain, mempool, pending_nonce_map, claim_nonce)
+        await _run_node(network, chain, mempool, pending_nonce_map, claim_nonce)
     finally:
         await network.stop()
 

core/__init__.py → minichain/__init__.py

@@ -1,13 +1,21 @@
+from .pow import mine_block, calculate_hash, MiningExceededError
 from .block import Block
 from .chain import Blockchain
 from .transaction import Transaction
 from .state import State
 from .contract import ContractMachine
+from .p2p import P2PNetwork
+from .mempool import Mempool
 
 __all__ = [
+    "mine_block",
+    "calculate_hash",
+    "MiningExceededError",
     "Block",
     "Blockchain",
     "Transaction",
     "State",
     "ContractMachine",
+    "P2PNetwork",
+    "Mempool",
 ]

core/block.py → minichain/block.py

@@ -2,8 +2,7 @@
 import hashlib
 import json
 from typing import List, Optional
-from core.transaction import Transaction
-
+from .transaction import Transaction
 
 def _sha256(data: str) -> str:
     return hashlib.sha256(data.encode()).hexdigest()

core/chain.py → minichain/chain.py

@@ -1,6 +1,6 @@
-from core.block import Block
-from core.state import State
-from consensus import calculate_hash
+from .block import Block
+from .state import State
+from .pow import calculate_hash
 import logging
 import threading
 

node/mempool.py → minichain/mempool.py

@@ -1,4 +1,4 @@
-from consensus.pow import calculate_hash
+from .pow import calculate_hash
 import logging
 import threading
 

network/p2p.py → minichain/p2p.py

@@ -19,16 +19,42 @@ class P2PNetwork:
         }
     """
 
-    def __init__(self, handler_callback):
+    def __init__(self, handler_callback=None):
+        self._handler_callback = None
+        if handler_callback is not None:
+            self.register_handler(handler_callback)
+        self.pubsub = None  # Will be set in real implementation
+
+    def register_handler(self, handler_callback):
         if not callable(handler_callback):
             raise ValueError("handler_callback must be callable")
-        self.handler_callback = handler_callback
-        self.pubsub = None  # Will be set in real implementation
+        self._handler_callback = handler_callback
 
     async def start(self):
         logger.info("Network: Listening on /ip4/0.0.0.0/tcp/0")
         # In real libp2p, we would await host.start() here
 
+    async def stop(self):
+        """Clean up network resources cleanly upon shutdown."""
+        logger.info("Network: Shutting down")
+        if self.pubsub:
+            try:
+                shutdown_meth = None
+                for method_name in ('close', 'stop', 'aclose', 'shutdown'):
+                    if hasattr(self.pubsub, method_name):
+                        shutdown_meth = getattr(self.pubsub, method_name)
+                        break
+
+                if shutdown_meth:
+                    import asyncio
+                    res = shutdown_meth()
+                    if asyncio.iscoroutine(res):
+                        await res
+            except Exception as e:
+                logger.error("Network: Error shutting down pubsub: %s", e)
+            finally:
+                self.pubsub = None
+
     async def _broadcast_message(self, topic, msg_type, payload):
         msg = json.dumps({"type": msg_type, "data": payload})
         if self.pubsub:
@@ -84,6 +110,9 @@ async def handle_message(self, msg):
             return
 
         try:
-            await self.handler_callback(data)
+            if self._handler_callback:
+                await self._handler_callback(data)
+            else:
+                logger.warning("Network Error: No handler_callback registered")
         except Exception:
             logger.exception("Error in network handler callback for data: %s", data)

core/state.py → minichain/state.py

@@ -1,6 +1,6 @@
 from nacl.hash import sha256
 from nacl.encoding import HexEncoder
-from core.contract import ContractMachine
+from .contract import ContractMachine
 import copy
 import logging
 

tests/test_contract.py

@@ -2,7 +2,7 @@
 import sys
 import os
 
-from core import State, Transaction
+from minichain import State, Transaction
 from nacl.signing import SigningKey
 from nacl.encoding import HexEncoder
 

tests/test_core.py

@@ -2,7 +2,7 @@
 from nacl.signing import SigningKey
 from nacl.encoding import HexEncoder
 
-from core import Transaction, Blockchain, State # Removed unused imports
+from minichain import Transaction, Blockchain, State # Removed unused imports
 
 class TestCore(unittest.TestCase):
     def setUp(self):