HoodPonzi

[
  {
    "inputs": [],
    "stateMutability": "nonpayable",
    "type": "constructor"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": false,
        "internalType": "uint256",
        "name": "newValue",
        "type": "uint256"
      }
    ],
    "name": "BaseDailyRewardPercentageUpdated",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "internalType": "address",
        "name": "user",
        "type": "address"
      },
      {
        "indexed": false,
        "internalType": "uint256",
        "name": "amount",
        "type": "uint256"
      }
    ],
    "name": "ClaimReferralRewards",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "internalType": "address",
        "name": "user",
        "type": "address"
      },
      {
        "indexed": false,
        "internalType": "uint256",
        "name": "amount",
        "type": "uint256"
      }
    ],
    "name": "ClaimRewards",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": false,
        "internalType": "uint256",
        "name": "newValue",
        "type": "uint256"
      }
    ],
    "name": "CompoundCooldownUpdated",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "internalType": "address",
        "name": "user",
        "type": "address"
      },
      {
        "indexed": false,
        "internalType": "uint256",
        "name": "amount",
        "type": "uint256"
      }
    ],
    "name": "CompoundRewards",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "internalType": "address",
        "name": "user",
        "type": "address"
      },
      {
        "indexed": false,
        "internalType": "uint256",
        "name": "amount",
        "type": "uint256"
      },
      {
        "indexed": true,
        "internalType": "address",
        "name": "referrer",
        "type": "address"
      }
    ],
    "name": "Deposit",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": false,
        "internalType": "uint256",
        "name": "newValue",
        "type": "uint256"
      }
    ],
    "name": "DeveloperFeePercentageUpdated",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": false,
        "internalType": "uint256",
        "name": "amount",
        "type": "uint256"
      }
    ],
    "name": "EmergencyWithdraw",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": false,
        "internalType": "uint256",
        "name": "newValue",
        "type": "uint256"
      }
    ],
    "name": "MaxDailyRewardPercentageUpdated",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": false,
        "internalType": "uint256",
        "name": "newValue",
        "type": "uint256"
      }
    ],
    "name": "MinDepositAmountUpdated",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": false,
        "internalType": "uint256",
        "name": "newValue",
        "type": "uint256"
      }
    ],
    "name": "ReferralTaxPercentageUpdated",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": false,
        "internalType": "uint256",
        "name": "newValue",
        "type": "uint256"
      }
    ],
    "name": "RewardClaimFeePercentageUpdated",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": false,
        "internalType": "uint256",
        "name": "launchedAt",
        "type": "uint256"
      }
    ],
    "name": "TradingEnabled",
    "type": "event"
  },
  {
    "inputs": [],
    "name": "addExternalRevenue",
    "outputs": [],
    "stateMutability": "payable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "baseDailyRewardPercentage",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "_user",
        "type": "address"
      }
    ],
    "name": "calculatePendingMiningRewards",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "_wallet",
        "type": "address"
      }
    ],
    "name": "changeClaimTaxWallet",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "_wallet",
        "type": "address"
      }
    ],
    "name": "changeDepositTaxWallet",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "_newOwner",
        "type": "address"
      }
    ],
    "name": "changeOwner",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "claimReferralRewards",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "claimRewards",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "claimTaxWallet",
    "outputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "compoundCooldown",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "compoundRewards",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "_referrer",
        "type": "address"
      }
    ],
    "name": "deposit",
    "outputs": [],
    "stateMutability": "payable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "depositTaxWallet",
    "outputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "developerFeePercentage",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "enableTrading",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "_user",
        "type": "address"
      }
    ],
    "name": "getTotalEarnings",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "_user",
        "type": "address"
      }
    ],
    "name": "getUserInfo",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "deposited",
        "type": "uint256"
      },
      {
        "internalType": "uint256",
        "name": "withdrawable",
        "type": "uint256"
      },
      {
        "internalType": "uint256",
        "name": "withdrawableAfterFee",
        "type": "uint256"
      },
      {
        "internalType": "uint256",
        "name": "dailyRate",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "launchedAt",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "maxDailyRewardPercentage",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "minDepositAmount",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "owner",
    "outputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "referralTaxPercentage",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "rewardClaimFeePercentage",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "uint256",
        "name": "_value",
        "type": "uint256"
      }
    ],
    "name": "setBaseDailyRewardPercentage",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "uint256",
        "name": "_value",
        "type": "uint256"
      }
    ],
    "name": "setCompoundCooldown",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "uint256",
        "name": "_value",
        "type": "uint256"
      }
    ],
    "name": "setDeveloperFeePercentage",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "uint256",
        "name": "_value",
        "type": "uint256"
      }
    ],
    "name": "setMaxDailyRewardPercentage",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "uint256",
        "name": "_value",
        "type": "uint256"
      }
    ],
    "name": "setMinDepositAmount",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "uint256",
        "name": "_value",
        "type": "uint256"
      }
    ],
    "name": "setReferralTaxPercentage",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "uint256",
        "name": "_value",
        "type": "uint256"
      }
    ],
    "name": "setRewardClaimFeePercentage",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "totalDeposits",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "totalMiningPool",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "totalMiningRewardsPaid",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "totalReferralPool",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "totalReferralRewardsPaid",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "totalUsers",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "tradingActive",
    "outputs": [
      {
        "internalType": "bool",
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "name": "userBankedRewards",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "name": "userDeposits",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "name": "userLastClaimTime",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "name": "userLastCompoundTime",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "name": "userMiningEarnings",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "name": "userReferralEarnings",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "name": "userReferrer",
    "outputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  }
]

pragma solidity 0.8.19;

// https://x.com/thehoodponzi
// https://www.thehoodponzi.com

contract HoodPonzi {

    // ===== TUNABLE PARAMETERS (owner-adjustable) =====

    uint256 public baseDailyRewardPercentage = 8;
    uint256 public maxDailyRewardPercentage  = 12;
    uint256 public referralTaxPercentage     = 10;
    uint256 public developerFeePercentage    = 5;
    uint256 public rewardClaimFeePercentage  = 5;
    uint256 public minDepositAmount          = 0.01 ether;
    uint256 public compoundCooldown          = 3600;

    // ===== ADDRESSES =====

    address public owner;
    address public depositTaxWallet;
    address public claimTaxWallet;

    // ===== REENTRANCY GUARD =====

    bool private locked = false;

    // ===== POOLS =====

    uint256 public totalMiningPool;
    uint256 public totalReferralPool;

    // ===== USER DATA =====

    mapping(address => uint256) public userDeposits;
    mapping(address => uint256) public userReferralEarnings;
    mapping(address => uint256) public userMiningEarnings;
    mapping(address => uint256) public userBankedRewards; 
    mapping(address => uint256) public userLastClaimTime;
    mapping(address => uint256) public userLastCompoundTime;
    mapping(address => address) public userReferrer;

    // ===== STATISTICS =====

    uint256 public totalUsers;
    uint256 public totalDeposits;
    uint256 public totalMiningRewardsPaid;
    uint256 public totalReferralRewardsPaid;

    // ===== CONTROL =====

    bool    public tradingActive = false;
    uint256 public launchedAt;

    // ===== EVENTS =====

    event Deposit(address indexed user, uint256 amount, address indexed referrer);
    event ClaimRewards(address indexed user, uint256 amount);
    event ClaimReferralRewards(address indexed user, uint256 amount);
    event CompoundRewards(address indexed user, uint256 amount);
    event TradingEnabled(uint256 launchedAt);
    event EmergencyWithdraw(uint256 amount);
    event BaseDailyRewardPercentageUpdated(uint256 newValue);
    event MaxDailyRewardPercentageUpdated(uint256 newValue);
    event ReferralTaxPercentageUpdated(uint256 newValue);
    event DeveloperFeePercentageUpdated(uint256 newValue);
    event RewardClaimFeePercentageUpdated(uint256 newValue);
    event MinDepositAmountUpdated(uint256 newValue);
    event CompoundCooldownUpdated(uint256 newValue);

    // ===== MODIFIERS =====

    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can call this function");
        _;
    }

    modifier validDeposit() {
        require(tradingActive, "Trading is not active yet");
        require(msg.value >= minDepositAmount, "Deposit amount is below minimum");
        _;
    }

    modifier userExists() {
        require(userDeposits[msg.sender] > 0, "User does not exist");
        _;
    }

    modifier respectsCompoundCooldown() {
        require(
            block.timestamp >= userLastCompoundTime[msg.sender] + compoundCooldown,
            "Compound cooldown not met"
        );
        _;
    }

    modifier noReentrancy() {
        require(!locked, "Reentrancy detected");
        locked = true;
        _;
        locked = false;
    }

    // ===== CONSTRUCTOR =====

    constructor() {
        owner            = msg.sender;
        depositTaxWallet = 0x3f4827B088B484b6976b07Ee0e246dbaD4ca2b80;
        claimTaxWallet   = 0xfFc5FD7a5e3b3dd06EE81f53f0337A7122CA347a; 
    }

    // ===== OWNER FUNCTIONS =====

    function enableTrading() external onlyOwner {
        require(!tradingActive, "Trading is already active");
        tradingActive = true;
        launchedAt    = block.timestamp;
        emit TradingEnabled(launchedAt);
    }

    function changeOwner(address _newOwner) public onlyOwner {
        require(_newOwner != address(0), "New owner cannot be zero address");
        owner = _newOwner;
    }

    function changeDepositTaxWallet(address _wallet) public onlyOwner {
        require(_wallet != address(0), "Cannot be zero address");
        require(_wallet.code.length == 0, "Must be EOA");
        depositTaxWallet = _wallet;
    }

    function changeClaimTaxWallet(address _wallet) public onlyOwner {
        require(_wallet != address(0), "Cannot be zero address");
        require(_wallet.code.length == 0, "Must be EOA");
        claimTaxWallet = _wallet;
    }

    function addExternalRevenue() public payable onlyOwner {
        totalMiningPool += msg.value;
    }

    function setBaseDailyRewardPercentage(uint256 _value) external onlyOwner {
        require(_value <= maxDailyRewardPercentage, "Base cannot exceed max");
        baseDailyRewardPercentage = _value;
        emit BaseDailyRewardPercentageUpdated(_value);
    }

    function setMaxDailyRewardPercentage(uint256 _value) external onlyOwner {
        require(_value >= baseDailyRewardPercentage, "Max cannot be below base");
        require(_value <= 100, "Max cannot exceed 100");
        maxDailyRewardPercentage = _value;
        emit MaxDailyRewardPercentageUpdated(_value);
    }

    function setReferralTaxPercentage(uint256 _value) external onlyOwner {
        require(_value + developerFeePercentage < 100, "Referral tax + developer fee must be below 100%");
        referralTaxPercentage = _value;
        emit ReferralTaxPercentageUpdated(_value);
    }

    function setDeveloperFeePercentage(uint256 _value) external onlyOwner {
        require(referralTaxPercentage + _value < 100, "Referral tax + developer fee must be below 100%");
        developerFeePercentage = _value;
        emit DeveloperFeePercentageUpdated(_value);
    }

    function setRewardClaimFeePercentage(uint256 _value) external onlyOwner {
        require(_value <= 100, "Claim fee cannot exceed 100%");
        rewardClaimFeePercentage = _value;
        emit RewardClaimFeePercentageUpdated(_value);
    }

    function setMinDepositAmount(uint256 _value) external onlyOwner {
        require(_value > 0, "Must be greater than zero");
        minDepositAmount = _value;
        emit MinDepositAmountUpdated(_value);
    }

    function setCompoundCooldown(uint256 _value) external onlyOwner {
        compoundCooldown = _value;
        emit CompoundCooldownUpdated(_value);
    }

    // ===== MAIN FUNCTIONS =====

    /**
     * @dev Deposit ETH
     *
     *  With referrer    : 85% pool | 10% referrer (pull) | 5% depositTaxWallet
     *  No referrer      : 90% pool | 5% depositTaxWallet (referral) | 5% depositTaxWallet (fee)
     */
    function deposit(address _referrer) public payable validDeposit noReentrancy {
        _checkpointRewards(msg.sender);

        uint256 referralTax      = msg.value * referralTaxPercentage / 100;
        uint256 developerFee     = msg.value * developerFeePercentage / 100;
        uint256 miningPoolAmount = msg.value - referralTax - developerFee;

        totalMiningPool += miningPoolAmount;

        if (userDeposits[msg.sender] == 0) {
            totalUsers++;
            userLastCompoundTime[msg.sender] = block.timestamp;
        }

        userDeposits[msg.sender] += msg.value;
        totalDeposits            += msg.value;

        uint256 devReferralPush = 0;

        if (userReferrer[msg.sender] != address(0)) {
            userReferralEarnings[userReferrer[msg.sender]] += referralTax;
            totalReferralPool                              += referralTax;
        } else if (_referrer != address(0) && _referrer != msg.sender) {
            userReferrer[msg.sender]         = _referrer;
            userReferralEarnings[_referrer] += referralTax;
            totalReferralPool               += referralTax;
        } else {
            uint256 devShare  = referralTax / 2;
            uint256 poolShare = referralTax - devShare;
            totalMiningPool  += poolShare;
            devReferralPush   = devShare;
        }

        emit Deposit(msg.sender, msg.value, userReferrer[msg.sender]);

        (bool ok1, ) = payable(depositTaxWallet).call{value: developerFee}("");
        require(ok1, "Deposit fee transfer failed");

        if (devReferralPush > 0) {
            (bool ok2, ) = payable(depositTaxWallet).call{value: devReferralPush}("");
            require(ok2, "Dev referral transfer failed");
        }
    }

    /**
     * @dev Claim mining rewards.
     *  
     */
    function claimRewards() public userExists noReentrancy {
        uint256 rewards = calculatePendingMiningRewards(msg.sender);
        require(rewards > 0, "No rewards to claim");

        uint256 claimFee    = rewards * rewardClaimFeePercentage / 100;
        uint256 userRewards = rewards - claimFee;

        userMiningEarnings[msg.sender] += userRewards;
        userBankedRewards[msg.sender]   = 0;
        userLastClaimTime[msg.sender]   = block.timestamp;
        totalMiningRewardsPaid         += userRewards;
        totalMiningPool                -= rewards;

        emit ClaimRewards(msg.sender, userRewards);

        (bool ok1, ) = payable(claimTaxWallet).call{value: claimFee}("");
        require(ok1, "Claim fee transfer failed");

        (bool ok2, ) = payable(msg.sender).call{value: userRewards}("");
        require(ok2, "Rewards transfer failed");
    }

    /**
     * @dev Compound rewards back into deposit - 1 hour cooldown.
     */
    function compoundRewards() public userExists respectsCompoundCooldown noReentrancy {
        uint256 rewards = calculatePendingMiningRewards(msg.sender);
        require(rewards > 0, "No rewards to compound");

        userMiningEarnings[msg.sender]   += rewards;
        userBankedRewards[msg.sender]     = 0;
        userLastClaimTime[msg.sender]     = block.timestamp;
        userLastCompoundTime[msg.sender]  = block.timestamp;
        totalMiningPool                  -= rewards;
        userDeposits[msg.sender]         += rewards;
        totalDeposits                    += rewards;

        emit CompoundRewards(msg.sender, rewards);
    }

    /**
     * @dev Claim referral rewards
     */
    function claimReferralRewards() public noReentrancy {
        uint256 rewards = userReferralEarnings[msg.sender];
        require(rewards > 0, "No referral rewards to claim");

        userReferralEarnings[msg.sender]  = 0;
        totalReferralRewardsPaid         += rewards;
        totalReferralPool                -= rewards;

        (bool success, ) = payable(msg.sender).call{value: rewards}("");
        require(success, "Referral rewards transfer failed");

        emit ClaimReferralRewards(msg.sender, rewards);
    }

    // ===== VIEW FUNCTIONS =====

    /**
     * @dev Reward accrued by the user's CURRENT deposit balance since userLastClaimTime.
     *      Does not include already-banked rewards from a prior, smaller balance.
     */
    function _freshAccrual(address _user) internal view returns (uint256) {
        if (userDeposits[_user] == 0 || totalDeposits == 0) return 0;

        uint256 timePassed          = block.timestamp - userLastClaimTime[_user];
        uint256 userShare           = userDeposits[_user] * 1e18 / totalDeposits;
        uint256 dailyRate           = _getCurrentDailyRewardPercentage();
        uint256 dailyRewards        = totalMiningPool * dailyRate / 100;
        uint256 userDailyRewards    = dailyRewards * userShare / 1e18;

        return userDailyRewards * timePassed / 86400;
    }

    function calculatePendingMiningRewards(address _user) public view returns (uint256) {
        uint256 total = userBankedRewards[_user] + _freshAccrual(_user);
        return total > totalMiningPool ? totalMiningPool : total;
    }

    function getUserInfo(address _user) public view returns (
        uint256 deposited,
        uint256 withdrawable,
        uint256 withdrawableAfterFee,
        uint256 dailyRate
    ) {
        deposited            = userDeposits[_user];
        withdrawable         = calculatePendingMiningRewards(_user);
        withdrawableAfterFee = withdrawable * (100 - rewardClaimFeePercentage) / 100;
        dailyRate            = totalDeposits > 0 ? _getCurrentDailyRewardPercentage() : 0;
    }

    function getTotalEarnings(address _user) public view returns (uint256) {
        return userMiningEarnings[_user] + userReferralEarnings[_user] + calculatePendingMiningRewards(_user);
    }

    // ===== INTERNAL =====

    /**
     * @dev Bank the reward earned by the current balance up to now, then reset the
     *      accrual clock. Must be called before userDeposits[_user] changes for any
     *      reason other than claim/compound (which already reset the clock themselves).
     */
    function _checkpointRewards(address _user) internal {
        uint256 fresh = _freshAccrual(_user);
        if (fresh > 0) {
            userBankedRewards[_user] += fresh;
        }
        userLastClaimTime[_user] = block.timestamp;
    }

    function _getCurrentDailyRewardPercentage() internal view returns (uint256) {
        if (totalDeposits == 0) return 0;

        uint256 contractRatio = totalMiningPool * 100 / totalDeposits;

        if (contractRatio < 80) {
            return baseDailyRewardPercentage * contractRatio / 80;
        } else if (contractRatio > 120) {
            uint256 bonus           = (contractRatio - 120) / 30;
            uint256 increasedReward = baseDailyRewardPercentage + bonus;
            return increasedReward > maxDailyRewardPercentage
                ? maxDailyRewardPercentage
                : increasedReward;
        }

        return baseDailyRewardPercentage;
    }
}