From 063a4a775cb75f46f9eec346e02d9265d3be7bdd Mon Sep 17 00:00:00 2001 From: CounterFire2023 <136581895+CounterFire2023@users.noreply.github.com> Date: Thu, 12 Sep 2024 12:04:34 +0800 Subject: [PATCH] =?UTF-8?q?=E7=AE=80=E5=8C=96stake=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- contracts/staking/RewardDistributor.sol | 84 ------- contracts/staking/RewardRouter.sol | 2 +- contracts/staking/RewardTracker.sol | 224 ++++-------------- contracts/staking/Vester.sol | 110 ++------- .../staking/interfaces/IRewardDistributor.sol | 9 - .../staking/interfaces/IRewardTracker.sol | 6 +- contracts/staking/interfaces/IVester.sol | 5 +- 7 files changed, 74 insertions(+), 366 deletions(-) delete mode 100644 contracts/staking/RewardDistributor.sol delete mode 100644 contracts/staking/interfaces/IRewardDistributor.sol diff --git a/contracts/staking/RewardDistributor.sol b/contracts/staking/RewardDistributor.sol deleted file mode 100644 index 943ffb0..0000000 --- a/contracts/staking/RewardDistributor.sol +++ /dev/null @@ -1,84 +0,0 @@ -// SPDX-License-Identifier: MIT -pragma solidity 0.8.19; - -import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; -import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol"; -import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; - -import {IRewardDistributor} from "./interfaces/IRewardDistributor.sol"; -import {IRewardTracker} from "./interfaces/IRewardTracker.sol"; -import {Governable} from "../core/Governable.sol"; - -contract RewardDistributor is IRewardDistributor, ReentrancyGuard, Governable { - using SafeERC20 for IERC20; - - address public override rewardToken; - uint256 public override tokensPerInterval; - uint256 public lastDistributionTime; - address public rewardTracker; - - address public admin; - - event Distribute(uint256 amount); - event TokensPerIntervalChange(uint256 amount); - - modifier onlyAdmin() { - require(msg.sender == admin, "RewardDistributor: forbidden"); - _; - } - - constructor(address _rewardToken, address _rewardTracker) { - rewardToken = _rewardToken; - rewardTracker = _rewardTracker; - admin = msg.sender; - } - - function setAdmin(address _admin) external onlyGov { - admin = _admin; - } - - // to help users who accidentally send their tokens to this contract - function withdrawToken(address _token, address _account, uint256 _amount) external onlyGov { - IERC20(_token).safeTransfer(_account, _amount); - } - - function updateLastDistributionTime() external onlyAdmin { - lastDistributionTime = block.timestamp; - } - - function setTokensPerInterval(uint256 _amount) external onlyAdmin { - require(lastDistributionTime != 0, "RewardDistributor: invalid lastDistributionTime"); - IRewardTracker(rewardTracker).updateRewards(); - tokensPerInterval = _amount; - emit TokensPerIntervalChange(_amount); - } - - function pendingRewards() public view override returns (uint256) { - if (block.timestamp == lastDistributionTime) { - return 0; - } - - uint256 timeDiff = block.timestamp - lastDistributionTime; - return tokensPerInterval * timeDiff; - } - - function distribute(uint256 _amount, uint256 _decimals) external override returns (uint256) { - require(msg.sender == rewardTracker, "RewardDistributor: invalid msg.sender"); - uint256 amount = pendingRewards(); - if (amount == 0) { - return 0; - } - - lastDistributionTime = block.timestamp; - - uint256 tokenAmount = amount * _amount / (10**_decimals); - - uint256 balance = IERC20(rewardToken).balanceOf(address(this)); - require(tokenAmount <= balance, "RewardDistributor: insufficient balance"); - - IERC20(rewardToken).safeTransfer(msg.sender, tokenAmount); - - emit Distribute(tokenAmount); - return amount; - } -} diff --git a/contracts/staking/RewardRouter.sol b/contracts/staking/RewardRouter.sol index 6bcd4c2..2798703 100644 --- a/contracts/staking/RewardRouter.sol +++ b/contracts/staking/RewardRouter.sol @@ -48,7 +48,7 @@ contract RewardRouter is ReentrancyGuard, Governable { // check if the user has staked CEC in the vester if (cecVester != address(0) && IVester(cecVester).needCheckStake()) { IVester(cecVester).updateVesting(msg.sender); - require(IERC20(cecVester).balanceOf(msg.sender) + _amount <= IRewardTracker(stakedCecTracker).depositBalances(msg.sender, cec), "RewardRouter: insufficient CEC balance"); + require(IERC20(cecVester).balanceOf(msg.sender) + _amount <= IRewardTracker(stakedCecTracker).stakedAmounts(msg.sender), "RewardRouter: insufficient CEC balance"); } _unstakeCec(msg.sender, cec, _amount); } diff --git a/contracts/staking/RewardTracker.sol b/contracts/staking/RewardTracker.sol index 2b50b64..e1eb61e 100644 --- a/contracts/staking/RewardTracker.sol +++ b/contracts/staking/RewardTracker.sol @@ -5,67 +5,46 @@ import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol"; import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; -import {IRewardDistributor} from "./interfaces/IRewardDistributor.sol"; import {IRewardTracker} from "./interfaces/IRewardTracker.sol"; import {Governable} from "../core/Governable.sol"; -contract RewardTracker is IERC20, ReentrancyGuard, IRewardTracker, Governable { +contract RewardTracker is ReentrancyGuard, IRewardTracker, Governable { using SafeERC20 for IERC20; - uint256 public constant BASIS_POINTS_DIVISOR = 10000; - uint256 public constant PRECISION = 1e30; - - bool public isInitialized; - - string public name; - string public symbol; - uint8 public decimals = 18; - uint256 public override totalSupply; - mapping(address account => uint256 amount) public balances; - mapping(address owner => mapping(address spender => uint256 amount)) public allowance; - - address public distributor; mapping(address token => bool status) public isDepositToken; - mapping(address account => mapping(address token => uint256 amount)) public override depositBalances; mapping(address token => uint256 amount) public totalDepositSupply; - - uint256 public cumulativeRewardPerToken; + mapping(address account => uint256 amount) public override stakedAmounts; mapping(address account => uint256 amount) public claimableReward; - mapping(address account => uint256 amount) public previousCumulatedRewardPerToken; mapping(address account => uint256 amount) public override cumulativeRewards; - mapping(address account => uint256 amount) public override averageStakedAmounts; - bool public inPrivateTransferMode; + mapping(address account => uint256 time) public lastUpdateTimes; + + uint256 public tokensPerInterval; + address public rewardToken; + uint8 public decimals = 18; + bool public inPrivateStakingMode; bool public inPrivateClaimingMode; mapping(address handler => bool status) public isHandler; event Claim(address receiver, uint256 amount); + event TokensPerIntervalChange(uint256 amount); - constructor(string memory _name, string memory _symbol) { - name = _name; - symbol = _symbol; - } - - function initialize(address[] memory _depositTokens, address _distributor) external onlyGov { - require(!isInitialized, "RewardTracker: already initialized"); - isInitialized = true; - - for (uint256 i = 0; i < _depositTokens.length; i++) { - address depositToken = _depositTokens[i]; - isDepositToken[depositToken] = true; - } - - distributor = _distributor; + constructor(address _rewardToken, address _depositToken, uint256 _tokensPerInterval, uint8 _decimals) { + rewardToken = _rewardToken; + isDepositToken[_depositToken] = true; + tokensPerInterval = _tokensPerInterval; + decimals = _decimals; } function setDepositToken(address _depositToken, bool _isDepositToken) external onlyGov { isDepositToken[_depositToken] = _isDepositToken; } - - function setInPrivateTransferMode(bool _inPrivateTransferMode) external onlyGov { - inPrivateTransferMode = _inPrivateTransferMode; + //TODO:: 是否更新用户未领取的奖励 + function setTokensPerInterval(uint256 _amount) external onlyGov { + tokensPerInterval = _amount; + emit TokensPerIntervalChange(_amount); } function setInPrivateStakingMode(bool _inPrivateStakingMode) external onlyGov { @@ -85,10 +64,6 @@ contract RewardTracker is IERC20, ReentrancyGuard, IRewardTracker, Governable { IERC20(_token).safeTransfer(_account, _amount); } - function balanceOf(address _account) external view override returns (uint256) { - return balances[_account]; - } - function stake(address _depositToken, uint256 _amount) external override nonReentrant { if (inPrivateStakingMode) { revert("RewardTracker: action not enabled"); @@ -123,37 +98,6 @@ contract RewardTracker is IERC20, ReentrancyGuard, IRewardTracker, Governable { _unstake(_account, _depositToken, _amount, _receiver); } - function transfer(address _recipient, uint256 _amount) external override returns (bool) { - _transfer(msg.sender, _recipient, _amount); - return true; - } - - - function approve(address _spender, uint256 _amount) external override returns (bool) { - _approve(msg.sender, _spender, _amount); - return true; - } - - function transferFrom(address _sender, address _recipient, uint256 _amount) external override returns (bool) { - if (isHandler[msg.sender]) { - _transfer(_sender, _recipient, _amount); - return true; - } - require(allowance[_sender][msg.sender] >= _amount, "RewardTracker: transfer amount exceeds allowance"); - uint256 nextAllowance = allowance[_sender][msg.sender] - _amount; - _approve(_sender, msg.sender, nextAllowance); - _transfer(_sender, _recipient, _amount); - return true; - } - - function tokensPerInterval() external view override returns (uint256) { - return IRewardDistributor(distributor).tokensPerInterval(); - } - - function updateRewards() external override nonReentrant { - _updateRewards(address(0)); - } - function claim(address _receiver) external override nonReentrant returns (uint256) { if (inPrivateClaimingMode) { revert("RewardTracker: action not enabled"); @@ -171,73 +115,21 @@ contract RewardTracker is IERC20, ReentrancyGuard, IRewardTracker, Governable { if (stakedAmount == 0) { return claimableReward[_account]; } - uint256 pendingRewards = IRewardDistributor(distributor).pendingRewards() * PRECISION; - uint256 nextCumulativeRewardPerToken = cumulativeRewardPerToken + pendingRewards; - return - claimableReward[_account] + - (stakedAmount / (10**decimals) * (nextCumulativeRewardPerToken - previousCumulatedRewardPerToken[_account])) / - PRECISION; - } - - function rewardToken() public view returns (address) { - return IRewardDistributor(distributor).rewardToken(); + uint256 pendingRewards = _getNextClaimableAmount(_account); + return claimableReward[_account] + pendingRewards; } function _claim(address _account, address _receiver) private returns (uint256) { _updateRewards(_account); - uint256 tokenAmount = claimableReward[_account]; claimableReward[_account] = 0; - if (tokenAmount > 0) { - IERC20(rewardToken()).safeTransfer(_receiver, tokenAmount); + IERC20(rewardToken).safeTransfer(_receiver, tokenAmount); emit Claim(_account, tokenAmount); } - return tokenAmount; } - function _mint(address _account, uint256 _amount) internal { - require(_account != address(0), "RewardTracker: mint to the zero address"); - - totalSupply = totalSupply + _amount; - balances[_account] = balances[_account] + _amount; - - emit Transfer(address(0), _account, _amount); - } - - function _burn(address _account, uint256 _amount) internal { - require(_account != address(0), "RewardTracker: burn from the zero address"); - require(balances[_account] >= _amount, "RewardTracker: burn amount exceeds balance"); - balances[_account] = balances[_account] - _amount; - totalSupply = totalSupply - _amount; - - emit Transfer(_account, address(0), _amount); - } - - function _transfer(address _sender, address _recipient, uint256 _amount) private { - require(_sender != address(0), "RewardTracker: transfer from the zero address"); - require(_recipient != address(0), "RewardTracker: transfer to the zero address"); - - if (inPrivateTransferMode) { - _validateHandler(); - } - require(balances[_sender] >= _amount, "RewardTracker: transfer amount exceeds balance"); - balances[_sender] = balances[_sender] - _amount; - balances[_recipient] = balances[_recipient] + _amount; - - emit Transfer(_sender, _recipient, _amount); - } - - function _approve(address _owner, address _spender, uint256 _amount) private { - require(_owner != address(0), "RewardTracker: approve from the zero address"); - require(_spender != address(0), "RewardTracker: approve to the zero address"); - - allowance[_owner][_spender] = _amount; - - emit Approval(_owner, _spender, _amount); - } - function _validateHandler() private view { require(isHandler[msg.sender], "RewardTracker: forbidden"); } @@ -245,75 +137,45 @@ contract RewardTracker is IERC20, ReentrancyGuard, IRewardTracker, Governable { function _stake(address _fundingAccount, address _account, address _depositToken, uint256 _amount) private { require(_amount > 0, "RewardTracker: invalid _amount"); require(isDepositToken[_depositToken], "RewardTracker: invalid _depositToken"); - IERC20(_depositToken).safeTransferFrom(_fundingAccount, address(this), _amount); - _updateRewards(_account); - stakedAmounts[_account] = stakedAmounts[_account] + _amount; - depositBalances[_account][_depositToken] = depositBalances[_account][_depositToken] + _amount; totalDepositSupply[_depositToken] = totalDepositSupply[_depositToken] + _amount; - - _mint(_account, _amount); } function _unstake(address _account, address _depositToken, uint256 _amount, address _receiver) private { require(_amount > 0, "RewardTracker: invalid _amount"); require(isDepositToken[_depositToken], "RewardTracker: invalid _depositToken"); - _updateRewards(_account); - uint256 stakedAmount = stakedAmounts[_account]; - require(stakedAmounts[_account] >= _amount, "RewardTracker: _amount exceeds stakedAmount"); - + require(stakedAmount >= _amount, "RewardTracker: _amount exceeds stakedAmount"); stakedAmounts[_account] = stakedAmount - _amount; - - uint256 depositBalance = depositBalances[_account][_depositToken]; - require(depositBalance >= _amount, "RewardTracker: _amount exceeds depositBalance"); - depositBalances[_account][_depositToken] = depositBalance - _amount; totalDepositSupply[_depositToken] = totalDepositSupply[_depositToken] - _amount; - - _burn(_account, _amount); IERC20(_depositToken).safeTransfer(_receiver, _amount); } + function updateRewards(address _account) public { + _updateRewards(_account); + } + function _updateRewards(address _account) private { - uint256 supply = totalSupply; - uint256 blockReward = IRewardDistributor(distributor).distribute(supply, decimals); - - - uint256 _cumulativeRewardPerToken = cumulativeRewardPerToken; - if (supply > 0 && blockReward > 0) { - _cumulativeRewardPerToken = _cumulativeRewardPerToken + blockReward * PRECISION; - cumulativeRewardPerToken = _cumulativeRewardPerToken; - } - - // cumulativeRewardPerToken can only increase - // so if cumulativeRewardPerToken is zero, it means there are no rewards yet - if (_cumulativeRewardPerToken == 0) { - return; - } - - if (_account != address(0)) { - uint256 stakedAmount = stakedAmounts[_account]; - uint256 accountReward = (stakedAmount / (10**decimals) * (_cumulativeRewardPerToken - previousCumulatedRewardPerToken[_account])) / - PRECISION; - uint256 _claimableReward = claimableReward[_account] + accountReward; - - claimableReward[_account] = _claimableReward; - previousCumulatedRewardPerToken[_account] = _cumulativeRewardPerToken; - - if (_claimableReward > 0 && stakedAmounts[_account] > 0) { - uint256 nextCumulativeReward = cumulativeRewards[_account] + accountReward; - - averageStakedAmounts[_account] = - (averageStakedAmounts[_account] * cumulativeRewards[_account]) / - nextCumulativeReward + - (stakedAmount / (10**decimals) * accountReward) / - nextCumulativeReward; - - cumulativeRewards[_account] = nextCumulativeReward; - } + uint256 accountReward = _getNextClaimableAmount(_account); + lastUpdateTimes[_account] = block.timestamp; + uint256 _claimableReward = claimableReward[_account] + accountReward; + claimableReward[_account] = _claimableReward; + if (_claimableReward > 0 && stakedAmounts[_account] > 0) { + uint256 nextCumulativeReward = cumulativeRewards[_account] + accountReward; + cumulativeRewards[_account] = nextCumulativeReward; } } + + function _getNextClaimableAmount(address _account) private view returns (uint256) { + uint256 timeDiff = block.timestamp - lastUpdateTimes[_account]; + uint256 stakedAmount = stakedAmounts[_account]; + if (stakedAmount == 0) { + return 0; + } + uint256 accountReward = (stakedAmount / (10 ** decimals)) * tokensPerInterval * timeDiff; + return accountReward; + } } diff --git a/contracts/staking/Vester.sol b/contracts/staking/Vester.sol index 988894f..c982b43 100644 --- a/contracts/staking/Vester.sol +++ b/contracts/staking/Vester.sol @@ -17,17 +17,16 @@ contract Vester is IVester, IERC20, ReentrancyGuard, Governable { uint8 public decimals = 18; uint256 public vestingDuration; address public esToken; - address public pairToken; address public claimableToken; - address public override rewardTracker; + address public override rewardTrackerCEC; + address public override rewardTrackerEsCEC; uint256 public override totalSupply; uint256 public pairSupply; bool public needCheckStake; mapping(address account => uint256 amount) public balances; - mapping(address account => uint256 amount) public override pairAmounts; mapping(address account => uint256 amount) public override cumulativeClaimAmounts; mapping(address account => uint256 amount) public override claimedAmounts; mapping(address account => uint256 time) public lastVestingTimes; @@ -40,7 +39,6 @@ contract Vester is IVester, IERC20, ReentrancyGuard, Governable { event Claim(address indexed receiver, uint256 amount); event Deposit(address indexed account, uint256 amount); event Withdraw(address indexed account, uint256 claimedAmount, uint256 balance); - event PairTransfer(address indexed from, address indexed to, uint256 value); event DurationUpdated(uint256 duration); constructor( @@ -48,18 +46,18 @@ contract Vester is IVester, IERC20, ReentrancyGuard, Governable { string memory _symbol, uint256 _vestingDuration, address _esToken, - address _pairToken, address _claimableToken, - address _rewardTracker, + address _rewardTrackerCEC, + address _rewardTrackerEsCEC, bool _needCheckStake ) { name = _name; symbol = _symbol; vestingDuration = _vestingDuration; esToken = _esToken; - pairToken = _pairToken; claimableToken = _claimableToken; - rewardTracker = _rewardTracker; + rewardTrackerCEC = _rewardTrackerCEC; + rewardTrackerEsCEC = _rewardTrackerEsCEC; needCheckStake = _needCheckStake; } @@ -100,12 +98,6 @@ contract Vester is IVester, IERC20, ReentrancyGuard, Governable { uint256 totalVested = balance + claimedAmount; require(totalVested > 0, "Vester: vested amount is zero"); - if (hasPairToken()) { - uint256 pairAmount = pairAmounts[account]; - _burnPair(account, pairAmount); - IERC20(pairToken).safeTransfer(_receiver, pairAmount); - } - IERC20(esToken).safeTransfer(_receiver, balance); _burn(account, balance); @@ -116,8 +108,12 @@ contract Vester is IVester, IERC20, ReentrancyGuard, Governable { emit Withdraw(account, claimedAmount, balance); } - function setRewardTracker(address _rewardTracker) external onlyGov { - rewardTracker = _rewardTracker; + function setRewardTrackerCEC(address _rewardTracker) external onlyGov { + rewardTrackerCEC = _rewardTracker; + } + + function setRewardTrackerEsCEC(address _rewardTracker) external onlyGov { + rewardTrackerEsCEC = _rewardTracker; } function updateDuration(uint256 _vestingDuration) external onlyGov { @@ -138,9 +134,14 @@ contract Vester is IVester, IERC20, ReentrancyGuard, Governable { function getMaxVestableAmount(address _account) public view override returns (uint256) { uint256 maxVestableAmount = bonusRewards[_account]; - if (hasRewardTracker()) { - uint256 cumulativeReward = IRewardTracker(rewardTracker).cumulativeRewards(_account); - maxVestableAmount = maxVestableAmount + cumulativeReward; + if (hasRewardTrackerCEC()) { + uint256 cumulativeRewardCEC = IRewardTracker(rewardTrackerCEC).cumulativeRewards(_account); + maxVestableAmount = maxVestableAmount + cumulativeRewardCEC ; + } + + if (hasRewardTrackerEsCEC()) { + uint256 cumulativeRewardEsCEC = IRewardTracker(rewardTrackerEsCEC).cumulativeRewards(_account); + maxVestableAmount = maxVestableAmount + cumulativeRewardEsCEC; } uint256 cumulativeRewardDeduction = cumulativeRewardDeductions[_account]; @@ -152,43 +153,12 @@ contract Vester is IVester, IERC20, ReentrancyGuard, Governable { return maxVestableAmount - cumulativeRewardDeduction; } - function getCombinedAverageStakedAmount(address _account) public view override returns (uint256) { - if (!hasRewardTracker()) { - return 0; - } - - uint256 cumulativeReward = IRewardTracker(rewardTracker).cumulativeRewards(_account); - if (cumulativeReward == 0) { - return 0; - } - - return IRewardTracker(rewardTracker).averageStakedAmounts(_account); + function hasRewardTrackerCEC() public view returns (bool) { + return rewardTrackerCEC != address(0); } - function getPairAmount(address _account, uint256 _esAmount) public view returns (uint256) { - if (!hasRewardTracker()) { - return 0; - } - - uint256 combinedAverageStakedAmount = getCombinedAverageStakedAmount(_account); - if (combinedAverageStakedAmount == 0) { - return 0; - } - - uint256 maxVestableAmount = getMaxVestableAmount(_account); - if (maxVestableAmount == 0) { - return 0; - } - - return (_esAmount * combinedAverageStakedAmount) / maxVestableAmount; - } - - function hasRewardTracker() public view returns (bool) { - return rewardTracker != address(0); - } - - function hasPairToken() public view returns (bool) { - return pairToken != address(0); + function hasRewardTrackerEsCEC() public view returns (bool) { + return rewardTrackerEsCEC != address(0); } function getTotalVested(address _account) public view returns (uint256) { @@ -238,15 +208,6 @@ contract Vester is IVester, IERC20, ReentrancyGuard, Governable { emit Transfer(address(0), _account, _amount); } - function _mintPair(address _account, uint256 _amount) private { - require(_account != address(0), "Vester: mint to the zero address"); - - pairSupply = pairSupply + _amount; - pairAmounts[_account] = pairAmounts[_account] + _amount; - - emit PairTransfer(address(0), _account, _amount); - } - function _burn(address _account, uint256 _amount) private { require(_account != address(0), "Vester: burn from the zero address"); require(balances[_account] >= _amount, "Vester: balance is not enough"); @@ -256,14 +217,6 @@ contract Vester is IVester, IERC20, ReentrancyGuard, Governable { emit Transfer(_account, address(0), _amount); } - function _burnPair(address _account, uint256 _amount) private { - require(_account != address(0), "Vester: burn from the zero address"); - require(pairAmounts[_account] >= _amount, "Vester: balance is not enough"); - pairAmounts[_account] = pairAmounts[_account] - _amount; - pairSupply = pairSupply - _amount; - - emit PairTransfer(_account, address(0), _amount); - } /** * @dev Deposit ES tokens to the contract */ @@ -275,18 +228,9 @@ contract Vester is IVester, IERC20, ReentrancyGuard, Governable { _mint(_account, _amount); - if (hasPairToken()) { - uint256 pairAmount = pairAmounts[_account]; - uint256 nextPairAmount = getPairAmount(_account, balances[_account]); - if (nextPairAmount > pairAmount) { - uint256 pairAmountDiff = nextPairAmount - pairAmount; - IERC20(pairToken).safeTransferFrom(_account, address(this), pairAmountDiff); - _mintPair(_account, pairAmountDiff); - } - } - if (needCheckStake && hasRewardTracker()) { + if (needCheckStake && hasRewardTrackerCEC()) { // if u want to transfer 100 esCec to cec, u need to have 100 cec in stake - uint256 cecAmount = IRewardTracker(rewardTracker).depositBalances(_account, claimableToken); + uint256 cecAmount = IRewardTracker(rewardTrackerCEC).stakedAmounts(_account); require(balances[_account] <= cecAmount, "Vester: insufficient cec balance"); } uint256 maxAmount = getMaxVestableAmount(_account); @@ -302,11 +246,9 @@ contract Vester is IVester, IERC20, ReentrancyGuard, Governable { function _updateVesting(address _account) public { uint256 amount = _getNextClaimableAmount(_account); lastVestingTimes[_account] = block.timestamp; - if (amount == 0) { return; } - // transfer claimableAmount from balances to cumulativeClaimAmounts _burn(_account, amount); cumulativeClaimAmounts[_account] = cumulativeClaimAmounts[_account] + amount; diff --git a/contracts/staking/interfaces/IRewardDistributor.sol b/contracts/staking/interfaces/IRewardDistributor.sol deleted file mode 100644 index d560210..0000000 --- a/contracts/staking/interfaces/IRewardDistributor.sol +++ /dev/null @@ -1,9 +0,0 @@ -// SPDX-License-Identifier: MIT -pragma solidity 0.8.19; - -interface IRewardDistributor { - function rewardToken() external view returns (address); - function tokensPerInterval() external view returns (uint256); - function pendingRewards() external view returns (uint256); - function distribute(uint256 _amount, uint256 _decimals) external returns (uint256); -} diff --git a/contracts/staking/interfaces/IRewardTracker.sol b/contracts/staking/interfaces/IRewardTracker.sol index d8470be..f9861d1 100644 --- a/contracts/staking/interfaces/IRewardTracker.sol +++ b/contracts/staking/interfaces/IRewardTracker.sol @@ -2,17 +2,15 @@ pragma solidity 0.8.19; interface IRewardTracker { - function depositBalances(address _account, address _depositToken) external view returns (uint256); function stakedAmounts(address _account) external view returns (uint256); - function updateRewards() external; + function updateRewards(address _account) external; function stake(address _depositToken, uint256 _amount) external; function stakeForAccount(address _fundingAccount, address _account, address _depositToken, uint256 _amount) external; function unstake(address _depositToken, uint256 _amount) external; function unstakeForAccount(address _account, address _depositToken, uint256 _amount, address _receiver) external; - function tokensPerInterval() external view returns (uint256); function claim(address _receiver) external returns (uint256); function claimForAccount(address _account, address _receiver) external returns (uint256); function claimable(address _account) external view returns (uint256); - function averageStakedAmounts(address _account) external view returns (uint256); + // function averageStakedAmounts(address _account) external view returns (uint256); function cumulativeRewards(address _account) external view returns (uint256); } diff --git a/contracts/staking/interfaces/IVester.sol b/contracts/staking/interfaces/IVester.sol index 6c332d6..7e9b071 100644 --- a/contracts/staking/interfaces/IVester.sol +++ b/contracts/staking/interfaces/IVester.sol @@ -5,14 +5,14 @@ interface IVester { function needCheckStake() external view returns (bool); function updateVesting(address _account) external; - function rewardTracker() external view returns (address); + function rewardTrackerCEC() external view returns (address); + function rewardTrackerEsCEC() external view returns (address); function claimForAccount(address _account, address _receiver) external returns (uint256); function claimable(address _account) external view returns (uint256); function cumulativeClaimAmounts(address _account) external view returns (uint256); function claimedAmounts(address _account) external view returns (uint256); - function pairAmounts(address _account) external view returns (uint256); function getVestedAmount(address _account) external view returns (uint256); function cumulativeRewardDeductions(address _account) external view returns (uint256); function bonusRewards(address _account) external view returns (uint256); @@ -21,5 +21,4 @@ interface IVester { function setBonusRewards(address _account, uint256 _amount) external; function getMaxVestableAmount(address _account) external view returns (uint256); - function getCombinedAverageStakedAmount(address _account) external view returns (uint256); }