mempool.py

"""
Module for managing the transaction pool (mempool) with thread-safe operations.
"""
import threading
import logging

# Get logger
logger = logging.getLogger(__name__)

# Internal pool mapping (sender, nonce) -> transaction dict
t_pool: dict[tuple[str, int], dict] = {}
# Lock for synchronizing access to the pool
_pool_lock = threading.Lock()


def add_transaction(tx: dict) -> None:
    """
    Add a validated transaction to the mempool.
    Keyed by (sender, nonce).
    """
    key = (tx['sender'], tx['nonce'])
    with _pool_lock:
        t_pool[key] = tx
        logger.debug(f"Mempool: {tx} is added")


def remove_transactions(txs: list[dict]) -> None:
    """
    Remove a list of transactions from the mempool.
    """
    with _pool_lock:
        for tx in txs:
            key = (tx['sender'], tx['nonce'])
            removed_tx = t_pool.pop(key, None)
            if removed_tx:
                logger.debug(f"Mempool: {removed_tx} was removed")
                pass


def get_all_transactions() -> list[dict]:
    """
    Retrieve all pending transactions from the mempool.
    """
    with _pool_lock:
        # Return a copy to prevent external mutation
        return list(t_pool.values())


def clear_mempool() -> None:
    """
    Remove all transactions from the mempool.
    """
    with _pool_lock:
        t_pool.clear()


def pool_snapshot() -> dict[tuple[str, int], dict]:
    """
    Return a shallow copy of the internal pool mapping.
    Useful for inspection or passing to validation functions.
    """
    with _pool_lock:
        return dict(t_pool)