Розробка системи токенізованого контенту

Розробка системи токенізованого контенту

Токенізований контент—модель, де творці видають свою роботу як токени (NFT або fungible), а читачі/глядачі отримують фінансову участь у успіху контенту. Це виходить за межі простого «купи NFT» до динамічної економіки навколо контенту.

Моделі токенізації контенту

Collect NFT (модель Lens Protocol)

Кожна публікація = унікальний NFT, який можна зібрати (купити). Творець встановлює ліміт (наприклад, тільки 100 копій) та ціну. Ранні покупці отримують статус раннього прихильника та потенційний приріст при перепродажу.

Дробова власність контенту

Контент (стаття, музичний трек, відео) представлений NFT, право на частку доходу розділене на ERC-20 фракції. Купівля токенів—отримання частки royalties.

Bonding Curve токени

Кожен контент має власний токен на bonding curve. Більше людей купує—дорожче. Ранні покупці виграють від зростання.

Subscription токени (Creator Coins)

Токен, що дає доступ до контенту творця на період (місяць, рік). ERC-20 з логікою закінчення або NFT з часовими атрибутами.

Смарт-контракт: збір з роялті

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/interfaces/IERC2981.sol";

contract TokenizedContent is ERC721, IERC2981 {
    struct ContentItem {
        address creator;
        string contentURI;     // IPFS CID
        uint256 price;         // в wei
        uint256 maxSupply;     // 0 = без обмежень
        uint256 currentSupply;
        uint256 royaltyPercent; // basis points
        bool paywalled;        // потребує збір для перегляду
        ContentType contentType;
    }
    
    enum ContentType { ARTICLE, IMAGE, VIDEO, MUSIC, EBOOK, NEWSLETTER }
    
    mapping(uint256 => ContentItem) public contentItems;
    mapping(uint256 => mapping(address => bool)) public hasCollected;
    
    uint256 public platformFee = 250; // 2.5%
    address public platform;
    
    // Створити контент з параметрами монетизації
    function publishContent(
        string calldata contentURI,
        uint256 price,
        uint256 maxSupply,
        uint256 royaltyPercent,
        bool paywalled,
        ContentType contentType
    ) external returns (uint256 contentId) {
        require(royaltyPercent <= 2000, "Royalty too high"); // макс 20%
        
        contentId = ++_contentCounter;
        
        contentItems[contentId] = ContentItem({
            creator: msg.sender,
            contentURI: contentURI,
            price: price,
            maxSupply: maxSupply,
            currentSupply: 0,
            royaltyPercent: royaltyPercent,
            paywalled: paywalled,
            contentType: contentType,
        });
        
        emit ContentPublished(contentId, msg.sender, contentURI, price, contentType);
    }
    
    // Зібрати (купити) контент
    function collect(uint256 contentId) external payable returns (uint256 tokenId) {
        ContentItem storage item = contentItems[contentId];
        require(item.creator != address(0), "Content not found");
        require(msg.value == item.price, "Wrong price");
        require(
            item.maxSupply == 0 || item.currentSupply < item.maxSupply,
            "Max supply reached"
        );
        
        item.currentSupply++;
        
        // Розподіл платежу
        uint256 fee = (msg.value * platformFee) / 10000;
        uint256 creatorProceeds = msg.value - fee;
        
        payable(platform).transfer(fee);
        payable(item.creator).transfer(creatorProceeds);
        
        // Mint NFT токена збору
        tokenId = ++_tokenCounter;
        _mint(msg.sender, tokenId);
        hasCollected[contentId][msg.sender] = true;
        
        // Map tokenId → contentId
        tokenToContent[tokenId] = contentId;
        
        emit Collected(contentId, tokenId, msg.sender, msg.value);
    }
    
    // ERC-2981 royalties для вторинного ринку
    function royaltyInfo(uint256 tokenId, uint256 salePrice) 
        external view override returns (address receiver, uint256 royaltyAmount) 
    {
        uint256 contentId = tokenToContent[tokenId];
        ContentItem storage item = contentItems[contentId];
        
        receiver = item.creator;
        royaltyAmount = (salePrice * item.royaltyPercent) / 10000;
    }
    
    // Доступ до платного контенту
    function canAccessContent(uint256 contentId, address user) 
        external view returns (bool) 
    {
        ContentItem storage item = contentItems[contentId];
        
        if (!item.paywalled) return true;
        if (item.creator == user) return true;
        if (hasCollected[contentId][user]) return true;
        
        return false;
    }
}

Bonding Curve для Creator Coins

contract CreatorCoin is ERC20 {
    // Bonding curve: ціна = reserveRatio * totalSupply / reserveBalance
    uint256 public reserveBalance;
    uint256 public reserveRatio = 500000; // 50% (в ppm, 1_000_000 = 100%)
    
    address public creator;
    uint256 public creatorFee = 500; // 5%
    
    function buy(uint256 minReturn) external payable returns (uint256 tokensReturned) {
        tokensReturned = calculatePurchaseReturn(
            totalSupply(),
            reserveBalance,
            uint32(reserveRatio),
            msg.value
        );
        
        require(tokensReturned >= minReturn, "Slippage exceeded");
        
        uint256 fee = (msg.value * creatorFee) / 10000;
        reserveBalance += msg.value - fee;
        payable(creator).transfer(fee);
        
        _mint(msg.sender, tokensReturned);
        emit Buy(msg.sender, msg.value, tokensReturned);
    }
    
    function sell(uint256 amount, uint256 minReturn) external returns (uint256 ethReturned) {
        ethReturned = calculateSaleReturn(
            totalSupply(),
            reserveBalance,
            uint32(reserveRatio),
            amount
        );
        
        require(ethReturned >= minReturn, "Slippage exceeded");
        
        _burn(msg.sender, amount);
        reserveBalance -= ethReturned;
        
        payable(msg.sender).transfer(ethReturned);
        emit Sell(msg.sender, amount, ethReturned);
    }
}

Гейтинг токенів контенту

// Бекенд: перевірити доступ до контенту
async function checkContentAccess(
  userAddress: string,
  contentId: string
): Promise<{ hasAccess: boolean; reason?: string }> {
  const content = await db.getContent(contentId);
  
  if (!content.isTokenGated) return { hasAccess: true };
  
  // Перевірити власність NFT
  if (content.requiredNFT) {
    const balance = await nftContract.balanceOf(userAddress);
    if (balance > 0n) return { hasAccess: true };
  }
  
  // Перевірити тримання creator coin
  if (content.requiredCreatorCoinAmount) {
    const coinBalance = await creatorCoinContract.balanceOf(userAddress);
    if (coinBalance >= content.requiredCreatorCoinAmount) {
      return { hasAccess: true };
    }
    return {
      hasAccess: false,
      reason: `Hold ${formatUnits(content.requiredCreatorCoinAmount, 18)} $CREATOR to access`,
    };
  }
  
  // Перевірити збір
  const hasCollected = await contentContract.hasCollected(contentId, userAddress);
  if (hasCollected) return { hasAccess: true };
  
  return { hasAccess: false, reason: "Collect to access" };
}

Аналітика для творців

interface CreatorDashboard {
  totalEarned: bigint;        // всього заробленого
  totalCollects: number;      // скільки разів зібрали
  uniqueCollectors: number;   // унікальних колекторів
  topContent: Array<{
    contentId: string;
    title: string;
    collects: number;
    earned: bigint;
  }>;
  revenueByDay: Array<{ date: string; revenue: bigint }>;
  secondarySalesRoyalties: bigint; // доход від вторинних продаж
}

Розробка базової системи токенізованого контенту (збір + paywall + панель творця)—5-7 тижнів. Bonding curve creator coins додають 3-4 тижні.