Block Explorer For Ethereum Mainnet

0x5370645B7af206e866bB021925Db56f7ad4B286c

Address

Address Details

Transactions	9485
Logs	12240
Balance	0 ETH (Updated: 2 years ago)

Contract-Name	MutualAlliance
Compiler	v0.5.0+commit.1d4f565a
Contract-Probability	1

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;
    }
}

Transactions

Filter:

Logs

Filter:

Explore the Ethereum Mainnet Blockchain Network

The Ethereum Mainnet network is a public blockchain that’s supported by all Ethereum clients including Geth, Parity, Nethermind, Hyperledger Besu and many more. The network supports a modified version of Nakamoto consensus via transaction-based state transitions.

Established in July 2015, Ethereum Mainnet is a proof-of-work network that has grown to become the single most active chain in the Ethereum ecosystem and almost all blockchain networks.

Discover our dedicated Block Explorer tool to search the Ethereum Mainnet network in the click of a button. Anyblock Analytics makes it fast and easy to search the Ethereum Mainnet using either transaction hashes, blockchain addresses, block numbers or log identifiers.

Stay in the loop and monitor on-chain events with up-to-date access to the latest Mainnet blocks and transactions. Using Block Explorer means accessing Ethereum Mainnet is as simple as clicking on a block or transaction to reveal a detailed summary of all the key information.

Anyblock Block Explorer Features

Our Block Explorer collates all internal transactions on Mainnet. We work with the network’s data to format the correct decimal place values for token transfers along with accurate token icons and metadata.

Anyblock Analytics translates all raw blockchain data into human-legible information that can be presented with a probability value between 0.1 and 1.0. A probability of 1.0 represents an exact match.

If you're searching the Mainnet explorer using smart contract addresses, the results page will show the source code and contract ABI if this information is available. You can easily filter through corresponding transactions and smart contract logs for fast and easy-to-use experiences.

Any address will show its balance in the native currency of the blockchain network.