Contract Name:
PathLPStaking
Contract Source Code:
//SPDX-License-Identifier: MIT
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
pragma solidity 0.8.4;
contract PathLPStaking is Ownable{
IERC20 public stakingToken;
IERC20 public rewardToken;
uint public rewardRate = 0;
uint public rewardsDuration = 365 days;
uint public startRewardsTime;
uint public lastUpdateTime;
uint public lastRewardTimestamp;
uint public rewardPerTokenStored;
// total staked
uint private stakedSupply = 0;
uint private claimedRewards = 0;
mapping(address => uint) public userRewardPerTokenPaid;
mapping(address => uint) public rewards;
mapping(address => uint) private _balances;
event Staked(address indexed user, uint amountStaked);
event Withdrawn(address indexed user, uint amountWithdrawn);
event RewardsClaimed(address indexed user, uint rewardsClaimed);
event RewardAmountSet(uint rewardRate, uint duration);
event Recovered(address tokenAddress, uint tokenAmount);
constructor(address _stakingTokenAddress, address _rewardTokenAddress, uint _startRewards) {
stakingToken = IERC20(_stakingTokenAddress);
rewardToken = IERC20(_rewardTokenAddress);
startRewardsTime = _startRewards;
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = rewardTimestamp();
if (account != address(0)){
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
//function to check if staking rewards have ended
function rewardTimestamp() internal view returns (uint) {
if (block.timestamp < lastRewardTimestamp) {
return block.timestamp;
}
else {
return lastRewardTimestamp;
}
}
//function to check if staking rewards have started
function startTimestamp() internal view returns (uint) {
if (startRewardsTime > lastUpdateTime) {
return startRewardsTime;
}
else {
return lastUpdateTime;
}
}
function balanceOf(address account) external view returns (uint) {
return _balances[account];
}
function totalStaked() public view returns (uint) {
return stakedSupply;
}
function totalClaimed() public view returns (uint) {
return claimedRewards;
}
function rewardPerToken() public view returns (uint) {
if (stakedSupply == 0 || block.timestamp < startRewardsTime) {
return 0;
}
return rewardPerTokenStored + (
(rewardRate * (rewardTimestamp()- startTimestamp()) * 1e18 / stakedSupply)
);
}
function earned(address account) public view returns (uint) {
return (
_balances[account] * (rewardPerToken() - userRewardPerTokenPaid[account]) / 1e18
) + rewards[account];
}
function stake(uint _amount) external updateReward(msg.sender) {
require(_amount > 0, "Must stake > 0 tokens");
stakedSupply += _amount;
_balances[msg.sender] += _amount;
require(stakingToken.transferFrom(msg.sender, address(this), _amount), "Token transfer failed");
emit Staked(msg.sender, _amount);
}
function withdraw(uint _amount) public updateReward(msg.sender) {
require(_amount > 0, "Must withdraw > 0 tokens");
stakedSupply -= _amount;
_balances[msg.sender] -= _amount;
require(stakingToken.transfer(msg.sender, _amount), "Token transfer failed");
emit Withdrawn(msg.sender, _amount);
}
function getReward() public updateReward(msg.sender) {
uint reward = rewards[msg.sender];
if (reward > 0) {
rewards[msg.sender] = 0;
claimedRewards += reward;
require(rewardToken.transfer(msg.sender, reward), "Token transfer failed");
emit RewardsClaimed(msg.sender, reward);
}
}
function exit() external {
withdraw(_balances[msg.sender]);
getReward();
}
//owner only functions
function setRewardAmount(uint reward, uint _rewardsDuration) onlyOwner external updateReward(address(0)) {
rewardsDuration = _rewardsDuration;
rewardRate = reward / rewardsDuration;
uint balance = rewardToken.balanceOf(address(this));
require(rewardRate <= balance / rewardsDuration, "Contract does not have enough tokens for current reward rate");
lastUpdateTime = block.timestamp;
if (block.timestamp < startRewardsTime) {
lastRewardTimestamp = startRewardsTime + rewardsDuration;
}
else {
lastRewardTimestamp = block.timestamp + rewardsDuration;
}
emit RewardAmountSet(rewardRate, _rewardsDuration);
}
// support recovering rewards
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
require(tokenAddress != address(stakingToken), "Cannot withdraw the staking token");
require(IERC20(tokenAddress).transfer(msg.sender, tokenAmount), "transfer failed");
emit Recovered(tokenAddress, tokenAmount);
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
pragma solidity ^0.8.0;
import "../utils/Context.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_transferOwnership(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}