playweb-node 1.0.0__py3-none-any.whl

playweb/__init__.py

@@ -0,0 +1,18 @@
+"""
+PlayWebit Network SDK
+L1 blockchain SDK for the PlayWebit public network.
+Chain ID: 4968 | Currency: PLWB
+"""
+
+__version__ = "1.0.0"
+__author__  = "PlayWebIT"
+__license__ = "MIT"
+
+from playweb.node   import PlayWebitNode
+from playweb.client import PlayWebitClient
+
+__all__ = [
+    "PlayWebitNode",
+    "PlayWebitClient",
+    "__version__",
+]

playweb/api/__init__.py

@@ -0,0 +1,4 @@
+from playweb.api.node_api   import create_node_api
+from playweb.api.public_api import create_public_api
+
+__all__ = ["create_node_api", "create_public_api"]

playweb/api/erc20.py

@@ -0,0 +1,66 @@
+"""
+PlayWebit Network — ERC20 Handler
+PLWB token as ERC20 — reads from chain directly.
+Contract address = Node wallet address.
+No separate contract storage needed.
+"""
+
+
+def handle_erc20_call(call_data: str, node) -> str:
+    """
+    Handle ERC20 function calls from MetaMask.
+    Returns ABI-encoded response or None if not ERC20.
+    """
+
+    # balanceOf(address) = 0x70a08231
+    if call_data.startswith("0x70a08231"):
+        addr    = "0x" + call_data[34:74]
+        balance = node.blockchain.get_balance(addr)
+        wei     = int(balance * 10**18)
+        return "0x" + hex(wei)[2:].zfill(64)
+
+    # totalSupply() = 0x18160ddd
+    elif call_data.startswith("0x18160ddd"):
+        addresses = node.blockchain.storage.get_all_addresses()
+        total = sum(
+            node.blockchain.get_balance(a)
+            for a in addresses
+        )
+        wei = int(total * 10**18)
+        return "0x" + hex(wei)[2:].zfill(64)
+
+    # name() = 0x06fdde03
+    elif call_data.startswith("0x06fdde03"):
+        return _encode_string("PlayWebit Coin")
+
+    # symbol() = 0x95d89b41
+    elif call_data.startswith("0x95d89b41"):
+        return _encode_string("PLWB")
+
+    # decimals() = 0x313ce567
+    elif call_data.startswith("0x313ce567"):
+        return "0x" + hex(18)[2:].zfill(64)
+
+    # allowance() = 0xdd62ed3e → always 0
+    elif call_data.startswith("0xdd62ed3e"):
+        return "0x" + "0" * 64
+
+    # approve() = 0x095ea7b3 → always true
+    elif call_data.startswith("0x095ea7b3"):
+        return "0x" + "1".zfill(64)
+
+    # supportsInterface = 0x01ffc9a7
+    elif call_data.startswith("0x01ffc9a7"):
+        return "0x" + "1".zfill(64)
+
+    return None
+
+
+def _encode_string(s: str) -> str:
+    """ABI encode a string response."""
+    b       = s.encode("utf-8")
+    offset  = "0" * 63 + "20"
+    length  = hex(len(b))[2:].zfill(64)
+    padding = 32 - len(b) % 32
+    pad     = b.hex() + "00" * (padding if padding != 32 else 0)
+    return "0x" + offset + length + pad

playweb/api/erc721.py

@@ -0,0 +1,88 @@
+"""
+PlayWebit Network — ERC721 Handler
+NFT ownership reads from L1 chain directly.
+Contract address = Node wallet address.
+
+Ownership is ALREADY on chain in content_registry
+and edition_registry. This just exposes it as ERC721.
+"""
+
+import hashlib
+
+
+def handle_erc721_call(call_data: str, node) -> str:
+    """
+    Handle ERC721 function calls from MetaMask.
+    Returns ABI-encoded response or None if not ERC721.
+    """
+
+    # balanceOf(address) = 0x70a08231
+    if call_data.startswith("0x70a08231"):
+        addr    = "0x" + call_data[34:74]
+        records = node.blockchain.storage.get_all_content_by_owner(addr)
+        count   = len(records)
+        return "0x" + hex(count)[2:].zfill(64)
+
+    # ownerOf(uint256) = 0x6352211e
+    elif call_data.startswith("0x6352211e"):
+        int_id = int(call_data[10:], 16)
+        cid    = node.blockchain.storage.get_cid_by_int_id(int_id)
+        if cid:
+            record = node.blockchain.storage.get_content_record(cid)
+            if record:
+                owner = record.get("current_owner", "0x" + "0" * 40)
+                return "0x" + owner[2:].zfill(64)
+        return "0x" + "0" * 64
+
+    # tokenURI(uint256) = 0xc87b56dd
+    elif call_data.startswith("0xc87b56dd"):
+        int_id = int(call_data[10:], 16)
+        cid    = node.blockchain.storage.get_cid_by_int_id(int_id)
+        if cid:
+            uri = f"{node.node_url}/api/metadata/{cid}"
+            return _encode_string(uri)
+        return "0x"
+
+    # name() = 0x06fdde03
+    elif call_data.startswith("0x06fdde03"):
+        return _encode_string("PlayWebit NFT")
+
+    # symbol() = 0x95d89b41
+    elif call_data.startswith("0x95d89b41"):
+        return _encode_string("PLWB-NFT")
+
+    # supportsInterface(bytes4) = 0x01ffc9a7
+    elif call_data.startswith("0x01ffc9a7"):
+        iface     = call_data[10:18].lower()
+        # ERC721=80ac58cd, ERC721Metadata=5b5e139f, ERC165=01ffc9a7
+        supported = iface in ["80ac58cd", "5b5e139f", "01ffc9a7"]
+        return "0x" + ("1" if supported else "0").zfill(64)
+
+    # getApproved(uint256) = 0x081812fc → always zero address
+    elif call_data.startswith("0x081812fc"):
+        return "0x" + "0" * 64
+
+    # isApprovedForAll = 0xe985e9c5 → always false
+    elif call_data.startswith("0xe985e9c5"):
+        return "0x" + "0" * 64
+
+    return None
+
+
+def _encode_string(s: str) -> str:
+    """ABI encode a string response."""
+    b       = s.encode("utf-8")
+    offset  = "0" * 63 + "20"
+    length  = hex(len(b))[2:].zfill(64)
+    padding = 32 - len(b) % 32
+    pad     = b.hex() + "00" * (padding if padding != 32 else 0)
+    return "0x" + offset + length + pad
+
+
+def cid_to_int_id(cid: str) -> int:
+    """
+    Convert CID string to integer token ID for MetaMask.
+    Deterministic — same CID always gives same int.
+    """
+    hash_obj = hashlib.sha256(cid.encode())
+    return int(hash_obj.hexdigest()[:16], 16)

playweb/api/metadata.py

@@ -0,0 +1,86 @@
+"""
+PlayWebit Network — NFT Metadata Endpoint
+Generic metadata for any NFT on the network.
+Platforms enrich via plugin get_nft_metadata() hook.
+
+MetaMask fetches: GET /api/metadata/{cid}
+Returns OpenSea-compatible metadata JSON.
+"""
+
+import logging
+from flask import Blueprint, jsonify
+
+logger = logging.getLogger(__name__)
+
+
+def create_metadata_api(node) -> Blueprint:
+    bp = Blueprint("metadata", __name__)
+
+    @bp.route("/api/metadata/<path:cid>", methods=["GET"])
+    def nft_metadata(cid):
+        """
+        Returns NFT metadata in OpenSea format.
+        Reads base data from chain.
+        Plugin can enrich with thumbnail, filename etc.
+        """
+        record = node.blockchain.storage.get_content_record(cid)
+        if not record:
+            return jsonify({"error": "CID not registered"}), 404
+
+        # Base metadata from chain — always available
+        metadata = {
+            "name":        f"PlayWebit NFT — {cid[:12]}...",
+            "description": (
+                f"Registered on PlayWebit Network by "
+                f"{record.get('first_platform', 'unknown')}. "
+                f"CID: {cid}"
+            ),
+            "image":       "",
+            "external_url": f"{node.node_url}/api/owner/{cid}",
+            "attributes":  [
+                {
+                    "trait_type": "CID",
+                    "value":      cid,
+                },
+                {
+                    "trait_type": "Platform",
+                    "value":      record.get("first_platform", "unknown"),
+                },
+                {
+                    "trait_type": "Total Editions",
+                    "value":      record.get("total_editions", 1),
+                },
+                {
+                    "trait_type": "Royalty",
+                    "value":      f"{record.get('royalty_pct', 0)}%",
+                },
+                {
+                    "trait_type": "Current Owner",
+                    "value":      record.get("current_owner", "unknown"),
+                },
+                {
+                    "trait_type": "Registered Block",
+                    "value":      record.get("first_block", 0),
+                },
+            ],
+        }
+
+        # Let plugin enrich metadata
+        # (adds thumbnail, filename, custom attributes etc)
+        if node.plugin_manager:
+            for plugin in node.plugin_manager.get_all_plugins():
+                if hasattr(plugin, "get_nft_metadata"):
+                    try:
+                        enriched = plugin.get_nft_metadata(cid, record)
+                        if enriched:
+                            metadata.update(enriched)
+                            break
+                    except Exception as e:
+                        logger.error(
+                            f"Plugin metadata error "
+                            f"({plugin.plugin_id}): {e}"
+                        )
+
+        return jsonify(metadata)
+
+    return bp

playweb/api/node_api.py

@@ -0,0 +1,224 @@
+"""
+PlayWebit Network — Node API (Peer-to-Peer)
+HTTP endpoints for node-to-node communication.
+Every node exposes these. Peers call these directly.
+Works on all cloud platforms — no WebSocket needed.
+"""
+
+import logging
+from flask import Blueprint, request, jsonify
+
+logger = logging.getLogger(__name__)
+
+
+def create_node_api(node) -> Blueprint:
+    """
+    Factory — creates the peer API blueprint bound to a node instance.
+    Mount in Flask app: app.register_blueprint(create_node_api(node))
+    """
+    bp = Blueprint("node_api", __name__, url_prefix="/peer")
+
+    # ─────────────────────────────────────────────────────────────
+    # Health check
+    # ─────────────────────────────────────────────────────────────
+
+    @bp.route("/health", methods=["GET"])
+    def health():
+        tip = node.blockchain.get_chain_tip()
+        return jsonify({
+            "status":       "ok",
+            "node_wallet":  node.node_wallet,
+            "block_height": tip.index if tip else 0,
+            "peer_count":   node.peer_manager.peer_count(),
+            "chain_id":     4968,
+            "synced":       node.sync.get_sync_status()["synced"],
+        })
+
+    # ─────────────────────────────────────────────────────────────
+    # Chain tip — used by new nodes to find canonical chain
+    # ─────────────────────────────────────────────────────────────
+
+    @bp.route("/chain_tip", methods=["GET"])
+    def chain_tip():
+        tip = node.blockchain.get_chain_tip()
+        if not tip:
+            return jsonify({"block_index": -1, "block_hash": None})
+        return jsonify({
+            "block_index": tip.index,
+            "block_hash":  tip.hash,
+            "timestamp":   tip.timestamp,
+        })
+
+    # ─────────────────────────────────────────────────────────────
+    # Block range — used during chain sync
+    # ─────────────────────────────────────────────────────────────
+
+    @bp.route("/blocks/<int:from_index>/<int:to_index>", methods=["GET"])
+    def get_blocks(from_index, to_index):
+        limit  = min(to_index - from_index + 1, 50)   # max 50 per request
+        blocks = node.blockchain.get_blocks_from(from_index, limit)
+        return jsonify({
+            "blocks":     [b.to_dict() for b in blocks],
+            "from_index": from_index,
+            "to_index":   to_index,
+            "count":      len(blocks),
+        })
+
+    # ─────────────────────────────────────────────────────────────
+    # Peer list — new nodes get peers from existing nodes
+    # ─────────────────────────────────────────────────────────────
+
+    @bp.route("/peers", methods=["GET"])
+    def get_peers():
+        return jsonify({
+            "peers": node.peer_manager.get_peer_list_for_sharing(),
+            "my_url": node.node_url,
+        })
+
+    # ─────────────────────────────────────────────────────────────
+    # Receive new transaction from peer
+    # ─────────────────────────────────────────────────────────────
+
+    @bp.route("/new_transaction", methods=["POST"])
+    def new_transaction():
+        data = request.get_json(silent=True)
+        if not data or "transaction" not in data:
+            return jsonify({"success": False, "error": "Missing transaction"}), 400
+
+        from playweb.core.transaction import Transaction
+        try:
+            tx = Transaction.from_dict(data["transaction"])
+        except Exception as e:
+            return jsonify({"success": False, "error": f"Invalid tx: {e}"}), 400
+
+        # Skip if already in mempool or chain
+        if node.blockchain.mempool.contains(tx.hash):
+            return jsonify({"success": True, "status": "already_known"})
+
+        success, result = node.blockchain.add_transaction(
+            tx          = tx,
+            node_wallet = node.node_wallet,
+        )
+
+        if success:
+            # Forward to our peers (gossip propagation)
+            node.gossip.broadcast_transaction(
+                tx    = tx,
+                peers = node.peer_manager.get_active_peers(),
+            )
+
+        return jsonify({
+            "success": success,
+            "result":  result,
+        })
+
+    # ─────────────────────────────────────────────────────────────
+    # Receive block proposal from consensus leader
+    # NVF: Spacetime Fabric activation received
+    # ─────────────────────────────────────────────────────────────
+
+    @bp.route("/propose", methods=["POST"])
+    def propose():
+        data = request.get_json(silent=True)
+        if not data or "block" not in data:
+            return jsonify({"success": False, "error": "Missing block"}), 400
+
+        from playweb.core.block import Block
+        try:
+            block        = Block.from_dict(data["block"])
+            round_number = data.get("round_number", block.index)
+            from_peer    = data.get("from_node", "unknown")
+        except Exception as e:
+            return jsonify({"success": False, "error": f"Invalid block: {e}"}), 400
+
+        # Hand off to consensus engine
+        node.consensus.on_propose(block, round_number, from_peer)
+
+        return jsonify({"success": True, "status": "proposal_received"})
+
+    # ─────────────────────────────────────────────────────────────
+    # Receive consensus vote
+    # NVF: Planck Threshold approach
+    # ─────────────────────────────────────────────────────────────
+
+    @bp.route("/vote", methods=["POST"])
+    def receive_vote():
+        data = request.get_json(silent=True)
+        if not data or "vote" not in data:
+            return jsonify({"success": False, "error": "Missing vote"}), 400
+
+        from playweb.consensus.vote import Vote
+        try:
+            vote = Vote.from_dict(data["vote"])
+        except Exception as e:
+            return jsonify({"success": False, "error": f"Invalid vote: {e}"}), 400
+
+        node.consensus.on_vote(vote)
+        return jsonify({"success": True, "status": "vote_received"})
+
+    # ─────────────────────────────────────────────────────────────
+    # Receive finalised block from peer
+    # For nodes that missed consensus round
+    # ─────────────────────────────────────────────────────────────
+
+    @bp.route("/new_block", methods=["POST"])
+    def new_block():
+        data = request.get_json(silent=True)
+        if not data or "block" not in data:
+            return jsonify({"success": False, "error": "Missing block"}), 400
+
+        from playweb.core.block import Block
+        try:
+            block = Block.from_dict(data["block"])
+            votes = data.get("votes", [])
+        except Exception as e:
+            return jsonify({"success": False, "error": f"Invalid block: {e}"}), 400
+
+        # Check if we already have this block
+        existing = node.blockchain.get_block(block.hash)
+        if existing:
+            return jsonify({"success": True, "status": "already_known"})
+
+        # Add to chain
+        success, result = node.blockchain.add_block(
+            block       = block,
+            votes       = votes,
+            node_wallet = node.node_wallet,
+        )
+
+        return jsonify({"success": success, "result": result})
+
+    # ─────────────────────────────────────────────────────────────
+    # New node joined the network
+    # Cloudflare calls this when a new node registers
+    # ─────────────────────────────────────────────────────────────
+
+    @bp.route("/new_node", methods=["POST"])
+    def new_node():
+        data = request.get_json(silent=True)
+        if not data or "url" not in data or "wallet" not in data:
+            return jsonify({"success": False, "error": "Missing url or wallet"}), 400
+
+        added = node.peer_manager.add_peer(
+            url      = data["url"],
+            wallet   = data["wallet"],
+            platform = data.get("platform", "unknown"),
+            role     = data.get("role", "validator"),
+        )
+
+        if added:
+            logger.info(f"New peer joined: {data['url']}")
+            # Forward new node info to our peers
+            node.gossip.broadcast_new_node(
+                new_node_url    = data["url"],
+                new_node_wallet = data["wallet"],
+                peers           = node.peer_manager.get_active_peers(),
+            )
+
+        return jsonify({
+            "success":    True,
+            "added":      added,
+            "peer_count": node.peer_manager.peer_count(),
+        })
+
+    return bp