P2P Network Architecture

import random

class BlockchainNode:
    def __init__(self, node_id: str, max_peers: int = 8):
        self.node_id = node_id
        self.peers: set = set()
        self.max_peers = max_peers
        self.mempool: set = set()
        self.blockchain: list = []

    def connect_to(self, other_node: "BlockchainNode") -> bool:
        if len(self.peers) >= self.max_peers:
            return False
        self.peers.add(other_node.node_id)
        other_node.peers.add(self.node_id)
        return True

    def broadcast_transaction(self, tx: str, all_nodes: dict, hops: int = 0):
        """Gossip protocol: forward tx to all peers who haven't seen it"""
        if tx in self.mempool:
            return  # Already seen � stop propagation
        self.mempool.add(tx)
        print(f"{'  ' * hops}Node {self.node_id} received tx: {tx} (hop {hops})")

        for peer_id in self.peers:
            peer = all_nodes.get(peer_id)
            if peer and tx not in peer.mempool:
                peer.broadcast_transaction(tx, all_nodes, hops + 1)

# Create a small P2P network
nodes = {f"N{i}": BlockchainNode(f"N{i}") for i in range(6)}

# Random connections (like DNS seed bootstrapping)
node_list = list(nodes.values())
for i, node in enumerate(node_list):
    for _ in range(3):
        other = random.choice(node_list)
        if other.node_id != node.node_id:
            node.connect_to(other)

# Show network topology
print("Network connections:")
for nid, node in nodes.items():
    print(f"  {nid}: peers={list(node.peers)}")

# Broadcast a transaction from N0
print("\nTransaction propagation from N0:")
nodes["N0"].broadcast_transaction("TX:Alice->Bob:1BTC", nodes)
print(f"\nNodes with tx: {[nid for nid, n in nodes.items() if 'TX:Alice->Bob:1BTC' in n.mempool]}")