公开拍卖合约

公开拍卖合约

需求分析

每个人都可以看到出价，同时每个人都可以在投标期间发送他们的出价。出价包含了资金/以太币，来将投标人与他们的投标绑定。如果最高出价提高了（被其他出价者的出价超过），之前出价最高的出价者可以拿回他的钱。在投标结束后，受益人需要手动调用合约来接收他的钱，合约不能自己激活接收。

思路

• 拍卖需要得到一个最终受益人address payable public beneficary;
• 需要拍卖时间，得知拍卖的结束时间，uint public auctionEndTime;
• 作为公开拍卖合约，需要知道拍卖的当前状态,即当前拍卖价格最高者address public highestBidder;和当前拍卖最高价格uint public highestBid;
• 在更新最高价格之后，可以回收之前最高价格出价者的资金mapping(address => uint) pendingReturns;
• 拍卖合约需要知道，拍卖的进行状态，用一个布尔值来表示，拍卖结束设为true，停止变更所有操作bool ended;
• 为了能够得知拍卖变化，我们需要设置变更事件event HighestBidIncreased(address bidder,uint amount);和event AuctionEnded(address winner,uint amount)
• 拍卖过程中，首先需要对拍卖时间和收益人地址进行初始化constructor(address payable _beneficiary,uint _biddingTime)public{}
• 接着对拍卖进行出价，具体出价随交易一起发送，如果没有在拍卖中胜出，则返回出价function bid()public payable{}
• 当出价被超越，取回出价function withdraw()public returns(bool){}
• 最后拍卖结束，把拍卖的最高出价发送给收益人function auctionEnd()public{}

智能合约代码：

pragma solidity >=0.5.0 <0.7.0;

contract SimpleAuction {
    // 拍卖的参数。
    address payable public beneficiary;
    // 时间是unix的绝对时间戳（自1970-01-01以来的秒数）
    // 或以秒为单位的时间段。
    uint public auctionEnd;

    // 拍卖的当前状态
    address public highestBidder;
    uint public highestBid;

    //可以取回的之前的出价
    mapping(address => uint) pendingReturns;

    // 拍卖结束后设为 true，将禁止所有的变更
    bool ended;

    // 变更触发的事件
    event HighestBidIncreased(address bidder, uint amount);
    event AuctionEnded(address winner, uint amount);

    // 以下是所谓的 natspec 注释，可以通过三个斜杠来识别。
    // 当用户被要求确认交易时将显示。

    /// 以受益者地址 `_beneficiary` 的名义，
    /// 创建一个简单的拍卖，拍卖时间为 `_biddingTime` 秒。
    constructor(
        uint _biddingTime,
        address payable _beneficiary
    ) public {
        beneficiary = _beneficiary;
        auctionEnd = now + _biddingTime;
    }

    /// 对拍卖进行出价，具体的出价随交易一起发送。
    /// 如果没有在拍卖中胜出，则返还出价。
    function bid() public payable {
        // 参数不是必要的。因为所有的信息已经包含在了交易中。
        // 对于能接收以太币的函数，关键字 payable 是必须的。

        // 如果拍卖已结束，撤销函数的调用。
        require(
            now <= auctionEnd,
            "Auction already ended."
        );

        // 如果出价不够高，返还你的钱
        require(
            msg.value > highestBid,
            "There already is a higher bid."
        );

        if (highestBid != 0) {
            // 返还出价时，简单地直接调用 highestBidder.send(highestBid) 函数，
            // 是有安全风险的，因为它有可能执行一个非信任合约。
            // 更为安全的做法是让接收方自己提取金钱。
            pendingReturns[highestBidder] += highestBid;
        }
        highestBidder = msg.sender;
        highestBid = msg.value;
        emit HighestBidIncreased(msg.sender, msg.value);
    }

    /// 取回出价（当该出价已被超越）
    function withdraw() public returns (bool) {
        uint amount = pendingReturns[msg.sender];
        if (amount > 0) {
            // 这里很重要，首先要设零值。
            // 因为，作为接收调用的一部分，
            // 接收者可以在 `send` 返回之前，重新调用该函数。
            pendingReturns[msg.sender] = 0;

            if (!msg.sender.send(amount)) {
                // 这里不需抛出异常，只需重置未付款
                pendingReturns[msg.sender] = amount;
                return false;
            }
        }
        return true;
    }

    /// 结束拍卖，并把最高的出价发送给受益人
    function auctionEnded() public {
        // 对于可与其他合约交互的函数（意味着它会调用其他函数或发送以太币），
        // 一个好的指导方针是将其结构分为三个阶段：
        // 1. 检查条件
        // 2. 执行动作 (可能会改变条件)
        // 3. 与其他合约交互
        // 如果这些阶段相混合，其他的合约可能会回调当前合约并修改状态，
        // 或者导致某些效果（比如支付以太币）多次生效。
        // 如果合约内调用的函数包含了与外部合约的交互，
        // 则它也会被认为是与外部合约有交互的。

        // 1. 条件
        require(now >= auctionEnd, "Auction not yet ended.");
        require(!ended, "auctionEnd has already been called.");

        // 2. 生效
        ended = true;
        emit AuctionEnded(highestBidder, highestBid);

        // 3. 交互
        beneficiary.transfer(highestBid);
    }
}