Solidity实现以太坊秘密竞拍智能合约

2020-10-03

基于remix在线平台进行智能合约的编写验证

前言

与传统拍卖和集中式电子拍卖相比，该方案以区块链为平台进行拍卖。所谓区块链的典型特征是：

（1）分散信任机制。系统本身保证了真实性，不需要外部信任背书人的干预；

（2）稳定性、可靠性和可持续性。由于它是一种分布式网络体系结构，不存在单点故障，因此与其他技术体系结构相比，其整体性能的稳定性、可靠性和可持续性更为突出；

（3）安全加密机制，协商一致机制，通过技术中介体达到整个交易，无需第三方干预；

（4）不可修改的特性，高度保证交易全过程的透明性和不可篡改性。因此，由于区块链的诸多优势，区块链技术非常适合类似拍卖的多种应用场景。

为了验证所提方案的可行性，在以太坊区块链上进行了系统解决方案的部署和实施。之所以选择以太坊作为测试平台，是因为以太坊区块不仅可以记录交易和存储数据，还可以在区块智能合约中存储一些可执行代码。任何人都可以创建合约并编写分散的应用程序。此外，由于区块大小的限制，比特币每秒只能处理7笔交易，而以太坊则没有区块大小的限制。因此，与比特币相比，以太坊的交易速度更快，更适合作为本次拍卖方案的底层平台。

公开拍卖智能合约

首先，让我们熟悉一个简单的公开拍卖智能合约，所有人都可以出价，把以太币发送到指定地址，出价B高于出价A时，那么A的资金会被自动退回。拍卖结束后，商品所有者会收到最高的出价资金。如下注释写得很清楚。

pragma solidity >=0.4.0 <0.6.0;

contract SimpleAuction {
    // 拍卖的参数
    address payable public beneficiary; // 拍卖的受益人
    uint public auctionEndTime; // 拍卖的结束时间
    address public highestBidder; // 当前的最高出价者
    uint public highestBid; // 当前的最高出价
    mapping(address => uint) pendingReturns; // 用于取回之前的出价
    bool ended; // 拍卖是否结束

    // 发生变化时的事件
    event HighestBidIncreased(address bidder, uint amount); // 出现新的最高价
    event AuctionEnded(address winner, uint amount); // 拍卖结束

    /// 创建一个拍卖，参数为拍卖时长和受益人
    constructor(
        uint _biddingTime,
        address payable _beneficiary
    ) public {
        beneficiary = _beneficiary;
        auctionEndTime = now + _biddingTime;
    }
    
	///出价的函数如下，标注payable说明函数可以接收转账，require(now <= auctionEnd)检查拍卖是否结束，如果已经结束就抛出异常，然后检查出价是否大于最高出价，然后将出价人记录到bidders数组（因为bids哈希表不支持遍历），然后记录新的最高出价人，记录日志
    /// 使用代币来进行拍卖
    /// 当拍卖失败时，会退回代币
    function bid() public payable {
        // 不需要参数，因为都被自动处理了
        // 当一个函数要处理Ether时，需要包含payable的修饰符

        // 如果超过了截止期，交易撤回
        require(
            now <= auctionEndTime,
            "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) {
            // 需要提前设置为0，因为接收者可以在这个函数结束前再次调用它，重放攻击！！
            pendingReturns[msg.sender] = 0;

            if (!msg.sender.send(amount)) {
                // 不需要throw，直接重制代币数量即可
                pendingReturns[msg.sender] = amount;
                return false;
            }
        }
        return true;
    }

    /// 结束拍卖，将金额给予受益人
    function auctionEnd() public {
        // 与其他协议交互的最好遵循以下顺序的三个步骤：
        // 1. 检查状况
        // 2. 修改状态
        // 3. 合约交互
        // 如果这三个步骤混在一起，那么攻击者可能通过多次调用这个函数来进行攻击
        // 1. 检查状况
        require(now >= auctionEndTime, "Auction not yet ended.");
        require(!ended, "auctionEnd has already been called.");
        // 2. 修改状态
        ended = true;
        emit AuctionEnded(highestBidder, highestBid);
        // 3. 合约交互
        beneficiary.transfer(highestBid);
    }
}

公开拍卖思路如下：

我们首先要记录拍卖的基本数据：谁是受益人，什么时候结束
我们开启拍卖，一个出价更高的人会替代之前出价最高的人
当出现替代时，还要退还之前出价高的人的代币
出于安全的考虑，退还过程将由之前用户主动发起（注意防止重放攻击）

为什么要由用户主动取钱？

假设由合约账户主动退还以太币到出价人账户

如果一个黑客通过外部账户发起交易调用自己的合约的函数，来发起竞拍，但是该合约账户未定义fallback函数

（ps：当我们调用某个智能合约时，如果指定的函数找不到，或者根本就没指定调用哪个函数（如向合约发送 ether）时，fallback 函数就会被调用）

而当竞拍合约退款时，用的是transfer方式，没有调用任何函数，这时会调用fallback函数，由于该合约没有定义，所以竞拍合约的退款会抛出异常，引起连锁式回滚，中间执行过程更改的数据结构也会全部还原，所以整个auction函数执行失败，所有人都收不到转账

所以，应当设计由投标者自己取回出价的方式，首先判断拍卖是否截止，检查取回的地址是否为最高出价人，然后判断余额是否大于0，然后将账户余额转给调用合约的人，然后在合约中给对应出价人清0

秘密竞拍智能合约

相比公开竞拍，其大概思路是：在投标期间，投标人实际上并没有发送她的出价，而只是发送一个哈希版本的出价。由于目前几乎不可能找到两个（足够长的）值，其哈希值是相等的，因此投标人可通过该方式提交报价。在投标结束后，投标人必须公开他们的出价：他们不加密的发送他们的出价，合约检查出价的哈希值是否与投标期间提供的相同

如何使拍卖同时做到绑定和秘密呢？唯一能阻止投标者在她赢得拍卖后不付款的方式是让她将钱连同出价一起发出。但由于资金转移在以太坊Ethereum中不能被隐藏，因此任何人都可以看到转移的资金，又难以保证秘密。该合约的解决思路如下：

pragma solidity >0.4.23 <0.7.0;

contract BlindAuction {

// 竞拍标地及出价的Bid对象
struct Bid {
bytes32 blindedBid;
uint256 deposit;
}

// 竞拍收益者
address payable public beneficiary;
// 竞拍时间
uint256 public biddingEnd;
// 揭秘时间
uint256 public revealEnd;
// 竞拍结束否
bool public ended;
// 封装用户所有竞拍数据
mapping(address => Bid[]) public bids;

// 最高出价人地址
address public highestBidder;
// 最高出价标地
uint256 public highestBid;
// 取回池
mapping(address => uint256) pendingReturns;

event AuctionEnded(address winner, uint256 highestBid);

modifier onlyBefore(uint256 _time){
        require(now < _time);
_;
}

modifier onlyAfter(uint256 _time){
        require(now > _time);
_;
}

// 构造函数 竞拍时间|揭秘时间|收益人
constructor(
uint256 _biddingTime,
uint256 _revealTime,
address payable _beneficiary
    ) public {
        beneficiary = _beneficiary;
        biddingEnd = now + _biddingTime;
        revealEnd = biddingEnd + _revealTime;
}

// 竞拍
function bid(bytes32 _blindedBid) public payable onlyBefore(biddingEnd)
    {
        bids[msg.sender].push(Bid({
            blindedBid : _blindedBid,
            deposit : msg.value
            }));
}

// 揭秘出价
    // 已竞拍[出价ether]数组
    // 已竞拍[true|false出价]数组
    // 已竞拍[出价secret]数组
function reveal(        
uint256[] memory _values,    
bool[] memory _fake,    
bytes32[] memory _secret
    )
public
onlyAfter(biddingEnd)
    onlyBefore(revealEnd)
    {
// 竞拍次数
uint256 length = bids[msg.sender].length;

require(_values.length == length);
require(_fake.length == length);
require(_secret.length == length);

// 退还
uint256 refund;
// 循环已出价数组
for (uint i = 0; i < length; i++) {    
   // 竞拍标地及出价的Bid对象
    Bid storage _bid = bids[msg.sender][i];
    (uint256 value, bool fake, bytes32 secret) = (_values[i], _fake[i], _secret[i]);
    if (_bid.blindedBid != keccak256(abi.encodePacked(value, fake, secret))) {    
       continue;
    }
   // 退还款总余额
    refund += _bid.deposit;
    // 只有在出价披露阶段被正确披露，已发送的以太币才会被退还
    if (!fake && _bid.deposit >= value) {            
   // 如果与出价一起发送的以太币至少为 “value” 且 “fake” 不为真，则出价有效。
    if (placeBid(msg.sender, value)) {
         refund -= value;
    }
}
            _bid.blindedBid = bytes32(0);
}
        msg.sender.transfer(refund);
}

// 出价
function placeBid(address bidder, uint256 value) internal returns (bool success)
    {    
    if (value <= highestBid) {
        return false;
     }
    if (highestBidder != address(0)) {
            pendingReturns[highestBidder] += highestBid;
     }
     highestBid = value;
     highestBidder = bidder;
     return true;
}

// 取回出价
function withdraw() public {    
    uint256 amount = pendingReturns[msg.sender];
    if (amount > 0) {
         pendingReturns[msg.sender] = 0;
         msg.sender.transfer(amount);
    }
}

// 结束竞拍
function auctionEnd() public onlyAfter(revealEnd)
    {
        require(!ended);
        emit AuctionEnded(highestBidder, highestBid);
        ended = true;
        beneficiary.transfer(highestBid);
    }
}

秘密竞拍通过keccak256哈希运算，将出价value、fake、密文secret整体哈希成一个32位随机数，将该随机数与钱一同转入合约账户，由于secret的存在，其他人很难验证出价value的真假，甚至可以通过伪装等方式传递虚假拍卖信息，因此实现了秘密竞拍。而在reveal方法中分别将最高竞拍价和每人应退还钱数予以实现。也保证了竞拍的公平性