ThrottledExit.sol

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

import "openzeppelin-solidity/contracts/math/SafeMath.sol";
import "./interfaces/IERC20Detailed.sol";
import "./SafeERC20Detailed.sol";


abstract contract ThrottledExit {
	using SafeMath for uint256;
	using SafeERC20Detailed for IERC20Detailed;

	uint256 public nextAvailableExitBlock;
	uint256 public nextAvailableRoundExitVolume;
	uint256 public throttleRoundBlocks;
	uint256 public throttleRoundCap;

	struct ExitInfo {
        uint256 exitBlock;
        uint256 exitStake;
        uint256[] rewards;
    }

	mapping(address => ExitInfo) public exitInfo;

	event ExitRequested(address user, uint256 exitBlock);
	event ExitCompleted(address user, uint256 stake);

	function setThrottleParams(uint256 _throttleRoundBlocks, uint256 _throttleRoundCap, uint256 throttleStart) internal {
		require(_throttleRoundBlocks > 0, "setThrottle::throttle round blocks must be more than 0");
		require(_throttleRoundCap > 0, "setThrottle::throttle round cap must be more than 0");
		require(throttleRoundBlocks == 0 && throttleRoundCap == 0, "setThrottle::throttle parameters were already set");
		throttleRoundBlocks = _throttleRoundBlocks;
		throttleRoundCap = _throttleRoundCap;
		nextAvailableExitBlock = throttleStart.add(throttleRoundBlocks);
	}

	function initiateExit(uint256 amountStaked, address[] memory _rewardsTokens, uint256[] memory _tokensOwed) virtual internal {
		initialiseExitInfo(msg.sender, _rewardsTokens.length);

		ExitInfo storage info = exitInfo[msg.sender];
		info.exitBlock = getAvailableExitTime(amountStaked);
		info.exitStake = info.exitStake.add(amountStaked);

		for (uint256 i = 0; i < _rewardsTokens.length; i++) {
			info.rewards[i] = info.rewards[i].add(_tokensOwed[i]);
        }

		emit ExitRequested(msg.sender, info.exitBlock);
	}

	function finalizeExit(address _stakingToken, address[] memory _rewardsTokens) virtual internal {
		ExitInfo storage info = exitInfo[msg.sender];
		require(block.number > info.exitBlock, "finalizeExit::Trying to exit too early");

		IERC20Detailed(_stakingToken).safeTransfer(address(msg.sender), info.exitStake);

		for (uint256 i = 0; i < _rewardsTokens.length; i++) {
			IERC20Detailed(_rewardsTokens[i]).safeTransfer(msg.sender, info.rewards[i]);
			info.rewards[i] = 0;
        }

		emit ExitCompleted(msg.sender, info.exitStake);
		info.exitStake = 0;
	}

	function getAvailableExitTime(uint256 exitAmount) internal returns(uint256 exitBlock) {
		if(block.number > nextAvailableExitBlock) { // We've passed the next available block and need to readjust
			uint i = nextAvailableExitBlock; // Using i instead of nextAvailableExitBlock to avoid SSTORE
			while(i < block.number) { // Find the next future round
				i = i.add(throttleRoundBlocks);
			}
			nextAvailableExitBlock = i;
			nextAvailableRoundExitVolume = exitAmount; // Reset volume
			return i;
		} else { // We are still before the next available block
			nextAvailableRoundExitVolume = nextAvailableRoundExitVolume.add(exitAmount); // Add volume
		}

		exitBlock = nextAvailableExitBlock;

		if (nextAvailableRoundExitVolume >= throttleRoundCap) { // If cap reached
			nextAvailableExitBlock = nextAvailableExitBlock.add(throttleRoundBlocks); // update next exit block
			nextAvailableRoundExitVolume = 0; // Reset volume
		}
	}

	function getPendingReward(uint256 tokenIndex) public view returns(uint256) {
		ExitInfo storage info = exitInfo[msg.sender];
		return info.rewards[tokenIndex];
	}

	function initialiseExitInfo(address _userAddress, uint256 tokensLength) private {
		ExitInfo storage info = exitInfo[_userAddress];

        if (info.rewards.length == tokensLength) {
            // Already initialised
            return;
        }

        for (uint256 i = info.rewards.length; i < tokensLength; i++) {
            info.rewards.push(0);
        }
	}

	

}