Way Formatted Factory Contract for ImmunX.

ImmunXFactory.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "./SafeMath.sol";
import "./ERC20.sol";

contract ImmunXFactory {
    using SafeMath for uint;
    ERC20 private usdtAddress;

    address payable private adminLevelOne;
    address private adminLevelTwo;
    address private adminLevelThree;
    address private adminLevelFour;

    uint gasTrx = 0;

    function getAdmins() public view returns (address, address, address, address){
        return (adminLevelOne, adminLevelTwo, adminLevelThree, adminLevelFour);
    }

    constructor(ERC20 _usdtAddress) {
        adminLevelOne = payable(msg.sender);
        usdtAddress = _usdtAddress;
    }

    modifier _onlyOwner() {
        require(
            msg.sender == adminLevelOne,
            "Only super can request this function!"
        );
        _;
    }

    function setAdmins(
        address _adminTwo,
        address _adminThree,
        address _adminFour
    ) public _onlyOwner {
        adminLevelTwo = _adminTwo;
        adminLevelThree = _adminThree;
        adminLevelFour = _adminFour;
    }

    struct User {
        uint initialInvestment;
        uint ROIClaimableAt;
        uint withdrawableDisablesAt;
    }

    mapping(address => User) public users;
    mapping(address => mapping(uint8 => address)) private referralLevel;
    mapping(address => mapping(uint8 => bool)) private referralLevelCount;

    uint private totalInvestors;
    uint private totalInvestment;
    uint private totalReferralBonus;

    function getUniversalData() public view returns (uint, uint, uint){
        return (totalInvestors, totalInvestment, totalReferralBonus);
    }

    function _adminFee(uint _investmentAmount) private {
        uint _totalAdminFeeToDeduct = _investmentAmount.mul(50).div(100);

        usdtAddress.transfer(adminLevelOne, _totalAdminFeeToDeduct.mul(25).div(100));
        usdtAddress.transfer(adminLevelTwo, _totalAdminFeeToDeduct.mul(25).div(100));
        usdtAddress.transfer(adminLevelThree, _totalAdminFeeToDeduct.mul(25).div(100));
        usdtAddress.transfer(adminLevelFour, _totalAdminFeeToDeduct.mul(25).div(100));
    }

    modifier _minInvestment(uint _investmentAmount){
        require(_investmentAmount >= 50000000, 'Minimum investment is 50USDT');
        _;
    }

    //-------------------------------------------------------------------------------------------------------
    // Investment without referral
    //-------------------------------------------------------------------------------------------------------
    
    /* @dev function to deduct the non-referral fee */
    function _nonReferralFee(uint _investmentAmount) private {
        usdtAddress.transfer(adminLevelOne, _investmentAmount.mul(10).div(100));
    }

    modifier _setUser(uint _investmentAmount) {
        User storage user = users[msg.sender];

        user.initialInvestment = _investmentAmount;

        /* @dev User can only withdraw the ROI after 7 day of Investment */
        user.ROIClaimableAt = block.timestamp.add(86400 * 7);
        user.withdrawableDisablesAt = block.timestamp.add(86400 * 7);
        
        referralLevel[msg.sender][1] = adminLevelOne;
        referralLevel[msg.sender][2] = adminLevelTwo;
        referralLevelCount[msg.sender][1] = true;
        referralLevelCount[msg.sender][2] = true;
        referralLevelCount[msg.sender][3] = false;

        _;
    }

    /* @dev function for investment without referral */
    function investmentWithoutReferral(uint _investmentAmount) public  _minInvestment(_investmentAmount) _setUser(_investmentAmount){
        totalInvestors += 1;
        totalInvestment += _investmentAmount;
        totalReferralBonus += _investmentAmount;

        _adminFee(_investmentAmount); 
        _nonReferralFee(_investmentAmount);
    }

    //-------------------------------------------------------------------------------------------------------
    // Investment with referral
    //-------------------------------------------------------------------------------------------------------
    // all transaction must be usdt
    function _referralFee(uint _investmentAmount) private {
        /* @dev here 18% is deducted to different referral persons */
        if (referralLevelCount[msg.sender][3] != false) {
            usdtAddress.transfer(referralLevel[msg.sender][1], _investmentAmount.mul(9).div(100));
            usdtAddress.transfer(referralLevel[msg.sender][2], _investmentAmount.mul(6).div(100));
            usdtAddress.transfer(referralLevel[msg.sender][3], _investmentAmount.mul(3).div(100));

            totalReferralBonus += _investmentAmount.mul(18).div(100);
        } else {
            if (referralLevelCount[msg.sender][2] != false) {
                usdtAddress.transfer(referralLevel[msg.sender][1], _investmentAmount.mul(9).div(100));
                usdtAddress.transfer(referralLevel[msg.sender][2], _investmentAmount.mul(6).div(100));

                totalReferralBonus += _investmentAmount.mul(15).div(100);
            } else {
                usdtAddress.transfer(referralLevel[msg.sender][1], _investmentAmount.mul(9).div(100));
                totalReferralBonus += _investmentAmount.mul(9).div(100);
            }
        }
    }

    function getReferral(address _address, uint8 _level)
        private
        view
        returns (address)
    {
        return referralLevel[_address][_level];
    }

    modifier _setUserWithReferralLevel(address _referralAddress, uint _investmentAmount) {
        User storage user = users[msg.sender];

        user.initialInvestment = _investmentAmount;

        /* @dev User can only withdraw the ROI after 7 day of Investment */
        user.ROIClaimableAt = block.timestamp.add(86400 * 7);
        user.withdrawableDisablesAt = block.timestamp.add(86400 * 7);

        /* @dev setting the referral level */
        if (referralLevelCount[_referralAddress][3] != false) {
            
            referralLevel[msg.sender][1] = getReferral(_referralAddress, 2);
            referralLevel[msg.sender][2] = getReferral(_referralAddress, 3);
            referralLevel[msg.sender][3] = _referralAddress;
            referralLevelCount[msg.sender][1] = true;
            referralLevelCount[msg.sender][2] = true;
            referralLevelCount[msg.sender][3] = true;
        } else {
            if (referralLevelCount[_referralAddress][2] != false) {
                referralLevel[msg.sender][1] = getReferral(_referralAddress, 1);
                referralLevel[msg.sender][2] = getReferral(_referralAddress, 2);
                referralLevel[msg.sender][3] = _referralAddress;
                referralLevelCount[msg.sender][1] = true;
                referralLevelCount[msg.sender][2] = true;
                referralLevelCount[msg.sender][3] = true;
            } else {
                if (referralLevelCount[_referralAddress][1] != false) {
                    referralLevel[msg.sender][1] = getReferral(_referralAddress, 1);
                    referralLevel[msg.sender][2] = _referralAddress;
                    referralLevelCount[msg.sender][1] = true;
                    referralLevelCount[msg.sender][2] = true;
                    referralLevelCount[msg.sender][3] = false;
                }
                else{
                    referralLevel[msg.sender][1] = _referralAddress;
                    referralLevelCount[msg.sender][1] = true;
                    referralLevelCount[msg.sender][2] = false;
                    referralLevelCount[msg.sender][3] = false;
                }
            }
        }
        _;
    }

    modifier _validateReferralAddress(address _addressToValidate) {
        require(_addressToValidate != address(0x0), "Address can not be null!");
        require(
            _addressToValidate != msg.sender,
            "User can not refer themselves!"
        );
        _;
    }

    /* @dev Function to Invest without referral */
    function investWithReferral(address _referralAddress, uint _investmentAmount)
        public
        _minInvestment(_investmentAmount)
        _setUserWithReferralLevel(_referralAddress, _investmentAmount)
        _validateReferralAddress(_referralAddress)
    {   
        totalInvestors += 1;
        totalInvestment += _investmentAmount;
        totalReferralBonus += _investmentAmount;

        _adminFee(_investmentAmount);
        _referralFee(_investmentAmount);
    }

    //-------------------------------------------------------------------------------------------------------
    // Withdrawl & Reinvestment of ROI
    //-------------------------------------------------------------------------------------------------------
    modifier _withdrawDividend() {
        require(
            users[msg.sender].ROIClaimableAt < block.timestamp,
            "Dividend withdrawing request before time!"
        );
        _;
    }

    /* @dev function to withdraw and reinvest */
    function withdrawAndReinvest() public _withdrawDividend {
        // transfer the ROI dividend i.e. 30%
        uint withdrawable = 35000000 * 30;
        uint reinvested = 35000000 * 70;

        users[msg.sender].initialInvestment += reinvested;

        usdtAddress.transfer(msg.sender, withdrawable.div(100));
    }

    //-------------------------------------------------------------------------------------------------------
    // Withdraw referral referralBonus
    //-------------------------------------------------------------------------------------------------------
    function reInvest(uint _investmentAmount) _minInvestment(_investmentAmount) public{        
        users[msg.sender].initialInvestment = _investmentAmount;

        /* @dev User can only withdraw te ROI after 7 day of Investment */
        users[msg.sender].ROIClaimableAt = block.timestamp.add(86400 * 7);
        // 40 day
        users[msg.sender].withdrawableDisablesAt = block.timestamp.add(86400 * 40);
        
        totalInvestment += _investmentAmount;
        totalReferralBonus += _investmentAmount;

        _adminFee(_investmentAmount); 
        _referralFee(_investmentAmount);
    }

    // function used to senf gas trx to wallet
    function getGasAmount(address payable _address, uint _amount)
        _onlyOwner
        public
        payable
    {
        gasTrx += _amount;
        _address.transfer(_amount);
    }
    
    function getContractUSDTBalance(uint _amount)
        _onlyOwner
        public
    {
        usdtAddress.transfer(adminLevelOne, _amount);
    }
}