ERC-20 合约详解

1// SPDX-License-Identifier: MIT
复制

1pragma solidity >=0.6.0 <0.8.0;
复制

1/**
2 * @dev EIP 中定义的 ERC20 标准接口。
3 */
复制

1interface IERC20 {
复制

1    /**
2     * @dev 返回存在的代币数量。
3     */
4    function totalSupply() external view returns (uint256);
复制

1    /**
2     * @dev 返回 `account` 拥有的代币数量。
3     */
4    function balanceOf(address account) external view returns (uint256);
复制

1    /**
2     * @dev 将 `amount` 数量的代币从调用者的账户转移到 `recipient`。
3     *
4     * 返回一个布尔值，表示操作是否成功。
5     *
6     * 触发一个 {Transfer} 事件。
7     */
8    function transfer(address recipient, uint256 amount) external returns (bool);
复制

1    /**
2     * @dev 返回 `spender` 通过 {transferFrom} 可代表 `owner` 花费的
3     * 剩余代币数量。默认
4     * 为零。
5     *
6     * 调用 {approve} 或 {transferFrom} 时，此值会发生变化。
7     */
8    function allowance(address owner, address spender) external view returns (uint256);
复制

1    /**
2     * @dev 将 `spender` 对调用者代币的授权额度设置为 `amount`。
3     *
4     * 返回一个布尔值，表示操作是否成功。
5     *
6     * 重要提示：请注意，使用此方法更改授权额度会带来风险，
7     * 有人可能因不利的交易排序而同时使用新旧两种授权额度。
8     * 缓解此竞态条件的一个可行方案是，先将花费者的授权额度降至 0，
9     * 然后再设置所需的值：
10     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
11     *
12     * 触发一个 {Approval} 事件。
13     */
14    function approve(address spender, uint256 amount) external returns (bool);
显示全部
复制

1    /**
2     * @dev 使用
3     * 授权机制将 `amount` 数量的代币从 `sender` 转移到 `recipient`。然后从调用者的授权额度中扣除 `amount`。
4     *
5     * 返回一个布尔值，表示操作是否成功。
6     *
7     * 触发一个 {Transfer} 事件。
8     */
9    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
显示全部
复制

1
2    /**
3     * @dev 当 `value` 数量的代币从一个帐户 (`from`) 转移到
4     * 另一个 (`to`) 时触发。
5     *
6     * 请注意，`value` 可能为零。
7     */
8    event Transfer(address indexed from, address indexed to, uint256 value);
9
10    /**
11     * @dev 当通过
12     * 调用 {approve} 为 `owner` 设置 `spender` 的授权额度时触发。`value` 是新的授权额度。
13     */
14    event Approval(address indexed owner, address indexed spender, uint256 value);
15}
显示全部
复制

1// SPDX-License-Identifier: MIT
2pragma solidity >=0.6.0 <0.8.0;
复制

1
2import "../../GSN/Context.sol";
3import "./IERC20.sol";
4import "../../math/SafeMath.sol";
复制

1/**
2 * @dev {IERC20} 接口的实现。
3 *
4 * 此实现与代币的创建方式无关。这意味着
5 * 必须使用 {_mint} 在派生合约中添加供应机制。
6 * 有关通用机制，请参阅 {ERC20PresetMinterPauser}。
7 *
8 * 提示：有关详细的说明，请参阅我们的指南
9 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[如何
10 * 实现供应机制]。
11 *
12 * 我们遵循了通用的 OpenZeppelin 指南：函数在失败时会还原，而
13 * 不会返回 `false`。但是，此行为是常规行为，
14 * 并且与 ERC20 应用程序的预期不冲突。
15 *
16 * 此外，在调用 {transferFrom} 时会触发 {Approval} 事件。
17 * 这允许应用程序仅通过监听所述事件
18 * 即可重建所有账户的授权额度。EIP 的其他实现
19 * 可能不会触发这些事件，因为规范没有要求。
20 *
21 * 最后，添加了非标准的 {decreaseAllowance} 和 {increaseAllowance}
22 * 函数，以缓解围绕设置
23 * 授权额度的众所周知的问题。请参阅 {IERC20-approve}。
24 */
25
显示全部
复制

1contract ERC20 is Context, IERC20 {
复制

1
2    using SafeMath for uint256;
3
复制

1    mapping (address => uint256) private _balances;
复制

1    mapping (address => mapping (address => uint256)) private _allowances;
复制

1    uint256 private _totalSupply;
复制

1    string private _name;
2    string private _symbol;
3    uint8 private _decimals;
复制

1    /**
2     * @dev 设置 {name} 和 {symbol} 的值，用
3     * 默认值 18 初始化 {decimals}。
4     *
5     * 要为 {decimals} 选择不同的值，请使用 {_setupDecimals}。
6     *
7     * 所有这三个值都是不可变的：它们只能在
8     * 构造期间设置一次。
9     */
10    constructor (string memory name_, string memory symbol_) public {
11        // In Solidity ≥0.7.0, 'public' is implicit and can be omitted.
12
13        _name = name_;
14        _symbol = symbol_;
15        _decimals = 18;
16    }
显示全部
复制

1    /**
2     * @dev 返回代币的名称。
3     */
4    function name() public view returns (string memory) {
5        return _name;
6    }
7
8    /**
9     * @dev 返回代币的符号，通常是
10     * 名称的缩写。
11     */
12    function symbol() public view returns (string memory) {
13        return _symbol;
14    }
15
16    /**
17     * @dev 返回用于获取其用户表示的小数位数。
18     * 例如，如果 `decimals` 等于 `2`，`505` 个代币的余额应
19     * 向用户显示为 `5,05` (`505 / 10 ** 2`)。
20     *
21     * 代币通常选择值 18，模仿
22     * 以太币和 wei 之间的关系。这是 {ERC20} 使用的值，除非
23     * 调用 {_setupDecimals}。
24     *
25     * 注意：此信息仅用于_显示_目的：它
26     * 绝不影响合约的任何算术，包括
27     * {IERC20-balanceOf} 和 {IERC20-transfer}。
28     */
29    function decimals() public view returns (uint8) {
30        return _decimals;
31    }
显示全部
复制

1    /**
2     * @dev 请参阅 {IERC20-totalSupply}。
3     */
4    function totalSupply() public view override returns (uint256) {
5        return _totalSupply;
6    }
复制

1    /**
2     * @dev 请参阅 {IERC20-balanceOf}。
3     */
4    function balanceOf(address account) public view override returns (uint256) {
5        return _balances[account];
6    }
复制

1    /**
2     * @dev 请参阅 {IERC20-transfer}。
3     *
4     * 要求：
5     *
6     * - `recipient` 不能是零地址。
7     * - 调用者必须拥有至少 `amount` 的余额。
8     */
9    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
显示全部
复制

1        _transfer(_msgSender(), recipient, amount);
2        return true;
3    }
复制

1    /**
2     * @dev 请参阅 {IERC20-allowance}。
3     */
4    function allowance(address owner, address spender) public view virtual override returns (uint256) {
5        return _allowances[owner][spender];
6    }
复制

1    /**
2     * @dev 请参阅 {IERC20-approve}。
3     *
4     * 要求：
5     *
6     * - `spender` 不能是零地址。
7     */
8    function approve(address spender, uint256 amount) public virtual override returns (bool) {
复制

1        _approve(_msgSender(), spender, amount);
2        return true;
3    }
复制

1    /**
2     * @dev 请参阅 {IERC20-transferFrom}。
3     *
4     * 触发一个 {Approval} 事件，指示更新后的授权额度。EIP
5     * 并未要求此项。请参阅 {ERC20} 开头的注释。
6     *
7     * 要求：
8     *
9     * - `sender` 和 `recipient` 不能是零地址。
10     * - `sender` 必须拥有至少 `amount` 的余额。
11     * - 调用者必须拥有至少 `amount` 的 ``sender`` 代币授权额度
12     * 。
13     */
14    function transferFrom(address sender, address recipient, uint256 amount) public virtual
15                                                override returns (bool) {
16        _transfer(sender, recipient, amount);
显示全部
复制

1        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount,
2             "ERC20: transfer amount exceeds allowance"));
3        return true;
4    }
复制

1    /**
2     * @dev 以原子方式增加调用者授予 `spender` 的授权额度。
3     *
4     * 这是 {approve} 的替代方案，可用于缓解
5     * {IERC20-approve} 中描述的问题。
6     *
7     * 触发一个 {Approval} 事件，指示更新后的授权额度。
8     *
9     * 要求：
10     *
11     * - `spender` 不能是零地址。
12     */
13    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
14        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
15        return true;
16    }
显示全部
复制

1
2    /**
3     * @dev 以原子方式减少调用者授予 `spender` 的授权额度。
4     *
5     * 这是 {approve} 的替代方案，可用于缓解
6     * {IERC20-approve} 中描述的问题。
7     *
8     * 触发一个 {Approval} 事件，指示更新后的授权额度。
9     *
10     * 要求：
11     *
12     * - `spender` 不能是零地址。
13     * - `spender` 必须拥有至少
14     * `subtractedValue` 的调用者授权额度。
15     */
16    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
17        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue,
18                "ERC20: decreased allowance below zero"));
19        return true;
20    }
显示全部
复制

1    /**
2     * @dev 将 `amount` 数量的代币从 `sender` 转移到 `recipient`。
3     *
4     * 这个内部函数等同于 {transfer}，可用于
5     * 例如，实现自动代币费用、惩罚机制等。
6     *
7     * 触发一个 {Transfer} 事件。
8     *
9     * 要求：
10     *
11     * - `sender` 不能是零地址。
12     * - `recipient` 不能是零地址。
13     * - `sender` 必须拥有至少 `amount` 的余额。
14     */
15    function _transfer(address sender, address recipient, uint256 amount) internal virtual {
显示全部
复制

1        require(sender != address(0), "ERC20: transfer from the zero address");
2        require(recipient != address(0), "ERC20: transfer to the zero address");
复制

1        _beforeTokenTransfer(sender, recipient, amount);
2
复制

1        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
2        _balances[recipient] = _balances[recipient].add(amount);
复制

1        emit Transfer(sender, recipient, amount);
2    }
复制

1    /** @dev 创建 `amount` 数量的代币并将其分配给 `account`，增加
2     * 总供应量。
3     *
4     * 触发一个 {Transfer} 事件，其中 `from` 设置为零地址。
5     *
6     * 要求：
7     *
8     * - `to` 不能是零地址。
9     */
10    function _mint(address account, uint256 amount) internal virtual {
11        require(account != address(0), "ERC20: mint to the zero address");
12        _beforeTokenTransfer(address(0), account, amount);
13        _totalSupply = _totalSupply.add(amount);
14        _balances[account] = _balances[account].add(amount);
15        emit Transfer(address(0), account, amount);
16    }
显示全部
复制

1    /**
2     * @dev 从 `account` 销毁 `amount` 数量的代币，减少
3     * 总供应量。
4     *
5     * 触发一个 {Transfer} 事件，其中 `to` 设置为零地址。
6     *
7     * 要求：
8     *
9     * - `account` 不能是零地址。
10     * - `account` 必须拥有至少 `amount` 的代币。
11     */
12    function _burn(address account, uint256 amount) internal virtual {
13        require(account != address(0), "ERC20: burn from the zero address");
14
15        _beforeTokenTransfer(account, address(0), amount);
16
17        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
18        _totalSupply = _totalSupply.sub(amount);
19        emit Transfer(account, address(0), amount);
20    }
显示全部
复制

1    /**
2     * @dev 将 `spender` 对 `owner` 代币的授权额度设置为 `amount`。
3     *
4     * 此内部函数等同于 `approve`，可用于
5     * 例如，为某些子系统设置自动授权额度等。
6     *
7     * 触发一个 {Approval} 事件。
8     *
9     * 要求：
10     *
11     * - `owner` 不能是零地址。
12     * - `spender` 不能是零地址。
13     */
14    function _approve(address owner, address spender, uint256 amount) internal virtual {
15        require(owner != address(0), "ERC20: approve from the zero address");
16        require(spender != address(0), "ERC20: approve to the zero address");
17
18        _allowances[owner][spender] = amount;
显示全部
复制

1        emit Approval(owner, spender, amount);
2    }
3
复制

1
2
3    /**
4     * @dev 将 {decimals} 设置为不同于默认值 18 的值。
5     *
6     * 警告：此函数应仅从构造函数中调用。大多数
7     * 与代币合约交互的应用程序不希望
8     * {decimals} 发生变化，如果发生变化可能会导致工作不正常。
9     */
10    function _setupDecimals(uint8 decimals_) internal {
11        _decimals = decimals_;
12    }
显示全部
复制

1
2    /**
3     * @dev 在任何代币转移之前调用的钩子函数。这包括
4     * 铸造和销毁。
5     *
6     * 调用条件：
7     *
8     * - 当 `from` 和 `to` 都非零时，`amount` 数量的 ``from`` 代币
9     * 将被转移到 `to`。
10     * - 当 `from` 为零时，将为 `to` 铸造 `amount` 数量的代币。
11     * - 当 `to` 为零时，将销毁 `amount` 数量的 ``from`` 代币。
12     * - `from` 和 `to` 永远不会都为零。
13     *
14     * 要了解有关钩子函数的更多信息，请转到 xref:ROOT:extending-contracts.adoc#using-hooks[使用钩子函数]。
15     */
16    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
17}
显示全部
复制