スマート・コントラクト言語

// 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():
    # 相互作用する関数を構築する際の優れたガイドラインは、
    # 他のコントラクトと（つまり、関数を呼び出したりEtherを送信したりする場合）、
    # 以下の3つのフェーズに分割することです：
    # 1. 条件の確認
    # 2. アクションの実行（条件を変更する可能性があります）
    # 3. 他のコントラクトとの相互作用
    # これらのフェーズが混ざっていると、他のコントラクトが
    # 現在のコントラクトにコールバックして状態を変更したり、
    # 効果（Etherの支払い）を複数回実行させたりする可能性があります。
    # 内部で呼び出される関数に外部の
    # コントラクトとの相互作用が含まれる場合、それらも
    # 外部のコントラクトとの相互作用と見なす必要があります。

    # 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()