playweb-node 1.0.0__py3-none-any.whl

playweb/api/rpc.py

@@ -0,0 +1,247 @@
+"""
+PlayWebit Network — Ethereum JSON-RPC Compatibility Layer
+Allows MetaMask to connect to PlayWebit Network.
+
+MetaMask setup:
+  RPC URL:   https://your-node.com/rpc
+  Chain ID:  4968
+  Currency:  PLWB
+
+Contract address = Node wallet address (for both ERC20 + ERC721)
+No Solidity. No deployment. No gas fees to deploy.
+"""
+
+import logging
+from flask import Blueprint, request, jsonify
+
+logger = logging.getLogger(__name__)
+
+
+def create_rpc(node) -> Blueprint:
+    bp = Blueprint("rpc", __name__)
+
+    @bp.route("/rpc", methods=["POST"])
+    def rpc():
+        data   = request.get_json(silent=True) or {}
+        method = data.get("method", "")
+        params = data.get("params", [])
+        req_id = data.get("id", 1)
+
+        def ok(val):
+            return jsonify({
+                "jsonrpc": "2.0",
+                "id":      req_id,
+                "result":  val,
+            })
+
+        def err(code, msg):
+            return jsonify({
+                "jsonrpc": "2.0",
+                "id":      req_id,
+                "error":   {"code": code, "message": msg},
+            }), 400
+
+        # ── Network identity ──────────────────────────────────
+        if method == "eth_chainId":
+            return ok("0x1368")   # 4968 in hex
+
+        if method == "net_version":
+            return ok("4968")
+
+        if method == "eth_blockNumber":
+            length = node.blockchain.get_chain_length()
+            return ok(hex(max(0, length - 1)))
+
+        if method == "eth_accounts":
+            return ok([])
+
+        if method == "eth_estimateGas":
+            return ok("0x5208")   # 21000 fixed
+
+        if method == "eth_gasPrice":
+            return ok("0x1")      # 1 wei fixed
+
+        if method == "eth_getTransactionCount":
+            return ok("0x1")
+
+        # ── PLWB native balance ───────────────────────────────
+        if method == "eth_getBalance":
+            addr    = params[0] if params else "0x0"
+            balance = node.blockchain.get_balance(addr)
+            wei     = int(balance * 10**18)
+            return ok(hex(wei))
+
+        # ── ERC20 + ERC721 via eth_call ───────────────────────
+        if method == "eth_call":
+            if not params or not isinstance(params[0], dict):
+                return ok("0x")
+
+            from playweb.api.erc20    import handle_erc20_call
+            from playweb.api.erc721   import handle_erc721_call
+
+            call_data = params[0].get("data", "0x")
+            to_addr   = params[0].get("to", "").lower()
+
+            # Both ERC20 + ERC721 use node wallet as contract address
+            if to_addr == node.node_wallet.lower():
+                # Try ERC20 first (PLWB token)
+                result = handle_erc20_call(call_data, node)
+                if result is not None:
+                    return ok(result)
+
+                # Then try ERC721 (NFT ownership)
+                result = handle_erc721_call(call_data, node)
+                if result is not None:
+                    return ok(result)
+
+            return ok("0x")
+
+        # ── Transaction submission ────────────────────────────
+        if method == "eth_sendRawTransaction":
+            raw_tx = params[0] if params else None
+            if not raw_tx:
+                return err(-32602, "Missing raw transaction")
+            try:
+                from eth_account          import Account
+                from eth_account.messages import encode_defunct
+                from playweb.core.transaction import Transaction
+                import time
+
+                decoded   = Account.decode_transaction(raw_tx)
+                from_addr = decoded.get("from", "")
+                if not from_addr:
+                    # recover from signature
+                    from_addr = Account.recover_transaction(raw_tx)
+
+                tx = Transaction(
+                    from_addr = from_addr.lower(),
+                    to_addr   = decoded["to"].lower(),
+                    amount    = decoded["value"] / 10**18,
+                    tx_type   = "transfer",
+                    signature = raw_tx,
+                    nonce     = decoded.get("nonce", int(time.time())),
+                )
+
+                success, result = node.blockchain.add_transaction(
+                    tx          = tx,
+                    node_wallet = node.node_wallet,
+                )
+
+                if success:
+                    node.gossip.broadcast_transaction(
+                        tx    = tx,
+                        peers = node.peer_manager.get_active_peers(),
+                    )
+                    return ok(tx.hash)
+                else:
+                    return err(-32000, result)
+
+            except Exception as e:
+                logger.error(f"eth_sendRawTransaction error: {e}")
+                return err(-32000, str(e))
+
+        # ── Transaction queries ───────────────────────────────
+        if method == "eth_getTransactionByHash":
+            tx_hash = params[0] if params else None
+            if not tx_hash:
+                return ok(None)
+            tx = node.blockchain.get_transaction(tx_hash)
+            if not tx:
+                return ok(None)
+            return ok({
+                "hash":             tx.hash,
+                "from":             tx.from_addr,
+                "to":               tx.to_addr,
+                "value":            hex(int(tx.amount * 10**18)),
+                "blockNumber":      None,
+                "transactionIndex": "0x0",
+                "gas":              "0x5208",
+                "gasPrice":         "0x1",
+                "nonce":            hex(tx.nonce or 0),
+                "input":            "0x",
+            })
+
+        if method == "eth_getTransactionReceipt":
+            tx_hash = params[0] if params else None
+            if not tx_hash:
+                return ok(None)
+            tx = node.blockchain.get_transaction(tx_hash)
+            if not tx:
+                return ok(None)
+            tip = node.blockchain.get_chain_tip()
+            return ok({
+                "transactionHash":  tx_hash,
+                "status":           "0x1",
+                "blockNumber":      hex(tip.index) if tip else "0x0",
+                "blockHash":        tip.hash if tip else "0x0",
+                "gasUsed":          "0x5208",
+                "cumulativeGasUsed":"0x5208",
+                "logs":             [],
+                "logsBloom":        "0x" + "0" * 512,
+            })
+
+        if method == "eth_getBlockByNumber":
+            block_param = params[0] if params else "latest"
+            include_txs = params[1] if len(params) > 1 else False
+
+            if block_param == "latest":
+                block = node.blockchain.get_chain_tip()
+            elif block_param == "earliest":
+                block = node.blockchain.get_block_by_index(0)
+            else:
+                try:
+                    block = node.blockchain.get_block_by_index(
+                        int(block_param, 16)
+                    )
+                except:
+                    block = node.blockchain.get_chain_tip()
+
+            if not block:
+                return ok(None)
+
+            txs = (
+                [tx.to_dict() for tx in block.transactions]
+                if include_txs
+                else [tx.hash for tx in block.transactions]
+            )
+            return ok({
+                "number":           hex(block.index),
+                "hash":             block.hash,
+                "parentHash":       block.previous_hash,
+                "timestamp":        hex(int(block.timestamp)),
+                "transactions":     txs,
+                "miner":            block.validator_wallet,
+                "gasLimit":         "0x1c9c380",
+                "gasUsed":          "0x0",
+                "difficulty":       "0x1",
+                "nonce":            "0x0000000000000000",
+                "extraData":        "0x",
+                "logsBloom":        "0x" + "0" * 512,
+            })
+
+        if method == "eth_getBlockByHash":
+            block_hash  = params[0] if params else None
+            include_txs = params[1] if len(params) > 1 else False
+            if not block_hash:
+                return ok(None)
+            block = node.blockchain.get_block(block_hash)
+            if not block:
+                return ok(None)
+            txs = (
+                [tx.to_dict() for tx in block.transactions]
+                if include_txs
+                else [tx.hash for tx in block.transactions]
+            )
+            return ok({
+                "number":      hex(block.index),
+                "hash":        block.hash,
+                "parentHash":  block.previous_hash,
+                "timestamp":   hex(int(block.timestamp)),
+                "transactions": txs,
+            })
+
+        # ── Unknown method ────────────────────────────────────
+        logger.debug(f"Unknown RPC method: {method}")
+        return ok("0x")
+
+    return bp

playweb/client.py

@@ -0,0 +1,341 @@
+"""
+PlayWebit Network — PlayWebitClient
+Lightweight client for dApps that connect to a validator node.
+No local chain storage. No consensus participation.
+Just calls a node's public API.
+
+Use this for:
+  - HuggingFace apps (CipherVault frontend)
+  - Any app that doesn't want to run a full node
+  - spiderweave-sdk integration without running a node
+
+Usage:
+    from playweb import PlayWebitClient
+
+    client = PlayWebitClient(
+        validator_url   = "https://node1.playwebit.com",
+        platform_wallet = os.getenv("PLATFORM_WALLET"),
+    )
+
+    result = client.register_content(
+        cid         = "QmXyz...",
+        owner       = "0xabc...",
+        editions    = 100,
+        royalty_pct = 10,
+        signature   = "0x...",
+    )
+"""
+
+import logging
+import requests
+from typing import Optional, Dict, Tuple
+
+from playweb.config import PEER_TIMEOUT, CHAIN_ID
+
+logger = logging.getLogger(__name__)
+
+
+class PlayWebitClient:
+
+    def __init__(
+        self,
+        validator_url:   str,
+        platform_wallet: str,
+        timeout:         int = PEER_TIMEOUT,
+    ):
+        self.validator_url   = validator_url.rstrip("/")
+        self.platform_wallet = platform_wallet.lower()
+        self.timeout         = timeout
+
+    # ─────────────────────────────────────────────────────────────
+    # Internal HTTP helpers
+    # ─────────────────────────────────────────────────────────────
+
+    def _get(self, path: str) -> Dict:
+        try:
+            res = requests.get(
+                f"{self.validator_url}{path}",
+                timeout=self.timeout,
+            )
+            return res.json()
+        except Exception as e:
+            logger.error(f"Client GET {path} failed: {e}")
+            return {"success": False, "error": str(e)}
+
+    def _post(self, path: str, data: Dict) -> Dict:
+        try:
+            res = requests.post(
+                f"{self.validator_url}{path}",
+                json    = data,
+                timeout = self.timeout,
+            )
+            return res.json()
+        except Exception as e:
+            logger.error(f"Client POST {path} failed: {e}")
+            return {"success": False, "error": str(e)}
+
+    def transfer_plwb(
+        self,
+        from_addr: str,
+        to_addr:   str,
+        amount:    float,
+        signature: str,
+    ) -> Tuple[bool, str, Optional[str]]:
+        """
+        Transfer PLWB between any two wallets.
+        Requires MetaMask signature from sender.
+        Network fee: 1 PLWB (split 50/50).
+        Returns (success, reason, tx_hash).
+        """
+        res = self._post("/api/transfer", {
+            "from_addr": from_addr.lower(),
+            "to_addr":   to_addr.lower(),
+            "amount":    amount,
+            "signature": signature,
+        })
+        success = res.get("success", False)
+        result  = res.get("tx_hash") or res.get("error", "Unknown error")
+        return success, result, res.get("tx_hash")
+
+    # ─────────────────────────────────────────────────────────────
+    # Content Registry
+    # ─────────────────────────────────────────────────────────────
+
+    def register_content(
+        self,
+        cid:         str,
+        owner:       str,
+        editions:    int   = 1,
+        royalty_pct: float = 0,
+        signature:   str   = None,
+        platform_id: str   = None,
+        extra_data:  Dict  = None,
+    ) -> Tuple[bool, str, Optional[str]]:
+        """
+        Register a CID on the PlayWebit Network.
+        Checks for duplicates automatically.
+        Returns (success, reason, tx_hash).
+        """
+        res = self._post("/api/transaction", {
+            "from_addr":   owner.lower(),
+            "to_addr":     owner.lower(),
+            "amount":      0,
+            "tx_type":     "content_register",
+            "signature":   signature,
+            "chain_id":    CHAIN_ID,
+            "cid":         cid,
+            "editions":    editions,
+            "royalty_pct": royalty_pct,
+            "data": {
+                "platform_id": platform_id or "unknown",
+                **(extra_data or {}),
+            },
+        })
+        success  = res.get("success", False)
+        result   = res.get("result") or res.get("error", "Unknown error")
+        tx_hash  = result if success else None
+        return success, result, tx_hash
+
+    def check_duplicate(self, cid: str) -> Dict:
+        """
+        Check if a CID is already registered anywhere on the network.
+        Returns { exists, first_owner, first_platform, first_seen, ... }
+        """
+        return self._get(f"/api/check_duplicate/{cid}")
+
+    def get_owner(self, cid: str) -> Optional[Dict]:
+        """Get current owner of a CID."""
+        res = self._get(f"/api/owner/{cid}")
+        return res if res.get("success") else None
+
+    def verify_ownership(self, cid: str, wallet: str) -> bool:
+        """Verify a wallet owns a CID."""
+        res = self._post("/api/verify_ownership", {
+            "cid":    cid,
+            "wallet": wallet,
+        })
+        return res.get("owns", False)
+
+    def transfer_ownership(
+        self,
+        cid:         str,
+        from_wallet: str,
+        to_wallet:   str,
+        signature:   str   = None,
+        sale_price:  float = 0,
+        platform_id: str   = None,
+    ) -> Tuple[bool, str, Optional[str]]:
+        """
+        Transfer ownership of a CID.
+        If sale_price > 0, royalty is automatically paid to creator.
+        Returns (success, reason, tx_hash).
+        """
+        res = self._post("/api/transaction", {
+            "from_addr": from_wallet.lower(),
+            "to_addr":   to_wallet.lower(),
+            "amount":    sale_price,
+            "tx_type":   "ownership_transfer",
+            "signature": signature,
+            "chain_id":  CHAIN_ID,
+            "cid":       cid,
+            "data": {
+                "platform_id":   platform_id or "unknown",
+                "sale_price":    sale_price,
+                "transfer_type": "sale" if sale_price > 0 else "gift",
+            },
+        })
+        success = res.get("success", False)
+        result  = res.get("result") or res.get("error", "Unknown error")
+        return success, result, result if success else None
+
+    # ─────────────────────────────────────────────────────────────
+    # Edition Registry
+    # ─────────────────────────────────────────────────────────────
+
+    def get_editions(self, cid: str) -> Dict:
+        """Get all editions for a CID across all platforms."""
+        return self._get(f"/api/editions/{cid}")
+
+    def get_edition(self, cid: str, edition_number: int) -> Optional[Dict]:
+        """Get a specific edition."""
+        res = self._get(f"/api/editions/{cid}/{edition_number}")
+        return res.get("edition") if res.get("success") else None
+
+    def transfer_edition(
+        self,
+        cid:            str,
+        edition_number: int,
+        from_wallet:    str,
+        to_wallet:      str,
+        signature:      str   = None,
+        sale_price:     float = 0,
+        platform_id:    str   = None,
+    ) -> Tuple[bool, str, Optional[str]]:
+        """Transfer a specific edition to a new owner."""
+        res = self._post("/api/transaction", {
+            "from_addr":      from_wallet.lower(),
+            "to_addr":        to_wallet.lower(),
+            "amount":         sale_price,
+            "tx_type":        "edition_transfer",
+            "signature":      signature,
+            "chain_id":       CHAIN_ID,
+            "cid":            cid,
+            "edition_number": edition_number,
+            "data": {
+                "platform_id": platform_id or "unknown",
+                "sale_price":  sale_price,
+                "action":      "transfer",
+            },
+        })
+        success = res.get("success", False)
+        result  = res.get("result") or res.get("error", "Unknown error")
+        return success, result, result if success else None
+
+    # ─────────────────────────────────────────────────────────────
+    # SpiderWeave hash anchoring
+    # Called internally by spiderweave-sdk's PlayWebitAdapter
+    # ─────────────────────────────────────────────────────────────
+
+    def anchor_spider_hash(
+        self,
+        chain_name:      str,
+        spider_hash:     str,
+        event_type:      str  = "integrity_check",
+        platform_wallet: str  = None,
+        signature:       str  = None,
+        metadata:        Dict = None,
+    ) -> Tuple[bool, Optional[str]]:
+        """
+        Anchor a SpiderWeave hash on the chain.
+        L1 stores it, never interprets it.
+        Returns (success, tx_hash).
+        """
+        res = self._post("/api/anchor_spider_hash", {
+            "chain_id":       chain_name,
+            "chain_name":     chain_name,
+            "spider_hash":    spider_hash,
+            "event_type":     event_type,
+            "platform_wallet": platform_wallet or self.platform_wallet,
+            "signature":      signature,
+            "metadata":       metadata or {},
+        })
+        success  = res.get("success", False)
+        tx_hash  = res.get("tx_hash")
+        return success, tx_hash
+
+    def verify_spider_hash(self, tx_hash: str) -> Optional[Dict]:
+        """Verify a previously anchored spider hash by tx_hash."""
+        res = self._get(f"/api/transaction/{tx_hash}")
+        if not res.get("success"):
+            return None
+        tx = res.get("transaction", {})
+        if tx.get("tx_type") != "spider_hash_anchor":
+            return None
+        return {
+            "tx_hash":     tx_hash,
+            "spider_hash": tx.get("spider_hash"),
+            "chain_name":  tx.get("chain_name"),
+            "timestamp":   tx.get("timestamp"),
+            "confirmed":   True,
+        }
+
+    def get_spider_hashes(self, chain_name: str) -> Dict:
+        """Get all anchored hashes for a chain_name."""
+        return self._get(f"/api/spider_hashes/{chain_name}")
+
+    # ─────────────────────────────────────────────────────────────
+    # Payments
+    # ─────────────────────────────────────────────────────────────
+
+    def pay(
+        self,
+        from_addr: str,
+        to_addr:   str,
+        amount:    float,
+        signature: str,
+    ) -> Tuple[bool, str, Optional[str]]:
+        """
+        Send PLWB from one wallet to another.
+        Returns (success, reason, tx_hash).
+        """
+        res = self._post("/api/transaction", {
+            "from_addr": from_addr.lower(),
+            "to_addr":   to_addr.lower(),
+            "amount":    amount,
+            "tx_type":   "transfer",
+            "signature": signature,
+            "chain_id":  CHAIN_ID,
+        })
+        success = res.get("success", False)
+        result  = res.get("result") or res.get("error", "Unknown error")
+        return success, result, result if success else None
+
+    def get_balance(self, address: str) -> float:
+        """Get PLWB balance for an address."""
+        res = self._get(f"/api/balance/{address}")
+        return float(res.get("balance", 0.0))
+
+    # ─────────────────────────────────────────────────────────────
+    # Network info
+    # ─────────────────────────────────────────────────────────────
+
+    def get_network_stats(self) -> Dict:
+        """Get network stats from the connected validator."""
+        return self._get("/api/network/stats")
+
+    def get_transaction(self, tx_hash: str) -> Optional[Dict]:
+        """Get a transaction by hash."""
+        res = self._get(f"/api/transaction/{tx_hash}")
+        return res.get("transaction") if res.get("success") else None
+
+    def health_check(self) -> bool:
+        """Check if the connected validator is online."""
+        res = self._get("/peer/health")
+        return res.get("status") == "ok"
+
+    def __repr__(self):
+        return (
+            f"PlayWebitClient("
+            f"validator={self.validator_url}, "
+            f"wallet={self.platform_wallet[:10]}...)"
+        )