《偷自行车的人》与RWA代币化：新现实主义视角下的实物资产

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

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

contract RWATokenization is ERC20, AccessControl, ReentrancyGuard {
    bytes32 public constant ASSET_MANAGER_ROLE = keccak256("ASSET_MANAGER_ROLE");
    bytes32 public constant VERIFIER_ROLE = keccak256("VERIFIER_ROLE");
    bytes32 public constant CUSTODIAN_ROLE = keccak256("CUSTODIAN_ROLE");

    enum AssetType {
        REAL_ESTATE, VEHICLE, ARTWORK, COLLECTIBLE, EQUIPMENT, COMMODITY, OTHER
    }

    enum AssetStatus {
        VERIFIED, TOKENIZED, ACTIVE, LIQUIDATED, FROZEN
    }

    struct RealWorldAsset {
        uint256 assetId;
        string name;
        string description;
        AssetType assetType;
        string location;
        uint256 valuation;  // USD cents
        uint256 totalSupply;
        uint256 circulatingSupply;
        AssetStatus status;
        address custodian;
        string ipfsDocumentCID;
        string ipfsImageCID;
        uint256 createdAt;
        uint256 lastValuationAt;
        bool isVerified;
    }

    struct Valuation {
        uint256 valuationId;
        uint256 assetId;
        address verifier;
        uint256 value;
        string reportCID;
        uint256 timestamp;
        bool isApproved;
    }

    struct AssetIncome {
        uint256 incomeId;
        uint256 assetId;
        string description;
        uint256 amount;
        uint256 timestamp;
        bool isDistributed;
    }

    uint256 private _assetCounter;
    uint256 private _valuationCounter;
    uint256 private _incomeCounter;

    mapping(uint256 => RealWorldAsset) public assets;
    mapping(uint256 => Valuation) public valuations;
    mapping(uint256 => AssetIncome) public assetIncome;
    mapping(uint256 => address[]) public assetHolders;
    mapping(uint256 => mapping(address => uint256)) public holderBalances;

    uint256 public constant MINIMUM_HOLDING = 10 * 10**18; // 10 tokens
    uint256 public constant VALUATION_PERIOD = 365 days;
    uint256 public constant MANAGEMENT_FEE = 100; // 1% basis points

    event AssetRegistered(uint256 indexed assetId, string name, AssetType assetType, uint256 valuation);
    event AssetTokenized(uint256 indexed assetId, uint256 totalSupply);
    event ValuationUpdated(uint256 indexed assetId, uint256 newValue, address indexed verifier);
    event IncomeDistributed(uint256 indexed assetId, uint256 totalAmount, uint256 recipientCount);
    event TokensBurned(uint256 indexed assetId, uint256 amount, address indexed holder);

    constructor() ERC20("RealWorldAsset", "RWA") {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
    }

    function registerAsset(
        string memory _name,
        string memory _description,
        AssetType _assetType,
        string memory _location,
        uint256 _valuation,
        address _custodian,
        string memory _documentCID,
        string memory _imageCID
    ) external onlyRole(ASSET_MANAGER_ROLE) returns (uint256) {
        uint256 assetId = _assetCounter++;
        assets[assetId] = RealWorldAsset({
            assetId: assetId,
            name: _name,
            description: _description,
            assetType: _assetType,
            location: _location,
            valuation: _valuation,
            totalSupply: 0,
            circulatingSupply: 0,
            status: AssetStatus.VERIFIED,
            custodian: _custodian,
            ipfsDocumentCID: _documentCID,
            ipfsImageCID: _imageCID,
            createdAt: block.timestamp,
            lastValuationAt: block.timestamp,
            isVerified: true
        });
        emit AssetRegistered(assetId, _name, _assetType, _valuation);
        return assetId;
    }

    function tokenizeAsset(uint256 _assetId, uint256 _totalSupply) external onlyRole(ASSET_MANAGER_ROLE) {
        RealWorldAsset storage asset = assets[_assetId];
        require(asset.status == AssetStatus.VERIFIED, "Asset not verified");
        require(_totalSupply > 0, "Supply must be > 0");
        asset.totalSupply = _totalSupply;
        asset.circulatingSupply = _totalSupply;
        asset.status = AssetStatus.TOKENIZED;
        _mint(address(this), _totalSupply);
        emit AssetTokenized(_assetId, _totalSupply);
    }

    function purchaseTokens(uint256 _assetId, uint256 _amount) external payable nonReentrant {
        RealWorldAsset storage asset = assets[_assetId];
        require(asset.status == AssetStatus.TOKENIZED || asset.status == AssetStatus.ACTIVE, "Not available");
        require(_amount > 0 && _amount <= asset.circulatingSupply, "Invalid amount");
        uint256 tokenPrice = asset.valuation * 10**18 / asset.totalSupply;
        uint256 cost = _amount * tokenPrice / 10**18;
        require(msg.value >= cost, "Insufficient payment");
        _transfer(address(this), msg.sender, _amount);
        asset.circulatingSupply -= _amount;
        if (holderBalances[_assetId][msg.sender] == 0) {
            assetHolders[_assetId].push(msg.sender);
        }
        holderBalances[_assetId][msg.sender] += _amount;
    }

    function distributeIncome(uint256 _assetId, uint256 _amount) external payable nonReentrant {
        require(_amount > 0, "Amount must be > 0");
        AssetIncome storage income = assetIncome[_incomeCounter];
        income.incomeId = _incomeCounter;
        income.assetId = _assetId;
        income.amount = _amount;
        income.timestamp = block.timestamp;
        income.isDistributed = false;
        _incomeCounter++;

        uint256 totalTokens = assetHolders[_assetId].length;
        uint256 amountPerHolder = _amount / totalTokens;
        for (uint256 i = 0; i < totalTokens; i++) {
            address holder = assetHolders[_assetId][i];
            uint256 holderTokens = holderBalances[_assetId][holder];
            uint256 holderShare = _amount * holderTokens / assets[_assetId].totalSupply;
            payable(holder).transfer(holderShare);
        }
        income.isDistributed = true;
        emit IncomeDistributed(_assetId, _amount, totalTokens);
    }

    function getAssetInfo(uint256 _assetId) external view returns (RealWorldAsset memory) {
        return assets[_assetId];
    }

    function getHolders(uint256 _assetId) external view returns (address[] memory) {
        return assetHolders[_assetId];
    }

    function getAssetsByType(AssetType _assetType) external view returns (uint256[] memory) {
        uint256 count = 0;
        for (uint256 i = 0; i < _assetCounter; i++) {
            if (assets[i].assetType == _assetType) count++;
        }
        uint256[] memory result = new uint256[](count);
        uint256 index = 0;
        for (uint256 i = 0; i < _assetCounter; i++) {
            if (assets[i].assetType == _assetType) {
                result[index] = i;
                index++;
            }
        }
        return result;
    }
}

# RWA Tokenization Platform
# Real World Asset tokenization with blockchain verification

import hashlib
import json
import time
from typing import List, Dict, Optional
from dataclasses import dataclass
from enum import Enum

class AssetType(Enum):
    REAL_ESTATE = "real_estate"
    VEHICLE = "vehicle"
    ARTWORK = "artwork"
    COLLECTIBLE = "collectible"
    EQUIPMENT = "equipment"
    COMMODITY = "commodity"
    OTHER = "other"

class AssetStatus(Enum):
    VERIFIED = "verified"
    TOKENIZED = "tokenized"
    ACTIVE = "active"
    LIQUIDATED = "liquidated"
    FROZEN = "frozen"

@dataclass
class RealWorldAsset:
    asset_id: int
    name: str
    description: str
    asset_type: AssetType
    location: str
    valuation: float
    total_supply: int
    circulating_supply: int
    status: AssetStatus
    custodian: str
    ipfs_document_cid: str
    ipfs_image_cid: str
    created_at: float
    last_valuation_at: float
    is_verified: bool

@dataclass
class TokenHolder:
    address: str
    asset_id: int
    balance: int
    purchase_price: float
    purchased_at: float

class RWAPlatform:
    def __init__(self):
        self.assets: Dict[int, RealWorldAsset] = {}
        self.holders: Dict[str, List[TokenHolder]] = {}
        self.valuations: List[Dict] = []
        self.incomes: List[Dict] = []
        self.asset_counter = 0

    def register_asset(self, name: str, description: str, asset_type: AssetType,
                      location: str, valuation: float, custodian: str,
                      document_cid: str, image_cid: str) -> RealWorldAsset:
        asset_id = self.asset_counter
        self.asset_counter += 1
        asset = RealWorldAsset(asset_id=asset_id, name=name, description=description,
                              asset_type=asset_type, location=location, valuation=valuation,
                              total_supply=0, circulating_supply=0, status=AssetStatus.VERIFIED,
                              custodian=custodian, ipfs_document_cid=document_cid,
                              ipfs_image_cid=image_cid, created_at=time.time(),
                              last_valuation_at=time.time(), is_verified=True)
        self.assets[asset_id] = asset
        print(f"[ASSET] Registered: {name} (${valuation:,.2f})")
        return asset

    def tokenize(self, asset_id: int, total_supply: int):
        if asset_id not in self.assets:
            raise ValueError(f"Asset {asset_id} not found")
        asset = self.assets[asset_id]
        if asset.status != AssetStatus.VERIFIED:
            raise ValueError("Asset not verified")
        asset.total_supply = total_supply
        asset.circulating_supply = total_supply
        asset.status = AssetStatus.TOKENIZED
        print(f"[TOKENIZE] {asset.name}: {total_supply} tokens created")

    def purchase(self, asset_id: int, buyer: str, amount: int) -> TokenHolder:
        if asset_id not in self.assets:
            raise ValueError(f"Asset {asset_id} not found")
        asset = self.assets[asset_id]
        if asset.status not in [AssetStatus.TOKENIZED, AssetStatus.ACTIVE]:
            raise ValueError("Asset not available for purchase")
        if amount > asset.circulating_supply:
            raise ValueError("Insufficient supply")
        token_price = asset.valuation / asset.total_supply
        holder = TokenHolder(address=buyer, asset_id=asset_id, balance=amount,
                           purchase_price=token_price * amount, purchased_at=time.time())
        if buyer not in self.holders:
            self.holders[buyer] = []
        self.holders[buyer].append(holder)
        asset.circulating_supply -= amount
        print(f"[PURCHASE] {buyer} bought {amount} tokens of {asset.name}")
        return holder

    def distribute_income(self, asset_id: int, total_amount: float) -> Dict:
        if asset_id not in self.assets:
            raise ValueError(f"Asset {asset_id} not found")
        asset = self.assets[asset_id]
        total_holders = 0
        total_distributed = 0
        for addr, holders in self.holders.items():
            for h in holders:
                if h.asset_id == asset_id:
                    share = total_amount * h.balance / asset.total_supply
                    total_distributed += share
                    total_holders += 1
        income = {"asset_id": asset_id, "total_amount": total_amount,
                 "distributed": total_distributed, "holders": total_holders,
                 "timestamp": time.time()}
        self.incomes.append(income)
        print(f"[INCOME] ${total_amount:,.2f} distributed to {total_holders} holders")
        return income

    def get_asset_summary(self, asset_id: int) -> Optional[Dict]:
        if asset_id not in self.assets:
            return None
        asset = self.assets[asset_id]
        return {"name": asset.name, "type": asset.asset_type.value,
                "valuation": asset.valuation, "total_supply": asset.total_supply,
                "circulating": asset.circulating_supply,
                "token_price": asset.valuation / asset.total_supply if asset.total_supply > 0 else 0,
                "status": asset.status.value, "custodian": asset.custodian}

# Example: A bicycle tokenization
platform = RWAPlatform()
bicycle = platform.register_asset("Vintage Bicycle 1950", "Restored vintage bicycle",
                                 AssetType.VEHICLE, "Rome, Italy", 5000.0,
                                 "0xCUSTODIAN", "ipfs://doc", "ipfs://img")
platform.tokenize(bicycle.asset_id, 1000)
holder = platform.purchase(bicycle.asset_id, "0xANTONIO", 100)
print(f"Holder: {json.dumps(platform.get_asset_summary(bicycle.asset_id), indent=2)}")

// RWA Tokenization Platform API
// Real World Asset tokenization and management

class RWAPlatform {
    constructor() {
        this.assets = new Map();
        this.holders = new Map();
        this.valuations = [];
        this.incomes = [];
        this.assetCounter = 0;
    }

    registerAsset(name, description, assetType, location, valuation, custodian, docCid, imgCid) {
        const assetId = this.assetCounter++;
        const asset = {
            assetId, name, description, assetType, location, valuation,
            totalSupply: 0, circulatingSupply: 0, status: 'verified',
            custodian, ipfsDocumentCid: docCid, ipfsImageCid: imgCid,
            createdAt: Date.now(), lastValuationAt: Date.now(), isVerified: true
        };
        this.assets.set(assetId, asset);
        console.log(`[ASSET] Registered: ${name} ($${valuation.toLocaleString()})`);
        return asset;
    }

    tokenize(assetId, totalSupply) {
        const asset = this.assets.get(assetId);
        if (!asset) throw new Error('Asset not found');
        if (asset.status !== 'verified') throw new Error('Not verified');
        asset.totalSupply = totalSupply;
        asset.circulatingSupply = totalSupply;
        asset.status = 'tokenized';
        console.log(`[TOKENIZE] ${asset.name}: ${totalSupply} tokens`);
    }

    purchase(assetId, buyer, amount) {
        const asset = this.assets.get(assetId);
        if (!asset) throw new Error('Asset not found');
        if (amount > asset.circulatingSupply) throw new Error('Insufficient supply');
        const tokenPrice = asset.valuation / asset.totalSupply;
        if (!this.holders.has(buyer)) this.holders.set(buyer, []);
        this.holders.get(buyer).push({
            address: buyer, assetId, balance: amount,
            purchasePrice: tokenPrice * amount, purchasedAt: Date.now()
        });
        asset.circulatingSupply -= amount;
        console.log(`[PURCHASE] ${buyer} bought ${amount} tokens of ${asset.name}`);
    }

    distributeIncome(assetId, totalAmount) {
        const asset = this.assets.get(assetId);
        if (!asset) throw new Error('Asset not found');
        let totalDistributed = 0, holderCount = 0;
        for (const [addr, holders] of this.holders) {
            holders.filter(h => h.assetId === assetId).forEach(h => {
                const share = totalAmount * h.balance / asset.totalSupply;
                totalDistributed += share;
                holderCount++;
            });
        }
        this.incomes.push({assetId, totalAmount, distributed: totalDistributed, holders: holderCount, timestamp: Date.now()});
        console.log(`[INCOME] $${totalAmount.toFixed(2)} to ${holderCount} holders`);
    }

    getAssetSummary(assetId) {
        const asset = this.assets.get(assetId);
        if (!asset) return null;
        return {name: asset.name, type: asset.assetType, valuation: asset.valuation,
                totalSupply: asset.totalSupply, circulating: asset.circulatingSupply,
                tokenPrice: asset.valuation / asset.totalSupply, status: asset.status};
    }
}

// Example
const platform = new RWAPlatform();
const bicycle = platform.registerAsset('Vintage Bicycle 1950', 'Restored vintage bicycle',
    'vehicle', 'Rome, Italy', 5000, '0xCUSTODIAN', 'ipfs://doc', 'ipfs://img');
platform.tokenize(bicycle.assetId, 1000);
platform.purchase(bicycle.assetId, '0xANTONIO', 100);
console.log('Summary:', platform.getAssetSummary(bicycle.assetId));