比特币Ordinals与链上艺术：数字铭文的收藏价值

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

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

contract OrdinalGallery is ERC721, AccessControl, ReentrancyGuard {
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    bytes32 public constant CURATOR_ROLE = keccak256("CURATOR_ROLE");

    enum Rarity {
        COMMON, UNCOMMON, RARE, EPIC, LEGENDARY, MYTHIC
    }

    enum ContentType {
        TEXT, IMAGE, VIDEO, AUDIO, HTML, APPLICATION
    }

    struct Inscription {
        uint256 inscriptionId;
        string contentURI;
        ContentType contentType;
        bytes contentHash;
        address creator;
        uint256 blockHeight;
        uint256 satoshiNumber;
        Rarity rarity;
        uint256 createdAt;
        uint256 salePrice;
        bool isForSale;
    }

    struct Collection {
        uint256 collectionId;
        string name;
        string description;
        address curator;
        uint256[] inscriptionIds;
        uint256 totalValue;
        uint256 createdAt;
        bool isActive;
    }

    struct RarityScore {
        Rarity rarity;
        uint256 score;
        uint256 count;
        uint256 totalValue;
    }

    mapping(uint256 => Inscription) public inscriptions;
    mapping(uint256 => Collection) public collections;
    mapping(address => uint256[]) public userInscriptions;
    mapping(Rarity => RarityScore) public rarityScores;

    uint256 public inscriptionCount;
    uint256 public collectionCount;
    uint256 public totalValue;
    uint256 public mintingFee = 0.001 ether;

    event InscriptionCreated(uint256 indexed inscriptionId, address indexed creator, ContentType contentType);
    event InscriptionSold(uint256 indexed inscriptionId, address indexed buyer, uint256 price);
    event CollectionCreated(uint256 indexed collectionId, string name, address curator);

    constructor() ERC721("Ordinal Gallery", "ORDG") {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(MINTER_ROLE, msg.sender);
        _grantRole(CURATOR_ROLE, msg.sender);
    }

    function createInscription(
        string memory _contentURI,
        ContentType _contentType,
        bytes calldata _contentHash,
        uint256 _satoshiNumber,
        Rarity _rarity
    ) external payable nonReentrant returns (uint256) {
        require(msg.value >= mintingFee, "Insufficient fee");
        inscriptionCount++;

        inscriptions[inscriptionCount] = Inscription({
            inscriptionId: inscriptionCount,
            contentURI: _contentURI,
            contentType: _contentType,
            contentHash: _contentHash,
            creator: msg.sender,
            blockHeight: block.number,
            satoshiNumber: _satoshiNumber,
            rarity: _rarity,
            createdAt: block.timestamp,
            salePrice: 0,
            isForSale: false
        });

        userInscriptions[msg.sender].push(inscriptionCount);
        _mint(msg.sender, inscriptionCount);

        RarityScore storage score = rarityScores[_rarity];
        score.count++;
        score.score += uint256(_rarity);
        totalValue += msg.value;

        emit InscriptionCreated(inscriptionCount, msg.sender, _contentType);
        return inscriptionCount;
    }

    function listForSale(uint256 _inscriptionId, uint256 _price) external {
        require(ownerOf(_inscriptionId) == msg.sender, "Not the owner");
        Inscription storage ins = inscriptions[_inscriptionId];
        ins.isForSale = true;
        ins.salePrice = _price;
    }

    function buyInscription(uint256 _inscriptionId) external payable nonReentrant {
        Inscription storage ins = inscriptions[_inscriptionId];
        require(ins.isForSale, "Not for sale");
        require(msg.value >= ins.salePrice, "Insufficient payment");

        address seller = ownerOf(_inscriptionId);
        ins.isForSale = false;
        ins.salePrice = 0;

        _transfer(seller, msg.sender, _inscriptionId);
        payable(seller).transfer(msg.value);

        emit InscriptionSold(_inscriptionId, msg.sender, msg.value);
    }

    function createCollection(
        string memory _name,
        string memory _description,
        uint256[] memory _inscriptionIds
    ) external onlyRole(CURATOR_ROLE) returns (uint256) {
        collectionCount++;
        collections[collectionCount] = Collection({
            collectionId: collectionCount,
            name: _name,
            description: _description,
            curator: msg.sender,
            inscriptionIds: _inscriptionIds,
            totalValue: 0,
            createdAt: block.timestamp,
            isActive: true
        });

        emit CollectionCreated(collectionCount, _name, msg.sender);
        return collectionCount;
    }

    function calculateRarityScore(uint256 _inscriptionId) external view returns (uint256) {
        Inscription storage ins = inscriptions[_inscriptionId];
        uint256 score = uint256(ins.rarity) * 100;
        score += ins.blockHeight / 1000;
        return score;
    }

    function getInscriptionCount(address _user) external view returns (uint256) {
        return userInscriptions[_user].length;
    }

    function supportsInterface(bytes4 interfaceId) public view override(ERC721, AccessControl) returns (bool) {
        return super.supportsInterface(interfaceId);
    }
}

import hashlib
import json
from typing import Dict, List, Optional
from dataclasses import dataclass
from datetime import datetime
import random
from web3 import Web3

@dataclass
class Inscription:
    inscription_id: int
    content_uri: str
    content_type: str
    content_hash: str
    creator: str
    block_height: int
    satoshi_number: int
    rarity: str
    created_at: str
    price: float
    is_for_sale: bool

class OrdinalCollector:
    def __init__(self):
        self.inscriptions: Dict[int, Inscription] = {}
        self.collections: Dict[int, Dict] = {}
        self.user_inscriptions: Dict[str, List[int]] = {}
        self.inscription_count = 0

    def create_inscription(self, creator: str, content_uri: str, content_type: str, satoshi_number: int) -> Inscription:
        self.inscription_count += 1
        content_hash = hashlib.sha256(content_uri.encode()).hexdigest()

        rarity = self._calculate_rarity(satoshi_number)
        inscription = Inscription(
            inscription_id=self.inscription_count,
            content_uri=content_uri,
            content_type=content_type,
            content_hash=content_hash,
            creator=creator,
            block_height=random.randint(700000, 850000),
            satoshi_number=satoshi_number,
            rarity=rarity,
            created_at=datetime.now().isoformat(),
            price=0,
            is_for_sale=False
        )

        self.inscriptions[self.inscription_count] = inscription
        if creator not in self.user_inscriptions:
            self.user_inscriptions[creator] = []
        self.user_inscriptions[creator].append(self.inscription_count)

        return inscription

    def _calculate_rarity(self, satoshi_number: int) -> str:
        if satoshi_number == 0:
            return 'mythic'
        if satoshi_number % 210000 == 0:
            return 'legendary'
        if satoshi_number % 336 == 0:
            return 'epic'
        if satoshi_number % 2016 == 0:
            return 'rare'
        if satoshi_number < 1000:
            return 'uncommon'
        return 'common'

    def calculate_rarity_score(self, inscription_id: int) -> int:
        ins = self.inscriptions.get(inscription_id)
        if not ins:
            return 0

        rarity_scores = {
            'common': 1, 'uncommon': 10, 'rare': 100,
            'epic': 1000, 'legendary': 10000, 'mythic': 100000
        }
        return rarity_scores.get(ins.rarity, 0) * 100 + ins.block_height // 1000

    def create_collection(self, name: str, description: str, inscription_ids: List[int]) -> Dict:
        collection_id = len(self.collections) + 1
        collection = {
            'collection_id': collection_id,
            'name': name,
            'description': description,
            'inscription_ids': inscription_ids,
            'total_value': sum(self.inscriptions.get(iid, Inscription).price for iid in inscription_ids),
            'created_at': datetime.now().isoformat(),
            'is_active': True
        }
        self.collections[collection_id] = collection
        return collection

    def estimate_value(self, inscription_id: int) -> Dict:
        ins = self.inscriptions.get(inscription_id)
        if not ins:
            return {'value': 0, 'factors': {}}

        rarity_scores = {'common': 1, 'uncommon': 10, 'rare': 100, 'epic': 1000, 'legendary': 10000, 'mythic': 100000}
        base_value = rarity_scores.get(ins.rarity, 1)
        age_factor = 1 + (datetime.now() - datetime.fromisoformat(ins.created_at)).days / 365
        content_factor = 1.5 if ins.content_type == 'video' else 1.2 if ins.content_type == 'image' else 1.0

        estimated_value = base_value * age_factor * content_factor
        return {
            'estimated_value': estimated_value,
            'factors': {
                'rarity': ins.rarity,
                'base_value': base_value,
                'age_factor': age_factor,
                'content_factor': content_factor
            }
        }

    def search_inscriptions(self, query: str) -> List[Inscription]:
        results = []
        for ins in self.inscriptions.values():
            if query.lower() in ins.content_uri.lower() or query.lower() in ins.rarity:
                results.append(ins)
        return results[:10]

    def get_market_stats(self) -> Dict:
        total = len(self.inscriptions)
        by_rarity = {}
        for ins in self.inscriptions.values():
            by_rarity[ins.rarity] = by_rarity.get(ins.rarity, 0) + 1
        return {
            'total_inscriptions': total,
            'by_rarity': by_rarity,
            'total_value': sum(ins.price for ins in self.inscriptions.values() if ins.is_for_sale)
        }

collector = OrdinalCollector()
ins = collector.create_inscription('0xArtist', 'ipfs://Qm...', 'image', 0)
print(f"Created {ins.rarity} inscription #{ins.inscription_id}")

const { ethers } = require('ethers');
const crypto = require('crypto');

class OrdinalClient {
  constructor(providerUrl) {
    this.provider = new ethers.providers.JsonRpcProvider(providerUrl);
    this.inscriptions = new Map();
    this.collections = new Map();
    this.userInscriptions = new Map();
    this.inscriptionCount = 0;
  }

  async createInscription(creator, contentURI, contentType, satoshiNumber) {
    this.inscriptionCount++;
    const contentHash = crypto.createHash('sha256').update(contentURI).digest('hex');

    const rarity = this.calculateRarity(satoshiNumber);
    const inscription = {
      id: this.inscriptionCount,
      contentURI,
      contentType,
      contentHash,
      creator,
      blockHeight: Math.floor(Math.random() * 150000) + 700000,
      satoshiNumber,
      rarity,
      createdAt: new Date().toISOString(),
      price: 0,
      isForSale: false
    };

    this.inscriptions.set(this.inscriptionCount, inscription);

    if (!this.userInscriptions.has(creator)) {
      this.userInscriptions.set(creator, []);
    }
    this.userInscriptions.get(creator).push(this.inscriptionCount);

    return inscription;
  }

  calculateRarity(satoshiNumber) {
    if (satoshiNumber === 0) return 'mythic';
    if (satoshiNumber % 210000 === 0) return 'legendary';
    if (satoshiNumber % 336 === 0) return 'epic';
    if (satoshiNumber % 2016 === 0) return 'rare';
    if (satoshiNumber < 1000) return 'uncommon';
    return 'common';
  }

  calculateRarityScore(inscriptionId) {
    const ins = this.inscriptions.get(inscriptionId);
    if (!ins) return 0;

    const scores = {
      common: 1, uncommon: 10, rare: 100,
      epic: 1000, legendary: 10000, mythic: 100000
    };

    return (scores[ins.rarity] || 1) * 100 + Math.floor(ins.blockHeight / 1000);
  }

  async createCollection(name, description, inscriptionIds) {
    const collectionId = this.collections.size + 1;
    const collection = {
      id: collectionId,
      name,
      description,
      inscriptionIds,
      totalValue: inscriptionIds.reduce((sum, id) => {
        const ins = this.inscriptions.get(id);
        return sum + (ins ? ins.price : 0);
      }, 0),
      createdAt: new Date().toISOString(),
      isActive: true
    };

    this.collections.set(collectionId, collection);
    return collection;
  }

  estimateValue(inscriptionId) {
    const ins = this.inscriptions.get(inscriptionId);
    if (!ins) return { value: 0, factors: {} };

    const scores = { common: 1, uncommon: 10, rare: 100, epic: 1000, legendary: 10000, mythic: 100000 };
    const baseValue = scores[ins.rarity] || 1;
    const ageInDays = (Date.now() - new Date(ins.createdAt).getTime()) / 86400000;
    const ageFactor = 1 + ageInDays / 365;
    const contentFactor = ins.contentType === 'video' ? 1.5 : ins.contentType === 'image' ? 1.2 : 1.0;

    return {
      estimatedValue: baseValue * ageFactor * contentFactor,
      factors: { rarity: ins.rarity, baseValue, ageFactor, contentFactor }
    };
  }

  getMarketStats() {
    const total = this.inscriptions.size;
    const byRarity = {};
    for (const ins of this.inscriptions.values()) {
      byRarity[ins.rarity] = (byRarity[ins.rarity] || 0) + 1;
    }

    return {
      totalInscriptions: total,
      byRarity,
      totalValue: Array.from(this.inscriptions.values())
        .filter(i => i.isForSale)
        .reduce((sum, i) => sum + i.price, 0)
    };
  }
}

const client = new OrdinalClient('https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY');
const ins = client.createInscription('0xArtist', 'ipfs://Qm...', 'image', 0);
console.log('Created:', ins.rarity, 'inscription');