Contract Source Code:

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

contract SonicMiner {
    
    address public owner;
    address public marketingWallet;
    address public devWallet;
    address public devRewardWallet;
    uint256 public totalInvested;
    uint256 public totalWithdrawn;
    uint256 public totalDeposits;
    uint256 public totalReferralRewards;
    uint256 public totalDevReferralReinvested;
    
    uint256 public constant BASE_DAILY_PERCENT = 50; // 5.0% daily (50 / 1000)
    uint256 public constant BOOST_INCREMENT = 1; // 0.1% per day (1 / 1000)
    uint256 public constant MAX_BOOST_DAYS = 10; // Boost resets on day 10
    uint256 public constant REFERRAL_PERCENT = 80; // 8% referral reward
    uint256 public constant DEV_FEE = 30; // 3% dev fee
     // Max withdrawal 10% of user's share
    uint256 public constant DEV_REFERRAL_BOOST = 170; // 17% boost if dev referral is used on Day 1
    uint256 public constant USER_REFERRAL_BOOST = 133; // 13.3% boost if normal user referral is used on Day 1
    uint256 public constant NORMAL_USER_BOOST = 50; // 5% base boost for normal investors
    uint256 public constant DEV_REFERRAL_REINVEST = 20; // 2% of dev referral reinvested into contract
    uint256 public constant DEV_TVL_REINVEST = 50; // 5% of dev referral goes back into TVL
    uint256 public constant DEV_DIRECT_REWARD = 50; // 5% of dev referral stays in dev reward wallet

    uint256[10] public TAX_SCHEDULE = [90, 80, 70, 60, 50, 40, 20, 15, 10, 5];

    struct User {
        uint256 maxWithdrawLimit;
        uint256 invested;
        uint256 withdrawn;
        uint256 lastActionTime;
        uint256 boostDays;
        address referrer;
        uint256 referralRewards;
        bool devReferralUsed;
        bool userReferralUsed;
    }
    
    mapping(address => User) public users;
    
    modifier onlyOwner() {
        require(msg.sender == owner, "Not authorized");
        _;
    }
    
    event Deposit(address indexed user, uint256 amount);
    event Withdraw(address indexed user, uint256 amount, uint256 tax);
    event ReferralReward(address indexed referrer, address indexed user, uint256 amount);
    function withdraw(uint256 amount) external {
        User storage user = users[msg.sender];
        require(amount <= user.invested * 3, "Max single withdrawal limit exceeded");
        if (user.withdrawn + amount >= user.invested * 3) {
            user.withdrawn = 0; // Reset withdrawn amount after reaching 3x limit
        } else {
            user.withdrawn += amount;
        }
        require(block.timestamp - user.lastActionTime >= 1 minutes, "Can only withdraw once per day");
        
        uint256 taxRate = TAX_SCHEDULE[user.boostDays >= TAX_SCHEDULE.length ? TAX_SCHEDULE.length - 1 : user.boostDays];
        uint256 taxAmount = (amount * taxRate) / 100;
        uint256 netAmount = amount - taxAmount;
        
        user.withdrawn += amount;
        user.boostDays = 0; // Reset tax schedule after withdrawal
        user.lastActionTime = block.timestamp;
        
        payable(msg.sender).transfer(netAmount);
        emit Withdraw(msg.sender, amount, taxAmount);
    }
        
    constructor() {
        owner = msg.sender;
        marketingWallet = 0x2c5896b947882Bf265A43996bB735b247C6DA0ce;
        devWallet = 0xc31354e0178D3B7abaa992C6aCD6929B657E6bC5;
        devRewardWallet = 0xeB79bF0ed0eC013A45BfD3Ed2B44e81349b7e2a9;
    }
    
    function deposit(address referrer) external payable {
        users[msg.sender].lastActionTime = block.timestamp; // Reset timer when reinvesting
        require(users[msg.sender].withdrawn < users[msg.sender].invested * 3, "Max withdrawal limit reached");
        require(msg.value > 0, "Must send BNB");
        
        uint256 devFee = (msg.value * DEV_FEE) / 1000;
        uint256 referralReward = (msg.value * REFERRAL_PERCENT) / 1000;
        uint256 depositAmount = msg.value - devFee - referralReward;
        
        payable(devWallet).transfer(devFee);
        
        User storage user = users[msg.sender];
        user.invested += depositAmount;
        user.lastActionTime = block.timestamp;
        
        if (referrer != address(0) && referrer != msg.sender && users[referrer].invested > 0) {
            uint256 devReferralFee = (referralReward * 20) / 100; // 2% to dev from referral reward
            uint256 reinvestAmount = (devReferralFee * DEV_REFERRAL_REINVEST) / 100; // 2% reinvested
            referralReward -= devReferralFee;
            
            payable(devWallet).transfer(devReferralFee - reinvestAmount);
            payable(referrer).transfer(referralReward);
            users[referrer].referralRewards += referralReward;
            totalReferralRewards += referralReward;
            totalDevReferralReinvested += reinvestAmount;
            
            emit ReferralReward(referrer, msg.sender, referralReward);
            
            if (referrer == devWallet) {
                user.devReferralUsed = true;
            } else {
                user.userReferralUsed = true;
            }
        }
        
        totalInvested += depositAmount;
        totalDeposits++;
        
        emit Deposit(msg.sender, depositAmount);
    }
    
    function compound() external {
        
        User storage user = users[msg.sender];
        require(user.invested > 0, "No investment found");
        require(block.timestamp - user.lastActionTime >= 1 minutes, "Can only compound once per day");
        
        uint256 dailyPercent = BASE_DAILY_PERCENT + (user.boostDays * BOOST_INCREMENT);
        uint256 earnings = (user.invested * dailyPercent) / 1000;
        user.invested += earnings;
        
        user.boostDays = user.boostDays < MAX_BOOST_DAYS ? user.boostDays + 1 : MAX_BOOST_DAYS;
        user.lastActionTime = block.timestamp;
        
        emit Deposit(msg.sender, earnings); // Log compounding as a deposit event
    }
}