智能合约语言

1// SPDX-License-Identifier: GPL-3.0
2pragma solidity >= 0.7.0;
3
4contract Coin {
5    // 关键字“public”使变量
6    // 可从其他合约访问
7    address public minter;
8    mapping (address => uint) public balances;
9
10    // 事件允许客户端对你声明的特定
11    // 合约更改做出反应
12    event Sent(address from, address to, uint amount);
13
14    // 构造函数代码仅在创建
15    // 合约时运行
16    constructor() {
17        minter = msg.sender;
18    }
19
20    // 将一定数量的新创建的代币发送到一个地址
21    // 只能由合约创建者调用
22    function mint(address receiver, uint amount) public {
23        require(msg.sender == minter);
24        require(amount < 1e60);
25        balances[receiver] += amount;
26    }
27
28    // 从任何调用者向一个地址
29    // 发送一定数量的现有代币
30    function send(address receiver, uint amount) public {
31        require(amount <= balances[msg.sender], "余额不足。");
32        balances[msg.sender] -= amount;
33        balances[receiver] += amount;
34        emit Sent(msg.sender, receiver, amount);
35    }
36}
显示全部
复制

1# 公开拍卖
2
3# 拍卖参数
4# 受益人从最高出价者处收款
5beneficiary: public(address)
6auctionStart: public(uint256)
7auctionEnd: public(uint256)
8
9# 拍卖的当前状态
10highestBidder: public(address)
11highestBid: public(uint256)
12
13# 结束时设置为 true，不允许任何更改
14ended: public(bool)
15
16# 跟踪已退还的出价，以便遵循取款模式
17pendingReturns: public(HashMap[address, uint256])
18
19# 创建一个简单拍卖，代表受益人地址 `_beneficiary`，
20# 拍卖时间为 `_bidding_time` 秒。
21@external
22def __init__(_beneficiary: address, _bidding_time: uint256):
23    self.beneficiary = _beneficiary
24    self.auctionStart = block.timestamp
25    self.auctionEnd = self.auctionStart + _bidding_time
26
27# 使用与此交易一起发送的价值对拍卖进行出价。
28# 只有未赢得拍卖，
29# 价值才会被退还。
30@external
31@payable
32def bid():
33    # 检查出价期是否结束。
34    assert block.timestamp < self.auctionEnd
35    # 检查出价是否足够高
36    assert msg.value > self.highestBid
37    # 跟踪先前最高出价者的退款
38    self.pendingReturns[self.highestBidder] += self.highestBid
39    # 跟踪新的最高出价
40    self.highestBidder = msg.sender
41    self.highestBid = msg.value
42
43# 取回先前已退还的出价。此处使用取款模式
44# 以避免安全问题。如果退款直接
45# 作为 bid() 的一部分发送，恶意出价合约可能会阻止
46# 这些退款，从而阻止新的更高出价进入。
47@external
48def withdraw():
49    pending_amount: uint256 = self.pendingReturns[msg.sender]
50    self.pendingReturns[msg.sender] = 0
51    send(msg.sender, pending_amount)
52
53# 结束拍卖并将最高出价
54# 发送给受益人。
55@external
56def endAuction():
57    # 一个好的指导原则是将与其他合约交互的函数（即调用函数或发送以太币）
58    # 结构化为三个阶段：
59    # 1. 检查条件
60    # 2. 执行操作（可能会改变条件）
61    # 3. 与其他合约交互
62    # 如果这些阶段混合在一起，另一个合约可能会回调
63    # 到当前合约并修改状态或导致
64    # 效果（以太币支付）被多次执行。
65    # 如果内部调用的函数包含与外部合约的交互，
66    # 它们也必须被视为与
67    # 外部合约的交互。
68
69    # 1. 条件
70    # 检查是否已达到拍卖结束时间
71    assert block.timestamp >= self.auctionEnd
72    # 检查此函数是否已被调用
73    assert not self.ended
74
75    # 2. 效果
76    self.ended = True
77
78    # 3. 交互
79    send(self.beneficiary, self.highestBid)
显示全部
复制

1{
2    function power(base, exponent) -> result
3    {
4        switch exponent
5        case 0 { result := 1 }
6        case 1 { result := base }
7        default
8        {
9            result := power(mul(base, base), div(exponent, 2))
10            if mod(exponent, 2) { result := mul(base, result) }
11        }
12    }
13    let res := power(calldataload(0), calldataload(32))
14    mstore(0, res)
15    return(0, 32)
16}
显示全部

1type BookMsg = bytes[100]
2
3contract GuestBook:
4    pub guest_book: map<address, BookMsg>
5
6    event Signed:
7        book_msg: BookMsg
8
9    pub def sign(book_msg: BookMsg):
10        self.guest_book[msg.sender] = book_msg
11
12        emit Signed(book_msg=book_msg)
13
14    pub def get_msg(addr: address) -> BookMsg:
15        return self.guest_book[addr].to_mem()
显示全部