Idle v4

1/**
2 * @title: Idle Token Governance main contract
3 * @summary: ERC20 that holds pooled user funds together
4 *           Each token rapresent a share of the underlying pools
5 *           and with each token user have the right to redeem a portion of these pools
6 * @author: Idle Labs Inc., idle.finance
7 */
8pragma solidity 0.5.16;
9import "@openzeppelin/contracts-ethereum-package/contracts/math/SafeMath.sol";
10import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/SafeERC20.sol";
11​
12import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/ERC20.sol";
13import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/ERC20Detailed.sol";
14​
15import "@openzeppelin/contracts-ethereum-package/contracts/utils/ReentrancyGuard.sol";
16import "@openzeppelin/contracts-ethereum-package/contracts/ownership/Ownable.sol";
17import "@openzeppelin/contracts-ethereum-package/contracts/lifecycle/Pausable.sol";
18​
19import "@openzeppelin/upgrades/contracts/Initializable.sol";
20​
21import "./interfaces/iERC20Fulcrum.sol";
22import "./interfaces/ILendingProtocol.sol";
23import "./interfaces/IGovToken.sol";
24import "./interfaces/IIdleTokenV3_1.sol";
25import "./interfaces/IERC3156FlashBorrower.sol";
26import "./interfaces/IAaveIncentivesController.sol";
27​
28import "./interfaces/Comptroller.sol";
29import "./interfaces/CERC20.sol";
30import "./interfaces/AToken.sol";
31import "./interfaces/IdleController.sol";
32import "./interfaces/IIdleTokenHelper.sol";
33​
34import "./GST2ConsumerV2.sol";
35​
36contract IdleTokenGovernance is Initializable, ERC20, ERC20Detailed, ReentrancyGuard, Ownable, Pausable, IIdleTokenV3_1, GST2ConsumerV2 {
37  using SafeERC20 for IERC20;
38  using SafeMath for uint256;
39​
40  uint256 private constant ONE_18 = 10**18;
41  // State variables
42  // eg. DAI address
43  address public token;
44  // eg. iDAI address
45  address private iToken;
46  // eg. cDAI address
47  address private cToken;
48  // Idle rebalancer current implementation address
49  address public rebalancer;
50  // Address collecting underlying fees
51  address public feeAddress;
52  // Last iToken price, used to pause contract in case of a black swan event
53  uint256 public lastITokenPrice;
54  // eg. 18 for DAI
55  uint256 private tokenDecimals;
56  // Max unlent assets percentage for gas friendly swaps
57  uint256 public maxUnlentPerc; // 100000 == 100% -> 1000 == 1%
58  // Current fee on interest gained
59  uint256 public fee;
60  // eg. [cTokenAddress, iTokenAddress, ...]
61  address[] public allAvailableTokens;
62  // eg. [COMPAddress, CRVAddress, ...]
63  address[] public govTokens;
64  // last fully applied allocations (ie when all liquidity has been correctly placed)
65  // eg. [5000, 0, 5000, 0] for 50% in compound, 0% fulcrum, 50% aave, 0 dydx. same order of allAvailableTokens
66  uint256[] public lastAllocations;
67  // Map that saves avg idleToken price paid for each user, used to calculate earnings
68  mapping(address => uint256) public userAvgPrices;
69  // eg. cTokenAddress => IdleCompoundAddress
70  mapping(address => address) public protocolWrappers;
71  // array with last balance recorded for each gov tokens
72  mapping (address => uint256) public govTokensLastBalances;
73  // govToken -> user_address -> user_index eg. usersGovTokensIndexes[govTokens[0]][msg.sender] = 1111123;
74  mapping (address => mapping (address => uint256)) public usersGovTokensIndexes;
75  // global indices for each gov tokens used as a reference to calculate a fair share for each user
76  mapping (address => uint256) public govTokensIndexes;
77  // Map that saves amount with no fee for each user
78  mapping(address => uint256) private userNoFeeQty;
79  // variable used for avoid the call of mint and redeem in the same tx
80  bytes32 private _minterBlock;
81​
82  // Events
83  event Rebalance(address _rebalancer, uint256 _amount);
84  event Referral(uint256 _amount, address _ref);
85​
86  // ########## IdleToken V4_1 updates
87  // Idle governance token
88  address public constant IDLE = address(0x875773784Af8135eA0ef43b5a374AaD105c5D39e);
89  // Compound governance token
90  address public constant COMP = address(0xc00e94Cb662C3520282E6f5717214004A7f26888);
91  uint256 private constant FULL_ALLOC = 100000;
92​
93  // Idle distribution controller
94  address public constant idleController = address(0x275DA8e61ea8E02d51EDd8d0DC5c0E62b4CDB0BE);
95  // oracle used for calculating the avgAPR with gov tokens
96  address public oracle;
97  // eg cDAI -> COMP
98  mapping(address => address) private protocolTokenToGov;
99  // Whether openRebalance is enabled or not
100  bool public isRiskAdjusted;
101  // last allocations submitted by rebalancer
102  uint256[] private lastRebalancerAllocations;
103​
104  // ########## IdleToken V5 updates
105  // Fee for flash loan
106  uint256 public flashLoanFee;
107  // IdleToken helper address
108  address public tokenHelper;
109​
110  /**
111  * @dev Emitted on flashLoan()
112  * @param target The address of the flash loan receiver contract
113  * @param initiator The address initiating the flash loan
114  * @param amount The amount flash borrowed
115  * @param premium The flash loan fee
116  **/
117  event FlashLoan(
118    address indexed target,
119    address indexed initiator,
120    uint256 amount,
121    uint256 premium
122  );
123​
124  // Addresses for stkAAVE distribution from Aave
125  address public constant stkAAVE = address(0x4da27a545c0c5B758a6BA100e3a049001de870f5);
126  address private aToken;
127  // ########## End IdleToken V5 updates
128​
129  // ERROR MESSAGES:
130  // 0 = is 0
131  // 1 = already initialized
132  // 2 = length is different
133  // 3 = Not greater then
134  // 4 = lt
135  // 5 = too high
136  // 6 = not authorized
137  // 7 = not equal
138  // 8 = error on flash loan execution
139  // 9 = Reentrancy
140​
141  function _init() public {
142    require(oracle == 0xB5A8f07dD4c3D315869405d702ee8F6EA695E8C5);
143    oracle = 0x758C10272A15f0E9D50Cbc035ff9a046945da0F2;
144    flashLoanFee = 20;
145  }
146​
147  // onlyOwner
148  /**
149   * It allows owner to modify allAvailableTokens array in case of emergency
150   * ie if a bug on a interest bearing token is discovered and reset protocolWrappers
151   * associated with those tokens.
152   *
153   * @param protocolTokens : array of protocolTokens addresses (eg [cDAI, iDAI, ...])
154   * @param wrappers : array of wrapper addresses (eg [IdleCompound, IdleFulcrum, ...])
155   * @param _newGovTokens : array of governance token addresses
156   * @param _newGovTokensEqualLen : array of governance token addresses for each
157   *  protocolToken (addr0 should be used for protocols with no govToken)
158   */
159  function setAllAvailableTokensAndWrappers(
160    address[] calldata protocolTokens,
161    address[] calldata wrappers,
162    address[] calldata _newGovTokens,
163    address[] calldata _newGovTokensEqualLen
164  ) external onlyOwner {
165    require(protocolTokens.length == wrappers.length, "2");
166    require(_newGovTokensEqualLen.length >= protocolTokens.length, '3');
167​
168    govTokens = _newGovTokens;
169​
170    address newGov;
171    address protToken;
172    for (uint256 i = 0; i < protocolTokens.length; i++) {
173      protToken = protocolTokens[i];
174      require(protToken != address(0) && wrappers[i] != address(0), "0");
175      protocolWrappers[protToken] = wrappers[i];
176​
177      // set protocol token to gov token mapping
178      newGov = _newGovTokensEqualLen[i];
179      if (newGov != IDLE) {
180        protocolTokenToGov[protToken] = newGov;
181      }
182    }
183​
184    allAvailableTokens = protocolTokens;
185  }
186​
187  /**
188   * It allows owner to set the cToken address
189   *
190   * @param _cToken : new cToken address
191   */
192  function setCToken(address _cToken)
193    external onlyOwner {
194      require((cToken = _cToken) != address(0), "0");
195  }
196​
197  /**
198   * It allows owner to set the aToken address
199   *
200   * @param _aToken : new aToken address
201   */
202  function setAToken(address _aToken)
203    external onlyOwner {
204      require((aToken = _aToken) != address(0), "0");
205  }
206​
207  /**
208   * It allows owner to set the tokenHelper address
209   *
210   * @param _tokenHelper : new tokenHelper address
211   */
212  function setTokenHelper(address _tokenHelper)
213    external onlyOwner {
214      require((tokenHelper = _tokenHelper) != address(0), "0");
215  }
216​
217  /**
218   * It allows owner to set the IdleRebalancerV3_1 address
219   *
220   * @param _rebalancer : new IdleRebalancerV3_1 address
221   */
222  function setRebalancer(address _rebalancer)
223    external onlyOwner {
224      require((rebalancer = _rebalancer) != address(0), "0");
225  }
226​
227  /*
228   * It allows owner to set the fee (1000 == 10% of gained interest)
229   *
230   * @param _fee : fee amount where 100000 is 100%, max settable is 10%
231   */
232  function setFee(uint256 _fee)
233    external onlyOwner {
234      / 100000 == 100% -> 10000 == 10%
235      require((fee = _fee) <= FULL_ALLOC / 10, "5");
236  }

Solidity Contracts

JavaScript Tests