EtherChain智能合约源码分析、Solidity学习

recoverbtc

  EtherChain 核心数据结构体

    struct User {    //会员结构体
        uint256 cycle;  //投资循环次数
        address upline;  //推荐地址
        uint256 referrals;  //直推人数
        uint256 payouts; //已产生收益	
        uint256 direct_bonus;  //直推收益
        uint256 pool_bonus;  //奖池收益
        uint256 match_bonus;  //匹配收益
        uint256 deposit_amount;  //充值数量
        uint256 deposit_payouts;   //充值收益
        uint40 deposit_time;   //充值时间
        uint256 total_deposits;  //累计充值
        uint256 total_payouts;  //累计产生收益
        uint256 total_structure;  //累计产生收益
    }

    mapping(address => User) public users;  地址用户结构体映射

    uint256[] public cycles;                        // ether  循环投资最大投资数量
    uint8[] public ref_bonuses;                     // 1 => 1% // 匹配奖励，等级对应比例

    uint8[] public pool_bonuses;                    // 1 => 1%   //奖池奖励，等级对应比例
    uint40 public pool_last_draw = uint40(block.timestamp);  //最后提现时间
    uint256 public pool_cycle;  //池当前轮
    uint256 public pool_balance;  //池余额   
    mapping(uint256 => mapping(address => uint256)) public pool_users_refs_deposits_sum;      //用户投资数量
    mapping(uint8 => address) public pool_top;    //当前投资最多地址

    uint256 public total_withdraw;
    
    event Upline(address indexed addr, address indexed upline);   //推荐人事件
    event NewDeposit(address indexed addr, uint256 amount);   //充值事件
    event DirectPayout(address indexed addr, address indexed from, uint256 amount);   //直推事件
    event MatchPayout(address indexed addr, address indexed from, uint256 amount);  //匹配事件
    event PoolPayout(address indexed addr, uint256 amount);   //池支付事件
    event Withdraw(address indexed addr, uint256 amount);   //提现事件
    event LimitReached(address indexed addr, uint256 amount);   //到达收益极限事件

recoverbtc

   //充值加入游戏
   function deposit(address _upline) payable external whenNotPaused {
        _setUpline(msg.sender, _upline);  //设置上线
        _deposit(msg.sender, msg.value);  //充值
    }

   //设置上线 、设置团队人数
  function _setUpline(address _addr, address _upline) private {
        if(users[_addr].upline == address(0) && _upline != _addr && (users[_upline].deposit_time > 0 || _upline == owner())) {
            users[_addr].upline = _upline;   //设置上线
            users[_upline].referrals++;    //设置直推人数 +1

            emit Upline(_addr, _upline);

            for(uint8 i = 0; i < ref_bonuses.length; i++) {
                if(_upline == address(0)) break;

                users[_upline].total_structure++;   //设置团队人数 +1

                _upline = users[_upline].upline;
            }
        }
    }

    //充值
    function _deposit(address _addr, uint256 _amount) private {
        require(users[_addr].upline != address(0) || _addr == owner(), "No upline");   //推荐地址不能为空或推荐人是合约所有者

        if(users[_addr].deposit_time > 0) {   //最近一轮充值时间
            users[_addr].cycle++;      //循环次数
            
            require(users[_addr].payouts >= this.maxPayoutOf(users[_addr].deposit_amount), "Deposit already exists");  //提现收益数量大于本轮最大可获取收益
            require(_amount >= users[_addr].deposit_amount && _amount <= cycles[users[_addr].cycle > cycles.length - 1 ? cycles.length - 1 : users[_addr].cycle], "Bad amount");   //投资数量要大于上轮同时要少于本轮最大可投数量
        }
        else require(_amount >= 0.1 ether && _amount <= cycles[0], "Bad amount");   //投资数量不有少于 0.1 ether 或大于本轮最大可投数量
        
        users[_addr].payouts = 0;
        users[_addr].deposit_amount = _amount;  //充值数量
        users[_addr].deposit_payouts = 0;
        users[_addr].deposit_time = uint40(block.timestamp);   //充值时间
        users[_addr].total_deposits += _amount;   //累计投资
         
        emit NewDeposit(_addr, _amount);

        if(users[_addr].upline != address(0)) {   //如果上线不是空
            users[users[_addr].upline].direct_bonus += _amount / 10;    //直推10%

            emit DirectPayout(users[_addr].upline, _addr, _amount / 10); 
        }

        _pollDeposits(_addr, _amount);

        if(pool_last_draw + 1 days < block.timestamp) {   //奖励池
            _drawPool();
        }

        payable(owner()).transfer(_amount / 100);  //合约开发者1%收益
    }

recoverbtc


     //奖励池
    function _pollDeposits(address _addr, uint256 _amount) private {
        pool_balance += _amount / 20;    //充值金额的5%

        address upline = users[_addr].upline;    //获取上线

        if(upline == address(0)) return;   //如果没有上线
        
        pool_users_refs_deposits_sum[pool_cycle][upline] += _amount;   //本轮上线直推充值数量

        for(uint8 i = 0; i < pool_bonuses.length; i++) {   //直推充值数量最多是4个人
            if(pool_top[i] == upline) break;  // 如果等于推荐人退出

            if(pool_top[i] == address(0)) {    //如果直推4个人没有填满设置成推荐人
                pool_top[i] = upline;
                break;
            }

            if(pool_users_refs_deposits_sum[pool_cycle][upline] > pool_users_refs_deposits_sum[pool_cycle][pool_top[i]]) {  //如果本轮推荐人直推充值数量是否大于当前充值最多的4个会员
                for(uint8 j = i + 1; j < pool_bonuses.length; j++) {
                    if(pool_top[j] == upline) {
                        for(uint8 k = j; k <= pool_bonuses.length; k++) {
                            pool_top[k] = pool_top[k + 1];
                        }
                        break;
                    }
                }

                for(uint8 j = uint8(pool_bonuses.length - 1); j > i; j--) {
                    pool_top[j] = pool_top[j - 1];
                }

                pool_top[i] = upline;

                break;
            }
        }
    }

recoverbtc

  //匹配奖励发放
 function _refPayout(address _addr, uint256 _amount) private {
        address up = users[_addr].upline;   //直推

        for(uint8 i = 0; i < ref_bonuses.length; i++) {
            if(up == address(0)) break;  //如果没有直推退出
            
            if(users[up].referrals >= i + 1) {   //判断直推人数是否能熟悉等级奖励
                uint256 bonus = _amount * ref_bonuses[i] / 100;  //计算资金 
                
                users[up].match_bonus += bonus;   //累计匹配奖励

                emit MatchPayout(up, _addr, bonus);
            }

            up = users[up].upline;  //查找上一线
        }
    }

recoverbtc

//发放最佳推荐人奖励
     function _drawPool() private {
        pool_last_draw = uint40(block.timestamp);  //当前区块链时间
        pool_cycle++;    //轮数

        uint256 draw_amount = pool_balance / 10;    //奖励池的10%

        for(uint8 i = 0; i < pool_bonuses.length; i++) {     //奖励池
            if(pool_top[i] == address(0)) break;   //如果地址不存在

            uint256 win = draw_amount * pool_bonuses[i] / 100;   //奖励池的10%按比例分

            users[pool_top[i]].pool_bonus += win;   //累加奖励池数量
            pool_balance -= win;   //奖励数量减少

            emit PoolPayout(pool_top[i], win);
        }
        
        for(uint8 i = 0; i < pool_bonuses.length; i++) {
            pool_top[i] = address(0);   //清空最佳推荐人
        }
    }

recoverbtc

   //会员提现
   function withdraw() external whenNotPaused {
        (uint256 to_payout, uint256 max_payout) = this.payoutOf(msg.sender);    //投资可获取最大收益
        
        require(users[msg.sender].payouts < max_payout, "Full payouts");   //超过投资可获取最大收益

        // Deposit payout
        if(to_payout > 0) {   //当前可获取收益大于0  
            if(users[msg.sender].payouts + to_payout > max_payout) {  累计收益加当前可获取收益 大于最大可获收益
                to_payout = max_payout - users[msg.sender].payouts;  最大收益 - 已经获取收益 = 本次还可以领取收益
            }

            users[msg.sender].deposit_payouts += to_payout;    //充值收益
            users[msg.sender].payouts += to_payout;   //累计收益

            _refPayout(msg.sender, to_payout);   //发放匹配奖励
        }
        
        // Direct payout   //直推收益
        if(users[msg.sender].payouts < max_payout && users[msg.sender].direct_bonus > 0) {
            uint256 direct_bonus = users[msg.sender].direct_bonus;

            if(users[msg.sender].payouts + direct_bonus > max_payout) {
                direct_bonus = max_payout - users[msg.sender].payouts;
            }

            users[msg.sender].direct_bonus -= direct_bonus;
            users[msg.sender].payouts += direct_bonus;
            to_payout += direct_bonus;
        }
        
        // Pool payout   //最佳推荐人
        if(users[msg.sender].payouts < max_payout && users[msg.sender].pool_bonus > 0) {
            uint256 pool_bonus = users[msg.sender].pool_bonus;

            if(users[msg.sender].payouts + pool_bonus > max_payout) {
                pool_bonus = max_payout - users[msg.sender].payouts;
            }

            users[msg.sender].pool_bonus -= pool_bonus;
            users[msg.sender].payouts += pool_bonus;
            to_payout += pool_bonus;
        }

        // Match payout   //匹配奖励
        if(users[msg.sender].payouts < max_payout && users[msg.sender].match_bonus > 0) {
            uint256 match_bonus = users[msg.sender].match_bonus;

            if(users[msg.sender].payouts + match_bonus > max_payout) {
                match_bonus = max_payout - users[msg.sender].payouts;
            }

            users[msg.sender].match_bonus -= match_bonus;
            users[msg.sender].payouts += match_bonus;
            to_payout += match_bonus;
        }

        require(to_payout > 0, "Zero payout");
        
        users[msg.sender].total_payouts += to_payout;  //累计提现 
        total_withdraw += to_payout;   //系统累计提现

        payable(msg.sender).transfer(to_payout);   //转帐

        emit Withdraw(msg.sender, to_payout); 

        if(users[msg.sender].payouts >= max_payout) {   //超过可获取最大收益
            emit LimitReached(msg.sender, users[msg.sender].payouts);
        }
    }