Piron.sol

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

interface IERC20 {
  function totalSupply() external view returns (uint256);

  function balanceOf(address account) external view returns (uint256);

  function allowance(address owner, address spender)
    external
    view
    returns (uint256);

  function transfer(address recipient, uint256 amount) external returns (bool);

  function approve(address spender, uint256 amount) external returns (bool);

  function transferFrom(
    address sender,
    address recipient,
    uint256 amount
  ) external returns (bool);

  event Transfer(address indexed from, address indexed to, uint256 value);
  event Approval(address indexed owner, address indexed spender, uint256 value);
}

contract PironToken is IERC20 {
  using SafeMath for uint256;

  string public name;
  string public symbol;
  uint8 public decimals;
  uint256 public totalSupply_;

  mapping(address => uint256) balances;
  mapping(address => mapping(address => uint256)) allowed;

  constructor() {
    name = "PironToken";
    symbol = "PTK";
    decimals = 10;
    totalSupply_ = 1000000000000; // total tokens would equal (totalSupply_/10**decimals)=1000
    balances[msg.sender] = totalSupply_;
  }

  function totalSupply() public view override returns (uint256) {
    return totalSupply_;
  }

  function balanceOf(address tokenOwner)
    public
    view
    override
    returns (uint256)
  {
    return balances[tokenOwner];
  }

  function transfer(address receiver, uint256 numTokens)
    public
    override
    returns (bool)
  {
    require(numTokens <= balances[msg.sender]);
    balances[msg.sender] = balances[msg.sender].sub(numTokens);
    balances[receiver] = balances[receiver].add(numTokens);
    emit Transfer(msg.sender, receiver, numTokens);
    return true;
  }

  function approve(address delegate, uint256 numTokens)
    public
    override
    returns (bool)
  {
    allowed[msg.sender][delegate] = numTokens;
    emit Approval(msg.sender, delegate, numTokens);
    return true;
  }

  function allowance(address owner, address delegate)
    public
    view
    override
    returns (uint256)
  {
    return allowed[owner][delegate];
  }

  function transferFrom(
    address owner,
    address buyer,
    uint256 numTokens
  ) public override returns (bool) {
    require(numTokens <= balances[owner]);
    require(numTokens <= allowed[owner][msg.sender]);

    balances[owner] = balances[owner].sub(numTokens);
    allowed[owner][msg.sender] = allowed[owner][msg.sender].sub(numTokens);
    balances[buyer] = balances[buyer].add(numTokens);
    emit Transfer(owner, buyer, numTokens);
    return true;
  }
}

library SafeMath {
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    assert(c >= a);
    return c;
  }
}

Staking.sol

// SPDX-License-Identifier: GPL-3.0-only

pragma solidity ^0.8.14;

import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Context.sol";

import "./Piron.sol";

contract StakePIR is Pausable, Ownable, ReentrancyGuard {
  IERC20 pirToken;

  // 30 Days (30 * 24 * 60 * 60)
  uint256 public planDuration = 2592000;

  // 180 Days (180 * 24 * 60 * 60)
  uint256 _planExpired = 15552000;

  uint8 public interestRate = 32;
  uint256 public planExpired;
  uint8 public totalStakers;

  struct StakeInfo {
    uint256 startTS;
    uint256 endTS;
    uint256 amount;
    uint256 claimed;
  }

  event Staked(address indexed from, uint256 amount);
  event Claimed(address indexed from, uint256 amount);

  mapping(address => StakeInfo) public stakeInfos;
  mapping(address => bool) public addressStaked;

  constructor(address _tokenAddress) {
    require(
      address(_tokenAddress) != address(0),
      "Token Address cannot be address 0"
    );
    pirToken = IERC20(_tokenAddress);
    planExpired = block.timestamp + _planExpired;
    totalStakers = 0;
  }

  function transferToken(address to, uint256 amount) external onlyOwner {
    require(pirToken.transfer(to, amount), "Token transfer failed!");
  }

  function claimReward() external returns (bool) {
    require(addressStaked[_msgSender()] == true, "You are not participated");
    require(
      stakeInfos[_msgSender()].endTS < block.timestamp,
      "Stake Time is not over yet"
    );
    require(stakeInfos[_msgSender()].claimed == 0, "Already claimed");

    uint256 stakeAmount = stakeInfos[_msgSender()].amount;
    uint256 totalTokens = stakeAmount + ((stakeAmount * interestRate) / 100); //adds interest
    stakeInfos[_msgSender()].claimed == totalTokens; // update the stakeinfo
    pirToken.transfer(_msgSender(), totalTokens);

    emit Claimed(_msgSender(), totalTokens);

    return true;
  }

  function getTokenExpiry() external view returns (uint256) {
    require(addressStaked[_msgSender()] == true, "You are not participated");
    return stakeInfos[_msgSender()].endTS;
  }

  function stakeToken(uint256 stakeAmount) external payable whenNotPaused {
    require(stakeAmount > 0, "Stake amount should be correct");
    require(block.timestamp < planExpired, "Plan Expired");
    require(addressStaked[msg.sender] == false, "You already participated");
    require(
      pirToken.balanceOf(msg.sender) >= stakeAmount,
      "Insufficient Balance"
    );

    pirToken.transferFrom(msg.sender, address(this), stakeAmount);
    totalStakers++;
    addressStaked[msg.sender] = true;

    stakeInfos[msg.sender] = StakeInfo({
      startTS: block.timestamp,
      endTS: block.timestamp + planDuration,
      amount: stakeAmount,
      claimed: 0
    });

    emit Staked(msg.sender, stakeAmount);
  }

  function pause() external onlyOwner {
    _pause();
  }

  function unpause() external onlyOwner {
    _unpause();
  }
}