Visor Finance

1contract Hypervisor is IHypervisor, Powered, Ownable {
2    using SafeMath for uint256;
3    using EnumerableSet for EnumerableSet.AddressSet;
4​
5    /* constants */
6​
7    // An upper bound on the number of active stakes per vault is required to prevent
8    // calls to rageQuit() from reverting.
9    // With 30 stakes in a vault, ragequit costs 432811 gas which is conservatively lower
10    // than the hardcoded limit of 500k gas on the vault.
11    // This limit is configurable and could be increased in a future deployment.
12    // Ultimately, to avoid a need for fixed upper bounds, the EVM would need to provide
13    // an error code that allows for reliably catching out-of-gas errors on remote calls.
14    uint256 public constant MAX_STAKES_PER_VAULT = 30;
15    uint256 public constant MAX_REWARD_TOKENS = 50;
16    uint256 public constant BASE_SHARES_PER_WEI = 1000000;
17    uint256 public stakeLimit = 2500 ether;
18​
19    /* storage */
20​
21    HypervisorData private _hypervisor;
22    mapping(address => VaultData) private _vaults;
23    EnumerableSet.AddressSet private _bonusTokenSet;
24    EnumerableSet.AddressSet private _vaultFactorySet;
25​
26    /* initializer */
27​
28    /// @notice Initizalize Hypervisor
29    /// access control: only proxy constructor
30    /// state machine: can only be called once
31    /// state scope: set initialization variables
32    /// token transfer: none
33    /// @param ownerAddress address The admin address
34    /// @param rewardPoolFactory address The factory to use for deploying the RewardPool
35    /// @param powerSwitchFactory address The factory to use for deploying the PowerSwitch
36    /// @param stakingToken address The address of the staking token for this Hypervisor
37    /// @param rewardToken address The address of the reward token for this Hypervisor
38    /// @param rewardScaling RewardScaling The config for reward scaling floor, ceiling, and time
39    constructor(
40        address ownerAddress,
41        address rewardPoolFactory,
42        address powerSwitchFactory,
43        address stakingToken,
44        address rewardToken,
45        RewardScaling memory rewardScaling,
46        uint256 _stakeLimit
47    ) {
48        // the scaling floor must be smaller than ceiling
49        require(rewardScaling.floor <= rewardScaling.ceiling, "Hypervisor: floor above ceiling");
50​
51        // setting rewardScalingTime to 0 would cause divide by zero error
52        // to disable reward scaling, use rewardScalingFloor == rewardScalingCeiling
53        require(rewardScaling.time != 0, "Hypervisor: scaling time cannot be zero");
54​
55        // deploy power switch
56        address powerSwitch = IFactory(powerSwitchFactory).create(abi.encode(ownerAddress));
57​
58        // deploy reward pool
59        address rewardPool = IFactory(rewardPoolFactory).create(abi.encode(powerSwitch));
60​
61        // set internal configs
62        Ownable.transferOwnership(ownerAddress);
63        Powered._setPowerSwitch(powerSwitch);
64​
65        // commit to storage
66        _hypervisor.stakingToken = stakingToken;
67        _hypervisor.rewardToken = rewardToken;
68        _hypervisor.rewardPool = rewardPool;
69        _hypervisor.rewardScaling = rewardScaling;
70​
71        stakeLimit = _stakeLimit;
72​
73         emit event
74        emit HypervisorCreated(rewardPool, powerSwitch);
75    }
76​
77    /* getter functions */
78​
79    function getBonusTokenSetLength() external view override returns (uint256 length) {
80        return _bonusTokenSet.length();
81    }
82​
83    function getBonusTokenAtIndex(uint256 index)
84        external
85        view
86        override
87        returns (address bonusToken)
88    {
89        return _bonusTokenSet.at(index);
90    }
91​
92    function getVaultFactorySetLength() external view override returns (uint256 length) {
93        return _vaultFactorySet.length();
94    }
95​
96    function getVaultFactoryAtIndex(uint256 index)
97        external
98        view
99        override
100        returns (address factory)
101    {
102        return _vaultFactorySet.at(index);
103    }
104​
105    function isValidVault(address target) public view override returns (bool validity) {
106        // validate target is created from whitelisted vault factory
107        for (uint256 index = 0; index < _vaultFactorySet.length(); index++) {
108            if (IInstanceRegistry(_vaultFactorySet.at(index)).isInstance(target)) {
109                return true;
110            }
111        }
112        // explicit return
113        return false;
114    }
115​
116    function isValidAddress(address target) public view override returns (bool validity) {
117        // sanity check target for potential input errors
118        return
119            target != address(this) &&
120            target != address(0) &&
121            target != _hypervisor.stakingToken &&
122            target != _hypervisor.rewardToken &&
123            target != _hypervisor.rewardPool &&
124            !_bonusTokenSet.contains(target);
125    }
126​
127    /* Hypervisor getters */
128​
129    function getHypervisorData() external view override returns (HypervisorData memory hypervisor) {
130        return _hypervisor;
131    }
132​
133    function getCurrentUnlockedRewards() public view override returns (uint256 unlockedRewards) {
134        // calculate reward available based on state
135        return getFutureUnlockedRewards(block.timestamp);
136    }
137​
138    function getFutureUnlockedRewards(uint256 timestamp)
139        public
140        view
141        override
142        returns (uint256 unlockedRewards)
143    {
144        // get reward amount remaining
145        uint256 remainingRewards = IERC20(_hypervisor.rewardToken).balanceOf(_hypervisor.rewardPool);
146        // calculate reward available based on state
147        unlockedRewards = calculateUnlockedRewards(
148            _hypervisor.rewardSchedules,
149            remainingRewards,
150            _hypervisor.rewardSharesOutstanding,
151            timestamp
152        );
153        // explicit return
154        return unlockedRewards;
155    }
156​
157    function getCurrentTotalStakeUnits() public view override returns (uint256 totalStakeUnits) {
158        // calculate new stake units
159        return getFutureTotalStakeUnits(block.timestamp);
160    }
161​
162    function getFutureTotalStakeUnits(uint256 timestamp)
163        public
164        view
165        override
166        returns (uint256 totalStakeUnits)
167    {
168        // return early if no change
169        if (timestamp == _hypervisor.lastUpdate) return _hypervisor.totalStakeUnits;
170        // calculate new stake units
171        uint256 newStakeUnits =
172            calculateStakeUnits(_hypervisor.totalStake, _hypervisor.lastUpdate, timestamp);
173        // add to cached total
174        totalStakeUnits = _hypervisor.totalStakeUnits.add(newStakeUnits);
175        // explicit return
176        return totalStakeUnits;
177    }
178​
179    /* vault getters */
180​
181    function getVaultData(address vault)
182        external
183        view
184        override
185        returns (VaultData memory vaultData)
186    {
187        return _vaults[vault];
188    }

Solidity Contracts

JavaScript Tests