ERC20合约标准详解分析

缺乏、安全感 2023-02-20 07:40 18阅读 0赞

contract ERC20 \{  
//\*\*\*\*\*\*\*\*\*\*9个函数\*\*\*\*\*\*\*  
//1.代币的名字  
function name() constant public returns (string name);  
//2.代币的简称，例如：HMB  
function symbol() public constant returns (string symbol);  
//3.代币的最小分割量 token使用的小数点后几位。比如如果设置为3，就是支持0.001表示  
function decimals() public constant returns (uint8 decimals);  
//4.token的总量  
function totalSupply() public constant returns (uint totalSupply);  
//5.余额 返回某个地址(账户)的账户余额  
function balanceOf(address \_owner) public constant returns (uint balance);  
/\*6.转账 交易代币 从消息发送者账户中往\_to账户转数量为\_value的token，  
从代币合约的调用者地址上转移 \_value的数量token到的地址 \_to  
【注意：并且必须触发Transfer事件】\*/  
function transfer(address \_to, uint \_value) public returns (bool success);  
/\*7.两个地址转账  
从账户\_from中往账户\_to转数量为\_value的token，与approve方法配合使用  
从地址 \_from发送数量为 \_value的token到地址 \_to  
【注意：并且必须触发Transfer事件】  
transferFrom方法用于允许合约代理某人转移token。条件是from账户必须经过了approve。\*/  
function transferFrom(address \_from, address \_to, uint \_value) public returns (bool success);  
//8.批准\_spender能从合约调用账户中转出数量为\_value的token  
function approve(address \_spender, uint \_value) public returns (bool success);  
//9.获取\_spender可以从账户\_owner中转出token的剩余数量  
function allowance(address \_owner, address \_spender) public constant returns (uint remaining);  
//\*\*\*\*\*\*\*\*\*\*2个事件\*\*\*\*\*\*\*  
//1.发生转账时必须要触发的事件,transfer 和 transferFrom 成功执行时必须触发的事件  
event Transfer(address indexed \_from, address indexed \_to, uint \_value);  
//2.当函数 approve(address \_spender, uint256 \_value)成功执行时必须触发的事件  
event Approval(address indexed \_owner, address indexed \_spender, uint \_value);  
//10.存储(映射)对账号的控制:mapping(owner => mapping(spender => amount)) allowed  
第一个address表示token拥有者  
第二个address表示授权的spender，即spender代理消费owner的token  
第三个amout表示代理的数量  
这是一个map的嵌套使用

// 此合约实现不记得是哪看到后复制保存的......和官网案例类似
    pragma solidity ^0.4.25;
    
    interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
    
    contract TokenERC20 {
        string public name; // ERC20标准
        string public symbol; // ERC20标准
        uint8 public decimals = 2;  // ERC20标准，decimals 可以有的小数点个数，最小的代币单位。18 是建议的默认值
        uint256 public totalSupply; // ERC20标准 总供应量
    
        // 用mapping保存每个地址对应的余额 ERC20标准
        mapping (address => uint256) public balanceOf;
        // 存储对账号的控制 ERC20标准
        mapping (address => mapping (address => uint256)) public allowance;
    
        // 事件，用来通知客户端交易发生 ERC20标准
        event Transfer(address indexed from, address indexed to, uint256 value);
    
        // 事件，用来通知客户端代币被消费 ERC20标准
        event Burn(address indexed from, uint256 value);
    
        /**
         * 初始化构造
         */
        function TokenERC20(uint256 initialSupply, string tokenName, string tokenSymbol) public {
            totalSupply = initialSupply * 10 ** uint256(decimals);  // 供应的份额，份额跟最小的代币单位有关，份额 = 币数 * 10 ** decimals。
            balanceOf[msg.sender] = totalSupply;                // 创建者拥有所有的代币
            name = tokenName;                                   // 代币名称
            symbol = tokenSymbol;                               // 代币符号
        }
    
        /**
         * 代币交易转移的内部实现
         */
        function _transfer(address _from, address _to, uint _value) internal {
            // 确保目标地址不为0x0，因为0x0地址代表销毁
            require(_to != 0x0);
            // 检查发送者余额
            require(balanceOf[_from] >= _value);
            // 确保转移为正数个
            require(balanceOf[_to] + _value > balanceOf[_to]);
    
            // 以下用来检查交易，
            uint previousBalances = balanceOf[_from] + balanceOf[_to];
            // Subtract from the sender
            balanceOf[_from] -= _value;
            // Add the same to the recipient
            balanceOf[_to] += _value;
            Transfer(_from, _to, _value);
    
            // 用assert来检查代码逻辑。
            assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
        }
    
        /**
         *  代币交易转移
         *  从自己（创建交易者）账号发送`_value`个代币到 `_to`账号
         * ERC20标准
         * @param _to 接收者地址
         * @param _value 转移数额
         */
        function transfer(address _to, uint256 _value) public {
            _transfer(msg.sender, _to, _value);
        }
    
        /**
         * 账号之间代币交易转移
         * ERC20标准
         * @param _from 发送者地址
         * @param _to 接收者地址
         * @param _value 转移数额
         */
        function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
            require(_value <= allowance[_from][msg.sender]);     // Check allowance
            allowance[_from][msg.sender] -= _value;
            _transfer(_from, _to, _value);
            return true;
        }
    
        /**
         * 设置某个地址（合约）可以创建交易者名义花费的代币数。
         *
         * 允许发送者`_spender` 花费不多于 `_value` 个代币
         * ERC20标准
         * @param _spender The address authorized to spend
         * @param _value the max amount they can spend
         */
        function approve(address _spender, uint256 _value) public
        returns (bool success) {
            allowance[msg.sender][_spender] = _value;
            return true;
        }
    
        /**
         * 设置允许一个地址（合约）以我（创建交易者）的名义可最多花费的代币数。
         *-非ERC20标准
         * @param _spender 被授权的地址（合约）
         * @param _value 最大可花费代币数
         * @param _extraData 发送给合约的附加数据
         */
        function approveAndCall(address _spender, uint256 _value, bytes _extraData)
        public
        returns (bool success) {
            tokenRecipient spender = tokenRecipient(_spender);
            if (approve(_spender, _value)) {
                // 通知合约
                spender.receiveApproval(msg.sender, _value, this, _extraData);
                return true;
            }
        }
    
        /**
         * 销毁我（创建交易者）账户中指定个代币
         *-非ERC20标准
         */
        function burn(uint256 _value) public returns (bool success) {
            require(balanceOf[msg.sender] >= _value);   // Check if the sender has enough
            balanceOf[msg.sender] -= _value;            // Subtract from the sender
            totalSupply -= _value;                      // Updates totalSupply
            Burn(msg.sender, _value);
            return true;
        }
    
        /**
         * 销毁用户账户中指定个代币
         *-非ERC20标准
         * Remove `_value` tokens from the system irreversibly on behalf of `_from`.
         *
         * @param _from the address of the sender
         * @param _value the amount of money to burn
         */
        function burnFrom(address _from, uint256 _value) public returns (bool success) {
            require(balanceOf[_from] >= _value);                // Check if the targeted balance is enough
            require(_value <= allowance[_from][msg.sender]);    // Check allowance
            balanceOf[_from] -= _value;                         // Subtract from the targeted balance
            allowance[_from][msg.sender] -= _value;             // Subtract from the sender's allowance
            totalSupply -= _value;                              // Update totalSupply
            Burn(_from, _value);
            return true;
        }
    }