智能合約語言

// SPDX-License-Identifier: GPL-3.0
pragma solidity >= 0.7.0;

contract Coin {
    // 「public」關鍵字讓變數
    // 可以從其他合約存取
    address public minter;
    mapping (address => uint) public balances;

    // 事件允許客戶端對特定的
    // 您宣告的合約變更做出反應
    event Sent(address from, address to, uint amount);

    // 建構子程式碼只會在合約
    // 建立時執行
    constructor() {
        minter = msg.sender;
    }

    // 將一定數量的新建代幣發送到一個地址
    // 只能由合約建立者呼叫
    function mint(address receiver, uint amount) public {
        require(msg.sender == minter);
        require(amount < 1e60);
        balances[receiver] += amount;
    }

    // 發送一定數量的現有代幣
    // 從任何呼叫者到一個地址
    function send(address receiver, uint amount) public {
        require(amount <= balances[msg.sender], "Insufficient balance.");
        balances[msg.sender] -= amount;
        balances[receiver] += amount;
        emit Sent(msg.sender, receiver, amount);
    }
}

# 公開拍賣

# 拍賣參數
# 受益人從最高出價者那裡收到資金
beneficiary: public(address)
auctionStart: public(uint256)
auctionEnd: public(uint256)

# 拍賣的當前狀態
highestBidder: public(address)
highestBid: public(uint256)

# 在結束時設為 true，不允許任何更改
ended: public(bool)

# 追蹤已退款的出價，以便我們可以遵循提款模式
pendingReturns: public(HashMap[address, uint256])

# 建立一個簡單的拍賣，競標時間為 `_bidding_time`
# 秒，代表
# 受益人地址 `_beneficiary`。
@external
def __init__(_beneficiary: address, _bidding_time: uint256):
    self.beneficiary = _beneficiary
    self.auctionStart = block.timestamp
    self.auctionEnd = self.auctionStart + _bidding_time

# 使用與此交易一起發送的
# 價值對拍賣進行出價。
# 只有在未贏得拍賣的情況下
# 才會退還該價值。
@external
@payable
def bid():
    # 檢查競標期是否已結束。
    assert block.timestamp < self.auctionEnd
    # 檢查出價是否夠高
    assert msg.value > self.highestBid
    # 追蹤前一個最高出價者的退款
    self.pendingReturns[self.highestBidder] += self.highestBid
    # 追蹤新的最高出價
    self.highestBidder = msg.sender
    self.highestBid = msg.value

# 提取先前退還的出價。這裡使用提款模式
# 是為了避免安全問題。如果退款直接
# 作為 bid() 的一部分發送，惡意出價合約可能會阻擋
# 這些退款，從而阻擋新的更高出價進入。
@external
def withdraw():
    pending_amount: uint256 = self.pendingReturns[msg.sender]
    self.pendingReturns[msg.sender] = 0
    send(msg.sender, pending_amount)

# 結束拍賣並將最高出價發送
# 給受益人。
@external
def endAuction():
    # 這是一個很好的準則，將與
    # 其他合約互動的函式（即它們呼叫函式或發送以太幣）
    # 結構化為三個階段：
    # 1. 檢查條件
    # 2. 執行動作（可能會改變條件）
    # 3. 與其他合約互動
    # 如果這些階段混合在一起，另一個合約可能會回呼
    # 到當前合約中並修改狀態，或導致
    # 效果（以太幣支付）被執行多次。
    # 如果內部呼叫的函式包含與外部
    # 合約的互動，它們也必須被視為與
    # 外部合約的互動。

    # 1. 條件
    # 檢查是否已達到拍賣結束時間
    assert block.timestamp >= self.auctionEnd
    # 檢查此函式是否已被呼叫
    assert not self.ended

    # 2. 效果
    self.ended = True

    # 3. 互動
    send(self.beneficiary, self.highestBid)

{
    function power(base, exponent) -> result
    {
        switch exponent
        case 0 { result := 1 }
        case 1 { result := base }
        default
        {
            result := power(mul(base, base), div(exponent, 2))
            if mod(exponent, 2) { result := mul(base, result) }
        }
    }
    let res := power(calldataload(0), calldataload(32))
    mstore(0, res)
    return(0, 32)
}

type BookMsg = bytes[100]

contract GuestBook:
    pub guest_book: map<address, BookMsg>

    event Signed:
        book_msg: BookMsg

    pub def sign(book_msg: BookMsg):
        self.guest_book[msg.sender] = book_msg

        emit Signed(book_msg=book_msg)

    pub def get_msg(addr: address) -> BookMsg:
        return self.guest_book[addr].to_mem()