Explorer by Anyblock Analytics

0x5370645B7af206e866bB021925Db56f7ad4B286c

Address

Address Details

Transactions	3980
Logs	5178

Name	MutualAlliance
Compiler	v0.5.0+commit.1d4f565a

Contract ABI

[{"constant":false,"inputs":[],"name":"reInvestIn","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[],"name":"getGameInfo","outputs":[{"name":"","type":"uint256"},{"name":"","type":"uint256"},{"name":"","type":"uint256"},{"name":"","type":"uint256"},{"name":"","type":"uint256"},{"name":"","type":"uint256"},{"name":"","type":"uint256"},{"name":"","type":"uint256"},{"name":"","type":"uint256"},{"name":"","type":"uint256"},{"name":"","type":"uint256"},{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"investTime","type":"uint256"}],"name":"getUnLockDay","outputs":[{"name":"unlockDay","type":"uint256"},{"name":"unlockAmountRedeemTime","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"everyDayInvestMapping","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"inviteCode","type":"string"},{"name":"referrer","type":"string"},{"name":"flag","type":"uint256"}],"name":"investIn","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[{"name":"investTime","type":"uint256"}],"name":"getCurrentInvestLimit","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"gameStart","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"investTime","type":"uint256"}],"name":"getCurrentInvestDay","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"userAddr","type":"address"}],"name":"getAvailableReInvestInAmount","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"notSuspended","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceWhitelistAdmin","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"userAddr","type":"address"}],"name":"getStaticProfits","outputs":[{"name":"","type":"uint256"},{"name":"","type":"uint256"},{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"userAddr","type":"address"}],"name":"getAvailableRedeemAmount","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"code","type":"string"}],"name":"isUsed","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"account","type":"address"}],"name":"removeWhitelistAdmin","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"time","type":"uint256"},{"name":"_baseTime","type":"uint256"}],"name":"activeGame","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"id","type":"uint256"}],"name":"getUserById","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"account","type":"address"}],"name":"addWhitelistAdmin","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"user","type":"address"},{"name":"roundId","type":"uint256"}],"name":"getUserInfo","outputs":[{"name":"ct","type":"uint256[19]"},{"name":"inviteCode","type":"string"},{"name":"referrer","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"amount","type":"uint256"}],"name":"getInvestTime","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"isOwner","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"withdrawProfit","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"code","type":"string"}],"name":"getUserAddressByCode","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"user","type":"address"}],"name":"calDynamicProfits","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"stopTime","type":"uint256"},{"name":"stopDays","type":"uint256"}],"name":"suspended","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"user","type":"address"},{"name":"inviteCode","type":"string"},{"name":"referrer","type":"string"}],"name":"registerUserInfo","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"indexMapping","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"amount","type":"uint256"},{"name":"investTime","type":"uint256"}],"name":"isLessThanLimit","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"account","type":"address"}],"name":"isWhitelistAdmin","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"investTime","type":"uint256"}],"name":"notSuspended","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"redeem","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"coeff","type":"uint256"},{"name":"_baseLimit","type":"uint256"}],"name":"setCoefficient","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"name":"who","type":"address"},{"indexed":true,"name":"uid","type":"uint256"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"time","type":"uint256"},{"indexed":false,"name":"investTime","type":"uint256"},{"indexed":false,"name":"inviteCode","type":"string"},{"indexed":false,"name":"referrer","type":"string"},{"indexed":false,"name":"t","type":"uint256"}],"name":"LogInvestIn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"who","type":"address"},{"indexed":true,"name":"uid","type":"uint256"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"time","type":"uint256"},{"indexed":false,"name":"t","type":"uint256"}],"name":"LogWithdrawProfit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"who","type":"address"},{"indexed":true,"name":"uid","type":"uint256"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"now","type":"uint256"}],"name":"LogRedeem","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"account","type":"address"}],"name":"WhitelistAdminAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"account","type":"address"}],"name":"WhitelistAdminRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"previousOwner","type":"address"},{"indexed":true,"name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"}]

Contract Sourcecode

pragma solidity ^0.5.0;

contract UtilMutualAlliance{
    uint ethWei = 1 ether;

    function getLevel(uint value) internal view returns (uint) {
        if (value >= 1 * ethWei && value <= 5 * ethWei) {
            return 1;
        }
        if (value >= 6 * ethWei && value <= 14 * ethWei) {
            return 2;
        }
        if (value >= 15 * ethWei && value <= 20 * ethWei) {
            return 3;
        }
        return 0;
    }

    function getLineLevel(uint value) internal view returns (uint) {
        if (value >= 1 * ethWei && value <= 5 * ethWei) {
            return 1;
        }
        if (value >= 6 * ethWei && value <= 14 * ethWei) {
            return 2;
        }
        if (value >= 15 * ethWei) {
            return 3;
        }
        return 0;
    }

    function getSepScByLevel(uint level) internal pure returns(uint) {
        if (level == 1) {
            return 65;
        }
        if (level == 2) {
            return 85;
        }
        if (level == 3) {
            return 120;
        }

        return 0;
    }

    function getScByLevel(uint level, uint reInvestCount) internal pure returns (uint) {
        if (level == 1) {
            if (reInvestCount == 0) {
                return 20;
            }
            if (reInvestCount == 1) {
                return 25;
            }
            if (reInvestCount == 2) {
                return 30;
            }
            if (reInvestCount == 3) {
                return 35;
            }
            if (reInvestCount >= 4) {
                return 50;
            }
        }
        if (level == 2) {
            if (reInvestCount == 0) {
                return 30;
            }
            if (reInvestCount == 1) {
                return 40;
            }
            if (reInvestCount == 2) {
                return 50;
            }
            if (reInvestCount == 3) {
                return 60;
            }
            if (reInvestCount >= 4) {
                return 70;
            }
        }
        if (level == 3) {
            if (reInvestCount == 0) {
                return 60;
            }
            if (reInvestCount == 1) {
                return 70;
            }
            if (reInvestCount == 2) {
                return 80;
            }
            if (reInvestCount == 3) {
                return 90;
            }
            if (reInvestCount >= 4) {
                return 100;
            }
        }
        return 0;
    }

    function getFireScByLevel(uint level) internal pure returns (uint) {
        if (level == 1) {
            return 3;
        }
        if (level == 2) {
            return 6;
        }
        if (level == 3) {
            return 10;
        }
        return 0;
    }

    function getDynamicFloor(uint level) internal pure returns (uint) {
        if (level == 1) {
            return 1;
        }
        if (level == 2) {
            return 2;
        }
        if (level == 3) {
            return 20;
        }

        return 0;
    }

    function getFloorIndex(uint floor) internal pure returns (uint) {
        if (floor == 1) {
            return 1;
        }
        if (floor == 2) {
            return 2;
        }
        if (floor == 3) {
            return 3;
        }
        if (floor >= 4 && floor <= 5) {
            return 4;
        }
        if (floor >= 6 && floor <= 10) {
            return 5;
        }
        if (floor >= 11) {
            return 6;
        }

        return 0;
    }

    function getRecommendScaleByLevelAndTim(uint level, uint floorIndex) internal pure returns (uint){
        if (level == 1 && floorIndex == 1) {
            return 20;
        }
        if (level == 2) {
            if (floorIndex == 1) {
                return 30;
            }
            if (floorIndex == 2) {
                return 20;
            }
        }
        if (level == 3) {
            if (floorIndex == 1) {
                return 50;
            }
            if (floorIndex == 2) {
                return 30;
            }
            if (floorIndex == 3) {
                return 20;
            }
            if (floorIndex == 4) {
                return 10;
            }
            if (floorIndex == 5) {
                return 5;
            }
            if (floorIndex >= 6) {
                return 2;
            }
        }
        return 0;
    }

    function isEmpty(string memory str) internal pure returns (bool) {
        if (bytes(str).length == 0) {
            return true;
        }

        return false;
    }
}

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
contract Context {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.
    constructor() internal {}
    // solhint-disable-previous-line no-empty-blocks

    function _msgSender() internal view returns (address) {
        return msg.sender;
    }

    function _msgData() internal view returns (bytes memory) {
        this;
        // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        _owner = _msgSender();
        emit OwnershipTransferred(address(0), _owner);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(isOwner(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Returns true if the caller is the current owner.
     */
    function isOwner() public view returns (bool) {
        return _msgSender() == _owner;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     */
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

/**
 * @title Roles
 * @dev Library for managing addresses assigned to a Role.
 */
library Roles {
    struct Role {
        mapping(address => bool) bearer;
    }

    /**
     * @dev Give an account access to this role.
     */
    function add(Role storage role, address account) internal {
        require(!has(role, account), "Roles: account already has role");
        role.bearer[account] = true;
    }

    /**
     * @dev Remove an account's access to this role.
     */
    function remove(Role storage role, address account) internal {
        require(has(role, account), "Roles: account does not have role");
        role.bearer[account] = false;
    }

    /**
     * @dev Check if an account has this role.
     * @return bool
     */
    function has(Role storage role, address account) internal view returns (bool) {
        require(account != address(0), "Roles: account is the zero address");
        return role.bearer[account];
    }
}

/**
 * @title WhitelistAdminRole
 * @dev WhitelistAdmins are responsible for assigning and removing Whitelisted accounts.
 */
contract WhitelistAdminRole is Context, Ownable {
    using Roles for Roles.Role;

    event WhitelistAdminAdded(address indexed account);
    event WhitelistAdminRemoved(address indexed account);

    Roles.Role private _whitelistAdmins;

    constructor () internal {
        _addWhitelistAdmin(_msgSender());
    }

    modifier onlyWhitelistAdmin() {
        require(isWhitelistAdmin(_msgSender()) || isOwner(), "WhitelistAdminRole: caller does not have the WhitelistAdmin role");
        _;
    }

    function isWhitelistAdmin(address account) public view returns (bool) {
        return _whitelistAdmins.has(account);
    }

    function addWhitelistAdmin(address account) public onlyWhitelistAdmin {
        _addWhitelistAdmin(account);
    }

    function removeWhitelistAdmin(address account) public onlyOwner {
        _whitelistAdmins.remove(account);
        emit WhitelistAdminRemoved(account);
    }

    function renounceWhitelistAdmin() public {
        _removeWhitelistAdmin(_msgSender());
    }

    function _addWhitelistAdmin(address account) internal {
        _whitelistAdmins.add(account);
        emit WhitelistAdminAdded(account);
    }

    function _removeWhitelistAdmin(address account) internal {
        _whitelistAdmins.remove(account);
        emit WhitelistAdminRemoved(account);
    }
}

contract MutualAlliance is UtilMutualAlliance, WhitelistAdminRole {

    using SafeMath for *;

    string constant private name = "MutualAlliance Official";

    uint ethWei = 1 ether;

    address payable private devAddr = address(0x3fd4967d8C5079c2D37cbaac8014c1e9584Fe5Dd);

    address payable private loyal = address(0x0EF71a4b3b37dbAb581bEc482bcd0eE7429917A3);

    address payable private other = address(0x0040E7d9808e9D344158D7379E0b91b61B93CC9F);

    struct User {
        uint id;
        address userAddress;
        uint staticLevel;
        uint dynamicLevel;
        uint allInvest;
        uint freezeAmount;
        uint unlockAmount;
        uint unlockAmountRedeemTime;
        uint allStaticAmount;
        uint hisStaticAmount;
        uint dynamicWithdrawn;
        uint staticWithdrawn;
        Invest[] invests;
        uint staticFlag;

        mapping(uint => mapping(uint => uint)) dynamicProfits;
        uint reInvestCount;
        uint inviteAmount;
        uint solitaire;
        uint hisSolitaire;
    }

    struct UserGlobal {
        uint id;
        address userAddress;
        string inviteCode;
        string referrer;
    }

    struct Invest {
        address userAddress;
        uint investAmount;
        uint investTime;
        uint realityInvestTime;
        uint times;
        uint modeFlag;
        bool isSuspendedInvest;
    }

    uint coefficient = 10;
    uint startTime;
    uint baseTime;
    uint investCount = 0;
    mapping(uint => uint) rInvestCount;
    uint investMoney = 0;
    mapping(uint => uint) rInvestMoney;
    uint uid = 0;
    uint rid = 1;
    uint period = 3 days;
    uint suspendedTime = 0;
    uint suspendedDays = 0 days;
    uint lastInvestTime = 0;
    mapping(uint => mapping(address => User)) userRoundMapping;
    mapping(address => UserGlobal) userMapping;
    mapping(string => address) addressMapping;
    mapping(uint => address) public indexMapping;
    mapping(uint => uint) public everyDayInvestMapping;
    mapping(uint => uint[]) investAmountList;
    mapping(uint => uint) transformAmount;
    uint baseLimit = 300 * ethWei;

    /**
     * @dev Just a simply check to prevent contract
     * @dev this by calling method in constructor.
     */
    modifier isHuman() {
        address addr = msg.sender;
        uint codeLength;

        assembly {codeLength := extcodesize(addr)}
        require(codeLength == 0, "sorry humans only");
        require(tx.origin == msg.sender, "sorry, human only");
        _;
    }

    modifier isSuspended() {
        require(notSuspended(), "suspended");
        _;
    }

    event LogInvestIn(address indexed who, uint indexed uid, uint amount, uint time, uint investTime, string inviteCode, string referrer, uint t);
    event LogWithdrawProfit(address indexed who, uint indexed uid, uint amount, uint time, uint t);
    event LogRedeem(address indexed who, uint indexed uid, uint amount, uint now);

    constructor () public {
    }

    function() external payable {
    }

    function activeGame(uint time, uint _baseTime) external onlyWhitelistAdmin
    {
        require(time > now, "invalid game start time");
        startTime = time;

        if (baseTime == 0) {
            baseTime = _baseTime;
        }
    }

    function setCoefficient(uint coeff, uint _baseLimit) external onlyWhitelistAdmin
    {
        require(coeff > 0, "invalid coeff");
        coefficient = coeff;
        require(_baseLimit > 0, "invalue base limit");
        baseLimit = _baseLimit;
    }

    function gameStart() public view returns (bool) {
        return startTime != 0 && now > startTime;
    }

    function investIn(string memory inviteCode, string memory referrer, uint flag)
    public
    isHuman()
    payable
    {
        require(flag == 0 || flag == 1, "invalid flag");
        require(gameStart(), "game not start");
        require(msg.value >= 1 * ethWei && msg.value <= 20 * ethWei, "between 1 and 20");
        require(msg.value == msg.value.div(ethWei).mul(ethWei), "invalid msg value");
        uint investTime = getInvestTime(msg.value);
        uint investDay = getCurrentInvestDay(investTime);
        everyDayInvestMapping[investDay] = msg.value.add(everyDayInvestMapping[investDay]);
        calUserQueueingStatic(msg.sender);

        UserGlobal storage userGlobal = userMapping[msg.sender];
        if (userGlobal.id == 0) {
            require(!isEmpty(inviteCode), "empty invite code");
            address referrerAddr = getUserAddressByCode(referrer);
            require(uint(referrerAddr) != 0, "referer not exist");
            require(referrerAddr != msg.sender, "referrer can't be self");
            require(!isUsed(inviteCode), "invite code is used");

            registerUser(msg.sender, inviteCode, referrer);
        }

        User storage user = userRoundMapping[rid][msg.sender];
        if (uint(user.userAddress) != 0) {
            require(user.freezeAmount == 0 && user.unlockAmount == 0, "your invest not unlocked");
            user.allInvest = user.allInvest.add(msg.value);
            user.freezeAmount = msg.value;
            user.staticLevel = getLevel(msg.value);
            user.dynamicLevel = getLineLevel(msg.value);
        } else {
            user.id = userGlobal.id;
            user.userAddress = msg.sender;
            user.freezeAmount = msg.value;
            user.staticLevel = getLevel(msg.value);
            user.dynamicLevel = getLineLevel(msg.value);
            user.allInvest = msg.value;
            if (!isEmpty(userGlobal.referrer)) {
                address referrerAddr = getUserAddressByCode(userGlobal.referrer);
                if (referrerAddr != address(0)) {
                    userRoundMapping[rid][referrerAddr].inviteAmount++;
                }
            }
        }
        Invest memory invest = Invest(msg.sender, msg.value, investTime, now, 0, flag, !notSuspended(investTime));
        user.invests.push(invest);
        lastInvestTime = investTime;

        investCount = investCount.add(1);
        investMoney = investMoney.add(msg.value);
        rInvestCount[rid] = rInvestCount[rid].add(1);
        rInvestMoney[rid] = rInvestMoney[rid].add(msg.value);
        
        if (user.staticLevel >= 3) {
            storeSolitaire(msg.sender);
        }
        investAmountList[rid].push(msg.value);

        storeDynamicPreProfits(msg.sender, getDayForProfits(investTime), flag);

        sendFeetoAdmin(msg.value);
        trySendTransform(msg.value);

        emit LogInvestIn(msg.sender, userGlobal.id, msg.value, now, investTime, userGlobal.inviteCode, userGlobal.referrer, 0);
    }

    function reInvestIn() external payable {
        require(gameStart(), "game not start");
        User storage user = userRoundMapping[rid][msg.sender];
        require(user.id > 0, "user haven't invest in round before");
        calStaticProfitInner(msg.sender);
        require(user.freezeAmount == 0, "user have had invest in round");
        require(user.unlockAmount > 0, "user must have unlockAmount");
        require(user.unlockAmount.add(msg.value) <= 20 * ethWei, "can not beyond 20 eth");
        require(user.unlockAmount.add(msg.value) == user.unlockAmount.add(msg.value).div(ethWei).mul(ethWei), "invalid msg value");

        bool isEnough;
        uint sendMoney;
        sendMoney = calDynamicProfits(msg.sender);
        if (sendMoney > 0) {
            (isEnough, sendMoney) = isEnoughBalance(sendMoney);

            if (sendMoney > 0) {
                user.dynamicWithdrawn = user.dynamicWithdrawn.add(sendMoney);
                sendMoneyToUser(msg.sender, sendMoney.mul(90).div(100));
                sendMoneyToUser(loyal, sendMoney.mul(10).div(100));
                emit LogWithdrawProfit(msg.sender, user.id, sendMoney, now, 2);
            }
            if (!isEnough) {
                endRound();
                return;
            }
        }

        uint reInvestAmount = user.unlockAmount.add(msg.value);

        uint investTime = now;
        calUserQueueingStatic(msg.sender);

        uint leastAmount = reInvestAmount.mul(4).div(100);
        (isEnough, sendMoney) = isEnoughBalance(leastAmount);
        if (!isEnough) {
            if (sendMoney > 0) {
                sendMoneyToUser(msg.sender, sendMoney);
            }
            endRound();
            return;
        }

        user.unlockAmount = 0;
        user.allInvest = user.allInvest.add(reInvestAmount);
        user.freezeAmount = user.freezeAmount.add(reInvestAmount);
        user.staticLevel = getLevel(user.freezeAmount);
        user.dynamicLevel = getLineLevel(user.freezeAmount);
        user.reInvestCount = user.reInvestCount.add(1);
        user.unlockAmountRedeemTime = 0;

        uint flag = user.invests[user.invests.length-1].modeFlag;
        Invest memory invest = Invest(msg.sender, reInvestAmount, investTime, now, 0, flag, !notSuspended(investTime));
        user.invests.push(invest);
        if (investTime > lastInvestTime) {
            lastInvestTime = investTime;
        }

        investCount = investCount.add(1);
        investMoney = investMoney.add(reInvestAmount);
        rInvestCount[rid] = rInvestCount[rid].add(1);
        rInvestMoney[rid] = rInvestMoney[rid].add(reInvestAmount);
        if (user.staticLevel >= 3) {
            storeSolitaire(msg.sender);
        }
        investAmountList[rid].push(reInvestAmount);
        storeDynamicPreProfits(msg.sender, getDayForProfits(investTime), flag);

        sendFeetoAdmin(reInvestAmount);
        trySendTransform(reInvestAmount);
        emit LogInvestIn(msg.sender, user.id, reInvestAmount, now, investTime, userMapping[msg.sender].inviteCode, userMapping[msg.sender].referrer, 1);
    }

    function storeSolitaire(address user) private {
        uint len = investAmountList[rid].length;
        if (len != 0) {
            uint tmpTotalInvest;
            for (uint i = 1; i <= 20 && i <= len; i++) {
                tmpTotalInvest = tmpTotalInvest.add(investAmountList[rid][len-i]);
            }
            uint reward = tmpTotalInvest.mul(1).div(10000).mul(6);
            if (reward > 0) {
                userRoundMapping[rid][user].solitaire = userRoundMapping[rid][user].solitaire.add(reward);
            }
        }
    }

    function withdrawProfit()
    public
    isHuman()
    {
        require(gameStart(), "game not start");
        User storage user = userRoundMapping[rid][msg.sender];
        calStaticProfitInner(msg.sender);

        uint sendMoney = user.allStaticAmount;

        bool isEnough = false;
        uint resultMoney = 0;
        (isEnough, resultMoney) = isEnoughBalance(sendMoney);
        if (!isEnough) {
            endRound();
        }

        if (resultMoney > 0) {
            sendMoneyToUser(msg.sender, resultMoney);
            user.staticWithdrawn = user.staticWithdrawn.add(sendMoney);
            user.allStaticAmount = 0;
            emit LogWithdrawProfit(msg.sender, user.id, resultMoney, now, 1);
        }
    }

    function isEnoughBalance(uint sendMoney) private view returns (bool, uint){
        if (sendMoney >= address(this).balance) {
            return (false, address(this).balance);
        } else {
            return (true, sendMoney);
        }
    }

    function isEnoughBalanceToRedeem(uint sendMoney, uint reInvestCount, uint hisStaticAmount) private view returns (bool, uint){
        uint deductedStaticAmount = 0;
        if (reInvestCount >= 0 && reInvestCount <= 6) {
            deductedStaticAmount = hisStaticAmount.mul(5).div(10);
            sendMoney = sendMoney.sub(deductedStaticAmount);
        }
        if (reInvestCount > 6 && reInvestCount <= 18) {
            deductedStaticAmount = hisStaticAmount.mul(4).div(10);
            sendMoney = sendMoney.sub(deductedStaticAmount);
        }
        if (reInvestCount > 18 && reInvestCount <= 36) {
            deductedStaticAmount = hisStaticAmount.mul(3).div(10);
            sendMoney = sendMoney.sub(deductedStaticAmount);
        }
        if (reInvestCount >= 37) {
            deductedStaticAmount = hisStaticAmount.mul(1).div(10);
            sendMoney = sendMoney.sub(deductedStaticAmount);
        }
        if (sendMoney >= address(this).balance) {
            return (false, address(this).balance);
        } else {
            return (true, sendMoney);
        }
    }

    function sendMoneyToUser(address payable userAddress, uint money) private {
        userAddress.transfer(money);
    }

    function calStaticProfitInner(address payable userAddr) private returns (uint){
        User storage user = userRoundMapping[rid][userAddr];
        if (user.id == 0 || user.freezeAmount == 0) {
            return 0;
        }
        uint allStatic = 0;
        uint i = user.invests.length.sub(1);
        Invest storage invest = user.invests[i];
        uint scale;
        if (invest.modeFlag == 0) {
            scale = getScByLevel(user.staticLevel, user.reInvestCount);
        } else if (invest.modeFlag == 1) {
            scale = getSepScByLevel(user.staticLevel);
        }
        uint startDay = invest.investTime.sub(8 hours).div(1 days).mul(1 days);
        if (now.sub(8 hours) < startDay) {
            return 0;
        }
        uint staticGaps = now.sub(8 hours).sub(startDay).div(1 days);

        if (staticGaps > 6) {
            staticGaps = 6;
        }
        if (staticGaps > invest.times) {
            if (invest.isSuspendedInvest) {
                allStatic = staticGaps.sub(invest.times).mul(scale).mul(invest.investAmount).div(10000).mul(2);
                invest.times = staticGaps;
            } else {
                allStatic = staticGaps.sub(invest.times).mul(scale).mul(invest.investAmount).div(10000);
                invest.times = staticGaps;
            }
        }

        (uint unlockDay, uint unlockAmountRedeemTime) = getUnLockDay(invest.investTime);

        if (unlockDay >= 6 && user.freezeAmount != 0) {
            user.staticFlag = user.staticFlag.add(1);
            user.freezeAmount = user.freezeAmount.sub(invest.investAmount);
            user.unlockAmount = user.unlockAmount.add(invest.investAmount);
            user.unlockAmountRedeemTime = unlockAmountRedeemTime;
            user.staticLevel = getLevel(user.freezeAmount);

            if (user.solitaire > 0) {
                userAddr.transfer(user.solitaire);
                user.hisSolitaire = user.hisSolitaire.add(user.solitaire);
                emit LogWithdrawProfit(userAddr, user.id, user.solitaire, now, 3);
            }
            user.solitaire = 0;
        }

        allStatic = allStatic.mul(coefficient).div(10);
        user.allStaticAmount = user.allStaticAmount.add(allStatic);
        user.hisStaticAmount = user.hisStaticAmount.add(allStatic);
        return user.allStaticAmount;
    }

    function getStaticProfits(address userAddr) public view returns(uint, uint, uint) {
        User memory user = userRoundMapping[rid][userAddr];
        if (user.id == 0 || user.invests.length == 0) {
            return (0, 0, 0);
        }
        if (user.freezeAmount == 0) {
            return (0, user.hisStaticAmount, user.staticWithdrawn);
        }
        uint allStatic = 0;
        uint i = user.invests.length.sub(1);
        Invest memory invest = user.invests[i];
        uint scale;
        if (invest.modeFlag == 0) {
            scale = getScByLevel(user.staticLevel, user.reInvestCount);
        } else if (invest.modeFlag == 1) {
            scale = getSepScByLevel(user.staticLevel);
        }
        uint startDay = invest.investTime.sub(8 hours).div(1 days).mul(1 days);
        if (now.sub(8 hours) < startDay) {
            return (0, user.hisStaticAmount, user.staticWithdrawn);
        }
        uint staticGaps = now.sub(8 hours).sub(startDay).div(1 days);

        if (staticGaps > 6) {
            staticGaps = 6;
        }
        if (staticGaps > invest.times) {
            if (invest.isSuspendedInvest) {
                allStatic = staticGaps.sub(invest.times).mul(scale).mul(invest.investAmount).div(10000).mul(2);
            } else {
                allStatic = staticGaps.sub(invest.times).mul(scale).mul(invest.investAmount).div(10000);
            }
        }

        allStatic = allStatic.mul(coefficient).div(10);
        return (
            user.allStaticAmount.add(allStatic),
            user.hisStaticAmount.add(allStatic),
            user.staticWithdrawn
        );
    }

    function storeDynamicPreProfits(address userAddr, uint investDay, uint modeFlag) private {
        uint freezeAmount = userRoundMapping[rid][userAddr].freezeAmount;
        if (freezeAmount >= 1 * ethWei) {
            uint scale;
            if (modeFlag == 0) {
                scale = getScByLevel(userRoundMapping[rid][userAddr].staticLevel, userRoundMapping[rid][userAddr].reInvestCount);
            } else if (modeFlag == 1) {
                scale = getSepScByLevel(userRoundMapping[rid][userAddr].staticLevel);
            }
            uint staticMoney = freezeAmount.mul(scale).div(10000);
            updateReferrerPreProfits(userMapping[userAddr].referrer, investDay, staticMoney);
        }
    }

    function updateReferrerPreProfits(string memory referrer, uint day, uint staticMoney) private {
        string memory tmpReferrer = referrer;

        for (uint i = 1; i <= 20; i++) {
            if (isEmpty(tmpReferrer)) {
                break;
            }
            uint floorIndex = getFloorIndex(i);
            address tmpUserAddr = addressMapping[tmpReferrer];
            if (tmpUserAddr == address(0)) {
                break;
            }

            for (uint j = 0; j < 6; j++) {
                uint dayIndex = day.add(j);
                uint currentMoney = userRoundMapping[rid][tmpUserAddr].dynamicProfits[floorIndex][dayIndex];
                userRoundMapping[rid][tmpUserAddr].dynamicProfits[floorIndex][dayIndex] = currentMoney.add(staticMoney);
            }
            tmpReferrer = userMapping[tmpUserAddr].referrer;
        }
    }

    function calDynamicProfits(address user) public view returns (uint) {
        uint len = userRoundMapping[rid][user].invests.length;
        if (len == 0) {
            return 0;
        }
        uint userInvestDay = getDayForProfits(userRoundMapping[rid][user].invests[len - 1].investTime);
        uint totalProfits;

        uint floor;
        uint dynamicLevel = userRoundMapping[rid][user].dynamicLevel;
        floor = getDynamicFloor(dynamicLevel);
        if (floor > 20) {
            floor = 20;
        }
        uint floorCap = getFloorIndex(floor);
        uint fireSc = getFireScByLevel(dynamicLevel);

        for (uint i = 1; i <= floorCap; i++) {
            uint recommendSc = getRecommendScaleByLevelAndTim(dynamicLevel, i);
            for (uint j = 0; j < 6; j++) {
                uint day = userInvestDay.add(j);
                uint staticProfits = userRoundMapping[rid][user].dynamicProfits[i][day];

                if (recommendSc != 0) {
                    uint tmpDynamicAmount = staticProfits.mul(fireSc).mul(recommendSc);
                    totalProfits = tmpDynamicAmount.div(10).div(100).add(totalProfits);
                }
            }
        }

        return totalProfits;
    }

    function registerUserInfo(address user, string calldata inviteCode, string calldata referrer) external onlyOwner {
        registerUser(user, inviteCode, referrer);
    }

    function calUserQueueingStatic(address userAddress) private returns(uint) {
        User storage calUser = userRoundMapping[rid][userAddress];

        uint investLength = calUser.invests.length;
        if (investLength == 0) {
            return 0;
        }

        Invest memory invest = calUser.invests[investLength - 1];
        if (invest.investTime <= invest.realityInvestTime) {
            return 0;
        }

        uint staticGaps = getQueueingStaticGaps(invest.investTime, invest.realityInvestTime);
        if (staticGaps <= 0) {
            return 0;
        }
        uint staticAmount = invest.investAmount.mul(staticGaps).mul(5).div(10000);
        calUser.hisStaticAmount = calUser.hisStaticAmount.add(staticAmount);
        calUser.allStaticAmount = calUser.allStaticAmount.add(staticAmount);
        return staticAmount;
    }

    function getQueueingStaticGaps(uint investTime, uint realityInvestTime) private pure returns (uint){
        if(investTime <= realityInvestTime){
            return 0;
        }
        uint startDay = realityInvestTime.sub(8 hours).div(1 days).mul(1 days);
        uint staticGaps = investTime.sub(8 hours).sub(startDay).div(1 days);
        return staticGaps;
    }

    function redeem()
    public
    isHuman()
    isSuspended()
    {
        require(gameStart(), "game not start");
        User storage user = userRoundMapping[rid][msg.sender];
        require(user.id > 0, "user not exist");
        withdrawProfit();
        require(now >= user.unlockAmountRedeemTime, "redeem time non-arrival");

        uint sendMoney = user.unlockAmount;
        require(sendMoney != 0, "you don't have unlock money");
        uint reInvestCount = user.reInvestCount;
        uint hisStaticAmount = user.hisStaticAmount;

        bool isEnough = false;
        uint resultMoney = 0;

        uint index = user.invests.length - 1;
        if (user.invests[index].modeFlag == 0) {
            (isEnough, resultMoney) = isEnoughBalanceToRedeem(sendMoney, reInvestCount, hisStaticAmount);
        } else if (user.invests[index].modeFlag == 1) {
            require(reInvestCount == 4 || (reInvestCount>4 && (reInvestCount-4)%5 == 0), "reInvest time not enough");
            (isEnough, resultMoney) = isEnoughBalance(sendMoney);
        } else {
            revert("invalid flag");
        }

        if (!isEnough) {
            endRound();
        }
        if (resultMoney > 0) {
            sendMoneyToUser(msg.sender, resultMoney);
            user.unlockAmount = 0;
            user.staticLevel = getLevel(user.freezeAmount);
            user.dynamicLevel = 0;
            user.reInvestCount = 0;
            user.hisStaticAmount = 0;
            emit LogRedeem(msg.sender, user.id, resultMoney, now);
        }
    }

    function getUnLockDay(uint investTime) public view returns (uint unlockDay, uint unlockAmountRedeemTime){
        uint gameStartTime = startTime;
        if (gameStartTime <= 0 || investTime > now || investTime < gameStartTime) {
            return (0, 0);
        }
        unlockDay = now.sub(investTime).div(1 days);
        unlockAmountRedeemTime = 0;
        if (unlockDay < 6) {
            return (unlockDay, unlockAmountRedeemTime);
        }
        unlockAmountRedeemTime = investTime.add(uint(6).mul(1 days));

        uint stopTime = suspendedTime;
        if (stopTime == 0) {
            return (unlockDay, unlockAmountRedeemTime);
        }

        uint stopDays = suspendedDays;
        uint stopEndTime = stopTime.add(stopDays.mul(1 days));
        if (investTime < stopTime){
            if(unlockAmountRedeemTime >= stopEndTime){
                unlockAmountRedeemTime = unlockAmountRedeemTime.add(stopDays.mul(1 days));
            }else if(unlockAmountRedeemTime < stopEndTime && unlockAmountRedeemTime > stopTime){
                unlockAmountRedeemTime = stopEndTime.add(unlockAmountRedeemTime.sub(stopTime));
            }
        }
        if (investTime >= stopTime && investTime < stopEndTime){
            if(unlockAmountRedeemTime >= stopEndTime){
                unlockAmountRedeemTime = unlockAmountRedeemTime.add(stopEndTime.sub(investTime));
            }else if(unlockAmountRedeemTime < stopEndTime && unlockAmountRedeemTime > stopTime){
                unlockAmountRedeemTime = stopEndTime.add(uint(6).mul(1 days));
            }
        }
        return (unlockDay, unlockAmountRedeemTime);
    }

    function endRound() private {
        rid++;
        startTime = now.add(period).div(1 days).mul(1 days);
        coefficient = 10;
    }

    function isUsed(string memory code) public view returns (bool) {
        address user = getUserAddressByCode(code);
        return uint(user) != 0;
    }

    function getUserAddressByCode(string memory code) public view returns (address) {
        return addressMapping[code];
    }

    function sendFeetoAdmin(uint amount) private {
        devAddr.transfer(amount.div(25));
    }

    function trySendTransform(uint amount) private {
        if (transformAmount[rid] > 500 * ethWei) {
            return;
        }
        uint sendAmount = amount.div(100);
        transformAmount[rid] = transformAmount[rid].add(sendAmount);
        other.transfer(sendAmount);
    }

    function getGameInfo() public isHuman() view returns (uint, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint, uint) {
        uint dayInvest;
        uint dayLimit;
        dayInvest = everyDayInvestMapping[getCurrentInvestDay(now)];
        dayLimit = getCurrentInvestLimit(now);
        return (
        rid,
        uid,
        startTime,
        investCount,
        investMoney,
        rInvestCount[rid],
        rInvestMoney[rid],
        coefficient,
        dayInvest,
        dayLimit,
        now,
        lastInvestTime
        );
    }

    function getUserInfo(address user, uint roundId) public isHuman() view returns (
        uint[19] memory ct, string memory inviteCode, string memory referrer
    ) {

        if (roundId == 0) {
            roundId = rid;
        }

        User memory userInfo = userRoundMapping[roundId][user];

        ct[0] = userInfo.id;
        ct[1] = userInfo.staticLevel;
        ct[2] = userInfo.dynamicLevel;
        ct[3] = userInfo.allInvest;
        Invest memory invest;
        if (userInfo.invests.length == 0) {
            ct[4] = 0;
        } else {
            invest = userInfo.invests[userInfo.invests.length-1];
            if (invest.modeFlag == 0) {
                ct[4] = getScByLevel(userInfo.staticLevel, userInfo.reInvestCount);
            } else if(invest.modeFlag == 1) {
                ct[4] = getSepScByLevel(userInfo.staticLevel);
            } else {
                ct[4] = 0;
            }
        }
        ct[5] = userInfo.inviteAmount;
        ct[6] = userInfo.freezeAmount;
        ct[7] = userInfo.staticWithdrawn.add(userInfo.dynamicWithdrawn);
        ct[8] = userInfo.staticWithdrawn;
        ct[9] = userInfo.dynamicWithdrawn;
        uint canWithdrawn;
        uint hisWithdrawn;
        uint staticWithdrawn;
        (canWithdrawn, hisWithdrawn, staticWithdrawn) = getStaticProfits(user);
        ct[10] = canWithdrawn;
        ct[11] = calDynamicProfits(user);
        uint lockDay;
        uint redeemTime;
        (lockDay, redeemTime) = getUnLockDay(invest.investTime);
        ct[12] = lockDay;
        ct[13] = redeemTime;
        ct[14] = userInfo.reInvestCount;
        ct[15] = invest.modeFlag;
        ct[16] = userInfo.unlockAmount;
        ct[17] = invest.investTime;
        ct[18] = userInfo.hisSolitaire;

        inviteCode = userMapping[user].inviteCode;
        referrer = userMapping[user].referrer;
        return (
        ct,
        inviteCode,
        referrer
        );
    }

    function getInvestTime(uint amount) public view returns (uint){
        uint lastTime = lastInvestTime;

        uint investTime = 0;

        if (isLessThanLimit(amount, now)) {
            if (now < lastTime) {
                investTime = lastTime.add(1 seconds);
            } else {
                investTime = now;
            }
        } else {
            investTime = lastTime.add(1 seconds);
            if (!isLessThanLimit(amount, investTime)) {
                investTime = getCurrentInvestDay(lastTime).mul(1 days).add(baseTime);
            }
        }
        return investTime;
    }


    function getDayForProfits(uint investTime) private pure returns (uint) {
        return investTime.sub(8 hours).div(1 days);
    }

    function getCurrentInvestLimit(uint investTime) public view returns (uint){
        uint currentDays = getCurrentInvestDay(investTime).sub(1);
        uint currentRound = currentDays.div(6).add(1);
        uint x = 3 ** (currentRound.sub(1));
        uint y = 2 ** (currentRound.sub(1));
        return baseLimit.mul(x).div(y);
    }

    function getCurrentInvestDay(uint investTime) public view returns (uint){
        uint gameStartTime = baseTime;
        if (gameStartTime == 0 || investTime < gameStartTime) {
            return 0;
        }
        uint currentInvestDay = investTime.sub(gameStartTime).div(1 days).add(1);
        return currentInvestDay;
    }
    function isLessThanLimit(uint amount, uint investTime) public view returns (bool){
        return getCurrentInvestLimit(investTime) >= amount.add(everyDayInvestMapping[getCurrentInvestDay(investTime)]);
    }
    function notSuspended() public view returns (bool) {
        uint sTime = suspendedTime;
        uint sDays = suspendedDays;
        return sTime == 0 || now < sTime || now >= sDays.mul(1 days).add(sTime);
    }

    function notSuspended(uint investTime) public view returns (bool) {
        uint sTime = suspendedTime;
        uint sDays = suspendedDays;
        return sTime == 0 || investTime < sTime || investTime >= sDays.mul(1 days).add(sTime);
    }

    function suspended(uint stopTime, uint stopDays) external onlyWhitelistAdmin {
        require(gameStart(), "game not start");
        require(stopTime > now, "stopTime shoule gt now");
        require(stopTime > lastInvestTime, "stopTime shoule gt lastInvestTime");
        suspendedTime = stopTime;
        suspendedDays = stopDays;
    }

    function getUserById(uint id) public view returns (address){
        return indexMapping[id];
    }

    function getAvailableReInvestInAmount(address userAddr) public view returns (uint){
        User memory user = userRoundMapping[rid][userAddr];
        if(user.freezeAmount == 0){
            return user.unlockAmount;
        }else{
            Invest memory invest = user.invests[user.invests.length - 1];
            (uint unlockDay, uint unlockAmountRedeemTime) = getUnLockDay(invest.investTime);
            if(unlockDay >= 6){
                return invest.investAmount;
            }
        }
        return 0;
    }

    function getAvailableRedeemAmount(address userAddr) public view returns (uint){
        User memory user = userRoundMapping[rid][userAddr];
        if (now < user.unlockAmountRedeemTime) {
            return 0;
        }
        uint allUnlock = user.unlockAmount;
        if (user.freezeAmount > 0) {
            Invest memory invest = user.invests[user.invests.length - 1];
            (uint unlockDay, uint unlockAmountRedeemTime) = getUnLockDay(invest.investTime);
            if (unlockDay >= 6 && now >= unlockAmountRedeemTime) {
                allUnlock = invest.investAmount;
            }
            if(invest.modeFlag == 1){
                if(user.reInvestCount < 4 || (user.reInvestCount - 4)%5 != 0){
                    allUnlock = 0;
                }
            }
        }
        return allUnlock;
    }

    function registerUser(address user, string memory inviteCode, string memory referrer) private {
        UserGlobal storage userGlobal = userMapping[user];
        if (userGlobal.id != 0) {
            userGlobal.userAddress = user;
            userGlobal.inviteCode = inviteCode;
            userGlobal.referrer = referrer;
            
            addressMapping[inviteCode] = user;
            indexMapping[uid] = user;
        } else {
            uid++;
            userGlobal.id = uid;
            userGlobal.userAddress = user;
            userGlobal.inviteCode = inviteCode;
            userGlobal.referrer = referrer;
            
            addressMapping[inviteCode] = user;
            indexMapping[uid] = user;
        }
        
    }
}

/**
 * @title SafeMath
 * @dev Math operations with safety checks that revert on error
 */
library SafeMath {

    /**
    * @dev Multiplies two numbers, reverts on overflow.
    */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "mul overflow");

        return c;
    }

    /**
    * @dev Integer division of two numbers truncating the quotient, reverts on division by zero.
    */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "div zero");
        // Solidity only automatically asserts when dividing by 0
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
    * @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).
    */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "lower sub bigger");
        uint256 c = a - b;

        return c;
    }

    /**
    * @dev Adds two numbers, reverts on overflow.
    */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "overflow");

        return c;
    }

    /**
    * @dev Divides two numbers and returns the remainder (unsigned integer modulo),
    * reverts when dividing by zero.
    */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b != 0, "mod zero");
        return a % b;
    }
}

Latest Transactions

Block	Hash	From	To
9109239	0xb2a...b31	0x335...8C6	0x537...86c
9109203	0x4da...d72	0xf62...4ba	0x537...86c
9109164	0x17f...5d5	0xA49...9A0	0x537...86c
9109045	0xbfa...7a3	0x069...208	0x537...86c
9108907	0x431...2a2	0xA49...9A0	0x537...86c
9108886	0x231...c43	0xB78...F84	0x537...86c
9108733	0x971...f3d	0x89c...e25	0x537...86c
9108677	0xe59...e0c	0x673...fFb	0x537...86c
9108642	0x12c...580	0x02B...4Eb	0x537...86c
9108373	0xdcb...5e7	0x396...248	0x537...86c
9108369	0x047...a62	0xF4D...1fd	0x537...86c
9108369	0x86e...359	0xF4D...1fd	0x537...86c
9108364	0xe3d...b49	0x123...AF5	0x537...86c
9108361	0x093...895	0x123...AF5	0x537...86c
9108360	0x7d9...bff	0x787...60C	0x537...86c
9108359	0x125...39a	0x787...60C	0x537...86c
9108353	0x4d9...8f2	0x003...3a6	0x537...86c
9108353	0x1cb...4e7	0x771...Ac4	0x537...86c
9108353	0x737...ce1	0x775...2dD	0x537...86c
9108257	0x3c5...bdf	0x911...a23	0x537...86c
9108129	0xc67...6be	0x3CC...7FE	0x537...86c
9108115	0xceb...174	0xA88...286	0x537...86c
9108049	0xd78...eb8	0x59c...67c	0x537...86c
9107993	0x83e...8d5	0x6fC...e76	0x537...86c
9107990	0x061...7b9	0x6fC...e76	0x537...86c
9107936	0x1f1...c42	0x5f5...EbD	0x537...86c
9107931	0xc0b...13d	0xD34...3Fc	0x537...86c
9107780	0xb12...ce3	0xf20...692	0x537...86c
9107510	0xe43...25e	0x5cF...0a3	0x537...86c
9107502	0xa4c...fb3	0x318...090	0x537...86c
9107492	0x1c0...8e1	0x9F3...d68	0x537...86c
9107474	0xe05...fc0	0x0B3...51b	0x537...86c
9107464	0x586...252	0x664...9F7	0x537...86c
9107450	0x4ea...bad	0x4D6...FdF	0x537...86c
9107430	0x75b...2f0	0x1fc...1Af	0x537...86c
9107422	0xfee...6f2	0x151...1D1	0x537...86c
9107143	0xd91...32e	0xEaf...0ca	0x537...86c
9107073	0xa73...0a0	0x2F3...C42	0x537...86c
9107027	0x513...332	0xe00...959	0x537...86c
9107002	0xc87...4f2	0x673...fFb	0x537...86c
9106959	0x229...a0d	0x766...036	0x537...86c
9106591	0x624...d77	0x68D...216	0x537...86c
9106585	0xc75...804	0x68D...216	0x537...86c
9106582	0x499...6cc	0xA4a...a44	0x537...86c
9106579	0xf4e...7cf	0xA4a...a44	0x537...86c
9106577	0x30a...d3b	0x1aA...cbf	0x537...86c
9106571	0x68b...f55	0x1aA...cbf	0x537...86c
9106565	0xc71...f2d	0xD2b...97E	0x537...86c
9106561	0xeaf...f77	0xD2b...97E	0x537...86c
9106548	0x2e2...6fc	0x866...49a	0x537...86c

Latest Logs

Block	Identifier	Address
9109239	0x996...c6f	0x537...86c
9109239	0xc5b...f0f	0x537...86c
9109239	0xe64...fd4	0x537...86c
9109203	0x0d2...f08	0x537...86c
9109164	0x655...a8e	0x537...86c
9109045	0xb24...045	0x537...86c
9108907	0xede...e55	0x537...86c
9108886	0x4c1...6f1	0x537...86c
9108886	0x8de...567	0x537...86c
9108886	0x56d...21a	0x537...86c
9108733	0x7b6...be1	0x537...86c
9108733	0x77e...182	0x537...86c
9108733	0x20b...df2	0x537...86c
9108677	0xae6...2a5	0x537...86c
9108677	0x0dd...920	0x537...86c
9108677	0xb48...ab3	0x537...86c
9108642	0x2ec...709	0x537...86c
9108373	0x977...8d2	0x537...86c
9108369	0x5fc...f5f	0x537...86c
9108369	0xfb9...a17	0x537...86c
9108369	0xdf0...765	0x537...86c
9108369	0xeff...e8a	0x537...86c
9108364	0x42d...a87	0x537...86c
9108364	0x21d...9e9	0x537...86c
9108361	0x626...9f1	0x537...86c
9108361	0xe7b...7cc	0x537...86c
9108360	0x9f4...56d	0x537...86c
9108360	0x43c...b5a	0x537...86c
9108359	0xd0f...c63	0x537...86c
9108359	0x65d...b33	0x537...86c
9108353	0xe42...221	0x537...86c
9108353	0x9d2...ae2	0x537...86c
9108353	0x8f8...8fd	0x537...86c
9108257	0x885...06e	0x537...86c
9108129	0x05b...7b8	0x537...86c
9108129	0x449...f27	0x537...86c
9108129	0x8f3...553	0x537...86c
9108115	0xc7d...2bf	0x537...86c
9108049	0x1ed...f32	0x537...86c
9107990	0xecd...13d	0x537...86c
9107936	0xca1...26a	0x537...86c
9107931	0x28d...ffd	0x537...86c
9107780	0x627...0d9	0x537...86c
9107510	0x26a...d15	0x537...86c
9107502	0xa40...167	0x537...86c
9107492	0xe33...c82	0x537...86c
9107474	0x8b4...759	0x537...86c
9107464	0xe79...4f9	0x537...86c
9107450	0x6ee...8a9	0x537...86c
9107430	0x19f...4a3	0x537...86c