pSTAKE Finance

function _calculatePendingRewards(
	uint256 principal,
	uint256 lastRewardTimestamp
) internal view returns (uint256 pendingRewards) {
	uint256 _index;
	uint256 _rewardBlocks;
	uint256 _simpleInterestOfInterval;
	uint256 _temp;
	// return 0 if principal or timeperiod is zero
	if (principal == 0 || block.timestamp.sub(lastRewardTimestamp) == 0)
		return 0;
	// calculate rewards for each interval period between rewardRate changes
	uint256 _lastMovingRewardLength = _lastMovingRewardTimestamp.length.sub(
		1
	);
	for (_index = _lastMovingRewardLength; _index >= 0; ) {
		// logic applies for all indexes of array except last index
		if (_index < _lastMovingRewardTimestamp.length.sub(1)) {
			if (_lastMovingRewardTimestamp[_index] > lastRewardTimestamp) {
				_rewardBlocks = (_lastMovingRewardTimestamp[_index.add(1)])
					.sub(_lastMovingRewardTimestamp[_index]);
				_temp = principal.mulDiv(_rewardRate[_index], 100);
				_simpleInterestOfInterval = _temp.mulDiv(
					_rewardBlocks,
					_valueDivisor
				);
				pendingRewards = pendingRewards.add(
					_simpleInterestOfInterval
				);
			} else {
				_rewardBlocks = (_lastMovingRewardTimestamp[_index.add(1)])
					.sub(lastRewardTimestamp);
				_temp = principal.mulDiv(_rewardRate[_index], 100);
				_simpleInterestOfInterval = _temp.mulDiv(
					_rewardBlocks,
					_valueDivisor
				);
				pendingRewards = pendingRewards.add(
					_simpleInterestOfInterval
				);
				break;
			}
		}
		// logic applies only for the last index of array
		else {
			if (_lastMovingRewardTimestamp[_index] > lastRewardTimestamp) {
				_rewardBlocks = (block.timestamp).sub(
					_lastMovingRewardTimestamp[_index]
				);
				_temp = principal.mulDiv(_rewardRate[_index], 100);
				_simpleInterestOfInterval = _temp.mulDiv(
					_rewardBlocks,
					_valueDivisor
				);
				pendingRewards = pendingRewards.add(
					_simpleInterestOfInterval
				);
			} else {
				_rewardBlocks = (block.timestamp).sub(lastRewardTimestamp);
				_temp = principal.mulDiv(_rewardRate[_index], 100);
				_simpleInterestOfInterval = _temp.mulDiv(
					_rewardBlocks,
					_valueDivisor
				);
				pendingRewards = pendingRewards.add(
					_simpleInterestOfInterval
				);
				break;
			}
		}

		if (_index == 0) break;
		else {
			_index = _index.sub(1);
		}
	}
	return pendingRewards;

		for (  uint256 _index = _lastMovingRewardLength;
			_index >= 0;
			_index = _index.sub(1))
...

		//	if (_index == 0) break;
		//	else {
		//		_index = _index.sub(1);
		//	}

function removeWhitelistedAddress(address whitelistedAddress)
	public
	virtual
	returns (bool success)
{
	require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "ST10");
	require(whitelistedAddress != address(0), "ST11");
	// remove whitelistedAddress from the list
	_whitelistedAddresses.remove(whitelistedAddress);
	address _holderContractAddressLocal = _holderContractAddress[
		whitelistedAddress
	];
	address _lpContractAddressLocal = _lpContractAddress[
		whitelistedAddress
	];

	// delete holder contract values
	delete _holderContractAddress[whitelistedAddress];
	delete _lpContractAddress[whitelistedAddress];

	emit RemoveWhitelistedAddress(
		whitelistedAddress,
		_holderContractAddressLocal,
		_lpContractAddressLocal,
		block.timestamp
	);
	success = true;
	return success;

	function removeWhitelistedAddress(address whitelistedAddress)
		public
		virtual
		returns (bool success)
	{
		require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "ST10");
		require(whitelistedAddress != address(0), "ST11"); // not really needed for this function
		// remove whitelistedAddress from the list
		_whitelistedAddresses.remove(whitelistedAddress);

		emit RemoveWhitelistedAddress(
			whitelistedAddress,
			_holderContractAddress[whitelistedAddress],
			_lpContractAddress[whitelistedAddress],
			block.timestamp
		);
		
		// delete holder contract values
		delete _holderContractAddress[whitelistedAddress];
		delete _lpContractAddress[whitelistedAddress];

		return true;
	}

function withdrawUnstakedTokens(address staker)
	public
	virtual
	override
	whenNotPaused
{
	require(staker == _msgSender(), "LQ20");
	uint256 _withdrawBalance;
	uint256 _unstakingExpirationLength = _unstakingExpiration[staker]
		.length;
	uint256 _counter = _withdrawCounters[staker];
	for (
		uint256 i = _counter;
		i < _unstakingExpirationLength;
		i = i.add(1)
	) {
		//get getUnstakeTime and compare it with current timestamp to check if 21 days + epoch difference has passed
		(uint256 _getUnstakeTime, , ) = getUnstakeTime(
			_unstakingExpiration[staker][i]
		);
		if (block.timestamp >= _getUnstakeTime) {
			//if 21 days + epoch difference has passed, then add the balance and then mint uTokens
			_withdrawBalance = _withdrawBalance.add(
				_unstakingAmount[staker][i]
			);
			_unstakingExpiration[staker][i] = 0;
			_unstakingAmount[staker][i] = 0;
			_withdrawCounters[staker] = _withdrawCounters[staker].add(1);
		}
	}

	require(_withdrawBalance > 0, "LQ21");
	emit WithdrawUnstakeTokens(staker, _withdrawBalance, block.timestamp);
	_uTokens.mint(staker, _withdrawBalance);
}

function setRewardRate(uint256 rewardRate)
	public
	virtual
	override
	returns (bool success)
{
	// range checks for rewardRate. Since rewardRate cannot be more than 100%, the max cap
	// is _valueDivisor * 100, which then brings the fees to 100 (percentage)
	require(rewardRate <= _valueDivisor.mul(100), "ST17");
	require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "ST2");
	_rewardRate.push(rewardRate);
	_lastMovingRewardTimestamp.push(block.timestamp);
	emit SetRewardRate(rewardRate);

	return true;
}

function calculateRewards(address to)
	public
	virtual
	override
	whenNotPaused
	returns (bool success)
{
	require(to == _msgSender(), "ST5");
	uint256 reward = _calculateRewards(to);
	emit TriggeredCalculateRewards(to, reward, block.timestamp);
	return true;
}

function initialize(address pauserAddress) public virtual initializer {
	__ERC20_init("pSTAKE Token", "PSTAKE");
	__AccessControl_init();
	__Pausable_init();
	_setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
	_setupRole(PAUSER_ROLE, pauserAddress);
	// PSTAKE IS A SIMPLE ERC20 TOKEN HENCE 18 DECIMAL PLACES
	_setupDecimals(18);
	// pre-allocate some tokens to an admin address which will air drop PSTAKE tokens
	// to each of holder contracts. This is only for testnet purpose. in Mainnet, we
	// will use a vesting contract to allocate tokens to admin in a certain schedule
	_mint(_msgSender(), 5000000000000000000000000);
}

function setUTokensContract(address uAddress) public virtual override {
	require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "LP9");
	_uTokens = IUTokens(uAddress);
	emit SetUTokensContract(uAddress);
}

/**
 * @dev Set 'contract address', called from constructor
 * @param sAddress: stoken contract address
 *
 * Emits a {SetSTokensContract} event with '_contract' set to the stoken contract address.
 *
 */
function setSTokensContract(address sAddress) public virtual override {
	require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "LP10");
	_sTokens = ISTokens(sAddress);
	emit SetSTokensContract(sAddress);
}

/**
 * @dev Set 'contract address', called from constructor
 * @param pstakeAddress: pStake contract address
 *
 * Emits a {SetPSTAKEContract} event with '_contract' set to the stoken contract address.
 *
 */
function setPSTAKEContract(address pstakeAddress) public virtual override {
	require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "LP11");
	_pstakeTokens = IPSTAKE(pstakeAddress);
	emit SetPSTAKEContract(pstakeAddress);
}

/**
 * @dev Set 'unstake props', called from admin
 * @param unstakingLockTime: varies from 21 hours to 21 days
 *
 * Emits a {SetUnstakeProps} event with 'fee' set to the stake and unstake.
 *
 */
function setUnstakingLockTime(uint256 unstakingLockTime)
	public
	virtual
	returns (bool success)
{
	require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "LQ3");
	_unstakingLockTime = unstakingLockTime;
	emit SetUnstakingLockTime(unstakingLockTime);
	return true;
}

	/* function mint(address to, uint256 tokens) public virtual override returns (bool success) {
        require(_msgSender() == _stakeLPCoreContract, "PS1");  // minted by STokens contract

        _mint(to, tokens);
        return true;
    } */

	/*
	 * @dev Burn utokens for the provided 'address' and 'amount'
	 * @param from: account address, tokens: number of tokens
	 *
	 * Emits a {BurnTokens} event with 'from' set to address and 'tokens' set to amount of tokens.
	 *
	 * Requirements:
	 *
	 * - `amount` cannot be less than zero.
	 *
	 */
	/* function burn(address from, uint256 tokens) public virtual override returns (bool success) {
        require((tx.origin == from && _msgSender()==_liquidStakingContract) ||  // staking operation
        (tx.origin == from && _msgSender() == _wrapperContract), "UT2"); // unwrap operation
        _burn(from, tokens);
        return true;
    } */