As of 19 Nov 2026, Idle Finance has 4 audit reports by 3 security firms on Trustblock; the latest is by Sherlock, dated 21 Dec 2024. Those reports list no open critical findings.
Record last updated . It holds audits and findings, contracts and incidents up to Nov 2026. Trustblock does not review code.
Newest first
| Report | Security firm | Date | Scope | Critical findings | Source |
|---|---|---|---|---|---|
| Idle Finance Credit Vaults auditAudit competition | Security firm: Sherlock | Date: | Scope: —Not recorded; see the report | None open | GitHub ↗ |
| Idle Finance | Security firm: Consensys | Date: | Scope: Files listed | None open | diligence.security ↗ |
| Idle Governance | Security firm: Quantstamp | Date: | Scope: Files listed | None open | certificate.quantstamp.com ↗ |
| Idle Finance | Security firm: Quantstamp | Date: | Scope: Files listed | None open | certificate.quantstamp.com ↗ |
Statuses are the security firm’s own, from each report.
| Severity | Open | Acknowledged | Fixed | Mitigated |
|---|---|---|---|---|
| Critical | 0 | 0 | 0 | 0 |
| High | 0 | 0 | 2 | 0 |
| Medium | 3 | 1 | 6 | 1 |
| Low | 6 | 3 | 9 | 1 |
Marked Informational or Undetermined by the firms. Not counted as findings.
(a) For `contracts\PriceOracle.sol`, a potentially malicious owner (if the private key was leaked) can change the feed contract addresses/block length to give incorrect price oracles that can affect the token. While privileged roles for the Idle token are addressed in https://developers.idle.finance/advanced/admin-powers, it is not addressed for the price oracle. (b) For `contracts/IdleController.sol`, the admin can manipulate the rate of tokens in which each market receives by adding/removing idle markets to the list. **update-2020-10-26**: Idle Team stated that the owner of the `PriceOracle.sol` and the `IdleController.sol` contracts will be the Timelock contract (i.e., the governance itself) directly on deploy.
Open the reportAs 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.
Open the reportThe `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).
Open the reportThe 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.
Open the reportThe 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.
Open the report1. 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.
Open the reportThe `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`.
Open the reportThe 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
Open the reportSmart 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.
Open the reportAlthough 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.
Open the reportThe function `_init` should ensure that `_tokenHelper` is non-zero.
Open the reportThe `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.
Open the reportSeveral important state variables: `token`, `tokenDecimals`, and `isRiskAdjusted`, are not initialized anywhere.
Open the reportFor `contracts\Idle.sol`, `delegateBySig()` should validate the `v` and `s` parameters as in `ECDSA.sol` (See: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/2bb06b1af4d57cf47c700992b327a08bebf64879/contracts/cryptography/ECDSA.sol#L46).
Open the reportInteger overflow/underflow occur when an integer hits its bit-size limit. Every integer has a set range; when that range is passed, the value loops back around. A clock is a good analogy: at 11:59, the minute hand goes to 0, not 60, because 59 is the largest possible minute. Integer overflow and underflow may cause many unexpected kinds of behavior and was the core reason for the `batchOverflow` attack. Here's an example with `uint8` variables, meaning unsigned integers with a range of `0..255`. ``` function under_over_flow() public { uint8 num_players = 0; num_players = num_players - 1; // 0 - 1 now equals 255! if (num_players == 255) { emit LogUnderflow(); // underflow occurred } uint8 jackpot = 255; jackpot = jackpot + 1; // 255 + 1 now equals 0! if (jackpot == 0) { emit LogOverflow(); // overflow occurred } } ``` In particular, for `contracts\PriceOracle.sol`, there is a potential underflow on `L70`: `... 10**(18-tokenDecimals) ...`. It is recommended to use `SafeMath` for this operation.
Open the reportFor `contracts\IdleController.sol`, the values inside the `priceOracle_` input parameter is not checked to be different from `0x0` inside the `_setPriceOracle` function.
Open the reportFor `contracts/PriceOracle.sol`, in function `getCompApr`, the computed pair will always return a result that has the last two digits as `0`, in `L58` due to division before multiplication `div(cTokenNAV).mul(100)`.
Open the reportIf `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.
Open the reportThe 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`.
Open the reportOn `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.
Open the reportIn `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.
Open the reportGas 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.
Open the reportThe `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`.
Open the report* 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.
Open the report* 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`.
Open the reportThere 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%.
Open the reportEvery 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.
Open the reportUntil 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.
Open the reportThe 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.
Open the reportThe reports name a repository or files. Open a report to see its scope.
Is this your project? Show this record on your own website. The label states what the record holds, links to this page and updates by itself. It is free and needs no sign-in.
Automatic: the three strongest facts of this project’s own record (its last audit and two more), highlighted. They update with the record. Picking a fact turns Automatic off.
<head><script src="https://widget.trustblock.run/project-widget.min.js" defer></script></head><body><divdata-tb-project-widgetdata-tb-project-slug="idle-finance"></div></body>
Paste the code where the label should appear. It uses no API credit and updates by itself.
Something 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