标签：sender uint256 代币 value assert 源码 msg BNB balanceOf

    contract SafeMath {
        
        // 乘法（internal修饰的函数只能够在当前合约或子合约中使用）
        function safeMul(uint256 a, uint256 b) internal pure returns (uint256) { 
            uint256 c = a * b;
            assert(a == 0 || c / a == b);
            return c;
        }
      
        // 除法
        function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
            assert(b > 0);
            uint256 c = a / b;
            assert(a == b * c + a % b);
            return c;
        }
     
        // 减法
        function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
            assert(b <= a);
            assert(b >=0);
            return a - b;
        }
     
        // 加法
        function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
            uint256 c = a + b;
            assert(c>=a && c>=b);
            return c;
        }
    }
     
    contract ZhongB is SafeMath{
        // 代币的名字
        string public name; 
        // 代币的符号
        string public symbol;
        // 代币支持的小数位
        uint8 public decimals;
        // 代表发行的总量
        uint256 public totalSupply;
        // 管理者
        address public owner;
     
        // 该mapping保存账户余额，Key表示账户地址，Value表示token个数
        mapping (address => uint256) public balanceOf;
        // 该mappin保存指定帐号被授权的token个数
        // key1表示授权人，key2表示被授权人，value2表示被授权token的个数
        mapping (address => mapping (address => uint256)) public allowance;
        // 冻结指定帐号token的个数
        mapping (address => uint256) public freezeOf;
     
        // 定义事件
        event Transfer(address indexed from, address indexed to, uint256 value);
        event Burn(address indexed from, uint256 value);
        event Freeze(address indexed from, uint256 value);
        event Unfreeze(address indexed from, uint256 value);
     
        // 构造函数（1000000, "ZhongB", 18, "ZB"）
        constructor( 
            uint256 initialSupply,  // 发行数量
            string tokenName,       // token的名字 BinanceToken
            uint8 decimalUnits,     // 最小分割，小数点后面的尾数 1ether = 10** 18wei
            string tokenSymbol      // ZB
        ) public {
            decimals = decimalUnits;                           
            balanceOf[msg.sender] = initialSupply * 10 ** 18;    
            totalSupply = initialSupply * 10 ** 18;   
            name = tokenName;      
            symbol = tokenSymbol;
            owner = msg.sender;
        }
     
        // 转账：某个人花费自己的币
        function transfer(address _to, uint256 _value) public {
            // 防止_to无效
            assert(_to != 0x0);
            // 防止_value无效                       
            assert(_value > 0);
            // 防止转账人的余额不足
            assert(balanceOf[msg.sender] >= _value);
            // 防止数据溢出
            assert(balanceOf[_to] + _value >= balanceOf[_to]);
            // 从转账人的账户中减去一定的token的个数
            balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);                     
            // 往接收帐号增加一定的token个数
            balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value); 
            // 转账成功后触发Transfer事件，通知其他人有转账交易发生
            emit Transfer(msg.sender, _to, _value);// Notify anyone listening that this transfer took place
        }
     
        // 授权：授权某人花费自己账户中一定数量的token
        function approve(address _spender, uint256 _value) public returns (bool success) {
            assert(_value > 0);
            allowance[msg.sender][_spender] = _value;
            return true;
        }
     
     
        // 授权转账：被授权人从_from帐号中给_to帐号转了_value个token
        function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
            // 防止地址无效
            assert(_to != 0x0);
            // 防止转账金额无效
            assert(_value > 0);
            // 检查授权人账户的余额是否足够
            assert(balanceOf[_from] >= _value);
            // 检查数据是否溢出
            assert(balanceOf[_to] + _value >= balanceOf[_to]);
            // 检查被授权人在allowance中可以使用的token数量是否足够
            assert(_value <= allowance[_from][msg.sender]);
            // 从授权人帐号中减去一定数量的token
            balanceOf[_from] = SafeMath.safeSub(balanceOf[_from], _value); 
            // 往接收人帐号中增加一定数量的token
            balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value); 
            // 从allowance中减去被授权人可使用token的数量
            allowance[_from][msg.sender] = SafeMath.safeSub(allowance[_from][msg.sender], _value);
            // 交易成功后触发Transfer事件，并返回true
            emit Transfer(_from, _to, _value);
            return true;
        }
     
        // 消币
        function burn(uint256 _value) public returns (bool success) {
            // 检查当前帐号余额是否足够
            assert(balanceOf[msg.sender] >= _value);
            // 检查_value是否有效
            assert(_value > 0);
            // 从sender账户中中减去一定数量的token
            balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);
            // 更新发行币的总量
            totalSupply = SafeMath.safeSub(totalSupply,_value);
            // 消币成功后触发Burn事件，并返回true
            emit Burn(msg.sender, _value);
            return true;
        }
     
        // 冻结
        function freeze(uint256 _value) public returns (bool success) {
            // 检查sender账户余额是否足够
            assert(balanceOf[msg.sender] >= _value);
            // 检查_value是否有效
            assert(_value > 0);
            // 从sender账户中减去一定数量的token
            balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value); 
            // 往freezeOf中给sender账户增加指定数量的token
            freezeOf[msg.sender] = SafeMath.safeAdd(freezeOf[msg.sender], _value); 
            // freeze成功后触发Freeze事件，并返回true
            emit Freeze(msg.sender, _value);
            return true;
        }
     
        // 解冻
        function unfreeze(uint256 _value) public returns (bool success) {
            // 检查解冻金额是否有效
            assert(freezeOf[msg.sender] >= _value);
            // 检查_value是否有效
            assert(_value > 0); 
            // 从freezeOf中减去指定sender账户一定数量的token
            freezeOf[msg.sender] = SafeMath.safeSub(freezeOf[msg.sender], _value); 
            // 向sender账户中增加一定数量的token
            balanceOf[msg.sender] = SafeMath.safeAdd(balanceOf[msg.sender], _value);    
            // 解冻成功后触发事件
            emit Unfreeze(msg.sender, _value);
            return true;
        }
     
        // 管理者自己取钱
        function withdrawEther(uint256 amount) public {
            // 检查sender是否是当前合约的管理者
            assert(msg.sender == owner);
            // sender给owner发送token
            owner.transfer(amount);
        }
    }

标签：sender,uint256,代币,value,assert,源码,msg,BNB,balanceOf
来源： https://www.cnblogs.com/sdgfsdgfsd/p/15588580.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。