playweb-node 1.0.0__py3-none-any.whl

playweb/network/gossip.py

@@ -0,0 +1,222 @@
+"""
+PlayWebit Network — Gossip Protocol
+P2P block and transaction propagation via HTTP webhooks.
+Works on ALL cloud platforms — HuggingFace, AWS, VPS, anywhere.
+No persistent connections needed. Fire and forget to peers.
+"""
+
+import logging
+import threading
+import requests
+from typing import List, TYPE_CHECKING
+
+from playweb.config import GOSSIP_FANOUT, PEER_TIMEOUT
+
+if TYPE_CHECKING:
+    from playweb.network.peer_manager import Peer
+    from playweb.consensus.vote       import Vote
+    from playweb.core.block           import Block
+    from playweb.core.transaction     import Transaction
+
+logger = logging.getLogger(__name__)
+
+
+class GossipProtocol:
+
+    def __init__(self, node_wallet: str):
+        self.node_wallet = node_wallet
+
+    # ─────────────────────────────────────────────────────────────
+    # Internal helpers
+    # ─────────────────────────────────────────────────────────────
+
+    def _post(self, url: str, data: dict, timeout: int = PEER_TIMEOUT):
+        """Fire-and-forget HTTP POST to a peer endpoint."""
+        try:
+            requests.post(url, json=data, timeout=timeout)
+        except Exception:
+            pass   # peer may be down — that's fine
+
+    def _broadcast(
+        self,
+        peers:    List["Peer"],
+        endpoint: str,
+        payload:  dict,
+        fanout:   int = GOSSIP_FANOUT,
+    ):
+        """
+        Broadcast payload to up to GOSSIP_FANOUT peers in parallel.
+        Each peer then forwards to their peers.
+        This is how messages propagate through the whole network.
+        """
+        # Limit fanout but prefer low-latency peers
+        targets = sorted(peers, key=lambda p: p.latency_ms)[:fanout]
+
+        threads = []
+        for peer in targets:
+            t = threading.Thread(
+                target=self._post,
+                args=(f"{peer.url}{endpoint}", payload),
+                daemon=True,
+            )
+            t.start()
+            threads.append(t)
+
+        # Don't wait — fire and forget
+        # Peers will propagate further themselves
+
+    # ─────────────────────────────────────────────────────────────
+    # Broadcast: new transaction
+    # ─────────────────────────────────────────────────────────────
+
+    def broadcast_transaction(
+        self,
+        tx:    "Transaction",
+        peers: List["Peer"],
+    ):
+        """
+        Broadcast a new transaction to peers.
+        Called when a node receives a tx from an API client.
+        """
+        if not peers:
+            return
+
+        payload = {
+            "transaction": tx.to_dict(),
+            "from_node":   self.node_wallet,
+        }
+        self._broadcast(peers, "/peer/new_transaction", payload)
+        logger.debug(f"Gossip: broadcast tx {tx.hash[:12]}... to {len(peers)} peers")
+
+    # ─────────────────────────────────────────────────────────────
+    # Broadcast: block proposal (from consensus leader)
+    # ─────────────────────────────────────────────────────────────
+
+    def broadcast_block_proposal(
+        self,
+        block:        "Block",
+        round_number: int,
+        peers:        List["Peer"],
+    ):
+        """
+        Broadcast a block proposal during PROPOSE phase.
+        Only the consensus leader calls this.
+        """
+        if not peers:
+            return
+
+        payload = {
+            "block":        block.to_dict(),
+            "round_number": round_number,
+            "from_node":    self.node_wallet,
+            "message_type": "proposal",
+        }
+        # Send to ALL peers for proposals (not just fanout)
+        # Every peer needs to receive the proposal to vote
+        threads = []
+        for peer in peers:
+            t = threading.Thread(
+                target=self._post,
+                args=(f"{peer.url}/peer/propose", payload),
+                daemon=True,
+            )
+            t.start()
+            threads.append(t)
+
+        logger.info(
+            f"Gossip: broadcast proposal block {block.index} "
+            f"to {len(peers)} peers"
+        )
+
+    # ─────────────────────────────────────────────────────────────
+    # Broadcast: vote
+    # ─────────────────────────────────────────────────────────────
+
+    def broadcast_vote(
+        self,
+        vote:  "Vote",
+        peers: List["Peer"],
+    ):
+        """
+        Broadcast a consensus vote to all peers.
+        Every validator calls this after validating a proposal.
+        """
+        if not peers:
+            return
+
+        payload = {
+            "vote":      vote.to_dict(),
+            "from_node": self.node_wallet,
+        }
+        # Send votes to ALL peers — every node needs to collect them
+        threads = []
+        for peer in peers:
+            t = threading.Thread(
+                target=self._post,
+                args=(f"{peer.url}/peer/vote", payload),
+                daemon=True,
+            )
+            t.start()
+            threads.append(t)
+
+        logger.debug(
+            f"Gossip: broadcast vote for block "
+            f"{vote.block_hash[:12]}... to {len(peers)} peers"
+        )
+
+    # ─────────────────────────────────────────────────────────────
+    # Broadcast: finalised block
+    # ─────────────────────────────────────────────────────────────
+
+    def broadcast_finalised_block(
+        self,
+        block:  "Block",
+        votes:  list,
+        peers:  List["Peer"],
+    ):
+        """
+        Broadcast a finalised block after consensus.
+        Nodes that missed the consensus round catch up via this.
+        """
+        if not peers:
+            return
+
+        payload = {
+            "block":        block.to_dict(),
+            "votes":        votes,
+            "from_node":    self.node_wallet,
+            "message_type": "finalised",
+        }
+        self._broadcast(peers, "/peer/new_block", payload)
+        logger.info(
+            f"Gossip: broadcast finalised block "
+            f"{block.index} to {len(peers)} peers"
+        )
+
+    # ─────────────────────────────────────────────────────────────
+    # Broadcast: new node joined
+    # ─────────────────────────────────────────────────────────────
+
+    def broadcast_new_node(
+        self,
+        new_node_url:    str,
+        new_node_wallet: str,
+        peers:           List["Peer"],
+    ):
+        """
+        Tell all existing peers about a new node.
+        Called when Cloudflare notifies us of a new registration.
+        """
+        if not peers:
+            return
+
+        payload = {
+            "url":       new_node_url,
+            "wallet":    new_node_wallet,
+            "from_node": self.node_wallet,
+        }
+        self._broadcast(peers, "/peer/new_node", payload)
+        logger.info(
+            f"Gossip: broadcast new node "
+            f"{new_node_url} to {len(peers)} peers"
+        )

playweb/network/peer_manager.py

@@ -0,0 +1,164 @@
+"""
+PlayWebit Network — Peer Manager
+Manages known peers in RAM. Lost on restart — rediscovered via bootstrap.
+"""
+
+import time
+import threading
+import logging
+import requests
+from typing import List, Optional, Dict
+from dataclasses import dataclass, field
+
+from playweb.config import MAX_PEERS, PEER_TIMEOUT
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Peer:
+    url:       str
+    wallet:    str
+    platform:  str    = "unknown"
+    role:      str    = "validator"
+    last_seen: float  = field(default_factory=time.time)
+    is_active: bool   = True
+    latency_ms: float = 0.0
+
+    def __hash__(self):
+        return hash(self.url)
+
+    def __eq__(self, other):
+        return self.url == other.url
+
+
+class PeerManager:
+
+    def __init__(self, my_url: str, my_wallet: str):
+        self.my_url    = my_url
+        self.my_wallet = my_wallet.lower()
+        self._peers:   Dict[str, Peer] = {}   # url → Peer
+        self._lock     = threading.Lock()
+
+    # ─────────────────────────────────────────────────────────────
+    # Add / Remove
+    # ─────────────────────────────────────────────────────────────
+
+    def add_peer(
+        self,
+        url:      str,
+        wallet:   str,
+        platform: str = "unknown",
+        role:     str = "validator",
+    ) -> bool:
+        """Add a new peer. Returns True if actually added (not duplicate)."""
+        # Don't add self
+        if url == self.my_url or wallet.lower() == self.my_wallet:
+            return False
+
+        with self._lock:
+            if url in self._peers:
+                # Update last_seen
+                self._peers[url].last_seen = time.time()
+                self._peers[url].is_active = True
+                return False
+
+            if len(self._peers) >= MAX_PEERS:
+                # Remove oldest inactive peer first
+                self._evict_one()
+
+            self._peers[url] = Peer(
+                url      = url,
+                wallet   = wallet.lower(),
+                platform = platform,
+                role     = role,
+            )
+            logger.info(f"Peer added: {url} ({wallet[:8]}...)")
+            return True
+
+    def remove_peer(self, url: str):
+        with self._lock:
+            if url in self._peers:
+                del self._peers[url]
+                logger.info(f"Peer removed: {url}")
+
+    def _evict_one(self):
+        """Remove the least recently seen inactive peer."""
+        inactive = [
+            p for p in self._peers.values()
+            if not p.is_active
+        ]
+        if inactive:
+            oldest = min(inactive, key=lambda p: p.last_seen)
+            del self._peers[oldest.url]
+
+    # ─────────────────────────────────────────────────────────────
+    # Query
+    # ─────────────────────────────────────────────────────────────
+
+    def get_active_peers(self) -> List[Peer]:
+        with self._lock:
+            return [p for p in self._peers.values() if p.is_active]
+
+    def get_all_peers(self) -> List[Peer]:
+        with self._lock:
+            return list(self._peers.values())
+
+    def get_peer(self, url: str) -> Optional[Peer]:
+        return self._peers.get(url)
+
+    def peer_count(self) -> int:
+        return len([p for p in self._peers.values() if p.is_active])
+
+    def get_peer_list_for_sharing(self) -> List[Dict]:
+        """Return peer list to share with new nodes."""
+        return [
+            {"url": p.url, "wallet": p.wallet, "platform": p.platform}
+            for p in self.get_active_peers()
+        ]
+
+    # ─────────────────────────────────────────────────────────────
+    # Health check
+    # ─────────────────────────────────────────────────────────────
+
+    def ping_all(self):
+        """Ping all peers and mark inactive ones."""
+        peers = self.get_all_peers()
+        for peer in peers:
+            self._ping_peer(peer)
+
+    def _ping_peer(self, peer: Peer):
+        try:
+            start = time.time()
+            res   = requests.get(
+                f"{peer.url}/peer/health",
+                timeout=PEER_TIMEOUT
+            )
+            latency = (time.time() - start) * 1000
+
+            if res.status_code == 200:
+                with self._lock:
+                    if peer.url in self._peers:
+                        self._peers[peer.url].is_active  = True
+                        self._peers[peer.url].last_seen  = time.time()
+                        self._peers[peer.url].latency_ms = latency
+            else:
+                self._mark_inactive(peer.url)
+
+        except Exception:
+            self._mark_inactive(peer.url)
+
+    def _mark_inactive(self, url: str):
+        with self._lock:
+            if url in self._peers:
+                self._peers[url].is_active = False
+                logger.debug(f"Peer marked inactive: {url}")
+
+    def load_peers_from_list(self, peers: List[Dict]):
+        """Load peers from a list (from bootstrap or another peer)."""
+        for p in peers:
+            self.add_peer(
+                url      = p.get("url", ""),
+                wallet   = p.get("wallet", ""),
+                platform = p.get("platform", "unknown"),
+            )

playweb/network/sync.py

@@ -0,0 +1,244 @@
+"""
+PlayWebit Network — Chain Sync
+Syncs chain from peers when a node starts or restarts.
+Downloads missing blocks in chunks, verifies each one.
+After sync completes, node joins consensus normally.
+"""
+
+import logging
+import requests
+from typing import List, Optional, Tuple, TYPE_CHECKING
+
+from playweb.config import SYNC_CHUNK_SIZE, PEER_TIMEOUT
+
+if TYPE_CHECKING:
+    from playweb.network.peer_manager import Peer
+
+logger = logging.getLogger(__name__)
+
+
+class ChainSync:
+
+    def __init__(self, blockchain, peer_manager):
+        self.blockchain   = blockchain
+        self.peer_manager = peer_manager
+        self._syncing     = False
+        self._progress    = {"current": 0, "target": 0, "synced": False}
+
+    # ─────────────────────────────────────────────────────────────
+    # Main sync entry point
+    # ─────────────────────────────────────────────────────────────
+
+    def sync(self) -> bool:
+        """
+        Sync chain from peers.
+        1. Find canonical chain tip from peers
+        2. Download missing blocks in chunks
+        3. Verify and apply each block
+        Returns True if fully synced.
+        """
+        peers = self.peer_manager.get_active_peers()
+        if not peers:
+            logger.info("Sync: no peers available — running as solo node")
+            return True
+
+        self._syncing = True
+
+        # Step 1: Find the canonical chain tip
+        target_index, best_peer = self._find_canonical_tip(peers)
+        if target_index is None:
+            logger.info("Sync: could not determine canonical tip from peers")
+            self._syncing = False
+            return False
+
+        my_index = self.blockchain.get_chain_length() - 1
+        self._progress["target"]  = target_index
+        self._progress["current"] = my_index
+
+        if my_index >= target_index:
+            logger.info(
+                f"Sync: already up to date (block {my_index})"
+            )
+            self._syncing         = False
+            self._progress["synced"] = True
+            return True
+
+        logger.info(
+            f"Sync: need blocks {my_index + 1} → {target_index} "
+            f"({target_index - my_index} blocks)"
+        )
+
+        # Step 2: Download blocks in chunks
+        success = self._download_blocks(
+            from_index  = my_index + 1,
+            to_index    = target_index,
+            peers       = peers,
+        )
+
+        self._syncing            = False
+        self._progress["synced"] = success
+        return success
+
+    # ─────────────────────────────────────────────────────────────
+    # Find canonical chain tip
+    # ─────────────────────────────────────────────────────────────
+
+    def _find_canonical_tip(
+        self,
+        peers: List["Peer"],
+    ) -> Tuple[Optional[int], Optional["Peer"]]:
+        """
+        Ask each peer for their chain tip.
+        The canonical chain is the one with the highest valid index.
+        Returns (target_block_index, best_peer).
+        """
+        tips = []
+
+        for peer in peers:
+            try:
+                res = requests.get(
+                    f"{peer.url}/peer/chain_tip",
+                    timeout=PEER_TIMEOUT,
+                )
+                if res.status_code == 200:
+                    data  = res.json()
+                    index = data.get("block_index", -1)
+                    hash_ = data.get("block_hash", "")
+                    if index >= 0:
+                        tips.append((index, hash_, peer))
+            except Exception as e:
+                logger.debug(f"Sync: could not get tip from {peer.url}: {e}")
+
+        if not tips:
+            return None, None
+
+        # Pick highest index — canonical chain
+        tips.sort(key=lambda t: t[0], reverse=True)
+        best_index, best_hash, best_peer = tips[0]
+
+        logger.info(
+            f"Sync: canonical tip is block {best_index} "
+            f"({best_hash[:12]}...) from {best_peer.url}"
+        )
+        return best_index, best_peer
+
+    # ─────────────────────────────────────────────────────────────
+    # Download blocks
+    # ─────────────────────────────────────────────────────────────
+
+    def _download_blocks(
+        self,
+        from_index: int,
+        to_index:   int,
+        peers:      List["Peer"],
+    ) -> bool:
+        """
+        Download blocks in chunks from peers.
+        Tries each peer in sequence — falls back if one fails.
+        Verifies each block before adding to chain.
+        """
+        current = from_index
+
+        while current <= to_index:
+            chunk_end = min(current + SYNC_CHUNK_SIZE - 1, to_index)
+            success   = False
+
+            # Try each peer until one works
+            for peer in peers:
+                blocks = self._fetch_chunk(peer, current, chunk_end)
+                if blocks:
+                    applied = self._apply_chunk(blocks)
+                    if applied:
+                        current += len(blocks)
+                        self._progress["current"] = current
+                        logger.info(
+                            f"Sync: applied blocks "
+                            f"{current - len(blocks)} → {current - 1}"
+                        )
+                        success = True
+                        break
+
+            if not success:
+                logger.error(
+                    f"Sync: failed to download blocks "
+                    f"{current} → {chunk_end} from any peer"
+                )
+                return False
+
+        logger.info(f"Sync: complete. Chain at block {to_index}")
+        return True
+
+    def _fetch_chunk(
+        self,
+        peer:       "Peer",
+        from_index: int,
+        to_index:   int,
+    ) -> List:
+        """Fetch a chunk of blocks from a peer."""
+        try:
+            res = requests.get(
+                f"{peer.url}/peer/blocks/{from_index}/{to_index}",
+                timeout=PEER_TIMEOUT * 3,  # longer timeout for bulk fetch
+            )
+            if res.status_code != 200:
+                return []
+
+            data   = res.json()
+            blocks_data = data.get("blocks", [])
+            blocks = []
+
+            from playweb.core.block import Block
+            for bd in blocks_data:
+                try:
+                    block = Block.from_dict(bd)
+                    blocks.append(block)
+                except Exception as e:
+                    logger.warning(f"Sync: failed to parse block: {e}")
+                    return []
+
+            return blocks
+
+        except Exception as e:
+            logger.debug(f"Sync: fetch failed from {peer.url}: {e}")
+            return []
+
+    def _apply_chunk(self, blocks: List) -> bool:
+        """Verify and apply a chunk of blocks to local chain."""
+        for block in blocks:
+            # Verify block integrity
+            tip = self.blockchain.get_chain_tip()
+            valid, reason = block.validate(previous_block=tip)
+
+            if not valid:
+                logger.warning(f"Sync: invalid block {block.index}: {reason}")
+                return False
+
+            # Add to chain (skip fee validation during sync —
+            # we trust the chain has been validated by consensus already)
+            success, reason = self.blockchain.add_block(block)
+            if not success:
+                logger.warning(
+                    f"Sync: failed to add block {block.index}: {reason}"
+                )
+                return False
+
+        return True
+
+    # ─────────────────────────────────────────────────────────────
+    # Status
+    # ─────────────────────────────────────────────────────────────
+
+    def get_sync_status(self) -> dict:
+        return {
+            "syncing":  self._syncing,
+            "current":  self._progress["current"],
+            "target":   self._progress["target"],
+            "synced":   self._progress["synced"],
+            "percent":  (
+                round(
+                    self._progress["current"] /
+                    max(self._progress["target"], 1) * 100, 1
+                )
+                if self._progress["target"] > 0 else 100
+            ),
+        }