Quantstamp reviewed Idle Finance on 13 Dec 2019: 13 findings, 0 critical; 11 marked fixed, 2 acknowledged; 2 more marked mitigated.
Report hosted on certificate.quantstamp.com.
Trustblock does not review code.
Statuses are the security firm’s own, from its report.
| Severity | Open | Acknowledged | Fixed | Mitigated |
|---|---|---|---|---|
| Critical | 0 | 0 | 0 | 0 |
| High | 0 | 0 | 0 | 0 |
| Medium | 0 | 0 | 3 | 1 |
| Low | 0 | 2 | 8 | 1 |
Marked Informational or Undetermined by the firm. Not counted as findings.
As it presently is constructed, the contract is vulnerable to the [allowance double-spend exploit](https://github.com/OpenZeppelin/openzeppelin-solidity/blob/b4f87bb8fc25fb07f73099701e39e167a3d36465/contracts/token/ERC20/ERC20.sol#L71-L78), as with other ERC20 tokens.
The `flashLoan` can be used to force triggering the rebalance process and moving funds in and out different underlying protocols. A related security issue is described in [EIP-3156](https://eips.ethereum.org/EIPS/eip-3156#flash-minting-external-security-considerations).
The function `flashLoan` can be used to force triggering the rebalance process and move funds in and out different underlying protocols. If any of the underlying lending protocols have a redemption fee, an attacker who seeks to damage IdleFinance can achieve this by rapidly performing large value flashloans that cause IdleFinance to redeem and mint the underlying protocol’s tokens and end up losing money.
The owner of the `IdleTokenV3_1.sol` could call `manualInitialize` multiple times. This would reset several state variables. The semantics of the function name gives the impression that it should only be called once.
1. The `manualInitialize` function does not check if the length of the 2nd, 3rd and 4th input arrays is the same. The `for`-loop inside this function assumes the length of `_protocolTokens`, `_wrappers` and `_lastRebalancerAllocations` input arrays is the same. 2. A comment on L105 indicates that the `_newGovTokens` array "should include IDLE". However, this is not verified inside the function. It could be verified by setting a binary flag to true inside the `if`-statement on `L124: if (newGov == IDLE) { continue; }`, and then checking this flag after the `for`-loop using a `require` statement.
The `getGovApr` function does not have an explicit return value for the cases where the `if`-statement is not entered, i.e. the `if`-condition is not `true`.
The owner of the `IdleTokenV3_1` contract has the right to change the following state variables at any time, they can even front-run end-users: 1. `setAllAvailableTokensAndWrappers` can be set to any address including EOAs 2. `setGovTokens` can be set to any address including EOAs 3. `setRebalancer` can be set to any address including an EOA 4. `setFee` upper bounded by 10% 5. `setMaxUnlentPerc` upper bounded to 100% 6. `setFeeAddress` can be set to any address including an EOA 7. `setOracleAddress` can be set to any address including an EOA 8. `setIdleControllerAddress` can be set to any address including an EOA 9. `setIsRiskAdjusted` 10. `setAllocations` this can also be done by the `rebalancer` address
Smart contracts will often have `owner` variables to designate the person with special privileges to make modifications to the smart contract. Within `IdleRebalancerV3_1`, the owner can perform the following actions: 1. Can set the idle token exactly once via `setIdleToken` 1. Can set the rebalance manager address any number of times via `setRebalanceManager` 1. Can add any number of new tokens via `setNewToken` 1. Another role enforced by `onlyRebalancerAndIdle` modifier, which allows the rebalance manager or idle token to set completely new token allocations, for exactly the same token addresses, that sum up to 100% (any number of times). The `IdleTokenV3_1.sol` contract contains the following privileged actions: 1. Modify the `allAvailableTokens` array any number of times 1. Set the address of the `iToken` any number of times 1. Set the governance token address `govTokens` any number of times 1. Set the rebalancer address any number of times 1. Set the fee taken from end users any number of times to any value lower or equal to 10% 1. Set the maximum unlent asset percentage to any value lower than 100% 1. Set the fee address any number of times.
Although there is no immediate exploit known at this time, since protocol wrappers can be added arbitrarily in the future, this issue could occur, and further unforeseen issues could arise in the existing underlying protocols.
The function `_init` should ensure that `_tokenHelper` is non-zero.
The `initialize` method has been replaced with the `manualInitialize` method, which is significantly different: 1. There are several inherited contracts which were initialized in the `initialize`, but are not initialized in the `manualyInitialize` method. The following code snippet indicates the initialization of these contracts, which was removed: ``` // Initialize inherited contracts ERC20Detailed.initialize(_name, _symbol, 18); Ownable.initialize(msg.sender); Pausable.initialize(msg.sender); ReentrancyGuard.initialize(); GST2ConsumerV2.initialize(); ``` 2. Similarly, the following state variables: `token`, `tokenDecimals`, `cToken` and `maxUnlentPerc`, were initialized in the `initialize` method, but are not initialized in the `manualyInitialize` method.
Several important state variables: `token`, `tokenDecimals`, and `isRiskAdjusted`, are not initialized anywhere.
If `newIdleToken()` is called with an existing `_token` address, the `IdleToken` contract referenced in the `underlyingToIdleTokenMap` will be overwritten. It is not clear if this is intended functionality.
The clone-and-own approach involves copying and adjusting open source code at one's own discretion. From the development perspective, it is initially beneficial as it reduces the amount of effort. However, from the security perspective, it involves some risks as the code may not follow the best practices, may contain a security vulnerability, or may include intentionally or unintentionally modified upstream libraries. In `IdleMcdBridge.sol`, there are several libraries that could be imported: `IERC20`, `SafeMath`, `Context`, and `Address`.
On `L508` of `IdleTokenV3.sol`, the modifier `whenITokenPriceHasNotDecreased` checks that function `_rebalance` can only be executed when the iToken price has not decreased. However, since `Fulcrum` could get hacked (or the price of collateral may drop), it might not always be true. When this happens, the system would not be able to rebalance/reallocate funds for a period of time.
In `GST2Consumer.sol`, several constants are defined related to gas usage. Since op-code gas costs may be updated in new forks, this may cause unforeseen gas issues in future forks.
Gas usage is a main concern for smart contract developers and users, since high gas costs may prevent users from wanting to use the smart contract. Even worse, some gas usage issues may prevent the contract from providing services entirely. For example, if a `for` loop requires too much gas to exit, then it may prevent the contract from functioning correctly entirely. It is best to break such loops into individual functions as possible. In particular, the rebalancing functions may require several loops in the bisection algorithm.
The `userNoFeeQtyFrom` part of the `qty` input parameter of the`_updateUserFeeInfo` function is subtracted twice from `totBalance`: on deposits on L889 and L892. See the following code snippet: ``` 889: uint256 totBalance = balanceOf(usr).sub(userNoFeeQty[usr]); 890: // noFeeQty should not be counted here 891: // (avgPrice * oldBalance) + (currPrice * newQty)) / totBalance 892: userAvgPrices[usr] = userAvgPrices[usr].mul(totBalance.sub(qty)).add(price.mul(qty)).div(totBalance); ``` This happens because `userNoFeeQtyFrom` was already added to `userNoFeeQty[usr]`, which is first subtracted on L889. This leads to an incorrect `userAvgPrice` for that user. <br> Additionally, the `price` should not be multiplied by `qty` on L892, because on transfers, the amount that is actually transfered to `usr` is equal to `userNoFeeQtyFrom`.
* In `IdleRebalancerV3.sol`, on L28, the constructor arguments `_yxToken` and `_rebalancerManager` were not checked to be non-zero. * In `IdleTokenV3.sol`, the constructor and all setter functions should check that addresses are non-zero.
* The functionality of `L907`: `userNoFeeQty[msg.sender] = noFees ? noFeeQty.sub(amount) : 0;`, is unclear. It seems that what we want to achieve here is more like `userNoFeeQty[msg.sender] = balanceOf(msg.sender).sub(_amount);` when `fee == 0` and `userNoFeeQty[msg.sender] = noFeeQty.sub(amount)` when `noFeeQty >= amount`.
There are several defined constants in the code that were unclear, and would benefit from added inline documentation: * In `IdleAave.sol`, L161: the number 29; * In `IdleAave.sol`, the constant on L143 of `getApr()`: `100/10^9`; * In `GST2Consumer.sol`, all numerical constants on L15, 19-20; * In `IdleRebalancerV3.sol`, on L32, it is not immediately clear that the constant 100000 is 100%.
Every Solidity file specifies in the header a version number of the format `pragma solidity (^)0.4.*`. The caret (`^`) before the version number implies an unlocked pragma, meaning that the compiler will use the specified version _and above_, hence the term "unlocked." The file `IdleMcdBridge.sol` has several instances of unlocked pragmas throughout.
Until solidity 0.6.0, the ABIEncoderV2 feature is still technically in experimental state. Although there are no known security risks associated with it, these features should be used judiciously.
The owner of the `IdleTokenGovernance` contract has the privilege of front running any end-user who calls `flashLoan()` by calling `setFlashLoanFee()` and increasing the flash loan fee. Coupled with the fact that the `flashLoanFee` can be set up to 100% inside the `setFlashLoanFee()` function, this could be detrimental to the caller if sufficient funds are available in the caller's balance.
The report names a repository or files. Open the report to see its scope.
Repository and files the report names (123)
240 projects reviewed · 338 reports · latest Nov 2026
See Quantstamp’s auditsSomething wrong on this page? A missing report, a wrong date, a finding that was fixed since. Tell us and we check it against its source.
Tell us