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 {transferFrom}を通じて`spender`が`owner`に代わって使用できる、残りのトークン数を返します。これは
3     * デフォルトではゼロです。
4     *
5     * この値は、{approve}または{transferFrom}が呼び出されると変化します。
6     */
7    function allowance(address owner, address spender) external view returns (uint256);
コピー

1    /**
2     * @dev `spender`が呼び出し元のトークンに対して持つ割当量を`amount`に設定します。
3     *
4     * 操作が成功したかを示すブール値を返します。
5     *
6     * 重要: このメソッドで割当量を変更すると、不運なトランザクションの順序によって、誰かが古い割当量と新しい割当量の両方を使用するリスクがあります。
7     * この競合状態を緩和するための一つの解決策は、まずspenderの割当量を0に減らしてから、目的の値を設定することです。
8     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
9     *
10     * {Approval}イベントを発行します。
11     */
12    function approve(address spender, uint256 amount) external returns (bool);
すべて表示
コピー

1    /**
2     * @dev 割当メカニズムを使用して、`amount`のトークンを`sender`から`recipient`に移動させます。`amount`は呼び出し元の割当量から差し引かれます。
3     *
4     * 操作が成功したかを示すブール値を返します。
5     *
6     * {Transfer}イベントを発行します。
7     */
8    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 {approve}の呼び出しによって`owner`に対する`spender`の割当量が設定されたときに発行されます。`value`は新しい割当量です。
12     */
13    event Approval(address indexed owner, address indexed spender, uint256 value);
14}
すべて表示
コピー

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 * OpenZeppelinの一般的なガイドラインに従っています。関数は失敗時に`false`を返すのではなく、リバートします。この動作は慣例的であり、ERC20アプリケーションの期待と矛盾しません。
12 *
13 * さらに、{transferFrom}の呼び出し時に{Approval}イベントが発行されます。
14 * これにより、アプリケーションは、これらのイベントをリッスンするだけで、すべてのアカウントの割当量を再構築できます。EIPの他の実装では、
15 * 仕様で要求されていないため、これらのイベントを発行しない場合があります。
16 *
17 * 最後に、割当量設定に関する既知の問題を緩和するために、非標準の{decreaseAllowance}および{increaseAllowance}関数が追加されています。
18 * {IERC20-approve}を参照してください。
19 */
20
すべて表示
コピー

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}の値を設定し、{decimals}を
3     * デフォルト値の18で初期化します。
4     *
5     * {decimals}に別の値を選択するには、{_setupDecimals}を使用します。
6     *
7     * これら3つの値はすべて不変です。構築時に一度しか設定できません。
8     */
9    constructor (string memory name_, string memory symbol_) public {
10        // Solidity ≥0.7.0では、'public'は暗黙的であり、省略できます。
11
12        _name = name_;
13        _symbol = symbol_;
14        _decimals = 18;
15    }
すべて表示
コピー

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     * トークンは通常、etherとweiの関係を模倣して、値18を選択します。これは、{_setupDecimals}が呼び出されない限り、{ERC20}が使用する値です。
22     *
23     * 注: この情報は_表示_目的でのみ使用されます。これは
24     * {IERC20-balanceOf}や{IERC20-transfer}を含む、コントラクトのどの算術にも
25     * 影響を与えません。
26     */
27    function decimals() public view returns (uint8) {
28        return _decimals;
29    }
すべて表示
コピー

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}イベントを発行します。これは
5     * EIPでは要求されていません。{ERC20}の冒頭の注記を参照してください。
6     *
7     * 要件:
8     *
9     * - `sender`と`recipient`はゼロアドレスであってはなりません。
10     * - `sender`は少なくとも`amount`の残高を持っている必要があります。
11     * - 呼び出し元は、`sender`のトークンに対して少なくとも
12     * `amount`の割当量を持っている必要があります。
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}の代替手段であり、{IERC20-approve}で説明されている問題を緩和するために使用できます。
5     *
6     * 更新された割当量を示す{Approval}イベントを発行します。
7     *
8     * 要件:
9     *
10     * - `spender`はゼロアドレスであってはなりません。
11     */
12    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
13        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
14        return true;
15    }
すべて表示
コピー

1
2    /**
3     * @dev 呼び出し元によって付与された`spender`への割当量をアトミックに減少させます。
4     *
5     * これは{approve}の代替手段であり、{IERC20-approve}で説明されている問題を緩和するために使用できます。
6     *
7     * 更新された割当量を示す{Approval}イベントを発行します。
8     *
9     * 要件:
10     *
11     * - `spender`はゼロアドレスであってはなりません。
12     * - `spender`は呼び出し元に対して、少なくとも
13     * `subtractedValue`の割当量を持っている必要があります。
14     */
15    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
16        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue,
17                "ERC20: decreased allowance below zero"));
18        return true;
19    }
すべて表示
コピー

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     * `from`がゼロアドレスに設定された{Transfer}イベントを発行します。
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     * `to`がゼロアドレスに設定された{Transfer}イベントを発行します。
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 `owner`のトークンに対する`spender`の割当量を`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`が両方ともゼロでない場合、`from`のトークンの`amount`が
9     * `to`に転送されます。
10     * - `from`がゼロの場合、`amount`のトークンが`to`のためにミントされます。
11     * - `to`がゼロの場合、`from`のトークンの`amount`がバーンされます。
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}
すべて表示
コピー