refactor: implement canonical p2p broadcasting and cross-instance tests

Author: sanaica

minichain/p2p.py

@@ -9,7 +9,7 @@
 import json
 import logging
 
-from .serialization import canonical_json_hash
+from .serialization import canonical_json_hash, canonical_json_dumps
 from .validators import is_valid_receiver
 
 logger = logging.getLogger(__name__)
@@ -46,10 +46,8 @@ def register_handler(self, handler_callback):
     async def start(self, port: int = 9000):
         """Start listening for incoming peer connections on the given port."""
         self._port = port
-        self._server = await asyncio.start_server(
-            self._handle_incoming, host, port
-        )
-        logger.info("Network: Listening on %s:%d", host, port)
+        self._server = await asyncio.start_server(self._handle_incoming, "0.0.0.0", port)
+        logger.info("Network: Listening on 0.0.0.0:%d", port)
 
     async def stop(self):
         """Gracefully shut down the server and disconnect all peers."""
@@ -204,9 +202,7 @@ def _validate_block_payload(self, payload):
         )
 
     def _validate_message(self, message):
-        if not isinstance(message, dict):
-            return False
-        if set(message) != {"type", "data"}:
+        if not {"type", "data"}.issubset(set(message)):
             return False
 
         msg_type = message.get("type")
@@ -303,6 +299,7 @@ async def _listen_to_peer(
     async def _broadcast_raw(self, payload: dict):
         """Send a JSON message to every connected peer."""
         line = (json.dumps(payload) + "\n").encode()
+        line = (canonical_json_dumps(payload) + "\n").encode()
         disconnected = []
         for reader, writer in self._peers:
             try:
@@ -333,10 +330,16 @@ async def broadcast_transaction(self, tx):
 
     async def broadcast_block(self, block, miner=None):
         logger.info("Network: Broadcasting Block #%d", block.index)
-        block_payload = block.to_dict()
-        if miner is not None:
-            block_payload["miner"] = miner
-        payload = {"type": "block", "data": block_payload}
+        
+        # 1. Convert block to a dict (deterministic via serialization.py)
+        block_data = json.loads(block.canonical_payload.decode('utf-8'))
+        
+        # 2. Wrap it in an envelope where 'miner' is OUTSIDE the 'data'
+        payload = {
+            "type": "block",
+            "data": block_data,
+            "miner": miner
+        }
         self._mark_seen("block", payload["data"])
         await self._broadcast_raw(payload)
 

tests/test_serialization.py

@@ -29,24 +29,31 @@ def test_transaction_id_stability():
     assert first_id == second_id
     print("Success: Transaction ID is stable and deterministic!\n")
 
-def test_block_hash_consistency():
-    print("--- Testing Block Hash Consistency ---")
-    # Create a block with one transaction
-    tx = Transaction(sender="A", receiver="B", amount=10, nonce=5)
-    block = Block(index=1, previous_hash="0"*64, transactions=[tx], difficulty=2)
+def test_block_serialization_determinism():
+    print("--- Testing Block Serialization & Cross-Instance Determinism ---")
+    tx_params = {"sender": "A", "receiver": "B", "amount": 10, "nonce": 5}
 
-    initial_hash = block.compute_hash()
-    print(f"Initial Block Hash: {initial_hash}")
+    # Create two SEPARATE block instances with the exact same data
+    tx1 = Transaction(**tx_params)
+    block1 = Block(index=1, previous_hash="0"*64, transactions=[tx1], difficulty=2)
 
-    # Manually re-computing to ensure it's identical
-    assert block.compute_hash() == initial_hash
-    print("Success: Block hash is consistent!\n")
+    tx2 = Transaction(**tx_params)
+    block2 = Block(index=1, previous_hash="0"*64, transactions=[tx2], difficulty=2)
+
+    # 1. Test stable bytes on one instance (same object, twice)
+    assert block1.canonical_payload == block1.canonical_payload
+    
+    # 2. Test cross-instance determinism (different objects, same data)
+    assert block1.canonical_payload == block2.canonical_payload, "Identical blocks must have identical payloads"
+    
+    # 3. Test hash consistency
+    assert block1.compute_hash() == block2.compute_hash()
+    
+    print("✅ Success: Block serialization is cross-instance deterministic!\n")
 
 if __name__ == "__main__":
-    try:
-        test_raw_data_determinism()
-        test_transaction_id_stability()
-        test_block_hash_consistency()
-        print("ALL CANONICAL TESTS PASSED!")
-    except AssertionError as e:
-        print("TEST FAILED: Serialization is not deterministic!")
+    # Removed try/except so that AssertionErrors 'bubble up' to the test runner
+    test_raw_data_determinism()
+    test_transaction_id_stability()
+    test_block_serialization_determinism()
+    print("🚀 ALL CANONICAL TESTS PASSED!")