RewardContract

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

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

contract Ownable {
    address private _owner;
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    constructor() {
        _owner = msg.sender;
        emit OwnershipTransferred(address(0), msg.sender);
    }
    modifier onlyOwner() {
        require(msg.sender == _owner, "Ownable: caller is not the owner");
        _;
    }
    function owner() public view returns (address) {
        return _owner;
    }
    function transferOwnership(address newOwner) public onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

contract ReentrancyGuard {
    uint256 private _status = 1;
    modifier nonReentrant() {
        require(_status != 2, "Reentrant call");
        _status = 2;
        _;
        _status = 1;
    }
}

contract RewardContract is Ownable, ReentrancyGuard {
    IERC20 public rewardToken;

    struct RewardHistory {
        uint256 amount;
        uint256 timestamp;
    }

    mapping(address => uint256) public rewards;
    mapping(address => RewardHistory[]) public rewardHistory;

    uint256 public claimStartTime;

    event RewardAdded(address indexed user, uint256 amount);
    event RewardClaimed(address indexed user, uint256 amount);

    constructor(address _rewardToken) {
        require(_rewardToken != address(0), "Invalid token address");
        rewardToken = IERC20(_rewardToken);
    }

    function addReward(address user, uint256 amount) external onlyOwner {
        require(user != address(0), "Invalid user address");
        require(amount > 0, "Amount must be greater than zero");
        rewards[user] += amount;
        rewardHistory[user].push(RewardHistory(amount, block.timestamp));
        emit RewardAdded(user, amount);
    }

    function claimReward() external nonReentrant {
        require(block.timestamp >= claimStartTime, "Claiming not started");
        uint256 reward = rewards[msg.sender];
        require(reward > 0, "No rewards available");
        require(rewardToken.balanceOf(address(this)) >= reward, "Insufficient contract balance");
        rewards[msg.sender] = 0;
        require(rewardToken.transfer(msg.sender, reward), "Transfer failed");
        emit RewardClaimed(msg.sender, reward);
    }

    function setClaimStartTime(uint256 _startTime) external onlyOwner {
        claimStartTime = _startTime;
    }

    function getPendingReward(address user) external view returns (uint256) {
        return rewards[user];
    }
}