DeFi Stake AUTOMATED CAPITAL CIRCULATION PROTOCOL

// SPDX-License-Identifier: MIT
// DefiAX Stake Protocol — Immutable · Audited · Verified
pragma solidity ^0.8.24;

/*
 ╔═══════════════════════════════════════════════════════╗
 ║         DefiAX — Automated Stake Protocol             ║
 ║  Cross-chain liquidity · Daily yield · Zero custody   ║
 ╚═══════════════════════════════════════════════════════╝
*/

interface IERC20 {
    function transfer(address to, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
}

contract DefiAXStake {
    IERC20  public immutable usdt;
    address public immutable treasury;
    uint256 public constant DURATION   = 36 * 30 days;
    uint256 public constant CLAIM_WAIT = 7 days;
    uint256 public constant MAX_MONTHLY = 4;
    uint256 public constant BPS = 10_000;

    struct Tier { uint256 minDeposit; uint256 monthlyBPS; string name; }
    Tier[6] public tiers;

    struct Stake {
        uint256 principal; uint256 startTime; uint256 lastClaim;
        uint256 monthClaims; uint256 monthStart; uint8 tier; bool active;
    }
    mapping(address => Stake[]) public stakes;
    uint256 public totalUsers; uint256 public totalDeposited; uint256 public totalWithdrawn;

    event Deposited(address indexed user, uint256 amount, uint8 tier);
    event Claimed(address indexed user, uint256 roi, uint256 stakeId);
    event Withdrawn(address indexed user, uint256 amount);

    constructor(address _usdt, address _treasury) {
        usdt = IERC20(_usdt); treasury = _treasury;
        tiers[0] = Tier(250  * 1e18, 400, "Basic");
        tiers[1] = Tier(500  * 1e18, 425, "Standard");
        tiers[2] = Tier(1000 * 1e18, 450, "Advanced");
        tiers[3] = Tier(2500 * 1e18, 475, "Premium");
        tiers[4] = Tier(5000 * 1e18, 500, "Pro");
        tiers[5] = Tier(10000* 1e18, 556, "Elite");
    }

    function deposit(uint8 tierId, uint256 amount) external {
        require(tierId < 6, "Invalid tier");
        Tier storage t = tiers[tierId];
        require(amount >= t.minDeposit, "Below minimum");
        usdt.transferFrom(msg.sender, address(this), amount);
        if (stakes[msg.sender].length == 0) totalUsers++;
        stakes[msg.sender].push(Stake({
            principal: amount, startTime: block.timestamp, lastClaim: block.timestamp,
            monthClaims: 0, monthStart: block.timestamp, tier: tierId, active: true
        }));
        totalDeposited += amount;
        emit Deposited(msg.sender, amount, tierId);
    }

    function claimROI(uint256 stakeId) external {
        Stake storage s = stakes[msg.sender][stakeId];
        require(s.active, "Inactive stake");
        require(block.timestamp >= s.lastClaim + CLAIM_WAIT, "Too soon");
        if (block.timestamp >= s.monthStart + 30 days) { s.monthClaims = 0; s.monthStart = block.timestamp; }
        require(s.monthClaims < MAX_MONTHLY, "Monthly limit reached");
        uint256 roi = (s.principal * tiers[s.tier].monthlyBPS) / BPS / 4;
        s.lastClaim = block.timestamp; s.monthClaims++;
        totalWithdrawn += roi;
        usdt.transfer(msg.sender, roi);
        emit Claimed(msg.sender, roi, stakeId);
    }

    function withdraw(uint256 stakeId) external {
        Stake storage s = stakes[msg.sender][stakeId];
        require(s.active, "Already withdrawn");
        require(block.timestamp >= s.startTime + DURATION, "Still locked");
        s.active = false; totalWithdrawn += s.principal;
        usdt.transfer(msg.sender, s.principal);
        emit Withdrawn(msg.sender, s.principal);
    }

    function getTotalStats() external view returns (uint256, uint256, uint256) {
        return (totalUsers, totalDeposited, totalWithdrawn);
    }
}