Разработка системы breeding NFT

Разработка системы breeding NFT

NFT breeding — создание нового NFT путём «скрещивания» двух существующих, с наследованием характеристик родителей. Механика стала популярной благодаря CryptoKitties и Axie Infinity. Правильно реализованная система breeding создаёт многоуровневую экономику: рынок «племенников», рынок «чистопородных», стратегические решения о breeding combinations.

Дизайн генетической системы

Ключевой вопрос: как передаются атрибуты от родителей к потомку?

Gene encoding

Каждый NFT имеет набор генов — числовых значений атрибутов. Типичная структура:

struct Genes {
    uint8 bodyType;       // 0-255, кодирует тип тела
    uint8 color;          // 0-255, цвет
    uint8 speed;          // 0-100, скорость
    uint8 strength;       // 0-100, сила  
    uint8 intelligence;   // 0-100, интеллект
    uint8 rarity;         // 0-7, уровень редкости
    uint8[4] hiddenGenes; // рецессивные гены (не видны, но передаются)
}

Рецессивные гены — скрытые гены, которые не влияют на характеристики текущего NFT, но могут проявиться у потомков. Это создаёт глубину системы: два обычных на вид NFT могут произвести редкого потомка.

Механика наследования

function _inheritGene(
    uint8 parentAGene,
    uint8 parentBGene,
    uint256 random,
    uint8 geneIndex
) internal pure returns (uint8 childGene) {
    // 50% шанс каждого родителя
    bool fromParentA = (random >> geneIndex) & 1 == 1;
    uint8 inheritedGene = fromParentA ? parentAGene : parentBGene;
    
    // 10% шанс мутации
    uint256 mutationRoll = (random >> (geneIndex + 8)) & 0xFF;
    if (mutationRoll < 26) { // ~10% (26/256)
        // Случайная мутация в пределах ±20% от унаследованного значения
        int16 mutation = int16(uint16((random >> (geneIndex + 16)) & 0xFF)) - 128;
        int16 mutated = int16(uint16(inheritedGene)) + mutation / 10;
        childGene = uint8(uint16(mutated < 0 ? 0 : mutated > 255 ? 255 : mutated));
    } else {
        childGene = inheritedGene;
    }
}

Smart contract: полная реализация

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";

contract BreedableNFT is ERC721, AccessControl, VRFConsumerBaseV2Plus {
    struct NFTData {
        uint256 tokenId;
        uint256 generation;    // поколение (0 = genesis)
        uint256 breedCount;    // сколько раз уже разводили
        uint256 maxBreeds;     // максимум разводок
        uint256 lastBreedTime; // timestamp последнего breeding
        uint256 breedCooldown; // в секундах
        Genes genes;
        bool isOnBreedingMarket;
    }
    
    mapping(uint256 => NFTData) public nftData;
    
    // Стоимость breeding в ERC-20 токенах
    IERC20 public breedingToken;
    uint256[] public breedingCosts; // по поколениям: gen0 дешевле, gen5 дороже
    
    // Cooldown растёт с каждым breeding
    uint256 public baseCooldown = 12 hours;
    
    mapping(uint256 => BreedingRequest) public pendingBreeds;
    
    struct BreedingRequest {
        address breeder;
        uint256 parent1Id;
        uint256 parent2Id;
        bool fulfilled;
    }
    
    event BreedingInitiated(uint256 requestId, uint256 parent1, uint256 parent2);
    event BreedingCompleted(uint256 requestId, uint256 newTokenId, Genes childGenes);
    
    function breed(uint256 parent1Id, uint256 parent2Id) 
        external returns (uint256 requestId) 
    {
        // Проверяем права
        require(ownerOf(parent1Id) == msg.sender, "Not owner of parent1");
        require(
            ownerOf(parent2Id) == msg.sender || nftData[parent2Id].isOnBreedingMarket,
            "No access to parent2"
        );
        
        // Проверяем ограничения
        NFTData storage p1 = nftData[parent1Id];
        NFTData storage p2 = nftData[parent2Id];
        
        require(p1.breedCount < p1.maxBreeds, "Parent1 max breeds reached");
        require(p2.breedCount < p2.maxBreeds, "Parent2 max breeds reached");
        
        require(
            block.timestamp >= p1.lastBreedTime + p1.breedCooldown,
            "Parent1 on cooldown"
        );
        require(
            block.timestamp >= p2.lastBreedTime + p2.breedCooldown,
            "Parent2 on cooldown"
        );
        
        // Предотвращаем инбридинг (опционально)
        require(!_areRelated(parent1Id, parent2Id), "Inbreeding not allowed");
        
        // Оплата breeding
        uint256 gen = Math.max(p1.generation, p2.generation);
        uint256 cost = breedingCosts[Math.min(gen, breedingCosts.length - 1)];
        breedingToken.transferFrom(msg.sender, address(this), cost);
        
        // Обновляем родителей
        p1.breedCount++;
        p1.lastBreedTime = block.timestamp;
        p1.breedCooldown = baseCooldown * (1 + p1.breedCount); // растущий cooldown
        
        p2.breedCount++;
        p2.lastBreedTime = block.timestamp;
        p2.breedCooldown = baseCooldown * (1 + p2.breedCount);
        
        // Запрашиваем VRF для генерации генов потомка
        requestId = _requestVRF();
        pendingBreeds[requestId] = BreedingRequest({
            breeder: msg.sender,
            parent1Id: parent1Id,
            parent2Id: parent2Id,
            fulfilled: false,
        });
        
        emit BreedingInitiated(requestId, parent1Id, parent2Id);
    }
    
    function fulfillRandomWords(uint256 requestId, uint256[] calldata randomWords) 
        internal override 
    {
        BreedingRequest storage req = pendingBreeds[requestId];
        require(!req.fulfilled, "Already fulfilled");
        req.fulfilled = true;
        
        NFTData storage p1 = nftData[req.parent1Id];
        NFTData storage p2 = nftData[req.parent2Id];
        
        // Генерируем гены потомка
        Genes memory childGenes = _generateChildGenes(p1.genes, p2.genes, randomWords[0]);
        
        // Определяем редкость потомка
        uint8 rarityRoll = uint8(randomWords[0] % 100);
        if (rarityRoll < 1) {
            childGenes.rarity = 7; // Legendary (1%)
        } else if (rarityRoll < 5) {
            childGenes.rarity = 6; // Epic (4%)
        } else if (rarityRoll < 15) {
            childGenes.rarity = 5; // Rare (10%)
        } else {
            // Наследует от родителей
            childGenes.rarity = uint8(Math.max(p1.genes.rarity, p2.genes.rarity));
        }
        
        // Минтим потомка
        uint256 newTokenId = ++tokenCounter;
        _mint(req.breeder, newTokenId);
        
        nftData[newTokenId] = NFTData({
            tokenId: newTokenId,
            generation: Math.max(p1.generation, p2.generation) + 1,
            breedCount: 0,
            maxBreeds: _calculateMaxBreeds(childGenes),
            lastBreedTime: 0,
            breedCooldown: baseCooldown,
            genes: childGenes,
            isOnBreedingMarket: false,
        });
        
        emit BreedingCompleted(requestId, newTokenId, childGenes);
    }
    
    function _generateChildGenes(
        Genes memory genesA,
        Genes memory genesB,
        uint256 random
    ) internal pure returns (Genes memory child) {
        child.bodyType = _inheritGene(genesA.bodyType, genesB.bodyType, random, 0);
        child.color = _inheritGene(genesA.color, genesB.color, random, 1);
        child.speed = _inheritGene(genesA.speed, genesB.speed, random, 2);
        child.strength = _inheritGene(genesA.strength, genesB.strength, random, 3);
        child.intelligence = _inheritGene(genesA.intelligence, genesB.intelligence, random, 4);
        
        // Рецессивные гены: берём из скрытых генов родителей
        for (uint8 i = 0; i < 4; i++) {
            child.hiddenGenes[i] = _inheritGene(
                genesA.hiddenGenes[i],
                genesB.hiddenGenes[i],
                random >> (32 + i * 8),
                0
            );
        }
    }
}

Breeding marketplace

Владелец может выставить своего NFT «в аренду» для breeding за плату:

struct BreedingOffer {
    uint256 sireId;         // NFT который сдаётся для breeding
    uint256 price;          // стоимость в токенах
    bool onlyWhitelisted;   // только для конкретных адресов
    mapping(address => bool) whitelist;
}

function listForBreeding(uint256 tokenId, uint256 price) external {
    require(ownerOf(tokenId) == msg.sender);
    nftData[tokenId].isOnBreedingMarket = true;
    breedingOffers[tokenId] = BreedingOffer({
        sireId: tokenId,
        price: price,
        onlyWhitelisted: false,
    });
}

// При breeding с чужим sire — оплата идёт владельцу sire
function _payBreedingFee(uint256 sireId, address breeder) internal {
    BreedingOffer storage offer = breedingOffers[sireId];
    if (ownerOf(sireId) != breeder && offer.price > 0) {
        breedingToken.transferFrom(breeder, ownerOf(sireId), offer.price);
    }
}

Генеалогическое дерево

Хранение истории родителей для отображения и anti-inbreeding логики:

CREATE TABLE nft_lineage (
    token_id BIGINT PRIMARY KEY,
    parent1_id BIGINT REFERENCES nft_lineage(token_id),
    parent2_id BIGINT REFERENCES nft_lineage(token_id),
    generation INTEGER NOT NULL DEFAULT 0,
    bred_at TIMESTAMPTZ
);

-- Рекурсивный запрос для получения всех предков
WITH RECURSIVE ancestors AS (
    SELECT token_id, parent1_id, parent2_id, 0 AS depth
    FROM nft_lineage WHERE token_id = $1
    
    UNION ALL
    
    SELECT n.token_id, n.parent1_id, n.parent2_id, a.depth + 1
    FROM nft_lineage n
    JOIN ancestors a ON n.token_id = a.parent1_id OR n.token_id = a.parent2_id
    WHERE a.depth < 5  -- ограничиваем глубину
)
SELECT * FROM ancestors;

Экономический баланс

Breeding система должна быть экономически сбалансированной:

Supply control:

• Ограниченное число breeds на NFT предотвращает гиперинфляцию
• Растущие breed costs делают high-gen breeding дорогим
• Cooldowns ограничивают скорость производства

Demand drivers:

• Уникальные визуальные атрибуты потомков
• Game mechanics advantage (если атрибуты влияют на gameplay)
• Rarity hunting (rare потомки стоят дорого)
• Breeding market revenue (пассивный доход от siring)

Genesis premium:

• Genesis (gen0) NFT с ограниченным supply ценятся больше
• Их атрибуты «чище» (нет dilution от многоколенного breeding)
• Они могут использоваться для breeding дольше

Стек

Сроки

• Базовый breeding (гены + VRF + наследование): 5-7 недель
• Breeding marketplace: +2-3 недели
• Genealogy tracking + визуализация: +2-3 недели
• Anti-cheat + economic tuning: +2-3 недели
• Security audit: обязателен, +4-5 недель
• Итого: 3-4 месяца