链上拍卖与数字收藏品：电影道具的NFT化交易

// 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 PropAuctionHouse is ERC721, AccessControl, ReentrancyGuard {
    bytes32 public constant AUCTIONEER_ROLE = keccak256("AUCTIONEER_ROLE");
    bytes32 public constant BIDDER_ROLE = keccak256("BIDDER_ROLE");

    enum AuctionType {
        ENGLISH, DUTCH, SEALED_BID, VICKREY
    }

    enum AuctionStatus {
        PENDING, ACTIVE, ENDED, CANCELLED, SETTLED
    }

    struct MovieProp {
        uint256 propId;
        string movieTitle;
        string propName;
        string description;
        string ipfsCID;
        address creator;
        uint256 year;
        uint256 royaltyBasisPoints;
    }

    struct Auction {
        uint256 auctionId;
        uint256 propId;
        AuctionType auctionType;
        AuctionStatus status;
        uint256 startPrice;
        uint256 reservePrice;
        uint256 highestBid;
        address highestBidder;
        uint256 startTime;
        uint256 endTime;
        uint256 minBidIncrement;
        address payable seller;
        bool isActive;
    }

    struct Bid {
        uint256 bidId;
        uint256 auctionId;
        address bidder;
        uint256 amount;
        uint256 timestamp;
        bool isRevealed;
    }

    mapping(uint256 => MovieProp) public props;
    mapping(uint256 => Auction) public auctions;
    mapping(uint256 => Bid[]) public bids;

    uint256 public propCount;
    uint256 public auctionCount;
    uint256 public totalVolume;
    uint256 public platformFee = 250; // 2.5%

    event PropCreated(uint256 indexed propId, string movieTitle, string propName);
    event AuctionStarted(uint256 indexed auctionId, uint256 indexed propId, AuctionType auctionType);
    event BidPlaced(uint256 indexed auctionId, address indexed bidder, uint256 amount);
    event AuctionSettled(uint256 indexed auctionId, address indexed winner, uint256 amount);

    constructor() ERC721("MovieProp NFT", "PROP") {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(AUCTIONEER_ROLE, msg.sender);
    }

    function createProp(
        string memory _movieTitle,
        string memory _propName,
        string memory _description,
        string memory _ipfsCID,
        uint256 _year,
        uint256 _royaltyBasisPoints
    ) external onlyRole(AUCTIONEER_ROLE) returns (uint256) {
        propCount++;
        props[propCount] = MovieProp({
            propId: propCount,
            movieTitle: _movieTitle,
            propName: _propName,
            description: _description,
            ipfsCID: _ipfsCID,
            creator: msg.sender,
            year: _year,
            royaltyBasisPoints: _royaltyBasisPoints
        });

        _mint(msg.sender, propCount);
        emit PropCreated(propCount, _movieTitle, _propName);
        return propCount;
    }

    function startAuction(
        uint256 _propId,
        AuctionType _auctionType,
        uint256 _startPrice,
        uint256 _reservePrice,
        uint256 _duration,
        uint256 _minBidIncrement
    ) external onlyRole(AUCTIONEER_ROLE) returns (uint256) {
        require(ownerOf(_propId) == msg.sender, "Not the owner");
        auctionCount++;

        auctions[auctionCount] = Auction({
            auctionId: auctionCount,
            propId: _propId,
            auctionType: _auctionType,
            status: AuctionStatus.ACTIVE,
            startPrice: _startPrice,
            reservePrice: _reservePrice,
            highestBid: 0,
            highestBidder: address(0),
            startTime: block.timestamp,
            endTime: block.timestamp + _duration,
            minBidIncrement: _minBidIncrement,
            seller: payable(msg.sender),
            isActive: true
        });

        emit AuctionStarted(auctionCount, _propId, _auctionType);
        return auctionCount;
    }

    function placeBid(uint256 _auctionId) external payable nonReentrant {
        Auction storage auction = auctions[_auctionId];
        require(auction.status == AuctionStatus.ACTIVE, "Auction not active");
        require(block.timestamp < auction.endTime, "Auction ended");
        require(msg.value >= auction.startPrice, "Below start price");

        if (auction.auctionType == AuctionType.ENGLISH) {
            require(msg.value >= auction.highestBid + auction.minBidIncrement, "Bid too low");
        }

        if (auction.highestBidder != address(0)) {
            payable(auction.highestBidder).transfer(auction.highestBid);
        }

        auction.highestBid = msg.value;
        auction.highestBidder = msg.sender;

        emit BidPlaced(_auctionId, msg.sender, msg.value);
    }

    function settleAuction(uint256 _auctionId) external nonReentrant {
        Auction storage auction = auctions[_auctionId];
        require(auction.status == AuctionStatus.ACTIVE, "Auction not active");
        require(block.timestamp >= auction.endTime, "Auction not ended");

        auction.status = AuctionStatus.ENDED;

        if (auction.highestBid >= auction.reservePrice) {
            uint256 fee = (auction.highestBid * platformFee) / 10000;
            uint256 sellerProceeds = auction.highestBid - fee;
            uint256 royalty = 0;

            MovieProp storage prop = props[auction.propId];
            if (prop.royaltyBasisPoints > 0) {
                royalty = (auction.highestBid * prop.royaltyBasisPoints) / 10000;
                sellerProceeds -= royalty;
                payable(prop.creator).transfer(royalty);
            }

            payable(auction.seller).transfer(sellerProceeds);
            _transfer(auction.seller, auction.highestBidder, auction.propId);
            totalVolume += auction.highestBid;

            emit AuctionSettled(_auctionId, auction.highestBidder, auction.highestBid);
        } else {
            payable(auction.seller).transfer(auction.highestBid);
            auction.status = AuctionStatus.CANCELLED;
        }

        auction.status = AuctionStatus.SETTLED;
    }

    function getAuctionBids(uint256 _auctionId) external view returns (Bid[] memory) {
        return bids[_auctionId];
    }

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

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

@dataclass
class MovieProp:
    prop_id: int
    movie_title: str
    prop_name: str
    ipfs_cid: str
    year: int

class PropAuctionHouse:
    def __init__(self):
        self.props: Dict[int, MovieProp] = {}
        self.auctions: Dict[int, Dict] = {}
        self.bids: Dict[int, List[Dict]] = {}
        self.prop_count = 0
        self.auction_count = 0
        self.total_volume = 0

    def create_prop(self, movie_title: str, prop_name: str, ipfs_cid: str, year: int) -> MovieProp:
        self.prop_count += 1
        prop = MovieProp(
            prop_id=self.prop_count,
            movie_title=movie_title,
            prop_name=prop_name,
            ipfs_cid=ipfs_cid,
            year=year
        )
        self.props[self.prop_count] = prop
        return prop

    def start_auction(self, prop_id: int, auction_type: str, start_price: float, reserve_price: float, duration: int) -> Dict:
        self.auction_count += 1
        auction = {
            'auction_id': self.auction_count,
            'prop_id': prop_id,
            'auction_type': auction_type,
            'status': 'active',
            'start_price': start_price,
            'reserve_price': reserve_price,
            'highest_bid': 0,
            'highest_bidder': None,
            'start_time': datetime.now().isoformat(),
            'end_time': (datetime.now() + timedelta(hours=duration)).isoformat(),
            'bids': []
        }
        self.auctions[self.auction_count] = auction
        self.bids[self.auction_count] = []
        return auction

    def place_bid(self, auction_id: int, bidder: str, amount: float) -> Dict:
        auction = self.auctions.get(auction_id)
        if not auction or auction['status'] != 'active':
            return {'success': False, 'error': 'Auction not active'}

        if datetime.now() > datetime.fromisoformat(auction['end_time']):
            return {'success': False, 'error': 'Auction ended'}

        if auction['auction_type'] == 'english' and amount <= auction['highest_bid']:
            return {'success': False, 'error': 'Bid too low'}

        bid = {
            'bid_id': len(self.bids[auction_id]) + 1,
            'bidder': bidder,
            'amount': amount,
            'timestamp': datetime.now().isoformat()
        }

        self.bids[auction_id].append(bid)
        auction['highest_bid'] = amount
        auction['highest_bidder'] = bidder

        return {'success': True, 'bid': bid}

    def settle_auction(self, auction_id: int) -> Dict:
        auction = self.auctions.get(auction_id)
        if not auction or auction['status'] != 'active':
            return {'success': False, 'error': 'Auction not available'}

        if datetime.now() < datetime.fromisoformat(auction['end_time']):
            return {'success': False, 'error': 'Auction not ended'}

        auction['status'] = 'ended'

        if auction['highest_bid'] >= auction['reserve_price']:
            auction['status'] = 'settled'
            self.total_volume += auction['highest_bid']
            return {
                'success': True,
                'winner': auction['highest_bidder'],
                'amount': auction['highest_bid'],
                'prop': self.props.get(auction['prop_id'])
            }
        else:
            auction['status'] = 'cancelled'
            return {'success': False, 'error': 'Reserve not met'}

    def search_props(self, query: str) -> List[MovieProp]:
        results = []
        for prop in self.props.values():
            if query.lower() in prop.movie_title.lower() or query.lower() in prop.prop_name.lower():
                results.append(prop)
        return results

house = PropAuctionHouse()
prop = house.create_prop('The Matrix', 'Red Pill', 'ipfs://Qm...', 1999)
auction = house.start_auction(prop.prop_id, 'english', 1, 0.5, 24)
house.place_bid(auction['auction_id'], '0xCollector', 1.5)
result = house.settle_auction(auction['auction_id'])
print(f"Sold to {result.get('winner', 'nobody')} for {result.get('amount', 0)}")

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

class PropAuctionClient {
  constructor(providerUrl) {
    this.provider = new ethers.providers.JsonRpcProvider(providerUrl);
    this.props = new Map();
    this.auctions = new Map();
    this.bids = new Map();
    this.propCount = 0;
    this.auctionCount = 0;
    this.totalVolume = ethers.BigNumber.from(0);
  }

  async createProp(movieTitle, propName, ipfsCID, year) {
    this.propCount++;
    const prop = {
      propId: this.propCount,
      movieTitle,
      propName,
      ipfsCID,
      year,
      createdAt: Math.floor(Date.now() / 1000)
    };
    this.props.set(this.propCount, prop);
    return prop;
  }

  async startAuction(propId, auctionType, startPrice, reservePrice, duration) {
    this.auctionCount++;
    const auction = {
      auctionId: this.auctionCount,
      propId,
      auctionType,
      status: 'active',
      startPrice: ethers.utils.parseEther(startPrice.toString()),
      reservePrice: ethers.utils.parseEther(reservePrice.toString()),
      highestBid: ethers.BigNumber.from(0),
      highestBidder: null,
      startTime: Math.floor(Date.now() / 1000),
      endTime: Math.floor(Date.now() / 1000) + duration * 3600
    };
    this.auctions.set(this.auctionCount, auction);
    this.bids.set(this.auctionCount, []);
    return auction;
  }

  async placeBid(auctionId, bidder, amount) {
    const auction = this.auctions.get(auctionId);
    if (!auction || auction.status !== 'active') {
      return { success: false, error: 'Not active' };
    }

    const amountWei = ethers.utils.parseEther(amount.toString());
    if (auction.auctionType === 'english' && amountWei.lte(auction.highestBid)) {
      return { success: false, error: 'Bid too low' };
    }

    const bid = { bidder, amount: amountWei, timestamp: Math.floor(Date.now() / 1000) };
    this.bids.get(auctionId).push(bid);
    auction.highestBid = amountWei;
    auction.highestBidder = bidder;

    return { success: true, bid };
  }

  async settleAuction(auctionId) {
    const auction = this.auctions.get(auctionId);
    if (!auction || auction.status !== 'active') {
      return { success: false, error: 'Not available' };
    }

    auction.status = 'ended';
    if (auction.highestBid.gte(auction.reservePrice)) {
      auction.status = 'settled';
      this.totalVolume = this.totalVolume.add(auction.highestBid);
      return { success: true, winner: auction.highestBidder, amount: ethers.utils.formatEther(auction.highestBid) };
    }

    auction.status = 'cancelled';
    return { success: false, error: 'Reserve not met' };
  }
}

const client = new PropAuctionClient('https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY');
client.createProp('The Matrix', 'Red Pill', 'ipfs://Qm...', 1999)
  .then(p => console.log('Prop:', p.propName));