LockedSOV.sol

pragma solidity ^0.5.17;

import "../openzeppelin/SafeMath.sol";
import "../interfaces/IERC20.sol";
import "../governance/Vesting/VestingRegistry.sol";
import "../governance/Vesting/VestingLogic.sol";
import "./ILockedSOV.sol";

/**
 *  @title The Locked SOV Contract.
 *  @author Franklin Richards - powerhousefrank@protonmail.com
 *  @notice This contract is used to receive reward from other contracts, Create Vesting and Stake Tokens.
 */
contract LockedSOV is ILockedSOV {
    using SafeMath for uint256;

    uint256 public constant MAX_BASIS_POINT = 10000;
    uint256 public constant MAX_DURATION = 37;

    /* Storage */

    /// @notice True if the migration to a new Locked SOV Contract has started.
    bool public migration;

    /// @notice The cliff is the time period after which the tokens begin to unlock.
    uint256 public cliff;
    /// @notice The duration is the time period after all tokens will have been unlocked.
    uint256 public duration;

    /// @notice The SOV token contract.
    IERC20 public SOV;
    /// @notice The Vesting registry contract.
    VestingRegistry public vestingRegistry;
    /// @notice The New (Future) Locked SOV.
    ILockedSOV public newLockedSOV;

    /// @notice The locked user balances.
    mapping(address => uint256) private lockedBalances;
    /// @notice The unlocked user balances.
    mapping(address => uint256) private unlockedBalances;
    /// @notice The contracts/wallets with admin power.
    mapping(address => bool) private isAdmin;

    /* Events */

    /// @notice Emitted when a new Admin is added to the admin list.
    /// @param _initiator The address which initiated this event to be emitted.
    /// @param _newAdmin The address of the new admin.
    event AdminAdded(address indexed _initiator, address indexed _newAdmin);

    /// @notice Emitted when an admin is removed from the admin list.
    /// @param _initiator The address which initiated this event to be emitted.
    /// @param _removedAdmin The address of the removed admin.
    event AdminRemoved(address indexed _initiator, address indexed _removedAdmin);

    /// @notice Emitted when Vesting Registry, Duration and/or Cliff is updated.
    /// @param _initiator The address which initiated this event to be emitted.
    /// @param _vestingRegistry The Vesting Registry Contract.
    /// @param _cliff The time period after which the tokens begin to unlock.
    /// @param _duration The time period after all tokens will have been unlocked.
    event RegistryCliffAndDurationUpdated(
        address indexed _initiator,
        address indexed _vestingRegistry,
        uint256 _cliff,
        uint256 _duration
    );

    /// @notice Emitted when a new deposit is made.
    /// @param _initiator The address which initiated this event to be emitted.
    /// @param _userAddress The user to whose un/locked balance a new deposit was made.
    /// @param _sovAmount The amount of SOV to be added to the un/locked balance.
    /// @param _basisPoint The % (in Basis Point) which determines how much will be unlocked immediately.
    event Deposited(
        address indexed _initiator,
        address indexed _userAddress,
        uint256 _sovAmount,
        uint256 _basisPoint
    );

    /// @notice Emitted when a user withdraws the fund.
    /// @param _initiator The address which initiated this event to be emitted.
    /// @param _userAddress The user whose unlocked balance has to be withdrawn.
    /// @param _sovAmount The amount of SOV withdrawn from the unlocked balance.
    event Withdrawn(address indexed _initiator, address indexed _userAddress, uint256 _sovAmount);

    /// @notice Emitted when a user creates a vesting for himself.
    /// @param _initiator The address which initiated this event to be emitted.
    /// @param _userAddress The user whose unlocked balance has to be withdrawn.
    /// @param _vesting The Vesting Contract.
    event VestingCreated(
        address indexed _initiator,
        address indexed _userAddress,
        address indexed _vesting
    );

    /// @notice Emitted when a user stakes tokens.
    /// @param _initiator The address which initiated this event to be emitted.
    /// @param _vesting The Vesting Contract.
    /// @param _amount The amount of locked tokens staked by the user.
    event TokenStaked(address indexed _initiator, address indexed _vesting, uint256 _amount);

    /// @notice Emitted when an admin initiates a migration to new Locked SOV Contract.
    /// @param _initiator The address which initiated this event to be emitted.
    /// @param _newLockedSOV The address of the new Locked SOV Contract.
    event MigrationStarted(address indexed _initiator, address indexed _newLockedSOV);

    /// @notice Emitted when a user initiates the transfer to a new Locked SOV Contract.
    /// @param _initiator The address which initiated this event to be emitted.
    /// @param _amount The amount of locked tokens to transfer from this contract to the new one.
    event UserTransfered(address indexed _initiator, uint256 _amount);

    /* Modifiers */

    modifier onlyAdmin() {
        require(isAdmin[msg.sender], "Only admin can call this.");
        _;
    }

    modifier migrationAllowed() {
        require(migration, "Migration has not yet started.");
        _;
    }

    /* Constructor */

    /**
     * @notice Setup the required parameters.
     * @param _SOV The SOV Token Address.
     * @param _vestingRegistry The Vesting Registry Address.
     * @param _cliff The time period after which the tokens begin to unlock.
     * @param _duration The time period after all tokens will have been unlocked.
     * @param _admins The list of Admins to be added.
     */
    constructor(
        address _SOV,
        address _vestingRegistry,
        uint256 _cliff,
        uint256 _duration,
        address[] memory _admins
    ) public {
        require(_SOV != address(0), "Invalid SOV Address.");
        require(_vestingRegistry != address(0), "Vesting registry address is invalid.");
        require(_duration < MAX_DURATION, "Duration is too long.");

        SOV = IERC20(_SOV);
        vestingRegistry = VestingRegistry(_vestingRegistry);
        cliff = _cliff * 4 weeks;
        duration = _duration * 4 weeks;

        for (uint256 index = 0; index < _admins.length; index++) {
            isAdmin[_admins[index]] = true;
        }
    }

    /* Public or External Functions */

    /**
     * @notice The function to add a new admin.
     * @param _newAdmin The address of the new admin.
     * @dev Only callable by an Admin.
     */
    function addAdmin(address _newAdmin) public onlyAdmin {
        require(_newAdmin != address(0), "Invalid Address.");
        require(!isAdmin[_newAdmin], "Address is already admin.");
        isAdmin[_newAdmin] = true;

        emit AdminAdded(msg.sender, _newAdmin);
    }

    /**
     * @notice The function to remove an admin.
     * @param _adminToRemove The address of the admin which should be removed.
     * @dev Only callable by an Admin.
     */
    function removeAdmin(address _adminToRemove) public onlyAdmin {
        require(isAdmin[_adminToRemove], "Address is not an admin.");
        isAdmin[_adminToRemove] = false;

        emit AdminRemoved(msg.sender, _adminToRemove);
    }

    /**
     * @notice The function to update the Vesting Registry, Duration and Cliff.
     * @param _vestingRegistry The Vesting Registry Address.
     * @param _cliff The time period after which the tokens begin to unlock.
     * @param _duration The time period after all tokens will have been unlocked.
     * @dev IMPORTANT 1: You have to change Vesting Registry if you want to change Duration and/or Cliff.
     * IMPORTANT 2: `_cliff` and `_duration` is multiplied by 4 weeks in this function.
     */
    function changeRegistryCliffAndDuration(
        address _vestingRegistry,
        uint256 _cliff,
        uint256 _duration
    ) external onlyAdmin {
        require(
            address(vestingRegistry) != _vestingRegistry,
            "Vesting Registry has to be different for changing duration and cliff."
        );
        /// If duration is also zero, then it is similar to Unlocked SOV.
        require(_duration != 0, "Duration cannot be zero.");
        require(_duration < MAX_DURATION, "Duration is too long.");

        vestingRegistry = VestingRegistry(_vestingRegistry);

        cliff = _cliff * 4 weeks;
        duration = _duration * 4 weeks;

        emit RegistryCliffAndDurationUpdated(msg.sender, _vestingRegistry, _cliff, _duration);
    }

    /**
     * @notice Adds SOV to the user balance (Locked and Unlocked Balance based on `_basisPoint`).
     * @param _userAddress The user whose locked balance has to be updated with `_sovAmount`.
     * @param _sovAmount The amount of SOV to be added to the locked and/or unlocked balance.
     * @param _basisPoint The % (in Basis Point)which determines how much will be unlocked immediately.
     */
    function deposit(address _userAddress, uint256 _sovAmount, uint256 _basisPoint) external {
        _deposit(_userAddress, _sovAmount, _basisPoint);
    }

    /**
     * @notice Adds SOV to the locked balance of a user.
     * @param _userAddress The user whose locked balance has to be updated with _sovAmount.
     * @param _sovAmount The amount of SOV to be added to the locked balance.
     * @dev This is here because there are dependency with other contracts.
     */
    function depositSOV(address _userAddress, uint256 _sovAmount) external {
        _deposit(_userAddress, _sovAmount, 0);
    }

    function _deposit(address _userAddress, uint256 _sovAmount, uint256 _basisPoint) private {
        // MAX_BASIS_POINT is not included because if 100% is unlocked, then LockedSOV is not required to be used.
        require(_basisPoint < MAX_BASIS_POINT, "Basis Point has to be less than 10000.");
        bool txStatus = SOV.transferFrom(msg.sender, address(this), _sovAmount);
        require(txStatus, "Token transfer was not successful. Check receiver address.");

        uint256 unlockedBal = _sovAmount.mul(_basisPoint).div(MAX_BASIS_POINT);

        unlockedBalances[_userAddress] = unlockedBalances[_userAddress].add(unlockedBal);
        lockedBalances[_userAddress] = lockedBalances[_userAddress].add(_sovAmount).sub(
            unlockedBal
        );

        emit Deposited(msg.sender, _userAddress, _sovAmount, _basisPoint);
    }

    /**
     * @notice A function to withdraw the unlocked balance.
     * @param _receiverAddress If specified, the unlocked balance will go to this address, else to msg.sender.
     */
    function withdraw(address _receiverAddress) public {
        _withdraw(msg.sender, _receiverAddress);
    }

    function _withdraw(address _sender, address _receiverAddress) private {
        address userAddr = _receiverAddress;
        if (_receiverAddress == address(0)) {
            userAddr = _sender;
        }

        uint256 amount = unlockedBalances[_sender];
        unlockedBalances[_sender] = 0;

        bool txStatus = SOV.transfer(userAddr, amount);
        require(txStatus, "Token transfer was not successful. Check receiver address.");

        emit Withdrawn(_sender, userAddr, amount);
    }

    /**
     * @notice Creates vesting if not already created and Stakes tokens for a user.
     * @dev Only use this function if the `duration` is small.
     */
    function createVestingAndStake() public {
        _createVestingAndStake(msg.sender);
    }

    function _createVestingAndStake(address _sender) private {
        address vestingAddr = _getVesting(_sender);

        if (vestingAddr == address(0)) {
            vestingAddr = _createVesting(_sender);
        }

        _stakeTokens(_sender, vestingAddr);
    }

    /**
     * @notice Creates vesting contract (if it hasn't been created yet) for the calling user.
     * @return _vestingAddress The New Vesting Contract Created.
     */
    function createVesting() public returns (address _vestingAddress) {
        _vestingAddress = _createVesting(msg.sender);
    }

    /**
     * @notice Stakes tokens for a user who already have a vesting created.
     * @dev The user should already have a vesting created, else this function will throw error.
     */
    function stakeTokens() public {
        VestingLogic vesting = VestingLogic(_getVesting(msg.sender));

        require(
            cliff == vesting.cliff() && duration == vesting.duration(),
            "Wrong Vesting Schedule."
        );

        _stakeTokens(msg.sender, address(vesting));
    }

    /**
     * @notice Withdraws unlocked tokens and Stakes Locked tokens for a user who already have a vesting created.
     * @param _receiverAddress If specified, the unlocked balance will go to this address, else to msg.sender.
     */
    function withdrawAndStakeTokens(address _receiverAddress) external {
        _withdraw(msg.sender, _receiverAddress);
        _createVestingAndStake(msg.sender);
    }

    /**
     * @notice Withdraws unlocked tokens and Stakes Locked tokens for a user who already have a vesting created.
     * @param _userAddress The address of user tokens will be withdrawn.
     */
    function withdrawAndStakeTokensFrom(address _userAddress) external {
        _withdraw(_userAddress, _userAddress);
        _createVestingAndStake(_userAddress);
    }

    /**
     * @notice Function to start the process of migration to new contract.
     * @param _newLockedSOV The new locked sov contract address.
     */
    function startMigration(address _newLockedSOV) external onlyAdmin {
        require(_newLockedSOV != address(0), "New Locked SOV Address is Invalid.");
        newLockedSOV = ILockedSOV(_newLockedSOV);
        SOV.approve(_newLockedSOV, uint256(-1));
        migration = true;

        emit MigrationStarted(msg.sender, _newLockedSOV);
    }

    /**
     * @notice Function to transfer the locked balance from this contract to new LockedSOV Contract.
     * @dev Address is not specified to discourage selling lockedSOV to other address.
     */
    function transfer() external migrationAllowed {
        uint256 amount = lockedBalances[msg.sender];
        lockedBalances[msg.sender] = 0;

        newLockedSOV.depositSOV(msg.sender, amount);

        emit UserTransfered(msg.sender, amount);
    }

    /* Internal Functions */

    /**
     * @notice Creates a Vesting Contract for a user.
     * @param _tokenOwner The owner of the vesting contract.
     * @return _vestingAddress The Vesting Contract Address.
     * @dev Does not do anything if Vesting Contract was already created.
     */
    function _createVesting(address _tokenOwner) internal returns (address _vestingAddress) {
        /// Here zero is given in place of amount, as amount is not really used in `vestingRegistry.createVesting()`.
        vestingRegistry.createVesting(_tokenOwner, 0, cliff, duration);
        _vestingAddress = _getVesting(_tokenOwner);
        emit VestingCreated(msg.sender, _tokenOwner, _vestingAddress);
    }

    /**
     * @notice Returns the Vesting Contract Address.
     * @param _tokenOwner The owner of the vesting contract.
     * @return _vestingAddress The Vesting Contract Address.
     */
    function _getVesting(address _tokenOwner) internal view returns (address _vestingAddress) {
        return vestingRegistry.getVesting(_tokenOwner);
    }

    /**
     * @notice Stakes the tokens in a particular vesting contract.
     * @param _vesting The Vesting Contract Address.
     */
    function _stakeTokens(address _sender, address _vesting) internal {
        uint256 amount = lockedBalances[_sender];
        lockedBalances[_sender] = 0;

        require(SOV.approve(_vesting, amount), "Approve failed.");
        VestingLogic(_vesting).stakeTokens(amount);

        emit TokenStaked(_sender, _vesting, amount);
    }

    /* Getter or Read Functions */

    /**
     * @notice The function to get the locked balance of a user.
     * @param _addr The address of the user to check the locked balance.
     * @return _balance The locked balance of the address `_addr`.
     */
    function getLockedBalance(address _addr) external view returns (uint256 _balance) {
        return lockedBalances[_addr];
    }

    /**
     * @notice The function to get the unlocked balance of a user.
     * @param _addr The address of the user to check the unlocked balance.
     * @return _balance The unlocked balance of the address `_addr`.
     */
    function getUnlockedBalance(address _addr) external view returns (uint256 _balance) {
        return unlockedBalances[_addr];
    }

    /**
     * @notice The function to check is an address is admin or not.
     * @param _addr The address of the user to check the admin status.
     * @return _status True if admin, False otherwise.
     */
    function adminStatus(address _addr) external view returns (bool _status) {
        return isAdmin[_addr];
    }
}