ERC20stakingg

// SPDX-License-Identifier: MIT
// Compatible with OpenZeppelin Contracts ^5.6.0
pragma solidity ^0.8.27;

import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract ERC20Staking is Ownable {
    struct Staking {
        uint256 totalAmount;
        uint256 claimed;
        uint64 startTime;
        uint64 endTime;
        uint64 cliff;
        uint64 minimalAmountToClaim;
        uint64 cooldownEndsAt;
    }

    /// @notice Vesting data per beneficiary
    mapping(address => Staking) public stakes;

    /// @notice ERC20 token used for payouts
    IERC20 public token;

    /// @notice Global vesting schedule parameters (shared by all beneficiaries)
    uint64 public globalStartTime;
    uint64 public globalEndTime;
    uint64 public globalCliff;
    uint64 public globalMinimalAmountToClaim;

    /// @notice Cooldown duration (in seconds) after each claim
    uint64 public cooldownDuration;

    /// @notice Total amount allocated across all beneficiaries
    uint256 public totalAllocated;

    event VestingStarted(address indexed beneficiary, uint256 amount);
    event Claimed(address indexed beneficiary, uint256 amount);
    event CooldownSet(address indexed beneficiary, uint64 until);

    constructor(
        address token_,
        uint64 startTime_,
        uint64 endTime_,
        uint64 cliff_,
        uint64 minimalAmountToClaim_,
        uint64 cooldownDuration_
    ) Ownable(msg.sender) {
        require(token_ != address(0), "Token is zero");
        require(startTime_ < endTime_, "Invalid time range");
        require(cliff_ >= startTime_, "Cliff before start");

        token = IERC20(token_);
        globalStartTime = startTime_;
        globalEndTime = endTime_;
        globalCliff = cliff_;
        globalMinimalAmountToClaim = minimalAmountToClaim_;
        cooldownDuration = cooldownDuration_;
    }

    /// @notice Fill or extend vesting stakes for multiple beneficiaries.
    /// @dev Assumes the contract is already funded with enough tokens.
    function startVesting(
        address[] calldata beneficiaries,
        uint256[] calldata amounts
    ) external onlyOwner {
        uint256 length = beneficiaries.length;
        require(length == amounts.length && length > 0, "Invalid input");

        uint256 addedTotal;

        for (uint256 i = 0; i < length; i++) {
            address beneficiary = beneficiaries[i];
            uint256 amount = amounts[i];

            require(beneficiary != address(0), "Zero beneficiary");
            require(amount > 0, "Zero amount");

            Staking storage s = stakes[beneficiary];

            // First time configuration for this beneficiary
            if (s.totalAmount == 0 && s.claimed == 0) {
                s.startTime = globalStartTime;
                s.endTime = globalEndTime;
                s.cliff = globalCliff;
                s.minimalAmountToClaim = globalMinimalAmountToClaim;
            } else {
                // Ensure that all schedules remain aligned with the global one
                require(
                    s.startTime == globalStartTime &&
                        s.endTime == globalEndTime &&
                        s.cliff == globalCliff &&
                        s.minimalAmountToClaim == globalMinimalAmountToClaim,
                    "Schedule mismatch"
                );
            }

            s.totalAmount += amount;
            addedTotal += amount;

            emit VestingStarted(beneficiary, amount);
        }

        totalAllocated += addedTotal;
        require(totalAllocated <= token.balanceOf(address(this)), "Insufficient pool");
    }

    /// @notice Claim vested tokens for the caller.
    /// @param requestedAmount If 0, claims full available amount, otherwise
    /// claims the minimum of requestedAmount and the currently claimable amount.
    function claim(uint256 requestedAmount) external {
        Staking storage s = stakes[msg.sender];

        require(s.totalAmount > 0, "No vesting");
        require(block.timestamp >= s.startTime, "Vesting not started");
        require(block.timestamp >= s.cliff, "Cliff not reached");
        require(block.timestamp < s.endTime, "Vesting ended");
        require(block.timestamp >= s.cooldownEndsAt, "Cooldown active");

        uint256 duration = uint256(s.endTime) - uint256(s.startTime);
        require(duration > 0, "Invalid duration");

        uint256 timePassed = block.timestamp - uint256(s.startTime);
        if (timePassed > duration) {
            timePassed = duration;
        }

        uint256 vestedTotal = (s.totalAmount * timePassed) / duration;

        if (vestedTotal <= s.claimed) {
            revert("Nothing to claim");
        }

        uint256 claimable = vestedTotal - s.claimed;
        require(claimable >= s.minimalAmountToClaim, "Too small");

        uint256 claimAmount = claimable;
        if (requestedAmount > 0 && requestedAmount < claimable) {
            claimAmount = requestedAmount;
        }

        s.claimed += claimAmount;
        s.cooldownEndsAt = uint64(block.timestamp + cooldownDuration);

        require(token.transfer(msg.sender, claimAmount), "Transfer failed");

        emit Claimed(msg.sender, claimAmount);
        emit CooldownSet(msg.sender, s.cooldownEndsAt);
    }
}