Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;

import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

import "../library/HomoraMath.sol";
import "../interfaces/AggregatorV3Interface.sol";
import "../interfaces/IBEP20.sol";
import "../interfaces/IPriceCalculator.sol";
import "../interfaces/ILToken.sol";

contract PriceCalculator is IPriceCalculator, Ownable {
  using SafeMath for uint256;
  using HomoraMath for uint256;

  // Min price setting interval
  address internal constant ETH = 0x0000000000000000000000000000000000000000;
  uint256 private constant THRESHOLD = 5 minutes;

  /* ========== STATE VARIABLES ========== */

  address public keeper;
  mapping(address => ReferenceData) public references;
  mapping(address => address) private tokenFeeds;

  /* ========== MODIFIERS ========== */

  /// @dev `msg.sender` 가 keeper 또는 owner 인지 검증
  modifier onlyKeeper() {
    require(msg.sender == keeper || msg.sender == owner(), "PriceCalculator: caller is not the owner or keeper");
    _;
  }

  /* ========== INITIALIZER ========== */

  constructor() public {}

  /* ========== RESTRICTED FUNCTIONS ========== */

  /// @notice Keeper address 변경
  /// @dev Keeper address 에서만 요청 가능
  /// @param _keeper New keeper address
  function setKeeper(address _keeper) external onlyKeeper {
    require(_keeper != address(0), "PriceCalculator: invalid keeper address");
    keeper = _keeper;
  }

  /// @notice Chainlink oracle feed 설정
  /// @param asset Asset address to be used as a key
  /// @param feed Chainlink oracle feed contract address
  function setTokenFeed(address asset, address feed) external onlyKeeper {
    tokenFeeds[asset] = feed;
  }

  /// @notice Set price by keeper
  /// @dev Keeper address 에서만 요청 가능
  /// @param assets Array of asset addresses to set
  /// @param prices Array of asset prices to set
  /// @param timestamp Timstamp of price information
  function setPrices(address[] memory assets, uint256[] memory prices, uint256 timestamp) external onlyKeeper {
    require(
      timestamp <= block.timestamp && block.timestamp.sub(timestamp) <= THRESHOLD,
      "PriceCalculator: invalid timestamp"
    );

    for (uint256 i = 0; i < assets.length; i++) {
      references[assets[i]] = ReferenceData({lastData: prices[i], lastUpdated: block.timestamp});
    }
  }

  /* ========== VIEWS ========== */

  function priceOf(address asset) public view override returns (uint256 priceInUSD) {
    if (asset == address(0)) {
      return priceOfETH();
    }
    uint256 decimals = uint256(IBEP20(asset).decimals());
    uint256 unitAmount = 10 ** decimals;
    return _oracleValueInUSDOf(asset, unitAmount, decimals);
  }

  function pricesOf(address[] memory assets) public view override returns (uint256[] memory) {
    uint256[] memory prices = new uint256[](assets.length);
    for (uint256 i = 0; i < assets.length; i++) {
      prices[i] = priceOf(assets[i]);
    }
    return prices;
  }

  function getUnderlyingPrice(address lToken) public view override returns (uint256) {
    return priceOf(ILToken(lToken).underlying());
  }

  function getUnderlyingPrices(address[] memory lTokens) public view override returns (uint256[] memory) {
    uint256[] memory prices = new uint256[](lTokens.length);
    for (uint256 i = 0; i < lTokens.length; i++) {
      prices[i] = priceOf(ILToken(lTokens[i]).underlying());
    }
    return prices;
  }

  function priceOfETH() public view override returns (uint256 valueInUSD) {
    valueInUSD = 0;
    if (tokenFeeds[ETH] != address(0)) {
      (, int256 price, , , ) = AggregatorV3Interface(tokenFeeds[ETH]).latestRoundData();
      return uint256(price).mul(1e10);
    } else if (references[ETH].lastUpdated > block.timestamp.sub(1 days)) {
      return references[ETH].lastData;
    } else {
      revert("PriceCalculator: invalid oracle value");
    }
  }

  /* ========== PRIVATE FUNCTIONS ========== */

  function _oracleValueInUSDOf(
    address asset,
    uint256 amount,
    uint256 decimals
  ) private view returns (uint256 valueInUSD) {
    valueInUSD = 0;
    uint256 assetDecimals = asset == address(0) ? 1e18 : 10 ** decimals;
    if (tokenFeeds[asset] != address(0)) {
      (, int256 price, , , ) = AggregatorV3Interface(tokenFeeds[asset]).latestRoundData();
      valueInUSD = uint256(price).mul(1e10).mul(amount).div(assetDecimals);
    } else if (references[asset].lastUpdated > block.timestamp.sub(1 days)) {
      valueInUSD = references[asset].lastData.mul(amount).div(assetDecimals);
    } else {
      revert("PriceCalculator: invalid oracle value");
    }
  }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.6.12;

import "@openzeppelin/contracts/math/SafeMath.sol";

library HomoraMath {
  using SafeMath for uint256;

  function divCeil(uint256 lhs, uint256 rhs) internal pure returns (uint256) {
    return lhs.add(rhs).sub(1) / rhs;
  }

  function fmul(uint256 lhs, uint256 rhs) internal pure returns (uint256) {
    return lhs.mul(rhs) / (2 ** 112);
  }

  function fdiv(uint256 lhs, uint256 rhs) internal pure returns (uint256) {
    return lhs.mul(2 ** 112) / rhs;
  }

  // implementation from https://github.com/Uniswap/uniswap-lib/commit/99f3f28770640ba1bb1ff460ac7c5292fb8291a0
  // original implementation: https://github.com/abdk-consulting/abdk-libraries-solidity/blob/master/ABDKMath64x64.sol#L687
  function sqrt(uint256 x) internal pure returns (uint256) {
    if (x == 0) return 0;
    uint256 xx = x;
    uint256 r = 1;

    if (xx >= 0x100000000000000000000000000000000) {
      xx >>= 128;
      r <<= 64;
    }

    if (xx >= 0x10000000000000000) {
      xx >>= 64;
      r <<= 32;
    }
    if (xx >= 0x100000000) {
      xx >>= 32;
      r <<= 16;
    }
    if (xx >= 0x10000) {
      xx >>= 16;
      r <<= 8;
    }
    if (xx >= 0x100) {
      xx >>= 8;
      r <<= 4;
    }
    if (xx >= 0x10) {
      xx >>= 4;
      r <<= 2;
    }
    if (xx >= 0x8) {
      r <<= 1;
    }

    r = (r + x / r) >> 1;
    r = (r + x / r) >> 1;
    r = (r + x / r) >> 1;
    r = (r + x / r) >> 1;
    r = (r + x / r) >> 1;
    r = (r + x / r) >> 1;
    r = (r + x / r) >> 1; // Seven iterations should be enough
    uint256 r1 = x / r;
    return (r < r1 ? r : r1);
  }
}

// SPDX-License-Identifier: GPL-3.0-or-later

pragma solidity >=0.4.0;

interface IBEP20 {
  /**
   * @dev Returns the amount of tokens in existence.
   */
  function totalSupply() external view returns (uint256);

  /**
   * @dev Returns the token decimals.
   */
  function decimals() external view returns (uint8);

  /**
   * @dev Returns the token symbol.
   */
  function symbol() external view returns (string memory);

  /**
   * @dev Returns the token name.
   */
  function name() external view returns (string memory);

  /**
   * @dev Returns the bep token owner.
   */
  function getOwner() external view returns (address);

  /**
   * @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);
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.6.0;

interface AggregatorV3Interface {
  function decimals() external view returns (uint8);

  function description() external view returns (string memory);

  function version() external view returns (uint256);

  // getRoundData and latestRoundData should both raise "No data present"
  // if they do not have data to report, instead of returning unset values
  // which could be misinterpreted as actual reported values.
  function getRoundData(
    uint80 _roundId
  ) external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);

  function latestRoundData()
    external
    view
    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;

import "../library/Constant.sol";

interface ILToken {
  function underlying() external view returns (address);

  function totalSupply() external view returns (uint256);

  function accountSnapshot(address account) external view returns (Constant.AccountSnapshot memory);

  function underlyingBalanceOf(address account) external view returns (uint256);

  function borrowBalanceOf(address account) external view returns (uint256);

  function totalBorrow() external view returns (uint256);

  function _totalBorrow() external view returns (uint256);

  function totalReserve() external view returns (uint256);

  function reserveFactor() external view returns (uint256);

  function lastAccruedTime() external view returns (uint256);

  function accInterestIndex() external view returns (uint256);

  function exchangeRate() external view returns (uint256);

  function getCash() external view returns (uint256);

  function getRateModel() external view returns (address);

  function getAccInterestIndex() external view returns (uint256);

  function accruedAccountSnapshot(address account) external returns (Constant.AccountSnapshot memory);

  function accruedBorrowBalanceOf(address account) external returns (uint256);

  function accruedTotalBorrow() external returns (uint256);

  function accruedExchangeRate() external returns (uint256);

  function approve(address spender, uint256 amount) external returns (bool);

  function allowance(address owner, address spender) external view returns (uint256);

  function balanceOf(address account) external view returns (uint256);

  function transfer(address dst, uint256 amount) external returns (bool);

  function transferFrom(address src, address dst, uint256 amount) external returns (bool);

  function supply(address account, uint256 underlyingAmount) external payable returns (uint256);

  function supplyBehalf(address account, address supplier, uint256 underlyingAmount) external payable returns (uint256);

  function redeemToken(address account, uint256 lTokenAmount) external returns (uint256);

  function redeemUnderlying(address account, uint256 underlyingAmount) external returns (uint256);

  function borrow(address account, uint256 amount) external returns (uint256);

  function borrowBehalf(address account, address borrower, uint256 amount) external returns (uint256);

  function repayBorrow(address account, uint256 amount) external payable returns (uint256);

  function liquidateBorrow(
    address lTokenCollateral,
    address liquidator,
    address borrower,
    uint256 amount
  ) external payable returns (uint256 seizeLAmount, uint256 rebateLAmount, uint256 liquidatorLAmount);

  function seize(address liquidator, address borrower, uint256 lTokenAmount) external;

  function withdrawReserves() external;

  function transferTokensInternal(address spender, address src, address dst, uint256 amount) external;
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.6.12;

interface IPriceCalculator {
  struct ReferenceData {
    uint256 lastData;
    uint256 lastUpdated;
  }

  function priceOf(address asset) external view returns (uint256);

  function pricesOf(address[] memory assets) external view returns (uint256[] memory);

  function priceOfETH() external view returns (uint256);

  function getUnderlyingPrice(address lToken) external view returns (uint256);

  function getUnderlyingPrices(address[] memory lTokens) external view returns (uint256[] memory);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.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, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b > a) return (false, 0);
        return (true, a - b);
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, 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 (true, 0);
        uint256 c = a * b;
        if (c / a != b) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a / b);
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a % b);
    }

    /**
     * @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) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    /**
     * @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) {
        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, reverting 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) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting 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) {
        require(b > 0, "SafeMath: modulo by zero");
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        return a - b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * 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, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * 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, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a % b;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

import "../utils/Context.sol";
/**
 * @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.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * 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.
 */
abstract 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 {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the 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 virtual 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 virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.6.12;

library Constant {
  uint256 public constant CLOSE_FACTOR_MIN = 5e16;
  uint256 public constant CLOSE_FACTOR_MAX = 9e17;
  uint256 public constant COLLATERAL_FACTOR_MAX = 9e17;
  uint256 public constant LIQUIDATION_THRESHOLD_MAX = 9e17;
  uint256 public constant LIQUIDATION_BONUS_MAX = 5e17;

  enum EcoScorePreviewOption {
    LOCK,
    CLAIM,
    EXTEND,
    LOCK_MORE
  }

  enum LoanState {
    None,
    Active,
    Auction,
    Repaid,
    Defaulted
  }

  struct MarketInfo {
    bool isListed;
    uint256 supplyCap;
    uint256 borrowCap;
    uint256 collateralFactor;
  }

  struct BorrowInfo {
    uint256 borrow;
    uint256 interestIndex;
  }

  struct AccountSnapshot {
    uint256 lTokenBalance;
    uint256 borrowBalance;
    uint256 exchangeRate;
  }

  struct AccrueSnapshot {
    uint256 totalBorrow;
    uint256 totalReserve;
    uint256 accInterestIndex;
  }

  struct AccrueLoanSnapshot {
    uint256 totalBorrow;
    uint256 accInterestIndex;
  }

  struct DistributionInfo {
    uint256 supplySpeed;
    uint256 borrowSpeed;
    uint256 totalBoostedSupply;
    uint256 totalBoostedBorrow;
    uint256 accPerShareSupply;
    uint256 accPerShareBorrow;
    uint256 accruedAt;
  }

  struct DistributionAccountInfo {
    uint256 accuredLAB; // Unclaimed LAB rewards amount
    uint256 boostedSupply; // effective(boosted) supply balance of user  (since last_action)
    uint256 boostedBorrow; // effective(boosted) borrow balance of user  (since last_action)
    uint256 accPerShareSupply; // Last integral value of LAB rewards per share. ∫(LABRate(t) / totalShare(t) dt) from 0 till (last_action)
    uint256 accPerShareBorrow; // Last integral value of LAB rewards per share. ∫(LABRate(t) / totalShare(t) dt) from 0 till (last_action)
  }

  struct DistributionAPY {
    uint256 apySupplyLab;
    uint256 apyBorrowLab;
    uint256 apyAccountSupplyLab;
    uint256 apyAccountBorrowLab;
  }

  struct RebateCheckpoint {
    uint256 timestamp;
    uint256 totalScore;
    uint256 adminFeeRate;
    uint256 weeklyLabSpeed;
    uint256 additionalLabAmount;
    mapping(address => uint256) marketFees;
  }

  struct LockInfo {
    uint256 timestamp;
    uint256 amount;
    uint256 expiry;
  }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.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.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

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

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"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"},{"inputs":[{"internalType":"address","name":"lToken","type":"address"}],"name":"getUnderlyingPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"lTokens","type":"address[]"}],"name":"getUnderlyingPrices","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"keeper","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"asset","type":"address"}],"name":"priceOf","outputs":[{"internalType":"uint256","name":"priceInUSD","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"priceOfETH","outputs":[{"internalType":"uint256","name":"valueInUSD","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"assets","type":"address[]"}],"name":"pricesOf","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"references","outputs":[{"internalType":"uint256","name":"lastData","type":"uint256"},{"internalType":"uint256","name":"lastUpdated","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_keeper","type":"address"}],"name":"setKeeper","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"assets","type":"address[]"},{"internalType":"uint256[]","name":"prices","type":"uint256[]"},{"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"setPrices","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"asset","type":"address"},{"internalType":"address","name":"feed","type":"address"}],"name":"setTokenFeed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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