refactor(mempool): implement single sorted list architecture for O(1) mining

Author: SIDDHANTCOOKIE

minichain/mempool.py

@@ -5,8 +5,7 @@
 
 class Mempool:
     def __init__(self, max_size=1000, transactions_per_block=100):
-        self._pool = {}
-        self._size = 0
+        self._list = []  # Single sorted list
         self._lock = threading.Lock()
         self.max_size = max_size
         self.transactions_per_block = transactions_per_block
@@ -17,64 +16,62 @@ def add_transaction(self, tx):
             return False
 
         with self._lock:
-            existing = self._pool.get(tx.sender, {}).get(tx.nonce)
+            existing_idx = None
+            i_min = 0
+            i_max = len(self._list)
+            
+            for i, existing_tx in enumerate(self._list):
+                if existing_tx.sender == tx.sender:
+                    if existing_tx.nonce == tx.nonce:
+                        existing_idx = i
+                    elif existing_tx.nonce < tx.nonce:
+                        # Must insert AFTER the largest lower-nonce transaction
+                        i_min = max(i_min, i + 1)
+                    elif existing_tx.nonce > tx.nonce:
+                        # Must insert BEFORE the smallest higher-nonce transaction
+                        i_max = min(i_max, i)
 
-            if existing:
-                if existing.tx_id == tx.tx_id:
+            if existing_idx is not None:
+                existing_tx = self._list[existing_idx]
+                if existing_tx.tx_id == tx.tx_id:
                     logger.warning("Mempool: Duplicate transaction rejected %s", tx.tx_id)
                     return False
-                # Fix: Guard against older replacements (e.g. rejected block restore)
-                # Only allow overwrite if it's a genuinely newer replacement
-                if tx.timestamp <= existing.timestamp:
+                if tx.timestamp <= existing_tx.timestamp:
                     logger.warning("Mempool: Ignoring older replacement %s", tx.tx_id)
                     return False
 
+                self._list.pop(existing_idx)
+                if i_max > existing_idx:
+                    i_max -= 1
+                if i_min > existing_idx:
+                    i_min -= 1
             else:
-                if self._size >= self.max_size:
+                if len(self._list) >= self.max_size:
                     logger.warning("Mempool: Full, rejecting transaction")
                     return False
-                self._size += 1
-            self._pool.setdefault(tx.sender, {})[tx.nonce] = tx
-            return True
-
-    def get_transactions_for_block(self):
-        with self._lock:
-            snapshot = {s: list(pool.values()) for s, pool in self._pool.items()}
 
-        for txs in snapshot.values():
-            txs.sort(key=lambda t: t.nonce)
+            i_min = min(i_min, i_max)
 
-        selected = []
-        while len(selected) < self.transactions_per_block:
-            best_tx = None
-            best_sender = None
+            # Insert before the first tx in [i_min, i_max] that has a lower fee
+            insert_idx = i_max
+            for j in range(i_min, i_max):
+                if getattr(self._list[j], 'fee', 0) < getattr(tx, 'fee', 0):
+                    insert_idx = j
+                    break
 
-            for sender, txs in snapshot.items():
-                if txs:
-                    current_criteria = (-getattr(txs[0], 'fee', 0), txs[0].timestamp, sender, txs[0].nonce)
-                    best_criteria = (-getattr(best_tx, 'fee', 0), best_tx.timestamp, best_sender, best_tx.nonce) if best_tx else None
-                    if best_tx is None or current_criteria < best_criteria:
-                        best_tx = txs[0]
-                        best_sender = sender
-                        
-            if not best_tx:
-                break
-                
-            selected.append(best_tx)
-            snapshot[best_sender].pop(0)
+            self._list.insert(insert_idx, tx)
+            return True
 
-        return selected
+    def get_transactions_for_block(self):
+        with self._lock:
+            # O(1) retrieval! The list is strictly ordered upon insertion.
+            return list(self._list[:self.transactions_per_block])
 
     def remove_transactions(self, transactions):
         with self._lock:
-            for tx in transactions:
-                pool = self._pool.get(tx.sender)
-                if pool and tx.nonce in pool:
-                    del pool[tx.nonce]
-                    self._size -= 1
-                    if not pool:
-                        del self._pool[tx.sender]
+            keys_to_remove = {(tx.sender, tx.nonce) for tx in transactions}
+            self._list = [tx for tx in self._list if (tx.sender, tx.nonce) not in keys_to_remove]
 
     def __len__(self):
         with self._lock:
-            return self._size
+            return len(self._list)