VibeAgent 智能合约设计#

interface IAgentNFT {
    event AgentMinted(
        uint256 indexed tokenId,
        address indexed owner,
        address tba,
        string metadataURI
    );

    function mint(address to, string calldata metadataURI)
        external returns (uint256 tokenId);

    function getTBA(uint256 tokenId) external view returns (address);

    function updateMetadata(uint256 tokenId, string calldata newURI)
        external;

    function totalSupply() external view returns (uint256);
}

// 使用 reference implementation
// https://github.com/erc6551/reference
//
// 每个 Agent NFT 创建时:
// 1. 计算 TBA 地址 (CREATE2 deterministic)
// 2. 部署 AgentAccount 合约
// 3. TBA 可持有 ETH/ERC-20, 可调用任意合约

enum PricingModel { PER_CALL, SUBSCRIPTION, BUYOUT }

struct Skill {
    bytes32 skillId;
    address creator;
    string metadataURI;       // ipfs://...
    PricingModel pricingModel;
    uint256 price;            // wei or USDC units
    uint256 royaltyBps;       // 版税 basis points (0-1000)
    bool active;
    uint256 createdAt;
}

struct SkillBinding {
    bytes32 skillId;
    uint256 agentId;
    bool active;
}

interface ISkillRegistry {
    event SkillRegistered(bytes32 indexed skillId, address indexed creator);
    event SkillBound(bytes32 indexed skillId, uint256 indexed agentId);
    event SkillVerified(bytes32 indexed skillId, address indexed verifier);

    function registerSkill(
        string calldata metadataURI,
        PricingModel pricingModel,
        uint256 price,
        uint256 royaltyBps
    ) external returns (bytes32 skillId);

    function bindSkillToAgent(bytes32 skillId, uint256 agentId) external;

    function verifySkill(bytes32 skillId) external;  // v0.2: 仅授权验证者

    function getSkill(bytes32 skillId) external view returns (Skill memory);

    function getAgentSkills(uint256 agentId) external view returns (bytes32[] memory);
}

enum EscrowStatus {
    CREATED, FUNDED, DELIVERED, COMPLETED, DISPUTED, REFUNDED, CANCELLED
}

struct EscrowOrder {
    uint256 escrowId;
    address consumer;
    address provider;         // Agent TBA address
    bytes32 skillId;
    uint256 amount;
    string taskCID;
    string deliveryCID;
    EscrowStatus status;
    uint256 deadline;
    uint256 createdAt;
}

interface IEscrow {
    event EscrowCreated(uint256 indexed escrowId, address consumer, address provider);
    event EscrowFunded(uint256 indexed escrowId, uint256 amount);
    event EscrowDelivered(uint256 indexed escrowId, string deliveryCID);
    event EscrowCompleted(uint256 indexed escrowId);
    event EscrowRefunded(uint256 indexed escrowId);

    function createEscrow(
        address provider,
        bytes32 skillId,
        string calldata taskCID,
        uint256 deadline
    ) external returns (uint256 escrowId);

    function fundEscrow(uint256 escrowId) external payable;

    function deliverEscrow(uint256 escrowId, string calldata deliveryCID) external;

    function confirmDelivery(uint256 escrowId) external;

    function disputeEscrow(uint256 escrowId) external;

    function refundExpired(uint256 escrowId) external;

    function getEscrow(uint256 escrowId) external view returns (EscrowOrder memory);
}

function _settle(EscrowOrder storage order) internal {
    uint256 amount = order.amount;
    Skill memory skill = skillRegistry.getSkill(order.skillId);

    uint256 protocolFee = amount * protocolFeeBps / 10000;
    uint256 royalty = amount * skill.royaltyBps / 10000;
    uint256 providerAmount = amount - protocolFee - royalty;

    // Checks-Effects-Interactions
    order.status = EscrowStatus.COMPLETED;

    payable(order.provider).transfer(providerAmount);
    payable(skill.creator).transfer(royalty);
    payable(treasury).transfer(protocolFee);
}

struct Device {
    bytes32 deviceId;
    address owner;
    string metadataURI;       // 算力描述、在线时段
    uint256 pricePerHour;
    uint256 stake;            // 质押金额
    bool active;
    uint256 lastHeartbeat;
}

interface IDeviceRegistry {
    function registerDevice(string calldata metadataURI, uint256 pricePerHour)
        external payable returns (bytes32 deviceId);

    function heartbeat(bytes32 deviceId) external;

    function deactivateDevice(bytes32 deviceId) external;
}