playweb-node 1.0.0__py3-none-any.whl

playweb/registry/content_registry.py

@@ -0,0 +1,259 @@
+"""
+PlayWebit Network — Content Registry
+Cross-platform CID ownership. The core value of PlayWebit Network.
+
+Any platform using IPFS CIDs gets duplicate detection for free —
+IPFS CID format matches across all platforms automatically.
+
+Register once → protected everywhere.
+"""
+
+import time
+import logging
+from typing import Dict, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+class ContentRegistry:
+
+    def __init__(self, blockchain, node_wallet: str):
+        self.blockchain  = blockchain
+        self.node_wallet = node_wallet
+
+    # ─────────────────────────────────────────────────────────────
+    # Register content
+    # ─────────────────────────────────────────────────────────────
+
+    def register(
+        self,
+        cid:           str,
+        owner_wallet:  str,
+        platform_id:   str,
+        editions:      int   = 1,
+        royalty_pct:   float = 0,
+        signature:     str   = None,
+        extra_data:    Dict  = None,
+    ) -> Tuple[bool, str, Optional[str]]:
+        """
+        Register a CID on the network.
+        Checks for duplicates first — rejects if already registered
+        by ANY platform on the network.
+
+        Returns (success, reason, tx_hash).
+        tx_hash is None on failure.
+
+        IPFS CIDs match automatically — a file registered on MusicApp
+        cannot be registered again on ArtApp.
+        """
+
+        # Duplicate check — most important check
+        existing = self.check_duplicate(cid)
+        if existing["exists"]:
+            return (
+                False,
+                f"CID already registered by {existing['first_platform']} "
+                f"on {existing['first_seen_human']}. "
+                f"Owner: {existing['first_owner']}",
+                None,
+            )
+
+        # Validate inputs
+        if not cid:
+            return False, "CID is required", None
+        if not owner_wallet:
+            return False, "Owner wallet is required", None
+        if editions < 1:
+            return False, "Editions must be at least 1", None
+        if not (0 <= royalty_pct <= 100):
+            return False, "Royalty must be 0-100%", None
+
+        from playweb.core.transaction import Transaction
+
+        # Create the content_register transaction
+        tx = Transaction(
+            from_addr   = owner_wallet.lower(),
+            to_addr     = owner_wallet.lower(),
+            amount      = 0,
+            tx_type     = "content_register",
+            signature   = signature,
+            cid         = cid,
+            editions    = editions,
+            royalty_pct = royalty_pct,
+            data        = {
+                "platform_id": platform_id,
+                **(extra_data or {}),
+            },
+        )
+
+        # Submit to blockchain (also creates cv_link fee tx)
+        success, result = self.blockchain.add_transaction(
+            tx          = tx,
+            node_wallet = self.node_wallet,
+        )
+
+        if not success:
+            return False, result, None
+
+        logger.info(
+            f"ContentRegistry: registered CID {cid[:16]}... "
+            f"by {platform_id} owner={owner_wallet[:8]}..."
+        )
+        return True, "Registered", tx.hash
+
+    # ─────────────────────────────────────────────────────────────
+    # Duplicate detection
+    # ─────────────────────────────────────────────────────────────
+
+    def check_duplicate(self, cid: str) -> Dict:
+        """
+        Check if a CID is already registered on the network.
+        Called by any platform before accepting a new upload.
+
+        Returns:
+        {
+            exists:            bool,
+            first_owner:       str or None,
+            first_platform:    str or None,
+            first_seen:        float or None,
+            first_seen_human:  str or None,
+            current_owner:     str or None,
+            tx_hash:           str or None,
+        }
+        """
+        record = self.blockchain.storage.get_content_record(cid)
+
+        if not record:
+            return {
+                "exists":           False,
+                "first_owner":      None,
+                "first_platform":   None,
+                "first_seen":       None,
+                "first_seen_human": None,
+                "current_owner":    None,
+                "tx_hash":          None,
+            }
+
+        from datetime import datetime
+        first_seen       = record.get("timestamp")
+        first_seen_human = (
+            datetime.fromtimestamp(first_seen).strftime("%Y-%m-%d %H:%M UTC")
+            if first_seen else None
+        )
+
+        return {
+            "exists":           True,
+            "first_owner":      record.get("first_owner"),
+            "first_platform":   record.get("first_platform"),
+            "first_seen":       first_seen,
+            "first_seen_human": first_seen_human,
+            "current_owner":    record.get("current_owner"),
+            "tx_hash":          record.get("first_tx_hash"),
+        }
+
+    # ─────────────────────────────────────────────────────────────
+    # Ownership queries
+    # ─────────────────────────────────────────────────────────────
+
+    def get_owner(self, cid: str) -> Optional[Dict]:
+        """
+        Get current owner of a CID.
+        Returns None if not registered.
+        """
+        record = self.blockchain.storage.get_content_record(cid)
+        if not record:
+            return None
+
+        return {
+            "cid":           cid,
+            "current_owner": record.get("current_owner"),
+            "creator":       record.get("creator_wallet"),
+            "platform":      record.get("first_platform"),
+            "royalty_pct":   record.get("royalty_pct", 0),
+            "total_editions": record.get("total_editions", 1),
+        }
+
+    def verify_ownership(self, cid: str, wallet: str) -> bool:
+        """
+        Verify that a wallet is the current owner of a CID.
+        Used by any platform to verify ownership claims.
+        """
+        record = self.blockchain.storage.get_content_record(cid)
+        if not record:
+            return False
+        return (
+            record.get("current_owner", "").lower() == wallet.lower()
+        )
+
+    # ─────────────────────────────────────────────────────────────
+    # Transfer ownership
+    # ─────────────────────────────────────────────────────────────
+
+    def transfer_ownership(
+        self,
+        cid:          str,
+        from_wallet:  str,
+        to_wallet:    str,
+        signature:    str = None,
+        platform_id:  str = "unknown",
+        sale_price:   float = 0,
+    ) -> Tuple[bool, str, Optional[str]]:
+        """
+        Transfer ownership of a CID from one wallet to another.
+        If sale_price > 0, royalty transactions are created automatically.
+        Returns (success, reason, tx_hash).
+        """
+
+        # Verify current ownership
+        if not self.verify_ownership(cid, from_wallet):
+            return False, f"{from_wallet[:8]}... does not own {cid[:16]}...", None
+
+        from playweb.core.transaction import Transaction
+
+        # If this is a sale with price, use royalty engine
+        if sale_price > 0:
+            from playweb.core.royalty_engine import RoyaltyEngine
+            royalty_engine = RoyaltyEngine(self.blockchain.storage)
+            txs = royalty_engine.create_royalty_transactions(
+                cid          = cid,
+                sale_price   = sale_price,
+                buyer_wallet = to_wallet,
+                seller_wallet= from_wallet,
+            )
+            for tx in txs:
+                tx.signature = signature
+                success, result = self.blockchain.add_transaction(
+                    tx          = tx,
+                    node_wallet = self.node_wallet,
+                )
+                if not success:
+                    return False, result, None
+
+            main_tx_hash = txs[0].hash if txs else None
+        else:
+            # Simple transfer (gift, internal move)
+            tx = Transaction(
+                from_addr   = from_wallet.lower(),
+                to_addr     = to_wallet.lower(),
+                amount      = 0,
+                tx_type     = "ownership_transfer",
+                signature   = signature,
+                cid         = cid,
+                data        = {
+                    "platform_id": platform_id,
+                    "transfer_type": "gift",
+                },
+            )
+            success, result = self.blockchain.add_transaction(
+                tx          = tx,
+                node_wallet = self.node_wallet,
+            )
+            if not success:
+                return False, result, None
+            main_tx_hash = tx.hash
+
+        logger.info(
+            f"ContentRegistry: transfer {cid[:16]}... "
+            f"from {from_wallet[:8]}... to {to_wallet[:8]}..."
+        )
+        return True, "Transfer queued", main_tx_hash

playweb/registry/edition_registry.py

@@ -0,0 +1,220 @@
+"""
+PlayWebit Network — Edition Registry
+Cross-platform edition tracking.
+Edition #3 of 100 on MusicApp is visible and verifiable on ArtApp.
+"""
+
+import time
+import logging
+from typing import List, Dict, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+class EditionRegistry:
+
+    def __init__(self, blockchain, node_wallet: str):
+        self.blockchain  = blockchain
+        self.node_wallet = node_wallet
+
+    # ─────────────────────────────────────────────────────────────
+    # Create editions
+    # ─────────────────────────────────────────────────────────────
+
+    def create_editions(
+        self,
+        cid:          str,
+        total:        int,
+        owner_wallet: str,
+        platform_id:  str,
+        signature:    str = None,
+    ) -> Tuple[bool, str]:
+        """
+        Create edition records for a registered CID.
+        Called after content_register when editions > 1.
+        Creates edition_transfer txs for each edition.
+        Returns (success, reason).
+        """
+        # Verify CID is registered
+        record = self.blockchain.storage.get_content_record(cid)
+        if not record:
+            return False, f"CID {cid[:16]}... not registered"
+
+        if record.get("current_owner", "").lower() != owner_wallet.lower():
+            return False, "Only the owner can create editions"
+
+        from playweb.core.transaction import Transaction
+
+        for edition_num in range(1, total + 1):
+            tx = Transaction(
+                from_addr      = owner_wallet.lower(),
+                to_addr        = owner_wallet.lower(),
+                amount         = 0,
+                tx_type        = "edition_transfer",
+                signature      = signature,
+                cid            = cid,
+                edition_number = edition_num,
+                data           = {
+                    "platform_id": platform_id,
+                    "edition_of":  total,
+                    "action":      "create",
+                },
+            )
+            success, result = self.blockchain.add_transaction(
+                tx          = tx,
+                node_wallet = self.node_wallet,
+            )
+            if not success:
+                logger.warning(
+                    f"EditionRegistry: failed to create edition "
+                    f"{edition_num}: {result}"
+                )
+
+        logger.info(
+            f"EditionRegistry: created {total} editions for "
+            f"{cid[:16]}... on {platform_id}"
+        )
+        return True, f"Created {total} editions"
+
+    # ─────────────────────────────────────────────────────────────
+    # Transfer edition
+    # ─────────────────────────────────────────────────────────────
+
+    def transfer_edition(
+        self,
+        cid:            str,
+        edition_number: int,
+        from_wallet:    str,
+        to_wallet:      str,
+        platform_id:    str,
+        signature:      str  = None,
+        sale_price:     float = 0,
+    ) -> Tuple[bool, str, Optional[str]]:
+        """
+        Transfer a specific edition to a new owner.
+        If sale_price > 0, royalty is paid to original creator.
+        Returns (success, reason, tx_hash).
+        """
+
+        # Verify edition ownership
+        if not self.verify_edition_owner(cid, edition_number, from_wallet):
+            return (
+                False,
+                f"{from_wallet[:8]}... does not own edition "
+                f"#{edition_number} of {cid[:16]}...",
+                None,
+            )
+
+        from playweb.core.transaction import Transaction
+
+        # Create the edition transfer tx
+        tx = Transaction(
+            from_addr      = from_wallet.lower(),
+            to_addr        = to_wallet.lower(),
+            amount         = sale_price,
+            tx_type        = "edition_transfer",
+            signature      = signature,
+            cid            = cid,
+            edition_number = edition_number,
+            data           = {
+                "platform_id": platform_id,
+                "sale_price":  sale_price,
+                "action":      "transfer",
+            },
+        )
+
+        success, result = self.blockchain.add_transaction(
+            tx          = tx,
+            node_wallet = self.node_wallet,
+        )
+        if not success:
+            return False, result, None
+
+        # If sale, create royalty transactions
+        if sale_price > 0:
+            from playweb.core.royalty_engine import RoyaltyEngine
+            royalty_engine = RoyaltyEngine(self.blockchain.storage)
+            royalty_txs = royalty_engine.create_royalty_transactions(
+                cid           = cid,
+                sale_price    = sale_price,
+                buyer_wallet  = to_wallet,
+                seller_wallet = from_wallet,
+            )
+            for rtx in royalty_txs:
+                rtx.signature = signature
+                self.blockchain.add_transaction(
+                    tx          = rtx,
+                    node_wallet = self.node_wallet,
+                )
+
+        logger.info(
+            f"EditionRegistry: transfer edition #{edition_number} "
+            f"of {cid[:16]}... "
+            f"from {from_wallet[:8]}... to {to_wallet[:8]}..."
+        )
+        return True, "Edition transfer queued", tx.hash
+
+    # ─────────────────────────────────────────────────────────────
+    # Queries
+    # ─────────────────────────────────────────────────────────────
+
+    def get_edition(self, cid: str, edition_number: int) -> Optional[Dict]:
+        """
+        Get a specific edition record.
+        Returns None if not found.
+        """
+        return self.blockchain.storage.get_edition_record(cid, edition_number)
+
+    def get_all_editions(self, cid: str) -> List[Dict]:
+        """
+        Get all editions for a CID across all platforms.
+        Any platform can see all editions globally.
+        """
+        return self.blockchain.storage.get_all_edition_records(cid)
+
+    def verify_edition_owner(
+        self,
+        cid:            str,
+        edition_number: int,
+        wallet:         str,
+    ) -> bool:
+        """
+        Verify that a wallet owns a specific edition.
+        Used by any platform to verify edition ownership claims.
+        """
+        record = self.blockchain.storage.get_edition_record(cid, edition_number)
+        if not record:
+            # If no edition record, check content record (edition 1 = content owner)
+            if edition_number == 1:
+                content = self.blockchain.storage.get_content_record(cid)
+                if content:
+                    return (
+                        content.get("current_owner", "").lower()
+                        == wallet.lower()
+                    )
+            return False
+
+        return record.get("current_owner", "").lower() == wallet.lower()
+
+    def get_edition_summary(self, cid: str) -> Dict:
+        """
+        Get a summary of all editions for a CID.
+        Useful for marketplace displays.
+        """
+        content = self.blockchain.storage.get_content_record(cid)
+        if not content:
+            return {"cid": cid, "found": False}
+
+        editions = self.get_all_editions(cid)
+        total    = content.get("total_editions", 1)
+
+        return {
+            "cid":            cid,
+            "found":          True,
+            "total_editions": total,
+            "editions_found": len(editions),
+            "creator":        content.get("creator_wallet"),
+            "royalty_pct":    content.get("royalty_pct", 0),
+            "first_platform": content.get("first_platform"),
+            "editions":       editions,
+        }

playweb/storage/__init__.py

@@ -0,0 +1,11 @@
+from playweb.storage.base            import ChainStorage
+from playweb.storage.ram_storage     import RAMStorage
+from playweb.storage.sqlite_storage  import SQLiteStorage
+from playweb.storage.supabase_storage import SupabaseStorage
+
+__all__ = [
+    "ChainStorage",
+    "RAMStorage",
+    "SQLiteStorage",
+    "SupabaseStorage",
+]

playweb/storage/base.py

@@ -0,0 +1,154 @@
+"""
+PlayWebit Network — ChainStorage Interface
+Any storage backend implements this.
+Blockchain core only calls these methods — never touches DB directly.
+"""
+
+from abc import ABC, abstractmethod
+from typing import List, Optional, Dict
+
+
+class ChainStorage(ABC):
+
+    # ─────────────────────────────────────────────────────────────
+    # Blocks
+    # ─────────────────────────────────────────────────────────────
+
+    @abstractmethod
+    def save_block(self, block) -> bool:
+        """Save a block to storage. Returns True on success."""
+        ...
+
+    @abstractmethod
+    def get_block(self, block_hash: str):
+        """Get a block by hash. Returns Block or None."""
+        ...
+
+    @abstractmethod
+    def get_block_by_index(self, index: int):
+        """Get a block by index. Returns Block or None."""
+        ...
+
+    @abstractmethod
+    def get_chain_tip(self):
+        """Get the latest block. Returns Block or None."""
+        ...
+
+    @abstractmethod
+    def get_chain_length(self) -> int:
+        """Get total number of blocks in the chain."""
+        ...
+
+    @abstractmethod
+    def get_blocks_from(self, from_index: int, limit: int = 50) -> List:
+        """
+        Get blocks from from_index up to limit.
+        Used for chain sync between nodes.
+        Returns List[Block].
+        """
+        ...
+
+    # ─────────────────────────────────────────────────────────────
+    # Transactions
+    # ─────────────────────────────────────────────────────────────
+
+    @abstractmethod
+    def save_transaction(self, tx) -> bool:
+        """Save a confirmed transaction. Returns True on success."""
+        ...
+
+    @abstractmethod
+    def get_transaction(self, tx_hash: str):
+        """Get a transaction by hash. Returns Transaction or None."""
+        ...
+
+    # ─────────────────────────────────────────────────────────────
+    # Balances
+    # ─────────────────────────────────────────────────────────────
+
+    @abstractmethod
+    def get_balance(self, address: str) -> float:
+        """Get PLWB balance for an address. Returns 0.0 if not found."""
+        ...
+
+    @abstractmethod
+    def save_balance(self, address: str, balance: float) -> bool:
+        """Update balance for an address. Returns True on success."""
+        ...
+
+    @abstractmethod
+    def get_all_addresses(self) -> List[str]:
+        """Get all addresses that have ever had a balance."""
+        ...
+
+    # ─────────────────────────────────────────────────────────────
+    # Content Registry
+    # Cross-platform CID ownership — the core value of the network
+    # ─────────────────────────────────────────────────────────────
+
+    @staticmethod
+    def normalise_record(record: Dict) -> Dict:
+        """Normalise wallet addresses to lowercase before saving."""
+        normalised = dict(record)
+        for key in ("creator_wallet", "first_owner", "current_owner"):
+            if normalised.get(key):
+                normalised[key] = normalised[key].lower()
+        return normalised
+
+    @abstractmethod
+    def save_content_record(self, record: Dict) -> bool:
+        record = self.normalise_record(record)
+        """
+        Save a content registration record.
+        record keys:
+            cid, creator_wallet, first_owner, first_platform,
+            first_tx_hash, first_block, timestamp,
+            total_editions, royalty_pct, current_owner
+        """
+        ...
+
+    @abstractmethod
+    def get_content_record(self, cid: str) -> Optional[Dict]:
+        """Get content record by CID. Returns dict or None."""
+        ...
+
+    # ─────────────────────────────────────────────────────────────
+    # Edition Registry
+    # ─────────────────────────────────────────────────────────────
+
+    @abstractmethod
+    def save_edition_record(self, record: Dict) -> bool:
+        """
+        Save an edition record.
+        record keys:
+            cid, edition_number, edition_of, current_owner,
+            platform, tx_hash, timestamp, provenance (list)
+        """
+        ...
+
+    @abstractmethod
+    def get_edition_record(self, cid: str, edition_number: int) -> Optional[Dict]:
+        """Get a specific edition record."""
+        ...
+
+    @abstractmethod
+    def get_all_edition_records(self, cid: str) -> List[Dict]:
+        """Get all edition records for a CID."""
+        ...
+
+    @abstractmethod
+    def get_all_content_by_owner(self, address: str) -> List[Dict]:
+        """
+        Get all content records where current_owner = address.
+        Used by ERC721 balanceOf() to count NFTs.
+        """
+        ...
+    
+    @abstractmethod
+    def get_cid_by_int_id(self, int_id: int) -> Optional[str]:
+        """
+        Get CID string from integer token ID.
+        Integer IDs are used by MetaMask (uint256).
+        Computed as: sha256(cid)[:16] as int.
+        """
+        ...