Solidity調試 - 實現變量打印

Solidity沒有print或console.log方法可以用來打印變量，這會給我們調試程序增加難度。

 

Solidity有event功能，可以在event中記錄變量信息，通過調用event方法也可以實現打印功能，但不可能處處寫event方法，麻煩。

 

以下代碼實現了可重用的log方法，只要調用log()方法就可以打印不同類型的變量值。

 

使用方法為：log(string name, var value)

 

pragma solidity ^0.4.21;

//通過log函數重載，對不同類型的變量trigger不同的event，實現solidity打印效果，使用方法為：log(string name, var value)

contract Console {
    event LogUint(string, uint);
    function log(string s , uint x) internal {
    emit LogUint(s, x);
    }
    
    event LogInt(string, int);
    function log(string s , int x) internal {
    emit LogInt(s, x);
    }
    
    event LogBytes(string, bytes);
    function log(string s , bytes x) internal {
    emit LogBytes(s, x);
    }
    
    event LogBytes32(string, bytes32);
    function log(string s , bytes32 x) internal {
    emit LogBytes32(s, x);
    }

    event LogAddress(string, address);
    function log(string s , address x) internal {
    emit LogAddress(s, x);
    }

    event LogBool(string, bool);
    function log(string s , bool x) internal {
    emit LogBool(s, x);
    }
}

 

我嘗試過用var替代變量類型，但是編譯不通過，應該是var不能做函數參數類型。

以下是編譯不過的：

pragma solidity ^0.4.21;

contract Console {
    event LogUint(string, var);
    function log(string s , var x) internal {
    emit LogUint(s, x);
    }
}

 

使用時只需要將Console.sol import進程序且繼承Console就好（注意第3行和第41行）：

pragma solidity ^0.4.21;

import "browser/Console.sol";

contract SimpleAuction is Console {
    // Parameters of the auction. Times are either
    // absolute unix timestamps (seconds since 1970-01-01)
    // or time periods in seconds.
    address public beneficiary;  //受益人
    uint public auctionEnd; //競拍終止時間

    // Current state of the auction.
    address public highestBidder; //最高競拍者
    uint public highestBid; //最高競拍

    // Allowed withdrawals of previous bids
    mapping(address => uint) pendingReturns;  //待退回的競拍（不是最高出價都退回）

    // Set to true at the end, disallows any change
    bool ended; //一旦設置不允許再投標

    // Events that will be fired on changes.
    event HighestBidIncreased(address bidder, uint amount); //最高出價變動時調用事件
    event AuctionEnded(address winner, uint amount); // 拍賣結束時調用事件

    // The following is a so-called natspec comment,
    // recognizable by the three slashes.
    // It will be shown when the user is asked to
    // confirm a transaction.

    /// Create a simple auction with `_biddingTime`
    /// seconds bidding time on behalf of the
    /// beneficiary address `_beneficiary`.
    /// 初始化拍賣對象：受益人地址、拍賣持續時間
    function SimpleAuction(
        uint _biddingTime,
        address _beneficiary
    ) public {
        beneficiary = _beneficiary;
        auctionEnd = now + _biddingTime;
        log("time now", now);
    }

    /// Bid on the auction with the value sent
    /// together with this transaction.
    /// The value will only be refunded if the
    /// auction is not won.
    ///對競拍投標，payable代表該交易可以獲取ether，只有沒有競拍成功的交易款才會退回
    function bid() public payable {
        // No arguments are necessary, all
        // information is already part of
        // the transaction. The keyword payable
        // is required for the function to
        // be able to receive Ether.

        // Revert the call if the bidding
        // period is over.
        //輸入檢查，競拍如果結束則終止
        require(now <= auctionEnd);

        // If the bid is not higher, send the
        // money back.
        //如果投標金額未超過當前最高金額，則終止
        require(msg.value > highestBid);

        if (highestBid != 0) {
            // Sending back the money by simply using
            // highestBidder.send(highestBid) is a security risk
            // because it could execute an untrusted contract.
            // It is always safer to let the recipients
            // withdraw their money themselves.
            pendingReturns[highestBidder] += highestBid; //原來的最高變次高出價，次高出價要退回
        }
        highestBidder = msg.sender; //新的最高出價者
        highestBid = msg.value; //新的最高出價
        emit HighestBidIncreased(msg.sender, msg.value); //觸發最高出價增加事件
    }

    /// Withdraw a bid that was overbid.
    /// 取回被淘汰的競拍
    function withdraw() public returns (bool) {
        uint amount = pendingReturns[msg.sender];
        if (amount > 0) {
            // It is important to set this to zero because the recipient
            // can call this function again as part of the receiving call
            // before `send` returns.
            pendingReturns[msg.sender] = 0; //在send方法被執行之前，將待退還的錢置為0 *這個很重要* 因為如果不置為0的話，可以重復發起withdraw交易，send需要時間，在交易沒確認之前，重復發起可能就要退N倍的錢

            if (!msg.sender.send(amount)) { //用戶自己取回退回的款項時，如果出錯不用調用throw方法，而是將被置0的待退款金額恢復
                // No need to call throw here, just reset the amount owing
                pendingReturns[msg.sender] = amount;
                return false;
            }
        }
        return true;
    }

    /// End the auction and send the highest bid
    /// to the beneficiary.
    function auctionEnd() public {
        // It is a good guideline to structure functions that interact
        // with other contracts (i.e. they call functions or send Ether)
        // into three phases:
        // 1. checking conditions
        // 2. performing actions (potentially changing conditions)
        // 3. interacting with other contracts
        // If these phases are mixed up, the other contract could call
        // back into the current contract and modify the state or cause
        // effects (ether payout) to be performed multiple times.
        // If functions called internally include interaction with external
        // contracts, they also have to be considered interaction with
        // external contracts.

        // 1. Conditions
        require(now >= auctionEnd); // auction did not yet end
        require(!ended); // this function has already been called

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

        // 3. Interaction
        beneficiary.transfer(highestBid);
    }
}

 

log方法執行后可以在這里找到打印出的變量信息：