Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
• library Address
•    - function isContract(address account)
•    - function toPayable(address account)
•    - function sendValue(address payable re ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function callOptionalReturn(IERC20 to ...
•  contract Context
•    - function _msgSender()
•    - function _msgData()
•  contract Ownable is Context
•    - function owner()
•    - function isOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• interface CERC20
•    - function mint(uint256 mintAmount)
•    - function comptroller()
•    - function redeem(uint256 redeemTokens)
•    - function exchangeRateStored()
•    - function supplyRatePerBlock()
•    - function borrowRatePerBlock()
•    - function totalReserves()
•    - function getCash()
•    - function totalBorrows()
•    - function reserveFactorMantissa()
•    - function interestRateModel()
• interface ILendingProtocol
•    - function mint()
•    - function redeem(address account)
•    - function nextSupplyRate(uint256 amoun ...
•    - function nextSupplyRateWithParams(uin ...
•    - function getAPR()
•    - function getPriceInToken()
•    - function token()
•    - function underlying()
•    - function availableLiquidity()
• interface WhitePaperInterestRateModel
•    - function getBorrowRate(uint256 cash, ...
•    - function getSupplyRate(uint256 cash, ...
•    - function multiplier()
•    - function baseRate()
•    - function blocksPerYear()
•    - function dsrPerBlock()
•  contract IdleCompoundV2 is ILendin ... *
•    - function setIdleToken(address _idleTo ...
•    - function setBlocksPerYear(uint256 _bl ...
•    - function nextSupplyRateWithParams(uin ...
•    - function nextSupplyRate(uint256 _amou ...
•    - function getPriceInToken()
•    - function getAPR()
•    - function mint()
•    - function redeem(address _account)
•    - function availableLiquidity()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-08-12
*/

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol

pragma solidity ^0.5.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
 * the optional functions; to access them see {ERC20Detailed}.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// File: @openzeppelin/contracts/math/SafeMath.sol

pragma solidity ^0.5.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     *
     * _Available since v2.4.0._
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     *
     * _Available since v2.4.0._
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     *
     * _Available since v2.4.0._
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// File: @openzeppelin/contracts/utils/Address.sol

pragma solidity ^0.5.5;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * This test is non-exhaustive, and there may be false-negatives: during the
     * execution of a contract's constructor, its address will be reported as
     * not containing a contract.
     *
     * IMPORTANT: It is unsafe to assume that an address for which this
     * function returns false is an externally-owned account (EOA) and not a
     * contract.
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies in extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != 0x0 && codehash != accountHash);
    }

    /**
     * @dev Converts an `address` into `address payable`. Note that this is
     * simply a type cast: the actual underlying value is not changed.
     *
     * _Available since v2.4.0._
     */
    function toPayable(address account) internal pure returns (address payable) {
        return address(uint160(account));
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     *
     * _Available since v2.4.0._
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-call-value
        (bool success, ) = recipient.call.value(amount)("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }
}

// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol

pragma solidity ^0.5.0;




/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves.

        // A Solidity high level call has three parts:
        //  1. The target address is checked to verify it contains contract code
        //  2. The call itself is made, and success asserted
        //  3. The return value is decoded, which in turn checks the size of the returned data.
        // solhint-disable-next-line max-line-length
        require(address(token).isContract(), "SafeERC20: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = address(token).call(data);
        require(success, "SafeERC20: low-level call failed");

        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File: @openzeppelin/contracts/GSN/Context.sol

pragma solidity ^0.5.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
contract Context {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.
    constructor () internal { }
    // solhint-disable-previous-line no-empty-blocks

    function _msgSender() internal view returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// File: @openzeppelin/contracts/ownership/Ownable.sol

pragma solidity ^0.5.0;

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        _owner = _msgSender();
        emit OwnershipTransferred(address(0), _owner);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(isOwner(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Returns true if the caller is the current owner.
     */
    function isOwner() public view returns (bool) {
        return _msgSender() == _owner;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     */
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// File: contracts/interfaces/CERC20.sol

pragma solidity 0.5.16;

interface CERC20 {
  function mint(uint256 mintAmount) external returns (uint256);
  function comptroller() external view returns (address);
  function redeem(uint256 redeemTokens) external returns (uint256);
  function exchangeRateStored() external view returns (uint256);
  function supplyRatePerBlock() external view returns (uint256);

  function borrowRatePerBlock() external view returns (uint256);
  function totalReserves() external view returns (uint256);
  function getCash() external view returns (uint256);
  function totalBorrows() external view returns (uint256);
  function reserveFactorMantissa() external view returns (uint256);
  function interestRateModel() external view returns (address);
}

// File: contracts/interfaces/ILendingProtocol.sol

pragma solidity 0.5.16;

interface ILendingProtocol {
  function mint() external returns (uint256);
  function redeem(address account) external returns (uint256);
  function nextSupplyRate(uint256 amount) external view returns (uint256);
  function nextSupplyRateWithParams(uint256[] calldata params) external view returns (uint256);
  function getAPR() external view returns (uint256);
  function getPriceInToken() external view returns (uint256);
  function token() external view returns (address);
  function underlying() external view returns (address);
  function availableLiquidity() external view returns (uint256);
}

// File: contracts/interfaces/WhitePaperInterestRateModel.sol

pragma solidity 0.5.16;

interface WhitePaperInterestRateModel {
  function getBorrowRate(uint256 cash, uint256 borrows, uint256 _reserves) external view returns (uint256, uint256);
  function getSupplyRate(uint256 cash, uint256 borrows, uint256 reserves, uint256 reserveFactorMantissa) external view returns (uint256);
  function multiplier() external view returns (uint256);
  function baseRate() external view returns (uint256);
  function blocksPerYear() external view returns (uint256);
  function dsrPerBlock() external view returns (uint256);
}

// File: contracts/wrappers/IdleCompoundV2.sol

/**
 * @title: Compound wrapper
 * @summary: Used for interacting with Compound. Has
 *           a common interface with all other protocol wrappers.
 *           This contract holds assets only during a tx, after tx it should be empty
 * @author: Idle Labs Inc., idle.finance
 */
pragma solidity 0.5.16;








contract IdleCompoundV2 is ILendingProtocol, Ownable {
  using SafeERC20 for IERC20;
  using SafeMath for uint256;

  // protocol token (cToken) address
  address public token;
  // underlying token (token eg DAI) address
  address public underlying;
  address public idleToken;
  uint256 public blocksPerYear;

  /**
   * @param _token : cToken address
   * @param _underlying : underlying token (eg DAI) address
   */
  constructor(address _token, address _underlying) public {
    require(_token != address(0) && _underlying != address(0), 'COMP: some addr is 0');

    token = _token;
    underlying = _underlying;
    blocksPerYear = 2371428;
    IERC20(_underlying).safeApprove(_token, uint256(-1));
  }

  /**
   * Throws if called by any account other than IdleToken contract.
   */
  modifier onlyIdle() {
    require(msg.sender == idleToken, "Ownable: caller is not IdleToken");
    _;
  }

  // onlyOwner
  /**
   * sets idleToken address
   * NOTE: can be called only once. It's not on the constructor because we are deploying this contract
   *       after the IdleToken contract
   * @param _idleToken : idleToken address
   */
  function setIdleToken(address _idleToken)
    external onlyOwner {
      require(idleToken == address(0), "idleToken addr already set");
      require(_idleToken != address(0), "_idleToken addr is 0");
      idleToken = _idleToken;
  }

  /**
   * sets blocksPerYear address
   *
   * @param _blocksPerYear : avg blocks per year
   */
  function setBlocksPerYear(uint256 _blocksPerYear)
    external onlyOwner {
      require(_blocksPerYear != 0, "_blocksPerYear is 0");
      blocksPerYear = _blocksPerYear;
  }
  // end onlyOwner

  /**
   * Calculate next supply rate for Compound, given an `_amount` supplied (last array param)
   * and all other params supplied.
   *
   * @param params : array with all params needed for calculation
   * @return : yearly net rate
   */
  function nextSupplyRateWithParams(uint256[] calldata params)
    external view
    returns (uint256) {
      CERC20 cToken = CERC20(token);
      WhitePaperInterestRateModel white = WhitePaperInterestRateModel(cToken.interestRateModel());
      uint256 ratePerBlock = white.getSupplyRate(
        params[1].add(params[5]),
        params[0],
        params[2],
        params[3]
      );
      return ratePerBlock.mul(params[4]).mul(100);
  }

  /**
   * Calculate next supply rate for Compound, given an `_amount` supplied
   *
   * @param _amount : new underlying amount supplied (eg DAI)
   * @return : yearly net rate
   */
  function nextSupplyRate(uint256 _amount)
    external view
    returns (uint256) {
      CERC20 cToken = CERC20(token);
      WhitePaperInterestRateModel white = WhitePaperInterestRateModel(cToken.interestRateModel());
      uint256 ratePerBlock = white.getSupplyRate(
        cToken.getCash().add(_amount),
        cToken.totalBorrows(),
        cToken.totalReserves(),
        cToken.reserveFactorMantissa()
      );
      return ratePerBlock.mul(blocksPerYear).mul(100);
  }

  /**
   * @return current price of cToken in underlying
   */
  function getPriceInToken()
    external view
    returns (uint256) {
      return CERC20(token).exchangeRateStored();
  }

  /**
   * @return apr : current yearly net rate
   */
  function getAPR()
    external view
    returns (uint256 apr) {
      CERC20 cToken = CERC20(token);
      uint256 cRate = cToken.supplyRatePerBlock(); // interest % per block
      apr = cRate.mul(blocksPerYear).mul(100);
  }

  /**
   * Gets all underlying tokens in this contract and mints cTokens
   * tokens are then transferred to msg.sender
   * NOTE: underlying tokens needs to be sended here before calling this
   *
   * @return iTokens minted
   */
  function mint()
    external onlyIdle
    returns (uint256 cTokens) {
      uint256 balance = IERC20(underlying).balanceOf(address(this));
      if (balance == 0) {
        return cTokens;
      }
      // get a handle for the corresponding cToken contract
      CERC20 _cToken = CERC20(token);
      // mint the cTokens and assert there is no error
      require(_cToken.mint(balance) == 0, "Error minting cTokens");
      // cTokens are now in this contract
      cTokens = IERC20(token).balanceOf(address(this));
      // transfer them to the caller
      IERC20(token).safeTransfer(msg.sender, cTokens);
  }

  /**
   * Gets all cTokens in this contract and redeems underlying tokens.
   * underlying tokens are then transferred to `_account`
   * NOTE: iTokens needs to be sended here before calling this
   *
   * @return underlying tokens redeemd
   */
  function redeem(address _account)
    external onlyIdle
    returns (uint256 tokens) {
      // Funds needs to be sended here before calling this
      CERC20 _cToken = CERC20(token);
      IERC20 _underlying = IERC20(underlying);
      // redeem all underlying sent in this contract
      require(_cToken.redeem(IERC20(token).balanceOf(address(this))) == 0, "Error redeeming cTokens");

      tokens = _underlying.balanceOf(address(this));
      _underlying.safeTransfer(_account, tokens);
  }

  function availableLiquidity() external view returns (uint256) {
    return CERC20(token).getCash();
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"address","name":"_underlying","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"constant":true,"inputs":[],"name":"availableLiquidity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"blocksPerYear","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getAPR","outputs":[{"internalType":"uint256","name":"apr","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getPriceInToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"idleToken","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"mint","outputs":[{"internalType":"uint256","name":"cTokens","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"nextSupplyRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256[]","name":"params","type":"uint256[]"}],"name":"nextSupplyRateWithParams","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"redeem","outputs":[{"internalType":"uint256","name":"tokens","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"_blocksPerYear","type":"uint256"}],"name":"setBlocksPerYear","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_idleToken","type":"address"}],"name":"setIdleToken","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"token","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"underlying","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"}]

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

21508:5369:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;21508:5369:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24706:125;;;:::i;:::-;;;;;;;;;;;;;;;;25372:626;;;:::i;21769:24::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;21739:25;;;:::i;18260:140::-;;;:::i;:::-;;26769:105;;;:::i;17449:79::-;;;:::i;17815:94::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;23495:454;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;23495:454:0;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;23495:454:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;23495:454:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;39:11;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;-1:-1;23495:454:0;;-1:-1:-1;23495:454:0;-1:-1:-1;23495:454:0;:::i;26258:505::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;26258:505:0;;;;:::i;22691:240::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;22691:240:0;;;;:::i;21798:28::-;;;:::i;24895:232::-;;;:::i;24145:489::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;24145:489:0;;:::i;23040:179::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;23040:179:0;;:::i;18555:109::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;18555:109:0;;;;:::i;21668:20::-;;;:::i;24706:125::-;24798:5;;24791:34;;;;;;;;24766:7;;24798:5;;;24791:32;;:34;;;;;;;;;;;;;;24798:5;24791:34;;;5:2:-1;;;;30:1;27;20:12;5:2;24791:34:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;24791:34:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;24791:34:0;;-1:-1:-1;24706:125:0;;:::o;25372:626::-;22377:9;;25425:15;;22377:9;;22363:10;:23;22355:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25476:10;;25469:43;;;;;;25506:4;25469:43;;;;;;25451:15;;25476:10;;;25469:28;;:43;;;;;;;;;;;;;;25476:10;25469:43;;;5:2:-1;;;;30:1;27;20:12;5:2;25469:43:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;25469:43:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;25469:43:0;;-1:-1:-1;25525:12:0;25521:53;;-1:-1:-1;25550:14:0;;25521:53;25667:5;;25746:21;;;;;;;;;;;;;;25667:5;;;;;;;25746:12;;:21;;;;;;;;;;;;;;25643:14;25667:5;25746:21;;;5:2:-1;;;;30:1;27;20:12;5:2;25746:21:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;25746:21:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;25746:21:0;:26;25738:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25867:5;;25860:38;;;;;;25892:4;25860:38;;;;;;25867:5;;;;;25860:23;;:38;;;;;;;;;;;;;;;25867:5;25860:38;;;5:2:-1;;;;30:1;27;20:12;5:2;25860:38:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;25860:38:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;25860:38:0;25952:5;;25860:38;;-1:-1:-1;25945:47:0;;25952:5;;25972:10;25860:38;25945:47;:26;:47;:::i;:::-;22430:1;;25372:626;:::o;21769:24::-;;;;;;:::o;21739:25::-;;;;;;:::o;18260:140::-;17661:9;:7;:9::i;:::-;17653:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18359:1;18343:6;;18322:40;;;18343:6;;;;18322:40;;18359:1;;18322:40;18390:1;18373:19;;;;;;18260:140::o;26769:105::-;26852:5;;26845:23;;;;;;;;26822:7;;26852:5;;;26845:21;;:23;;;;;;;;;;;;;;26852:5;26845:23;;;5:2:-1;;;;30:1;27;20:12;17449:79:0;17487:7;17514:6;;;17449:79;:::o;17815:94::-;17855:4;17895:6;;;;17879:12;:10;:12::i;:::-;:22;;;17872:29;;17815:94;:::o;23495:454::-;23630:5;;23709:26;;;;;;;;23589:7;;23630:5;;;23589:7;;23630:5;;23709:24;;:26;;;;;;;;;;;;;;23630:5;23709:26;;;5:2:-1;;;;30:1;27;20:12;5:2;23709:26:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;23709:26:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;23709:26:0;;-1:-1:-1;23745:20:0;23768:19;;;;23798:24;23812:6;;23819:1;23812:9;;;;;;;;;;;;;23798:6;;23805:1;23798:9;;;;;;;;;;;;;:13;;:24;;;;:::i;:::-;23833:6;;23840:1;23833:9;;;;;;;;;;;;;23853:6;;23860:1;23853:9;;;;;;;;;;;;;23873:6;;23880:1;23873:9;;;;;;;;;;;;;23768:123;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;23768:123:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;23768:123:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;23768:123:0;;-1:-1:-1;23907:36:0;23939:3;23907:27;23924:6;;23931:1;23924:9;;;;;;;;;;;;;23907:12;:16;;:27;;;;:::i;:::-;:31;:36;:31;:36;:::i;:::-;23900:43;;;;;23495:454;;;;;:::o;26258:505::-;22377:9;;26329:14;;22377:9;;22363:10;:23;22355:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26438:5;;26481:10;;26578:38;;;;;;26610:4;26578:38;;;;;;26438:5;;;;;26481:10;;;;26438:5;;26563:14;;26438:5;;26578:23;;:38;;;;;;;;;;;;;;26438:5;26578:38;;;5:2:-1;;;;30:1;27;20:12;5:2;26578:38:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;26578:38:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;26578:38:0;26563:54;;;;;;;;;;;;;;;;;;;;;;;;26578:38;;26563:54;;;;;;;-1:-1:-1;26563:54:0;;;;5:2:-1;;;;30:1;27;20:12;5:2;26563:54:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;26563:54:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;26563:54:0;:59;26555:95;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26670:36;;;;;;26700:4;26670:36;;;;;;:21;;;;;;:36;;;;;;;;;;;;;;:21;:36;;;5:2:-1;;;;30:1;27;20:12;5:2;26670:36:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;26670:36:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;26670:36:0;;-1:-1:-1;26715:42:0;:24;;;26740:8;26670:36;26715:42;:24;:42;:::i;:::-;22430:1;;26258:505;;;:::o;22691:240::-;17661:9;:7;:9::i;:::-;17653:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22774:9;;:23;:9;:23;22766:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22845:24;;;22837:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22903:9;:22;;;;;;;;;;;;;;;22691:240::o;21798:28::-;;;;:::o;24895:232::-;24991:5;;25022:27;;;;;;;;24946:11;;24991:5;;;24946:11;;24991:5;;25022:25;;:27;;;;;;;;;;;;;;24991:5;25022:27;;;5:2:-1;;;;30:1;27;20:12;5:2;25022:27:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;25022:27:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;25022:27:0;25098:13;;25022:27;;-1:-1:-1;25088:33:0;;25117:3;;25088:24;;25022:27;;25088:24;:9;:24;:::i;:33::-;25082:39;;24895:232;;;:::o;24145:489::-;24260:5;;24339:26;;;;;;;;24219:7;;24260:5;;;24219:7;;24260:5;;24339:24;;:26;;;;;;;;;;;;;;24260:5;24339:26;;;5:2:-1;;;;30:1;27;20:12;5:2;24339:26:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;24339:26:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;24339:26:0;;;;;;;;;;;;;;;;24275:91;;24375:20;24398:5;:19;;;24428:29;24449:7;24428:6;:14;;;:16;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;24428:16:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;24428:16:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;24428:16:0;;:29;:20;:29;:::i;:::-;24468:6;:19;;;:21;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;24468:21:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;24468:21:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;24468:21:0;24500:22;;;;;;;;:20;;;;;;:22;;;;;24468:21;;24500:22;;;;;;;:20;:22;;;5:2:-1;;;;30:1;27;20:12;5:2;24500:22:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;24500:22:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;24500:22:0;24533:30;;;;;;;;:28;;;;;;:30;;;;;24500:22;;24533:30;;;;;;;:28;:30;;;5:2:-1;;;;30:1;27;20:12;5:2;24533:30:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;24533:30:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;24533:30:0;24398:174;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24533:30;;24398:174;;;;;;;;;;;5:2:-1;;;;30:1;27;20:12;5:2;24398:174:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;24398:174:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;24398:174:0;24605:13;;24398:174;;-1:-1:-1;24588:40:0;;24624:3;;24588:31;;24398:174;;24588:31;:16;:31;:::i;:40::-;24581:47;24145:489;-1:-1:-1;;;;;24145:489:0:o;23040:179::-;17661:9;:7;:9::i;:::-;17653:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23131:19;23123:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23183:13;:30;23040:179::o;18555:109::-;17661:9;:7;:9::i;:::-;17653:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18628:28;18647:8;18628:18;:28::i;:::-;18555:109;:::o;21668:20::-;;;;;;:::o;12180:176::-;12289:58;;;12312:14;12289:58;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;12289:58:0;;;;;;;;25:18:-1;;61:17;;12289:58:0;182:15:-1;12312:23:0;179:29:-1;160:49;;12263:85:0;;12282:5;;12263:18;:85::i;:::-;12180:176;;;:::o;16198:98::-;16278:10;16198:98;:::o;3793:181::-;3851:7;3883:5;;;3907:6;;;;3899:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3965:1;3793:181;-1:-1:-1;;;3793:181:0:o;5165:471::-;5223:7;5468:6;5464:47;;-1:-1:-1;5498:1:0;5491:8;;5464:47;5535:5;;;5539:1;5535;:5;:1;5559:5;;;;;:10;5551:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18770:229;18844:22;;;18836:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18946:6;;;18925:38;;;;;;;18946:6;;;18925:38;;;18974:6;:17;;;;;;;;;;;;;;;18770:229::o;14219:1114::-;14823:27;14831:5;14823:25;;;:27::i;:::-;14815:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14960:12;14974:23;15009:5;15001:19;;15021:4;15001:25;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;139:12;;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;15001:25:0;;;;;;;;;;;;;;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;14959:67:0;;;;15045:7;15037:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15106:17;;:21;15102:224;;15248:10;15237:30;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;15237:30:0;15229:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14219:1114;;;;:::o;9018:810::-;9078:4;9737:20;;9580:66;9777:15;;;;;:42;;;9808:11;9796:8;:23;;9777:42;9769:51;9018:810;-1:-1:-1;;;;9018:810:0:o;12576:621::-;12946:10;;;12945:62;;-1:-1:-1;12962:39:0;;;;;;12986:4;12962:39;;;;:15;:39;;;;;;;;;:15;;;;;;:39;;;;;;;;;;;;;;;:15;:39;;;5:2:-1;;;;30:1;27;20:12;5:2;12962:39:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;12962:39:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;12962:39:0;:44;12945:62;12937:152;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13126:62;;;13149:13;13126:62;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;13126:62:0;;;;;;;;25:18:-1;;61:17;;13126:62:0;182:15:-1;13149:22:0;179:29:-1;160:49;;13100:89:0;;13119:5;;13100:18;:89::i

bzzr://0d1e360af84af3b35ff252f16f05d26f8de763367ffa27e5481dfcd18f818125