playweb-node 1.0.0__py3-none-any.whl

playweb/core/transaction.py

@@ -0,0 +1,270 @@
+"""
+PlayWebit Network — Transaction
+Clean L1 transaction. No CipherVault logic. No Supabase.
+"""
+
+import hashlib
+import json
+import time
+import logging
+from typing import Optional, Dict, Any
+
+from playweb.config import CHAIN_ID, L1_TX_TYPES, AUTHORITY_TX_TYPES
+
+logger = logging.getLogger(__name__)
+
+
+class Transaction:
+    """
+    L1 Transaction.
+
+    MANDATORY fields — L1 validates all of these:
+        from_addr, to_addr, amount, tx_type,
+        timestamp, signature, nonce, chain_id
+
+    CONDITIONAL fields — required for specific tx_types:
+        cid            → required for content_register, cv_link,
+                         ownership_transfer, edition_transfer
+        editions       → required for content_register
+        royalty_pct    → required for content_register
+        edition_number → required for edition_transfer
+        spider_hash    → required for spider_hash_anchor
+        chain_name     → required for spider_hash_anchor
+
+    OPTIONAL free field — L1 carries it, never reads it:
+        data: {}       → platform stores anything here
+                         license_type, song_title, platform_id,
+                         spider_hash metadata, custom fields etc
+    """
+
+    def __init__(
+        self,
+        from_addr:      str,
+        to_addr:        str,
+        amount:         float,
+        tx_type:        str,
+        signature:      str   = None,
+        nonce:          int   = None,
+        timestamp:      float = None,
+
+        # Conditional fields
+        cid:            Optional[str]   = None,
+        editions:       Optional[int]   = None,
+        royalty_pct:    Optional[float] = None,
+        edition_number: Optional[int]   = None,
+        spider_hash:    Optional[str]   = None,
+        chain_name:     Optional[str]   = None,
+
+        # Free optional data field — L1 never reads this
+        data:           Optional[Dict[str, Any]] = None,
+    ):
+        # ── Mandatory fields ──────────────────────────────────
+        self.from_addr  = from_addr.lower() if from_addr else from_addr
+        self.to_addr    = to_addr.lower()   if to_addr   else to_addr
+        self.amount     = float(amount)
+        self.tx_type    = tx_type
+        self.timestamp  = timestamp or time.time()
+        self.nonce      = nonce if nonce is not None else int(self.timestamp * 1000)
+        self.chain_id   = CHAIN_ID
+        self.signature  = signature
+
+        # ── Conditional fields ────────────────────────────────
+        self.cid            = cid
+        self.editions       = editions
+        self.royalty_pct    = royalty_pct
+        self.edition_number = edition_number
+        self.spider_hash    = spider_hash
+        self.chain_name     = chain_name
+
+        # ── Optional free data field ──────────────────────────
+        self.data = data or {}
+
+        # ── Computed ──────────────────────────────────────────
+        self.hash = self.calculate_hash()
+
+    # ─────────────────────────────────────────────────────────────
+    # Hashing
+    # ─────────────────────────────────────────────────────────────
+
+    def get_signable_data(self) -> Dict:
+        """
+        Returns the canonical dict that gets hashed and signed.
+        Only mandatory + conditional fields — not data{} field
+        because platforms may add data after signing.
+        """
+        d = {
+            "from_addr":  self.from_addr,
+            "to_addr":    self.to_addr,
+            "amount":     self.amount,
+            "tx_type":    self.tx_type,
+            "timestamp":  self.timestamp,
+            "nonce":      self.nonce,
+            "chain_id":   self.chain_id,
+        }
+
+        # Include conditional fields only if set
+        if self.cid            is not None: d["cid"]            = self.cid
+        if self.editions       is not None: d["editions"]       = self.editions
+        if self.royalty_pct    is not None: d["royalty_pct"]    = self.royalty_pct
+        if self.edition_number is not None: d["edition_number"] = self.edition_number
+        if self.spider_hash    is not None: d["spider_hash"]    = self.spider_hash
+        if self.chain_name     is not None: d["chain_name"]     = self.chain_name
+
+        return d
+
+    def calculate_hash(self) -> str:
+        """SHA256 of canonical signable data."""
+        raw = json.dumps(self.get_signable_data(), sort_keys=True)
+        return hashlib.sha256(raw.encode()).hexdigest()
+
+    # ─────────────────────────────────────────────────────────────
+    # Validation
+    # ─────────────────────────────────────────────────────────────
+
+    def validate_fields(self) -> tuple[bool, str]:
+        """
+        Validate mandatory and conditional fields.
+        Returns (is_valid, reason).
+        """
+
+        # Mandatory checks
+        if not self.from_addr:
+            return False, "Missing from_addr"
+        if not self.to_addr:
+            return False, "Missing to_addr"
+        if self.amount < 0:
+            return False, "Amount cannot be negative"
+        if self.tx_type not in L1_TX_TYPES:
+            return False, f"Unknown tx_type: {self.tx_type}"
+        if self.chain_id != CHAIN_ID:
+            return False, f"Wrong chain_id: {self.chain_id}, expected {CHAIN_ID}"
+        if self.nonce is None:
+            return False, "Missing nonce"
+
+        # Conditional checks
+        if self.tx_type == "content_register":
+            if not self.cid:
+                return False, "content_register requires cid"
+            if self.editions is None:
+                return False, "content_register requires editions"
+            if self.royalty_pct is None:
+                return False, "content_register requires royalty_pct"
+            if not (0 <= self.royalty_pct <= 100):
+                return False, "royalty_pct must be 0-100"
+
+        if self.tx_type in ("cv_link", "ownership_transfer"):
+            if not self.cid:
+                return False, f"{self.tx_type} requires cid"
+
+        if self.tx_type == "edition_transfer":
+            if not self.cid:
+                return False, "edition_transfer requires cid"
+            if self.edition_number is None:
+                return False, "edition_transfer requires edition_number"
+
+        if self.tx_type == "spider_hash_anchor":
+            if not self.spider_hash:
+                return False, "spider_hash_anchor requires spider_hash"
+            if not self.chain_name:
+                return False, "spider_hash_anchor requires chain_name"
+
+        return True, "Valid"
+
+    def verify_signature(self, public_key: str = None) -> bool:
+        """
+        Verify the transaction signature.
+        Authority transactions skip verification.
+        MetaMask personal_sign compatible.
+        """
+        # Authority txs don't need signature verification
+        if self.tx_type in AUTHORITY_TX_TYPES:
+            return True
+
+        if not self.signature:
+            logger.warning(f"Transaction {self.hash} missing signature")
+            return False
+
+        try:
+            from eth_account import Account
+            from eth_account.messages import encode_defunct
+
+            signable  = json.dumps(self.get_signable_data(), sort_keys=True)
+            message   = encode_defunct(text=signable)
+            recovered = Account.recover_message(message, signature=self.signature)
+
+            return recovered.lower() == self.from_addr.lower()
+
+        except ImportError:
+            # eth_account not installed — basic format check only
+            logger.warning(
+                "eth_account not installed. "
+                "Skipping full signature verification. "
+                "Install: pip install eth-account"
+            )
+            return bool(self.signature and self.signature.startswith("0x"))
+
+        except Exception as e:
+            logger.error(f"Signature verification failed: {e}")
+            return False
+
+    # ─────────────────────────────────────────────────────────────
+    # Serialisation
+    # ─────────────────────────────────────────────────────────────
+
+    def to_dict(self) -> Dict:
+        d = {
+            # Mandatory
+            "hash":       self.hash,
+            "from_addr":  self.from_addr,
+            "to_addr":    self.to_addr,
+            "amount":     self.amount,
+            "tx_type":    self.tx_type,
+            "timestamp":  self.timestamp,
+            "nonce":      self.nonce,
+            "chain_id":   self.chain_id,
+            "signature":  self.signature,
+            # Optional free field
+            "data":       self.data,
+        }
+
+        # Conditional — only include if set
+        if self.cid            is not None: d["cid"]            = self.cid
+        if self.editions       is not None: d["editions"]       = self.editions
+        if self.royalty_pct    is not None: d["royalty_pct"]    = self.royalty_pct
+        if self.edition_number is not None: d["edition_number"] = self.edition_number
+        if self.spider_hash    is not None: d["spider_hash"]    = self.spider_hash
+        if self.chain_name     is not None: d["chain_name"]     = self.chain_name
+
+        return d
+
+    @classmethod
+    def from_dict(cls, d: Dict) -> "Transaction":
+        tx = cls(
+            from_addr      = d["from_addr"],
+            to_addr        = d["to_addr"],
+            amount         = d["amount"],
+            tx_type        = d["tx_type"],
+            signature      = d.get("signature"),
+            nonce          = d.get("nonce"),
+            timestamp      = d.get("timestamp"),
+            cid            = d.get("cid"),
+            editions       = d.get("editions"),
+            royalty_pct    = d.get("royalty_pct"),
+            edition_number = d.get("edition_number"),
+            spider_hash    = d.get("spider_hash"),
+            chain_name     = d.get("chain_name"),
+            data           = d.get("data", {}),
+        )
+        # Restore original hash (don't recalculate — it was stored)
+        if "hash" in d:
+            tx.hash = d["hash"]
+        return tx
+
+    def __repr__(self):
+        return (
+            f"Transaction(type={self.tx_type}, "
+            f"from={self.from_addr[:8]}..., "
+            f"to={self.to_addr[:8]}..., "
+            f"amount={self.amount}, "
+            f"hash={self.hash[:12]}...)"
+        )

playweb/network/__init__.py

@@ -0,0 +1,6 @@
+from playweb.network.peer_manager import PeerManager, Peer
+from playweb.network.bootstrap    import Bootstrap
+from playweb.network.gossip       import GossipProtocol
+from playweb.network.sync         import ChainSync
+
+__all__ = ["PeerManager", "Peer", "Bootstrap", "GossipProtocol", "ChainSync"]

playweb/network/bootstrap.py

@@ -0,0 +1,217 @@
+"""
+PlayWebit Network — Bootstrap
+First peer discovery via Cloudflare Worker.
+After first connection, pure P2P gossip takes over.
+Cloudflare is never needed again until node restarts.
+"""
+
+import time
+import json
+import hashlib
+import logging
+import threading
+import requests
+from typing import List, Dict, Optional
+
+from playweb.config import (
+    BOOTSTRAP_URL,
+    BOOTSTRAP_ENDPOINTS,
+    BOOTSTRAP_FALLBACK_NODES,
+    BOOTSTRAP_HEARTBEAT_INTERVAL,
+    PEER_TIMEOUT,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class Bootstrap:
+
+    def __init__(
+        self,
+        node_url:         str,
+        node_wallet:      str,
+        node_private_key: str,
+        platform:         str = "unknown",
+        role:             str = "validator",
+    ):
+        self.node_url         = node_url
+        self.node_wallet      = node_wallet.lower()
+        self.node_private_key = node_private_key
+        self.platform         = platform
+        self.role             = role
+        self._heartbeat_thread: Optional[threading.Thread] = None
+        self._running          = False
+
+    # ─────────────────────────────────────────────────────────────
+    # Signature for Cloudflare verification
+    # ─────────────────────────────────────────────────────────────
+
+    def _sign(self, timestamp: int) -> str:
+        """
+        Sign the bootstrap message with node's wallet.
+        message = "playwebit-bootstrap:{url}:{timestamp}"
+        """
+        try:
+            from eth_account import Account
+            from eth_account.messages import encode_defunct
+
+            message = f"playwebit-bootstrap:{self.node_url}:{timestamp}"
+            msg     = encode_defunct(text=message)
+            signed  = Account.sign_message(msg, private_key=self.node_private_key)
+            sig = signed.signature.hex()
+            # ensure 0x prefix — Worker requires it
+            return sig if sig.startswith("0x") else "0x" + sig
+        except ImportError:
+            # Fallback placeholder signature (format-valid)
+            raw = f"{self.node_url}:{timestamp}:{self.node_wallet}"
+            return "0x" + hashlib.sha256(raw.encode()).hexdigest() + "0" * 66
+        except Exception as e:
+            logger.error(f"Bootstrap signing failed: {e}")
+            return "0x" + "0" * 130
+
+    # ─────────────────────────────────────────────────────────────
+    # Discover peers
+    # ─────────────────────────────────────────────────────────────
+
+    def discover_peers(self) -> List[Dict]:
+        """
+        Get list of active nodes from Cloudflare Worker.
+        Falls back to hardcoded nodes if Cloudflare unreachable.
+        Returns list of { url, wallet, platform } dicts.
+        """
+        url = BOOTSTRAP_URL + BOOTSTRAP_ENDPOINTS["nodes"]
+        try:
+            res = requests.get(url, timeout=PEER_TIMEOUT)
+            if res.status_code == 200:
+                data  = res.json()
+                nodes = data.get("nodes", [])
+                # Filter out self
+                nodes = [
+                    n for n in nodes
+                    if n.get("url") != self.node_url
+                    and n.get("wallet", "").lower() != self.node_wallet
+                ]
+                logger.info(
+                    f"Bootstrap: discovered {len(nodes)} peers "
+                    f"from Cloudflare"
+                )
+                return nodes
+            else:
+                logger.warning(
+                    f"Bootstrap Cloudflare returned {res.status_code}"
+                )
+        except Exception as e:
+            logger.warning(f"Bootstrap Cloudflare unreachable: {e}")
+
+        # Fallback to hardcoded nodes
+        logger.info("Bootstrap: using fallback nodes")
+        return [
+            {"url": url, "wallet": "unknown", "platform": "playwebit"}
+            for url in BOOTSTRAP_FALLBACK_NODES
+            if url != self.node_url
+        ]
+
+    # ─────────────────────────────────────────────────────────────
+    # Register node
+    # ─────────────────────────────────────────────────────────────
+
+    def register_node(self) -> bool:
+        """
+        Register this node with the Cloudflare bootstrap directory.
+        Cloudflare will notify all existing nodes about us.
+        """
+        timestamp = int(time.time())
+        signature = self._sign(timestamp)
+        url       = BOOTSTRAP_URL + BOOTSTRAP_ENDPOINTS["register"]
+
+        try:
+            res = requests.post(url, json={
+                "url":       self.node_url,
+                "wallet":    self.node_wallet,
+                "signature": signature,
+                "timestamp": timestamp,
+                "platform":  self.platform,
+                "role":      self.role,
+            }, timeout=PEER_TIMEOUT)
+
+            if res.status_code == 200:
+                data = res.json()
+                logger.info(
+                    f"Bootstrap: node registered. "
+                    f"Network has {data.get('node_count', '?')} nodes"
+                )
+                # Cloudflare returns peer list in registration response
+                # — use it to seed peer manager immediately
+                return True
+            else:
+                logger.warning(
+                    f"Bootstrap registration failed: "
+                    f"{res.status_code} {res.text}"
+                )
+                return False
+
+        except Exception as e:
+            logger.warning(f"Bootstrap registration error: {e}")
+            return False
+
+    # ─────────────────────────────────────────────────────────────
+    # Heartbeat — keeps node listed in Cloudflare KV
+    # ─────────────────────────────────────────────────────────────
+
+    def start_heartbeat(self):
+        """Start background heartbeat thread (every 12 hours)."""
+        self._running = True
+        self._heartbeat_thread = threading.Thread(
+            target = self._heartbeat_loop,
+            daemon = True,
+            name   = "bootstrap-heartbeat",
+        )
+        self._heartbeat_thread.start()
+        logger.info("Bootstrap heartbeat started (every 12h)")
+
+    def stop_heartbeat(self):
+        self._running = False
+
+    def _heartbeat_loop(self):
+        while self._running:
+            time.sleep(BOOTSTRAP_HEARTBEAT_INTERVAL)
+            self._send_heartbeat()
+
+    def _send_heartbeat(self):
+        timestamp = int(time.time())
+        signature = self._sign(timestamp)
+        url       = BOOTSTRAP_URL + BOOTSTRAP_ENDPOINTS["heartbeat"]
+        try:
+            res = requests.post(url, json={
+                "url":       self.node_url,
+                "wallet":    self.node_wallet,
+                "signature": signature,
+                "timestamp": timestamp,
+            }, timeout=PEER_TIMEOUT)
+            if res.status_code == 200:
+                logger.debug("Bootstrap heartbeat sent")
+            else:
+                logger.warning(f"Bootstrap heartbeat failed: {res.status_code}")
+        except Exception as e:
+            logger.warning(f"Bootstrap heartbeat error: {e}")
+
+    # ─────────────────────────────────────────────────────────────
+    # Deregister
+    # ─────────────────────────────────────────────────────────────
+
+    def deregister(self):
+        """Clean removal when node shuts down gracefully."""
+        self.stop_heartbeat()
+        timestamp = int(time.time())
+        signature = self._sign(timestamp)
+        url       = BOOTSTRAP_URL + BOOTSTRAP_ENDPOINTS["deregister"]
+        try:
+            requests.post(url, json={
+                "url":       self.node_url,
+                "wallet":    self.node_wallet,
+                "signature": signature,
+                "timestamp": timestamp,
+            }, timeout=PEER_TIMEOUT)
+            logger.info("Bootstrap: node deregistered")
+        except Exception as e:
+            logger.warning(f"Bootstrap deregistration error: {e}")