openzeppelin学习笔记 - 5

openzeppelin中很重要的一块就是token,而其中比较常见的就是ERC20,而在ERC20基本合约的基础上openzeppelin也扩展出一些合约。

  • IERC20

IERC20格式的接口,自己实现ERC20合约时可以使用这个接口

  • ERC20

一个基本的ERC20合约,包含基本的交易功能

  • ERC20Burnable.sol

ERC20上添加了燃币功能

  • ERC20Capped.sol

ERC20Mintable上添加了设置币量上限功能,可发币的同时限制发币量不可以大于上限

  • ERC20Detailed.sol

ERC20上添加了详细信息,可以设置币种的名称,符号和精度

  • ERC20Mintable.sol

ERC20上添加了发币功能,发布者需要拥有发币角色

  • ERC20Pausable.sol

ERC20上添加了冻结功能,拥有冻结角色者可以冻结代币,冻结后代币无法流通交易

  • SafeERC20.sol

ERC20上安全认证,在交易相关的方法中认证返回值

  • TokenTimelock.sol

这一个锁定时间提取代币的合约,这个在固定时间后可以将代币合约账户内的代币转移给对应的账户

当然这些合约的核心还是ERC20.sol,我们主要看一下ERC20相关的内容和实现:

ERC20

全局变量

  • 账户余额
1
mapping (address => uint256) private _balances
  • 账户授权
1
mapping (address => mapping (address => uint256)) private _allowed;
  • 发币总额
1
uint256 private _totalSupply;
事件

  • 交易事件
1
2
3
4
5
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
  • 授权事件
1
2
3
4
5
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
方法

  • 获取发行总额
1
function totalSupply() public view returns (uint256)
  • 获取账户余额
1
function balanceOf(address owner) public view returns (uint256)
  • 获取授权额度
1
2
3
4
5
function allowance(
address owner,
address spender
)
public view returns (uint256)
  • 代币交易(发送代币)
1
function transfer(address to, uint256 value) public returns (bool)
  • 代币授权
1
function approve(address spender, uint256 value) public returns (bool)
  • 代币授权交易(发送授权方的代币)
1
2
3
4
5
6
function transferFrom(
address from,
address to,
uint256 value
)
public returns (bool)
  • 增长授权额度
1
2
3
4
5
function increaseAllowance(
address spender,
uint256 addedValue
)
public returns (bool)
  • 减少授权额度
1
2
3
4
function decreaseAllowance(
address spender,
uint256 subtractedValue
)
  • 代币交易(内部)
1
function _transfer(address from, address to, uint256 value) internal
  • 发币(内部)
1
function _mint(address account, uint256 value) internal
  • 烧币(内部)(将代币发送到空地址)
1
function _mint(address account, uint256 value) internal
  • 烧币-授权方(内部)
1
function _burnFrom(address account, uint256 value) internal
合约代码

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
contract ERC20 is IERC20 {
using SafeMath for uint256;

mapping (address => uint256) private _balances;

mapping (address => mapping (address => uint256)) private _allowed;

uint256 private _totalSupply;

/**
* @dev Total number of tokens in existence
* @dev 代币总额
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}

/**
* @dev Gets the balance of the specified address.
* @dev 获取对应账户代币余额
* @param owner The address to query the balance of.
* @return An uint256 representing the amount owned by the passed address.
*/
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}

/**
* @dev Function to check the amount of tokens that an owner allowed to a spender.
* @dev 获取对应账户授权额
* @param owner address The address which owns the funds.
* @param spender address The address which will spend the funds.
* @return A uint256 specifying the amount of tokens still available for the spender.
*/
function allowance(
address owner,
address spender
)
public
view
returns (uint256)
{
return _allowed[owner][spender];
}

/**
* @dev Transfer token for a specified address
* @dev 将代币发送指定地址
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}

/**
* @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
* Beware that changing an allowance with this method brings the risk that someone may use both the old
* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
*/
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));

_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}

/**
* @dev Transfer tokens from one address to another
* @dev 发送指定地址的代币-需要授权
* @param from address The address which you want to send tokens from
* @param to address The address which you want to transfer to
* @param value uint256 the amount of tokens to be transferred
*/
function transferFrom(
address from,
address to,
uint256 value
)
public
returns (bool)
{
require(value <= _allowed[from][msg.sender]);

_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
return true;
}

/**
* @dev Increase the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed_[_spender] == 0. To increment
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param spender The address which will spend the funds.
* @param addedValue The amount of tokens to increase the allowance by.
*/
function increaseAllowance(
address spender,
uint256 addedValue
)
public
returns (bool)
{
require(spender != address(0));

_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].add(addedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}

/**
* @dev Decrease the amount of tokens that an owner allowed to a spender.
* approve should be called when allowed_[_spender] == 0. To decrement
* allowed value is better to use this function to avoid 2 calls (and wait until
* the first transaction is mined)
* From MonolithDAO Token.sol
* @param spender The address which will spend the funds.
* @param subtractedValue The amount of tokens to decrease the allowance by.
*/
function decreaseAllowance(
address spender,
uint256 subtractedValue
)
public
returns (bool)
{
require(spender != address(0));

_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}

/**
* @dev Transfer token for a specified addresses
* @param from The address to transfer from.
* @param to The address to transfer to.
* @param value The amount to be transferred.
*/
function _transfer(address from, address to, uint256 value) internal {
require(value <= _balances[from]);
require(to != address(0));

_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}

/**
* @dev Internal function that mints an amount of the token and assigns it to
* an account. This encapsulates the modification of balances such that the
* proper events are emitted.
* @param account The account that will receive the created tokens.
* @param value The amount that will be created.
*/
function _mint(address account, uint256 value) internal {
require(account != 0);
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}

/**
* @dev Internal function that burns an amount of the token of a given
* account.
* @param account The account whose tokens will be burnt.
* @param value The amount that will be burnt.
*/
function _burn(address account, uint256 value) internal {
require(account != 0);
require(value <= _balances[account]);

_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}

/**
* @dev Internal function that burns an amount of the token of a given
* account, deducting from the sender's allowance for said account. Uses the
* internal burn function.
* @param account The account whose tokens will be burnt.
* @param value The amount that will be burnt.
*/
function _burnFrom(address account, uint256 value) internal {
require(value <= _allowed[account][msg.sender]);

// Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
// this function needs to emit an event with the updated approval.
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(
value);
_burn(account, value);
}
}