1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

//定义一个名为Coin的智能合约
contract Coin {

    /*
    关键字 "public"会自动生成一个函数，使得该变量可以被其他合约访问。生成的函数大致如下：
    function minter() external view returns (address) { return minter; }
    */
    address public minter;

    //mapping可以被看作是被初始化的哈希表，每一个可能的键从一开始就存在，并被映射到一个值，其字节表示为全零的值。但是无法获得所有的键或所有的值
    mapping(address => uint) public balances;

    // 使用event关键字定义事件，允许客户端对声明的特定合约变化做出反应
    event Sent(address from, address to, uint amount);

    // 构造函数代码只有在合约第一次部署创建时运行，因此部署者将成为minter，才有权限铸币。
    constructor() {
        minter = msg.sender;
    }

    // 向一个地址发送一定数量的新创建的代币，但只能由合约创建者minter调用
    function mint(address receiver, uint amount) public {
        require(msg.sender == minter);
        balances[receiver] += amount;
    }

    // 使用 error 关键字自定义错误
    error InsufficientBalance(uint requested, uint available);

    // 从调用者那里发送一定数量的代币到一个地址也就是转账
    function send(address receiver, uint amount) public {
        if (amount > balances[msg.sender])
        // 使用 revert 抛出自定义的错误（类似 throw），终止并恢复所有变化
            revert InsufficientBalance({
                requested: amount,
                available: balances[msg.sender]
            });

        balances[msg.sender] -= amount;
        balances[receiver] += amount;

        //发送事件，以太坊客户端如网络应用，可以监听区块链上发出的这些事件，事件一旦发出，监听器就会被动收到参数 from， to 和 amount，这使得跟踪交易成为可能。
        emit Sent(msg.sender, receiver, amount);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

1 wei == 1

1 gwei == 1e9

1 szabo == 1e12 (Solidity 0.7.0 版本中被正式弃用)

1 finney == 1e15 wei (Solidity 0.7.0 版本中被正式弃用)

1 ether == 1e18 == 1ETH

由于 `闰秒` 会造成不是每一年都等于365天，甚至不是每一天都有24小时，而且因为闰秒是无法预测的，所以需要借助外部的预言机来对一个确定的日期代码库进行时间矫正！因此在 0.5.0 版本中删除了后缀 years

1 == 1 seconds

1 minutes == 60 seconds

1 hours == 60 minutes

1 days == 24 hours

1 weeks == 7 days

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

//计算 (x + y) % k，加法会在任意精度下执行，并且加法的结果即使超过 2**256 也不会被截取。从 0.5.0 版本的编译器开始会加入对 k != 0 的校验（assert）。
addmod(uint x, uint y, uint k) returns (uint)

//计算 (x * y) % k，乘法会在任意精度下执行，并且乘法的结果即使超过 2**256 也不会被截取。从 0.5.0 版本的编译器开始会加入对 k != 0 的校验（assert）。
mulmod(uint x, uint y, uint k) returns (uint)

//计算输入的 Keccak-256 哈希值。
keccak256(bytes memory) returns (bytes32)

//计算输入的 SHA-256 哈希值。
sha256(bytes memory) returns (bytes32)

//计算输入的 RIPEMD-160 哈希值。
ripemd160(bytes memory) returns (bytes20)

//利用椭圆曲线签名恢复与公钥相关的地址，错误返回零值。
ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) returns (address)
/**函数参数对应于签名的 ECDSA 值
r = 签名的前32字节
s = 签名的第二个32字节
v = 签名的最后1个字节
ecrecover 返回一个 address，而不是 address payable。*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

//以 Wei 为单位的 地址类型 的余额。
<address>.balance （ uint256 ）

//在 地址类型 的代码（可以是空的）。
<address>.code （ bytes memory ）

//地址类型 的代码哈希值
<address>.codehash （ bytes32 ）

//向 地址类型 发送数量为 amount 的 Wei，失败时revert，自动回滚，发送2300燃料的矿工费，不可调节。
<address payable>.transfer(uint256 amount)

//向 地址类型 发送数量为 amount 的 Wei，失败时返回 false，不会自动revert，2300燃料的矿工费用，不可调节。
<address payable>.send(uint256 amount) returns (bool)

/**
在 EVM（以太坊虚拟机）中，所有合约交互最终都通过以下操作码实现：
CALL → 普通调用
DELEGATECALL → 代理调用
STATICCALL → 只读调用

Solidity 的 .call()、.delegatecall()、.staticcall() 就是对上述操作码的封装，这些函数都是低级别的函数，应该谨慎使用。因为任何未知的合约都可能是恶意的，调用未知合约就意味着把控制权交给了该合约，而该合约又可能回调到原合约中，所以要准备好在调用返回时改变您合约的状态变量。
*/

//低级调用，向目标地址发起普通消息调用，执行其代码，使用目标合约的存储、余额和上下文，返回是否成功的结果和数据，发送所有可用燃料，燃料费可调节。应避免在执行另一个合约函数时使用 .call()，因为它绕过了类型检查、函数存在性检查和参数打包.
<address>.call(bytes memory) returns (bool, bytes memory)

//代理调用，在当前合约的上下文中，执行目标合约的代码，返回是否成功的结果和数据，发送所有可用燃料，燃料费可调节。
<address>.delegatecall(bytes memory) returns (bool, bytes memory)

//发起一次只读调用，禁止任何状态修改（包括发送 ETH、写 storage 等），返回是否成功的结果和数据，发送所有可用燃料，燃料费可调节。
<address>.staticcall(bytes memory) returns (bool, bytes memory)

1
2
3
4
5
6

//如果 Child 继承自 Parent，那么 Child 实例可隐式转为 Parent 类型：
Parent p = new Child();

//任何合约实例都可以显式转为 address：
MyToken token = new MyToken();
address addr = address(token);