RewardContract

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

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() external view returns (address) {
        return _owner;
    }

    function transferOwnership(address newOwner) external onlyOwner {
        require(newOwner != address(0), "Ownable: zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

contract ReentrancyGuard {
    uint256 private _status = 1;

    modifier nonReentrant() {
        require(_status != 2, "ReentrancyGuard: reentrant call");
        _status = 2;
        _;
        _status = 1;
    }
}

contract RewardContract is Ownable, ReentrancyGuard {
    IERC20 public immutable 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 > 0");
        rewards[user] += amount;
        rewardHistory[user].push(RewardHistory(amount, block.timestamp));
        emit RewardAdded(user, amount);
    }

    /// @notice 사용자가 보상을 청구
    function claimReward() external nonReentrant {
        require(block.timestamp >= claimStartTime, "Claiming not started");
        uint256 reward = rewards[msg.sender];
        require(reward > 0, "No rewards available");

        uint256 contractBalance = rewardToken.balanceOf(address(this));
        require(contractBalance >= reward, "Insufficient contract balance");

        rewards[msg.sender] = 0;

        bool sent = rewardToken.transfer(msg.sender, reward);
        require(sent, "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];
    }
}