DevelopmentFund.sol

pragma solidity ^0.5.17;

import "../../openzeppelin/SafeMath.sol";
import "../../interfaces/IERC20.sol";

/**
 *  @title A holding contract for Sovryn Development Fund.
 *  @author Franklin Richards
 *  @notice You can use this contract for timed token release from Dev Fund.
 */
contract DevelopmentFund {
    using SafeMath for uint256;

    /* Storage */

    /// @notice The SOV token contract.
    IERC20 public SOV;

    /// @notice The current contract status.
    enum Status {
        Deployed,
        Active,
        Expired
    }
    Status public status;

    /// @notice The owner of the locked tokens (usually Governance).
    address public lockedTokenOwner;
    /// @notice The owner of the unlocked tokens (usually MultiSig).
    address public unlockedTokenOwner;
    /// @notice The emergency transfer wallet/contract.
    address public safeVault;
    /// @notice The new locked token owner waiting to be approved.
    address public newLockedTokenOwner;

    /// @notice The last token release timestamp or the time of contract creation.
    uint256 public lastReleaseTime;

    /// @notice The release duration array in seconds.
    uint256[] public releaseDuration;
    /// @notice The release token amount.
    uint256[] public releaseTokenAmount;

    /* Events */

    /// @notice Emitted when the contract is activated.
    event DevelopmentFundActivated();

    /// @notice Emitted when the contract is expired due to total token transfer.
    event DevelopmentFundExpired();

    /// @notice Emitted when a new locked owner is added to the contract.
    /// @param _initiator The address which initiated this event to be emitted.
    /// @param _newLockedOwner The address which is added as the new locked owner.
    /// @dev Can only be initiated by the current locked owner.
    event NewLockedOwnerAdded(address indexed _initiator, address indexed _newLockedOwner);

    /// @notice Emitted when a new locked owner is approved to the contract.
    /// @param _initiator The address which initiated this event to be emitted.
    /// @param _oldLockedOwner The address of the previous locked owner.
    /// @param _newLockedOwner The address which is added as the new locked owner.
    /// @dev Can only be initiated by the current unlocked owner.
    event NewLockedOwnerApproved(
        address indexed _initiator,
        address indexed _oldLockedOwner,
        address indexed _newLockedOwner
    );

    /// @notice Emitted when a new unlocked owner is updated in the contract.
    /// @param _initiator The address which initiated this event to be emitted.
    /// @param _newUnlockedOwner The address which is updated as the new unlocked owner.
    /// @dev Can only be initiated by the current locked owner.
    event UnlockedOwnerUpdated(address indexed _initiator, address indexed _newUnlockedOwner);

    /// @notice Emitted when a new token deposit is done.
    /// @param _initiator The address which initiated this event to be emitted.
    /// @param _amount The total amount of token deposited.
    event TokenDeposit(address indexed _initiator, uint256 _amount);

    /// @notice Emitted when a new release schedule is created.
    /// @param _initiator The address which initiated this event to be emitted.
    /// @param _releaseCount The number of releases planned in the schedule.
    event TokenReleaseChanged(address indexed _initiator, uint256 _releaseCount);

    /// @notice Emitted when a unlocked owner transfers all the tokens to a safe vault.
    /// @param _initiator The address which initiated this event to be emitted.
    /// @param _receiver The address which receives this token withdrawn.
    /// @param _amount The total amount of token transferred.
    /// @dev This is done in an emergency situation only to a predetermined wallet by locked token owner.
    event LockedTokenTransferByUnlockedOwner(
        address indexed _initiator,
        address indexed _receiver,
        uint256 _amount
    );

    /// @notice Emitted when a unlocked owner withdraws the released tokens.
    /// @param _initiator The address which initiated this event to be emitted.
    /// @param _amount The total amount of token withdrawn.
    /// @param _releaseCount The total number of releases done based on duration.
    event UnlockedTokenWithdrawalByUnlockedOwner(
        address indexed _initiator,
        uint256 _amount,
        uint256 _releaseCount
    );

    /// @notice Emitted when a locked owner transfers all the tokens to a receiver.
    /// @param _initiator The address which initiated this event to be emitted.
    /// @param _receiver The address which receives this token transfer.
    /// @param _amount The total amount of token transferred.
    /// @dev This is done only by locked token owner.
    event LockedTokenTransferByLockedOwner(
        address indexed _initiator,
        address indexed _receiver,
        uint256 _amount
    );

    /* Modifiers */

    modifier onlyLockedTokenOwner() {
        require(msg.sender == lockedTokenOwner, "Only Locked Token Owner can call this.");
        _;
    }

    modifier onlyUnlockedTokenOwner() {
        require(msg.sender == unlockedTokenOwner, "Only Unlocked Token Owner can call this.");
        _;
    }

    modifier checkStatus(Status s) {
        require(status == s, "The contract is not in the right state.");
        _;
    }

    /* Functions */

    /**
     * @notice Setup the required parameters.
     * @param _SOV The SOV token address.
     * @param _lockedTokenOwner The owner of the locked tokens & contract.
     * @param _safeVault The emergency wallet/contract to transfer token.
     * @param _unlockedTokenOwner The owner of the unlocked tokens.
     * @param _lastReleaseTime If the last release time is to be changed, zero if no change required.
     * @param _releaseDuration The time duration between each release calculated from `lastReleaseTime` in seconds.
     * @param _releaseTokenAmount The amount of token to be released in each duration/interval.
     * @dev Initial release schedule should be verified, error will result in either redeployment or calling changeTokenReleaseSchedule() after init() along with token transfer.
     */
    constructor(
        address _SOV,
        address _lockedTokenOwner,
        address _safeVault,
        address _unlockedTokenOwner,
        uint256 _lastReleaseTime,
        uint256[] memory _releaseDuration,
        uint256[] memory _releaseTokenAmount
    ) public {
        require(_SOV != address(0), "Invalid SOV Address.");
        require(_lockedTokenOwner != address(0), "Locked token & contract owner address invalid.");
        require(_safeVault != address(0), "Safe Vault address invalid.");
        require(_unlockedTokenOwner != address(0), "Unlocked token address invalid.");

        SOV = IERC20(_SOV);
        lockedTokenOwner = _lockedTokenOwner;
        safeVault = _safeVault;
        unlockedTokenOwner = _unlockedTokenOwner;

        lastReleaseTime = _lastReleaseTime;
        /// If last release time passed is zero, then current time stamp will be used as the last release time.
        if (_lastReleaseTime == 0) {
            lastReleaseTime = block.timestamp;
        }

        /// Checking if the schedule duration and token allocation length matches.
        require(
            _releaseDuration.length == _releaseTokenAmount.length,
            "Release Schedule does not match."
        );

        /// Finally we update the token release schedule.
        releaseDuration = _releaseDuration;
        releaseTokenAmount = _releaseTokenAmount;
    }

    /**
     * @notice This function is called once after deployment for token transfer based on schedule.
     * @dev Without calling this function, the contract will not work.
     */
    function init() public checkStatus(Status.Deployed) {
        uint256[] memory _releaseTokenAmount = releaseTokenAmount;
        require(_releaseTokenAmount.length != 0, "Release Schedule not set.");

        /// Getting the current release schedule total token amount.
        uint256 _releaseTotalTokenAmount;
        for (uint256 amountIndex = 0; amountIndex < _releaseTokenAmount.length; amountIndex++) {
            _releaseTotalTokenAmount = _releaseTotalTokenAmount.add(
                _releaseTokenAmount[amountIndex]
            );
        }

        bool txStatus = SOV.transferFrom(msg.sender, address(this), _releaseTotalTokenAmount);
        require(txStatus, "Not enough token sent to change release schedule.");

        status = Status.Active;

        emit DevelopmentFundActivated();
    }

    /**
     * @notice Update Locked Token Owner.
     * @param _newLockedTokenOwner The owner of the locked tokens & contract.
     */
    function updateLockedTokenOwner(
        address _newLockedTokenOwner
    ) public onlyLockedTokenOwner checkStatus(Status.Active) {
        require(_newLockedTokenOwner != address(0), "New locked token owner address invalid.");

        newLockedTokenOwner = _newLockedTokenOwner;

        emit NewLockedOwnerAdded(msg.sender, _newLockedTokenOwner);
    }

    /**
     * @notice Approve Locked Token Owner.
     * @dev This approval is an added security to avoid development fund takeover by a compromised locked token owner.
     */
    function approveLockedTokenOwner() public onlyUnlockedTokenOwner checkStatus(Status.Active) {
        require(newLockedTokenOwner != address(0), "No new locked owner added.");

        emit NewLockedOwnerApproved(msg.sender, lockedTokenOwner, newLockedTokenOwner);

        lockedTokenOwner = newLockedTokenOwner;

        newLockedTokenOwner = address(0);
    }

    /**
     * @notice Update Unlocked Token Owner.
     * @param _newUnlockedTokenOwner The new unlocked token owner.
     */
    function updateUnlockedTokenOwner(
        address _newUnlockedTokenOwner
    ) public onlyLockedTokenOwner checkStatus(Status.Active) {
        require(_newUnlockedTokenOwner != address(0), "New unlocked token owner address invalid.");

        unlockedTokenOwner = _newUnlockedTokenOwner;

        emit UnlockedOwnerUpdated(msg.sender, _newUnlockedTokenOwner);
    }

    /**
     * @notice Deposit tokens to this contract.
     * @param _amount the amount of tokens deposited.
     * @dev These tokens can be withdrawn/transferred any time by the lockedTokenOwner.
     */
    function depositTokens(uint256 _amount) public checkStatus(Status.Active) {
        require(_amount > 0, "Amount needs to be bigger than zero.");

        bool txStatus = SOV.transferFrom(msg.sender, address(this), _amount);
        require(txStatus, "Token transfer was not successful.");

        emit TokenDeposit(msg.sender, _amount);
    }

    /**
     * @notice Change the Token release schedule. It creates a completely new schedule, and does not append on the previous one.
     * @param _newLastReleaseTime If the last release time is to be changed, zero if no change required.
     * @param _releaseDuration The time duration between each release calculated from `lastReleaseTime` in seconds.
     * @param _releaseTokenAmount The amount of token to be released in each duration/interval.
     * @dev _releaseDuration and _releaseTokenAmount should be specified in reverse order of release.
     */
    function changeTokenReleaseSchedule(
        uint256 _newLastReleaseTime,
        uint256[] memory _releaseDuration,
        uint256[] memory _releaseTokenAmount
    ) public onlyLockedTokenOwner checkStatus(Status.Active) {
        /// Checking if the schedule duration and token allocation length matches.
        require(
            _releaseDuration.length == _releaseTokenAmount.length,
            "Release Schedule does not match."
        );

        /// If the last release time has to be changed, then you can pass a new one here.
        /// Or else, the duration of release will be calculated based on this timestamp.
        /// Even a future timestamp can be mentioned here.
        if (_newLastReleaseTime != 0) {
            lastReleaseTime = _newLastReleaseTime;
        }

        /// Checking if the contract have enough token balance for the release.
        uint256 _releaseTotalTokenAmount;
        for (uint256 amountIndex = 0; amountIndex < _releaseTokenAmount.length; amountIndex++) {
            _releaseTotalTokenAmount = _releaseTotalTokenAmount.add(
                _releaseTokenAmount[amountIndex]
            );
        }

        /// Getting the current token balance of the contract.
        uint256 remainingTokens = SOV.balanceOf(address(this));

        /// If the token balance is not sufficient, then we transfer the change to contract.
        if (remainingTokens < _releaseTotalTokenAmount) {
            bool txStatus = SOV.transferFrom(
                msg.sender,
                address(this),
                _releaseTotalTokenAmount.sub(remainingTokens)
            );
            require(txStatus, "Not enough token sent to change release schedule.");
        } else if (remainingTokens > _releaseTotalTokenAmount) {
            /// If there are more tokens than required, send the extra tokens back.
            bool txStatus = SOV.transfer(
                msg.sender,
                remainingTokens.sub(_releaseTotalTokenAmount)
            );
            require(txStatus, "Token not received by the Locked Owner.");
        }

        /// Finally we update the token release schedule.
        releaseDuration = _releaseDuration;
        releaseTokenAmount = _releaseTokenAmount;

        emit TokenReleaseChanged(msg.sender, _releaseDuration.length);
    }

    /**
     * @notice Transfers all of the remaining tokens in an emergency situation.
     * @dev This could be called when governance or development fund might be compromised.
     */
    function transferTokensByUnlockedTokenOwner()
        public
        onlyUnlockedTokenOwner
        checkStatus(Status.Active)
    {
        uint256 remainingTokens = SOV.balanceOf(address(this));
        bool txStatus = SOV.transfer(safeVault, remainingTokens);
        require(txStatus, "Token transfer was not successful. Check receiver address.");
        status = Status.Expired;

        emit LockedTokenTransferByUnlockedOwner(msg.sender, safeVault, remainingTokens);
        emit DevelopmentFundExpired();
    }

    /**
     * @notice Withdraws all unlocked/released token.
     * @param _amount The amount to be withdrawn.
     */
    function withdrawTokensByUnlockedTokenOwner(
        uint256 _amount
    ) public onlyUnlockedTokenOwner checkStatus(Status.Active) {
        require(_amount > 0, "Zero can't be withdrawn.");

        uint256 count; /// To know how many elements to be removed from the release schedule.
        uint256 amount = _amount; /// To know the total amount to be transferred.
        uint256 newLastReleaseTimeMemory = lastReleaseTime; /// Better to use memory than storage.
        uint256 releaseLength = releaseDuration.length.sub(1); /// Also checks if there are any elements in the release schedule.

        /// Getting the amount of tokens, the number of releases and calculating the total duration.
        while (
            amount > 0 &&
            newLastReleaseTimeMemory.add(releaseDuration[releaseLength]) < block.timestamp
        ) {
            if (amount >= releaseTokenAmount[releaseLength]) {
                amount = amount.sub(releaseTokenAmount[releaseLength]);
                newLastReleaseTimeMemory = newLastReleaseTimeMemory.add(
                    releaseDuration[releaseLength]
                );
                count++;
            } else {
                /// This will be the last case, if correct amount is passed.
                releaseTokenAmount[releaseLength] = releaseTokenAmount[releaseLength].sub(amount);
                amount = 0;
            }
            releaseLength--;
        }

        /// Checking to see if atleast a single schedule was reached or not.
        require(count > 0 || amount == 0, "No release schedule reached.");

        /// If locked token owner tries to send a higher amount that schedule
        uint256 value = _amount.sub(amount);

        /// Now clearing up the release schedule.
        releaseDuration.length -= count;
        releaseTokenAmount.length -= count;

        /// Updating the last release time.
        lastReleaseTime = newLastReleaseTimeMemory;

        /// Sending the amount to unlocked token owner.
        bool txStatus = SOV.transfer(msg.sender, value);
        require(txStatus, "Token transfer was not successful. Check receiver address.");

        emit UnlockedTokenWithdrawalByUnlockedOwner(msg.sender, value, count);
    }

    /**
     * @notice Transfers all of the remaining tokens by the owner maybe for an upgrade.
     * @dev This could be called when the current development fund has to be upgraded.
     * @param _receiver The address which receives this token transfer.
     */
    function transferTokensByLockedTokenOwner(
        address _receiver
    ) public onlyLockedTokenOwner checkStatus(Status.Active) {
        uint256 remainingTokens = SOV.balanceOf(address(this));
        bool txStatus = SOV.transfer(_receiver, remainingTokens);
        require(txStatus, "Token transfer was not successful. Check receiver address.");
        status = Status.Expired;

        emit LockedTokenTransferByLockedOwner(msg.sender, _receiver, remainingTokens);
        emit DevelopmentFundExpired();
    }

    /* Getter Functions */

    /**
     * @notice Function to read the current token release duration.
     * @return _currentReleaseDuration The current release duration.
     */
    function getReleaseDuration() public view returns (uint256[] memory _releaseTokenDuration) {
        return releaseDuration;
    }

    /**
     * @notice Function to read the current token release amount.
     * @return _currentReleaseTokenAmount The current release token amount.
     */
    function getReleaseTokenAmount()
        public
        view
        returns (uint256[] memory _currentReleaseTokenAmount)
    {
        return releaseTokenAmount;
    }
}