address coderabbit comments

Author: SIDDHANTCOOKIE

main.py

@@ -122,6 +122,9 @@ async def handler(data):
         payload = data.get("data")
         peer_addr = data.get("_peer_addr", "unknown")
 
+        if payload is None and msg_type in ("hello", "chain_request", "chain_response"):
+            return
+
         if msg_type == "hello":
             peer_chain_id = payload.get("chain_id")
             peer_gen_hash = payload.get("genesis_hash")

minichain/contract.py

@@ -38,7 +38,7 @@ def _safe_exec_worker(code, globals_dict, context_dict, result_queue, gas_limit)
         try:
             import resource
             # Limit CPU time (seconds) and memory (bytes) - example values
-            resource.setrlimit(resource.RLIMIT_CPU, (2, 2)) # Align with p.join timeout (2 seconds)
+            resource.setrlimit(resource.RLIMIT_CPU, (10, 10)) # Align with p.join timeout (10 seconds)
             resource.setrlimit(resource.RLIMIT_AS, (100 * 1024 * 1024, 100 * 1024 * 1024))
         except ImportError:
             logger.warning("Resource module not available. Contract will run without OS-level resource limits.")

minichain/p2p.py

@@ -31,6 +31,8 @@ def __init__(self, handler_callback=None):
         self._seen_block_hashes = set()
         self._to_trio = queue.Queue()
         self._to_asyncio = queue.Queue()
+        self._peer_count = 0
+        self._peer_count_lock = threading.Lock()
 
     def register_handler(self, handler_callback):
         self._handler_callback = handler_callback
@@ -96,7 +98,8 @@ async def disconnect_peer(self, peer_addr):
 
     @property
     def peer_count(self) -> int:
-        return 0
+        with self._peer_count_lock:
+            return self._peer_count
 
     async def _asyncio_reader(self):
         while True:
@@ -132,6 +135,8 @@ async def _trio_main(self):
 
         async def stream_handler(stream):
             streams.append(stream)
+            with self._peer_count_lock:
+                self._peer_count += 1
             peer_id = stream.muxed_conn.peer_id
             addr = f"peer:{peer_id}"
             self._to_asyncio.put(("PEER_CONNECTED", None))
@@ -147,7 +152,10 @@ async def stream_handler(stream):
                             self._to_asyncio.put(("MSG", msg))
                         except Exception: pass
             except Exception: pass
-            if stream in streams: streams.remove(stream)
+            if stream in streams:
+                streams.remove(stream)
+                with self._peer_count_lock:
+                    self._peer_count -= 1
 
         host.set_stream_handler(PROTOCOL_ID, stream_handler)
 
@@ -185,7 +193,10 @@ async def check_queue():
                                 if addr == arg:
                                     try: await s.reset()
                                     except Exception: pass
-                                    if s in streams: streams.remove(s)
+                                    if s in streams:
+                                        streams.remove(s)
+                                        with self._peer_count_lock:
+                                            self._peer_count -= 1
                 except Exception: pass
                 await trio.sleep(0.1)
 

requirements.txt

@@ -1,5 +1,5 @@
 pynacl==1.6.2
 trie>=3.1.0
 libp2p
-aiohttp
+aiohttp>=3.10.11
 multiaddr

tests/test_contract_transfers.py

@@ -61,7 +61,7 @@ def test_failed_transfer_out_insufficient_balance(self):
         contract_addr = receipt.contract_address
 
         # 2. Call Contract
-        call_tx = self._sign(Transaction(self.sender_pk, contract_addr, amount=0, nonce=1, data={"target": self.target_pk}, fee=1000))
+        call_tx = self._sign(Transaction(self.sender_pk, contract_addr, amount=50, nonce=1, data={"target": self.target_pk}, fee=1000))
         receipt2 = self.state.apply_transaction(call_tx)
 
         # Should fail with status 0
@@ -72,6 +72,11 @@ def test_failed_transfer_out_insufficient_balance(self):
         self.assertEqual(self.state.get_account(contract_addr)['balance'], 100)
         self.assertEqual(self.state.get_account(self.target_pk)['balance'], 0)
 
+        # Sender's balance should have decreased by only the fee amount (or gas_used if refunded) as the 50 amount was refunded
+        # Starting balance 10000, minus (100+1000) for deploy = 8900
+        # Call tx net cost is receipt2.gas_used
+        self.assertEqual(self.state.get_account(self.sender_pk)['balance'], 8900 - receipt2.gas_used)
+
         # Storage should NOT be updated
         self.assertEqual(self.state.get_account(contract_addr)['storage'], {})