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;   // 36 months
    uint256 public constant CLAIM_WAIT  = 7 days;        // 7-day claim interval
    uint256 public constant MAX_MONTHLY = 4;            // 4 claims/month max
    uint256 public constant BPS         = 10_000;

    // ── PACKAGE TIERS ──────────────────────────────────
    struct Tier {
        uint256 minDeposit;    // in USDT (18 decimals)
        uint256 monthlyBPS;    // monthly ROI in basis points
        string  name;
    }
    Tier[6] public tiers;

    // ── USER STATE ─────────────────────────────────────
    struct Stake {
        uint256 principal;     // deposited amount
        uint256 startTime;
        uint256 lastClaim;
        uint256 monthClaims;   // resets every 30 days
        uint256 monthStart;
        uint8   tier;
        bool    active;
    }
    mapping(address => Stake[]) public stakes;

    // ── GLOBAL STATS ───────────────────────────────────
    uint256 public totalUsers;
    uint256 public totalDeposited;
    uint256 public totalWithdrawn;

    // ── EVENTS ─────────────────────────────────────────
    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;

        // Initialize 6 package tiers
        tiers[0] = Tier(250  * 1e18, 400,  "Basic");    // 4.00% / mo
        tiers[1] = Tier(500  * 1e18, 425,  "Standard"); // 4.25% / mo
        tiers[2] = Tier(1000 * 1e18, 450,  "Advanced"); // 4.50% / mo
        tiers[3] = Tier(2500 * 1e18, 475,  "Premium");  // 4.75% / mo
        tiers[4] = Tier(5000 * 1e18, 500,  "Pro");      // 5.00% / mo
        tiers[5] = Tier(10000* 1e18, 556,  "Elite");    // 5.56% / mo
    }

    // ── DEPOSIT ────────────────────────────────────────
    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);
    }

    // ── CLAIM ROI ──────────────────────────────────────
    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");

        // Reset monthly counter every 30 days
        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);
    }

    // ── WITHDRAW PRINCIPAL (after maturity) ────────────
    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);
    }

    // ── VIEW HELPERS ───────────────────────────────────
    function pendingROI(address user, uint256 stakeId)
        external view returns (uint256)
    {
        Stake storage s = stakes[user][stakeId];
        if (!s.active) return 0;
        if (block.timestamp < s.lastClaim + CLAIM_WAIT) return 0;
        return (s.principal * tiers[s.tier].monthlyBPS) / BPS / 4;
    }

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

    function getStakes(address user)
        external view returns (Stake[] memory)
    {
        return stakes[user];
    }
}