Contract

Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

import "SafeMath.sol";

import "IUniswapV2Pair.sol";


/**
 * @title UniswapTwapPriceOracleV2Ceiling
 * @dev based on UniswapTwapPriceOracleRoot by David Lucid <[email protected]> (https://github.com/davidlucid)
 * @notice Stores cumulative prices and returns TWAPs for assets on Uniswap V2 pairs.
 */
contract UniswapTwapPriceOracleV2CeilingV2 {
    using SafeMath for uint256;

    /**
     * @dev Current price ceiling for the oracle
     */
    uint public priceCeiling;

    /**
     * @dev maximum amount ceilining can be set above current price, in basis points, above. 1 = 0.01%
     */
    uint public maxBPCeiling;

    /**
     * @dev minimum amount ceiling can be set above current price in, basis points, above current price. 1 = 0.01%
     */
    uint public minBPCeiling;

    /**
     * @dev WETH token contract address.
     */
    address constant public WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;

    /**
     * @dev underlying token contract address.
     */
    address constant public underlying = 0x41D5D79431A913C4aE7d69a668ecdfE5fF9DFB68;

    /**
     * @dev uniswapV2 pair between underlying and WETH
     */
    IUniswapV2Pair constant public pair = IUniswapV2Pair(0x73E02EAAb68a41Ea63bdae9Dbd4b7678827B2352);

    /**
     * @dev Governance address, can set maxBPCeiling and minBPCeiling
     */
    address public governance;

    /**
     * @dev Guardian address, can raise or lower price ceiling
     */
    address public guardian;

    /**
     * @dev Minimum TWAP interval.
     */
    uint256 immutable public MIN_TWAP_TIME;

    /**
     * @dev Internal baseUnit used as mantissa, set from decimals of underlying.
     */
    uint immutable private baseUnit;

    constructor(uint MIN_TWAP_TIME_, uint maxBPCeiling_, uint minBPCeiling_, uint underlyingDecimals, address governance_, address guardian_) public {
        MIN_TWAP_TIME = MIN_TWAP_TIME_;
        maxBPCeiling = maxBPCeiling_;
        minBPCeiling = minBPCeiling_;
        governance = governance_;
        guardian = guardian_;
        baseUnit = 10 ** underlyingDecimals;
        priceCeiling = type(uint).max;
        //Update oracle at deployment, to avoid having to check against 0 observations for the rest of the oracle's lifetime
        _update();
    }

    /**
     * @dev Return the TWAP value price0. Revert if TWAP time range is not within the threshold.
     * Copied from: https://github.com/AlphaFinanceLab/homora-v2/blob/master/contracts/oracle/BaseKP3ROracle.sol
     */
    function priceTWAP() internal view returns (uint) {
        uint length = observationCount;
        Observation memory lastObservation = observations[(length - 1) % OBSERVATION_BUFFER];
        if (lastObservation.timestamp > now - MIN_TWAP_TIME) {
            require(length > 1, 'No length-2 TWAP observation.');//TODO: A lot of checking to do for something that's only relevant when only 1 observation have been made
            lastObservation = observations[(length - 2) % OBSERVATION_BUFFER];
        }
        uint elapsedTime = now - lastObservation.timestamp;
        require(elapsedTime >= MIN_TWAP_TIME, 'Bad TWAP time.');
        return (currentPxCumu() - lastObservation.priceCumulative) / elapsedTime; // overflow is desired
    }
    /**
     * @dev Return the current price cumulative value on Uniswap.
     * Copied from: https://github.com/AlphaFinanceLab/homora-v2/blob/master/contracts/oracle/BaseKP3ROracle.sol
     */
    function currentPxCumu() internal view returns (uint pxCumu) {
        uint32 currTime = uint32(now);
        pxCumu = pair.price0CumulativeLast();
        (uint reserve0, uint reserve1, uint32 lastTime) = pair.getReserves();
        if (lastTime != now) {
            uint32 timeElapsed = currTime - lastTime; // overflow is desired
            pxCumu += uint((reserve1 << 112) / reserve0) * timeElapsed; // overflow is desired
        }
    }
    /**
     * @dev Returns the price of `underlying` in terms of `baseToken` given `factory`.
     */
    function price() public view returns (uint) {
        // Return ERC20/ETH TWAP
        uint twapPrice = priceTWAP().div(2 ** 56).mul(baseUnit).div(2 ** 56);
        return twapPrice < priceCeiling ? twapPrice : priceCeiling;
    }

    /**
     * @dev Struct for cumulative price observations.
     */
    struct Observation {
        uint32 timestamp;
        uint256 priceCumulative;
    }

    /**
     * @dev Length after which observations roll over to index 0.
     */
    uint8 public constant OBSERVATION_BUFFER = 4;

    /**
     * @dev Total observation count for each pair.
     */
    uint256 public observationCount;

    /**
     * @dev Array of cumulative price observations for each pair.
     */
    Observation[OBSERVATION_BUFFER] public observations;

    /// @dev Internal function to check if oracle is workable (updateable AND reserves have changed AND deviation threshold is satisfied).
    function workable(uint256 minPeriod, uint256 deviationThreshold) external view returns (bool) {
        // Workable if:
        // The elapsed time since the last observation is > minPeriod AND reserves have changed AND deviation threshold is satisfied 
        // Note that we loop observationCount around OBSERVATION_BUFFER so we don't waste gas on new storage slots
        (, , uint32 lastTime) = pair.getReserves();
        return (block.timestamp - observations[(observationCount - 1) % OBSERVATION_BUFFER].timestamp) > (minPeriod >= MIN_TWAP_TIME ? minPeriod : MIN_TWAP_TIME) &&
            lastTime != observations[(observationCount - 1) % OBSERVATION_BUFFER].timestamp &&
            _deviation() >= deviationThreshold;
    }

    /// @dev Internal function to return oracle deviation from its TWAP price as a ratio scaled by 1e18
    function _deviation() internal view returns (uint256) {
        // Get TWAP price
        uint256 twapPrice = priceTWAP().div(2 ** 56).mul(baseUnit).div(2 ** 56); // Scaled by 1e18, not 2 ** 112
    
        // Get spot price
        (uint reserve0, uint reserve1, ) = pair.getReserves();
        uint256 spotPrice = reserve1.mul(baseUnit).div(reserve0);

        // Get ratio and return deviation
        uint256 ratio = spotPrice.mul(1e18).div(twapPrice);
        return ratio >= 1e18 ? ratio - 1e18 : 1e18 - ratio;
    }
    
    /// @dev Internal function to check if oracle is updatable at all.
    function _updateable() internal view returns (bool) {
        // Updateable if:
        // 1) The elapsed time since the last observation is > MIN_TWAP_TIME
        // 2) The observation price (current price) is below priceCeiling
        // Note that we loop observationCount around OBSERVATION_BUFFER so we don't waste gas on new storage slots
        return(block.timestamp - observations[(observationCount - 1) % OBSERVATION_BUFFER].timestamp) > MIN_TWAP_TIME;
    }
    
    function timeSinceLastUpdate() public view returns (uint) {
        return block.timestamp - observations[(observationCount - 1) % OBSERVATION_BUFFER].timestamp;
    }

    /// @notice Update the oracle
    function update() external returns(bool) {
        if(!_updateable()){
            return false;
        }
        _update();
        return true;
    }


    /// @dev Internal function to update
    function _update() internal{
        // Get cumulative price
        uint256 priceCumulative = pair.price0CumulativeLast();
        
        // Loop observationCount around OBSERVATION_BUFFER so we don't waste gas on new storage slots
        (, , uint32 lastTime) = pair.getReserves();
        observations[observationCount % OBSERVATION_BUFFER] = Observation(lastTime, priceCumulative);
        observationCount++;
    }
    // **************************
    // **  GUARDIAN FUNCTIONS  **
    // **************************

    /**
     * @dev Function for setting newPriceCeiling, only callable by guardian
     * @param newPriceCeiling_ The new price ceiling, must be within max and min parameters
     */
    function setPriceCeiling(uint newPriceCeiling_) external {
        require(msg.sender == guardian);
        uint currentPrice = price();
        require(newPriceCeiling_ <= currentPrice + currentPrice*maxBPCeiling/10_000);
        require(newPriceCeiling_ >= currentPrice + currentPrice*minBPCeiling/10_000);
        priceCeiling = newPriceCeiling_;
        emit newPriceCeiling(newPriceCeiling_);
    }

    // **************************
    // ** GOVERNANCE FUNCTIONS **
    // **************************

    /**
     * @dev Function for setting new governance, only callable by governance
     * @param newGovernance_ address of the new guardian
     */
    function setGovernance(address newGovernance_) external {
        require(msg.sender == governance);
        governance = newGovernance_;
        emit newGovernance(newGovernance_);
    }

    /**
     * @dev Function for setting new guardian, only callable by governance
     * @param newGuardian_ address of the new guardian
     */
    function setGuardian(address newGuardian_) external {
        require(msg.sender == governance);
        guardian = newGuardian_;
        emit newGuardian(newGuardian_);
    }

    /**
     * @dev Function for setting new max height of price ceiling in basis points. 1 = 0.01%
     * @param newMaxBPCeiling_ New maximum amount a ceiling can go above current price
     */
    function setMaxBPCeiling(uint newMaxBPCeiling_) external {
        require(msg.sender == governance);
        require(newMaxBPCeiling_ >= minBPCeiling);
        maxBPCeiling = newMaxBPCeiling_;
        emit newMaxBPCeiling(newMaxBPCeiling_);
    }

    /**
     * @dev Function for setting new min height of price ceiling in basis points. 1 = 0.01%
     * @param newMinBPCeiling_ New minimum amount a ceiling must be above current price
     */
    function setMinBPCeiling(uint newMinBPCeiling_) external {
        require(msg.sender == governance);
        require(maxBPCeiling >= newMinBPCeiling_);
        minBPCeiling = newMinBPCeiling_;
        emit newMinBPCeiling(newMinBPCeiling_);
    }

    // ************
    // ** EVENTS **
    // ************
    event newPriceCeiling(uint newPriceCeiling);
    event newGuardian(address newGuardian);
    event newGovernance(address newGovernance);
    event newMaxBPCeiling(uint newMaxBPCeiling);
    event newMinBPCeiling(uint newMinBPCeiling);
}

pragma solidity >=0.5.0;

interface IUniswapV2Pair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint);

    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

    event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint);
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function price0CumulativeLast() external view returns (uint);
    function price1CumulativeLast() external view returns (uint);
    function kLast() external view returns (uint);

    function mint(address to) external returns (uint liquidity);
    function burn(address to) external returns (uint amount0, uint amount1);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function skim(address to) external;
    function sync() external;

    function initialize(address, address) external;
}

// 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;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"MIN_TWAP_TIME_","type":"uint256"},{"internalType":"uint256","name":"maxBPCeiling_","type":"uint256"},{"internalType":"uint256","name":"minBPCeiling_","type":"uint256"},{"internalType":"uint256","name":"underlyingDecimals","type":"uint256"},{"internalType":"address","name":"governance_","type":"address"},{"internalType":"address","name":"guardian_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newGovernance","type":"address"}],"name":"newGovernance","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newGuardian","type":"address"}],"name":"newGuardian","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newMaxBPCeiling","type":"uint256"}],"name":"newMaxBPCeiling","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newMinBPCeiling","type":"uint256"}],"name":"newMinBPCeiling","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newPriceCeiling","type":"uint256"}],"name":"newPriceCeiling","type":"event"},{"inputs":[],"name":"MIN_TWAP_TIME","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"OBSERVATION_BUFFER","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WETH","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"governance","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"guardian","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxBPCeiling","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minBPCeiling","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"observationCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"observations","outputs":[{"internalType":"uint32","name":"timestamp","type":"uint32"},{"internalType":"uint256","name":"priceCumulative","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pair","outputs":[{"internalType":"contract IUniswapV2Pair","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"priceCeiling","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newGovernance_","type":"address"}],"name":"setGovernance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newGuardian_","type":"address"}],"name":"setGuardian","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newMaxBPCeiling_","type":"uint256"}],"name":"setMaxBPCeiling","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newMinBPCeiling_","type":"uint256"}],"name":"setMinBPCeiling","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPriceCeiling_","type":"uint256"}],"name":"setPriceCeiling","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"timeSinceLastUpdate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"underlying","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"update","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"minPeriod","type":"uint256"},{"internalType":"uint256","name":"deviationThreshold","type":"uint256"}],"name":"workable","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

60c060405234801561001057600080fd5b506040516111a43803806111a4833981810160405260c081101561003357600080fd5b50805160208201516040830151606084015160808086015160a0968701519186905260018590556002849055600380546001600160a01b038084166001600160a01b0319928316179092556004805492851692909116919091179055600a83900a90965260001960005593949293919290916100ad6100b8565b50505050505061021f565b60007373e02eaab68a41ea63bdae9dbd4b7678827b23526001600160a01b0316635909c0d56040518163ffffffff1660e01b815260040160206040518083038186803b15801561010757600080fd5b505afa15801561011b573d6000803e3d6000fd5b505050506040513d602081101561013157600080fd5b505160408051630240bc6b60e21b815290519192506000917373e02eaab68a41ea63bdae9dbd4b7678827b235291630902f1ac916004808301926060929190829003018186803b15801561018457600080fd5b505afa158015610198573d6000803e3d6000fd5b505050506040513d60608110156101ae57600080fd5b50604090810151815180830190925263ffffffff8116825260208201849052600554909250600690600316600481106101e357fe5b825160029190910291909101805463ffffffff191663ffffffff9092169190911781556020909101516001918201556005805490910190555050565b60805160a051610f3f6102656000398061062c528061081c52806108ec52508061045a5280610482528061074352806109b35280610a795280610bc75250610f3f6000f3fe608060405234801561001057600080fd5b50600436106101375760003560e01c806394beff40116100b8578063ab033ea91161007c578063ab033ea9146102a6578063ad5c4648146102cc578063af8a9ba5146102d4578063b9ba8d2c146102dc578063ca1e20d8146102e4578063e7be71a7146102ec57610137565b806394beff401461026957806398d4102f14610286578063a035b1fe1461028e578063a2e6204514610296578063a8aa1b311461029e57610137565b80635aa6e675116100ff5780635aa6e675146101f4578063614f5471146101fc5780636f307dc314610204578063835d1f6b1461020c5780638a0dac4a1461024357610137565b8063252c09d71461013c578063290ad26e146101795780632d3b5a86146101975780633f327e55146101b1578063452a9320146101d0575b600080fd5b6101596004803603602081101561015257600080fd5b5035610309565b6040805163ffffffff909316835260208301919091528051918290030190f35b61018161032f565b6040805160ff9092168252519081900360200190f35b61019f610334565b60408051918252519081900360200190f35b6101ce600480360360208110156101c757600080fd5b503561033a565b005b6101d861039b565b604080516001600160a01b039092168252519081900360200190f35b6101d86103aa565b61019f6103b9565b6101d86103bf565b61022f6004803603604081101561022257600080fd5b50803590602001356103d7565b604080519115158252519081900360200190f35b6101ce6004803603602081101561025957600080fd5b50356001600160a01b031661051c565b6101ce6004803603602081101561027f57600080fd5b5035610587565b61019f6105e8565b61019f61061c565b61022f610682565b6101d86106a6565b6101ce600480360360208110156102bc57600080fd5b50356001600160a01b03166106be565b6101d8610729565b61019f610741565b61019f610765565b61019f61076b565b6101ce6004803603602081101561030257600080fd5b5035610771565b6006816004811061031657fe5b60020201805460019091015463ffffffff909116915082565b600481565b60005481565b6003546001600160a01b0316331461035157600080fd5b60025481101561036057600080fd5b60018190556040805182815290517fd65d188cb1b4c0056182e73384cf1b9e809bccda94748ca69c4be2fd926a91bb9181900360200190a150565b6004546001600160a01b031681565b6003546001600160a01b031681565b60055481565b7341d5d79431a913c4ae7d69a668ecdfe5ff9dfb6881565b6000807373e02eaab68a41ea63bdae9dbd4b7678827b23526001600160a01b0316630902f1ac6040518163ffffffff1660e01b815260040160606040518083038186803b15801561042757600080fd5b505afa15801561043b573d6000803e3d6000fd5b505050506040513d606081101561045157600080fd5b506040015190507f00000000000000000000000000000000000000000000000000000000000000008410156104a6577f00000000000000000000000000000000000000000000000000000000000000006104a8565b835b6005546006906004906000190106600481106104c057fe5b600202015463ffffffff1642031180156104ff57506005546006906004906000190106600481106104ed57fe5b600202015463ffffffff828116911614155b801561051257508261050f61080c565b10155b9150505b92915050565b6003546001600160a01b0316331461053357600080fd5b600480546001600160a01b0383166001600160a01b0319909116811790915560408051918252517f889dc2ee68a089a71ce62caf084bb83f24206f456dc6627f29c517b34e2e6a1c9181900360200190a150565b6003546001600160a01b0316331461059e57600080fd5b8060015410156105ad57600080fd5b60028190556040805182815290517f13e60ce70769ceddba7ba2581da08b53dedb8ecb0a82dd51c13d6e5cbde4e86e9181900360200190a150565b60006006600460ff16600160055403816105fe57fe5b066004811061060957fe5b600202015463ffffffff16420390505b90565b600080610667600160381b61065b7f0000000000000000000000000000000000000000000000000000000000000000610661600160381b61065b610962565b90610afc565b90610b63565b9050600054811061067a5760005461067c565b805b91505090565b600061068c610bc3565b61069857506000610619565b6106a0610c18565b50600190565b7373e02eaab68a41ea63bdae9dbd4b7678827b235281565b6003546001600160a01b031633146106d557600080fd5b600380546001600160a01b0383166001600160a01b0319909116811790915560408051918252517ffde02a4f703e481bfb5905674415a2bc82ecbc28a00e4e0760c7c84c196d781f9181900360200190a150565b73c02aaa39b223fe8d0a0e5c4f27ead9083c756cc281565b7f000000000000000000000000000000000000000000000000000000000000000081565b60025481565b60015481565b6004546001600160a01b0316331461078857600080fd5b600061079261061c565b90506127106001548202816107a357fe5b0481018211156107b257600080fd5b6127106002548202816107c157fe5b0481018210156107d057600080fd5b60008290556040805183815290517f7d6b66e3885fc0bc485b33a2370d8c5056feba726e8bfb9240711ed42f1de7669181900360200190a15050565b60008061084b600160381b61065b7f0000000000000000000000000000000000000000000000000000000000000000610661600160381b61065b610962565b90506000807373e02eaab68a41ea63bdae9dbd4b7678827b23526001600160a01b0316630902f1ac6040518163ffffffff1660e01b815260040160606040518083038186803b15801561089d57600080fd5b505afa1580156108b1573d6000803e3d6000fd5b505050506040513d60608110156108c757600080fd5b5080516020909101516001600160701b03918216935016905060006109108361065b847f0000000000000000000000000000000000000000000000000000000000000000610b63565b9050600061092a8561065b84670de0b6b3a7640000610b63565b9050670de0b6b3a764000081101561094c5780670de0b6b3a764000003610958565b670de0b6b3a764000081035b9550505050505090565b600554600090610970610ed1565b600660046000198401066004811061098457fe5b6040805180820190915260029190910291909101805463ffffffff1680835260019091015460208301529091507f000000000000000000000000000000000000000000000000000000000000000042031015610a6d5760018211610a2f576040805162461bcd60e51b815260206004820152601d60248201527f4e6f206c656e6774682d322054574150206f62736572766174696f6e2e000000604482015290519081900360640190fd5b6006600460011984010660048110610a4357fe5b6040805180820190915260029190910291909101805463ffffffff16825260010154602082015290505b805163ffffffff1642037f0000000000000000000000000000000000000000000000000000000000000000811015610add576040805162461bcd60e51b815260206004820152600e60248201526d2130b2102a2ba0a8103a34b6b29760911b604482015290519081900360640190fd5b808260200151610aeb610d7f565b0381610af357fe5b04935050505090565b6000808211610b52576040805162461bcd60e51b815260206004820152601a60248201527f536166654d6174683a206469766973696f6e206279207a65726f000000000000604482015290519081900360640190fd5b818381610b5b57fe5b049392505050565b600082610b7257506000610516565b82820282848281610b7f57fe5b0414610bbc5760405162461bcd60e51b8152600401808060200182810382526021815260200180610ee96021913960400191505060405180910390fd5b9392505050565b60007f00000000000000000000000000000000000000000000000000000000000000006006600460ff1660016005540381610bfa57fe5b0660048110610c0557fe5b600202015463ffffffff16420311905090565b60007373e02eaab68a41ea63bdae9dbd4b7678827b23526001600160a01b0316635909c0d56040518163ffffffff1660e01b815260040160206040518083038186803b158015610c6757600080fd5b505afa158015610c7b573d6000803e3d6000fd5b505050506040513d6020811015610c9157600080fd5b505160408051630240bc6b60e21b815290519192506000917373e02eaab68a41ea63bdae9dbd4b7678827b235291630902f1ac916004808301926060929190829003018186803b158015610ce457600080fd5b505afa158015610cf8573d6000803e3d6000fd5b505050506040513d6060811015610d0e57600080fd5b50604090810151815180830190925263ffffffff811682526020820184905260055490925060069060031660048110610d4357fe5b825160029190910291909101805463ffffffff191663ffffffff9092169190911781556020909101516001918201556005805490910190555050565b6000804290507373e02eaab68a41ea63bdae9dbd4b7678827b23526001600160a01b0316635909c0d56040518163ffffffff1660e01b815260040160206040518083038186803b158015610dd257600080fd5b505afa158015610de6573d6000803e3d6000fd5b505050506040513d6020811015610dfc57600080fd5b505160408051630240bc6b60e21b81529051919350600091829182917373e02eaab68a41ea63bdae9dbd4b7678827b235291630902f1ac916004808301926060929190829003018186803b158015610e5357600080fd5b505afa158015610e67573d6000803e3d6000fd5b505050506040513d6060811015610e7d57600080fd5b50805160208201516040909201516001600160701b03918216955091169250905063ffffffff81164214610eca5780840363ffffffff811684607085901b81610ec257fe5b040286019550505b5050505090565b60408051808201909152600080825260208201529056fe536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f77a2646970667358221220805fb36dc798e0cd5a3aa14c47ceb1c8b1d42a720e245d586c48e9a7b9fbf5cd64736f6c634300060c00330000000000000000000000000000000000000000000000000000000000000708000000000000000000000000000000000000000000000000000000000000753000000000000000000000000000000000000000000000000000000000000013880000000000000000000000000000000000000000000000000000000000000012000000000000000000000000926df14a23be491164dcf93f4c468a50ef659d5b000000000000000000000000e3ed95e130ad9e15643f5a5f232a3dae980784cd

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

0000000000000000000000000000000000000000000000000000000000000708000000000000000000000000000000000000000000000000000000000000753000000000000000000000000000000000000000000000000000000000000013880000000000000000000000000000000000000000000000000000000000000012000000000000000000000000926df14a23be491164dcf93f4c468a50ef659d5b000000000000000000000000e3ed95e130ad9e15643f5a5f232a3dae980784cd

-----Decoded View---------------
Arg [0] : MIN_TWAP_TIME_ (uint256): 1800
Arg [1] : maxBPCeiling_ (uint256): 30000
Arg [2] : minBPCeiling_ (uint256): 5000
Arg [3] : underlyingDecimals (uint256): 18
Arg [4] : governance_ (address): 0x926dF14a23BE491164dCF93f4c468A50ef659D5B
Arg [5] : guardian_ (address): 0xE3eD95e130ad9E15643f5A5f232a3daE980784cd

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000708
Arg [1] : 0000000000000000000000000000000000000000000000000000000000007530
Arg [2] : 0000000000000000000000000000000000000000000000000000000000001388
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000012
Arg [4] : 000000000000000000000000926df14a23be491164dcf93f4c468a50ef659d5b
Arg [5] : 000000000000000000000000e3ed95e130ad9e15643f5a5f232a3dae980784cd

367:10034:2:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4780:51;;;;;;;;;;;;;;;;-1:-1:-1;4780:51:2;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;4542:44;;;:::i;:::-;;;;;;;;;;;;;;;;;;;514:24;;;:::i;:::-;;;;;;;;;;;;;;;;9403:247;;;;;;;;;;;;;;;;-1:-1:-1;9403:247:2;;:::i;:::-;;1514:23;;;:::i;:::-;;;;-1:-1:-1;;;;;1514:23:2;;;;;;;;;;;;;;1403:25;;;:::i;4660:31::-;;;:::i;1057:79::-;;;:::i;4977:734::-;;;;;;;;;;;;;;;;-1:-1:-1;4977:734:2;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;9027:175;;;;;;;;;;;;;;;;-1:-1:-1;9027:175:2;-1:-1:-1;;;;;9027:175:2;;:::i;9852:247::-;;;;;;;;;;;;;;;;-1:-1:-1;9852:247:2;;:::i;6905:167::-;;;:::i;4063:230::-;;;:::i;7112:152::-;;;:::i;1214:96::-;;;:::i;8688:187::-;;;;;;;;;;;;;;;;-1:-1:-1;8688:187:2;-1:-1:-1;;;;;8688:187:2;;:::i;914:73::-;;;:::i;1595:38::-;;;:::i;826:24::-;;;:::i;664:::-;;;:::i;8026:403::-;;;;;;;;;;;;;;;;-1:-1:-1;8026:403:2;;:::i;4780:51::-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4780:51:2;:::o;4542:44::-;4585:1;4542:44;:::o;514:24::-;;;;:::o;9403:247::-;9492:10;;-1:-1:-1;;;;;9492:10:2;9478;:24;9470:33;;;;;;9541:12;;9521:16;:32;;9513:41;;;;;;9564:12;:31;;;9610:33;;;;;;;;;;;;;;;;;9403:247;:::o;1514:23::-;;;-1:-1:-1;;;;;1514:23:2;;:::o;1403:25::-;;;-1:-1:-1;;;;;1403:25:2;;:::o;4660:31::-;;;;:::o;1057:79::-;1094:42;1057:79;:::o;4977:734::-;5065:4;5359:15;1267:42;-1:-1:-1;;;;;5378:16:2;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;5378:18:2;;;;-1:-1:-1;5517:13:2;5504:26;;;:54;;5545:13;5504:54;;;5533:9;5504:54;5446:16;;5432:12;;4585:1;;-1:-1:-1;;5446:20:2;5445:43;5432:57;;;;;;;;;;:67;;;5414:15;:85;5413:146;:241;;;;-1:-1:-1;5601:16:2;;5587:12;;4585:1;;-1:-1:-1;;5601:20:2;5600:43;5587:57;;;;;;;;;;:67;;5575:79;;;5587:67;;5575:79;;5413:241;:291;;;;;5686:18;5670:12;:10;:12::i;:::-;:34;;5413:291;5406:298;;;4977:734;;;;;:::o;9027:175::-;9111:10;;-1:-1:-1;;;;;9111:10:2;9097;:24;9089:33;;;;;;9132:8;:23;;-1:-1:-1;;;;;9132:23:2;;-1:-1:-1;;;;;;9132:23:2;;;;;;;;9170:25;;;;;;;;;;;;;;;;9027:175;:::o;9852:247::-;9941:10;;-1:-1:-1;;;;;9941:10:2;9927;:24;9919:33;;;;;;9986:16;9970:12;;:32;;9962:41;;;;;;10013:12;:31;;;10059:33;;;;;;;;;;;;;;;;;9852:247;:::o;6905:167::-;6957:4;6998:12;4585:1;7011:43;;7031:1;7012:16;;:20;7011:43;;;;;;6998:57;;;;;;;;;;:67;;;6980:15;:85;;-1:-1:-1;6905:167:2;;:::o;4063:230::-;4101:4;4150:14;4167:51;-1:-1:-1;;;4167:38:2;4196:8;4167:24;-1:-1:-1;;;4167:11:2;:9;:11::i;:::-;:15;;:24::i;:::-;:28;;:38::i;:51::-;4150:68;;4247:12;;4235:9;:24;:51;;4274:12;;4235:51;;;4262:9;4235:51;4228:58;;;4063:230;:::o;7112:152::-;7147:4;7167:13;:11;:13::i;:::-;7163:55;;-1:-1:-1;7202:5:2;7195:12;;7163:55;7227:9;:7;:9::i;:::-;-1:-1:-1;7253:4:2;7112:152;:::o;1214:96::-;1267:42;1214:96;:::o;8688:187::-;8776:10;;-1:-1:-1;;;;;8776:10:2;8762;:24;8754:33;;;;;;8797:10;:27;;-1:-1:-1;;;;;8797:27:2;;-1:-1:-1;;;;;;8797:27:2;;;;;;;;8839:29;;;;;;;;;;;;;;;;8688:187;:::o;914:73::-;945:42;914:73;:::o;1595:38::-;;;:::o;826:24::-;;;;:::o;664:::-;;;;:::o;8026:403::-;8115:8;;-1:-1:-1;;;;;8115:8:2;8101:10;:22;8093:31;;;;;;8134:17;8154:7;:5;:7::i;:::-;8134:27;;8240:6;8227:12;;8214;:25;:32;;;;;;8199:12;:47;8179:16;:67;;8171:76;;;;;;8326:6;8313:12;;8300;:25;:32;;;;;;8285:12;:47;8265:16;:67;;8257:76;;;;;;8343:12;:31;;;8389:33;;;;;;;;;;;;;;;;;8026:403;;:::o;5821:523::-;5866:7;5911:17;5931:51;-1:-1:-1;;;5931:38:2;5960:8;5931:24;-1:-1:-1;;;5931:11:2;:9;:11::i;:51::-;5911:71;;6056:13;6071;1267:42;-1:-1:-1;;;;;6090:16:2;;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;6090:18:2;;;;;;;-1:-1:-1;;;;;6055:53:2;;;;-1:-1:-1;6055:53:2;;-1:-1:-1;6118:17:2;6138:36;6055:53;6138:22;6055:53;6151:8;6138:12;:22::i;:36::-;6118:56;-1:-1:-1;6227:13:2;6243:34;6267:9;6243:19;6118:56;6257:4;6243:13;:19::i;:34::-;6227:50;;6303:4;6294:5;:13;;:43;;6332:5;6325:4;:12;6294:43;;;6318:4;6310:5;:12;6294:43;6287:50;;;;;;;5821:523;:::o;2567:744::-;2641:16;;2611:4;;2667:34;;:::i;:::-;2704:12;4585:1;-1:-1:-1;;2718:10:2;;2717:33;2704:47;;;;;;;2667:84;;;;;;;;;2704:47;;;;;;;;;2667:84;;;;;;;;;;;;;;;;;;-1:-1:-1;2799:13:2;2793:3;:19;-1:-1:-1;2761:314:2;;;2845:1;2836:6;:10;2828:52;;;;;-1:-1:-1;;;2828:52:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;3017:12;4585:1;-1:-1:-1;;3031:10:2;;3030:33;3017:47;;;;;;;2999:65;;;;;;;;;3017:47;;;;;;;;;2999:65;;;;;;;;;;;;;;-1:-1:-1;2761:314:2;3109:25;;3103:31;;:3;:31;3167:13;3152:28;;;3144:55;;;;;-1:-1:-1;;;3144:55:2;;;;;;;;;;;;-1:-1:-1;;;3144:55:2;;;;;;;;;;;;;;;3270:11;3235:15;:31;;;3217:15;:13;:15::i;:::-;:49;3216:65;;;;;;3209:72;;;;;2567:744;:::o;4217:150:1:-;4275:7;4306:1;4302;:5;4294:44;;;;;-1:-1:-1;;;4294:44:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;4359:1;4355;:5;;;;;;;4217:150;-1:-1:-1;;;4217:150:1:o;3538:215::-;3596:7;3619:6;3615:20;;-1:-1:-1;3634:1:1;3627:8;;3615:20;3657:5;;;3661:1;3657;:5;:1;3680:5;;;;;:10;3672:56;;;;-1:-1:-1;;;3672:56:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3745:1;3538:215;-1:-1:-1;;;3538:215:1:o;6425:470:2:-;6471:4;6875:13;6804:12;4585:1;6817:43;;6837:1;6818:16;;:20;6817:43;;;;;;6804:57;;;;;;;;;;:67;;;6786:15;:85;6785:103;;-1:-1:-1;6425:470:2;:::o;7312:422::-;7381:23;1267:42;-1:-1:-1;;;;;7407:25:2;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7407:27:2;7579:18;;;-1:-1:-1;;;7579:18:2;;;;7407:27;;-1:-1:-1;7560:15:2;;1267:42;;7579:16;;:18;;;;;;;;;;;;;;1267:42;7579:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7579:18:2;;;;;7661:38;;;;;;;;;;;;;7579:18;7661:38;;;;;7620:16;;7579:18;;-1:-1:-1;7607:12:2;;7620:37;;4585:1;7607:51;;;;;;:92;;:51;;;;;;;;;:92;;-1:-1:-1;;7607:92:2;;;;;;;;;;;;;;;;-1:-1:-1;7607:92:2;;;;7709:16;:18;;;;;;;-1:-1:-1;;7312:422:2:o;3511:444::-;3559:11;3582:15;3607:3;3582:29;;1267:42;-1:-1:-1;;;;;3630:25:2;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3630:27:2;3717:18;;;-1:-1:-1;;;3717:18:2;;;;3630:27;;-1:-1:-1;3668:13:2;;;;;;1267:42;;3717:16;;:18;;;;;;;;;;;;;;1267:42;3717:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3717:18:2;;;;;;;;;;;-1:-1:-1;;;;;3667:68:2;;;;-1:-1:-1;3667:68:2;;;-1:-1:-1;3717:18:2;-1:-1:-1;3749:15:2;;;3761:3;3749:15;3745:204;;3801:19;;;3867:48;;;3892:8;3885:3;3873:15;;;3892:8;3872:28;;;;;3867:48;3857:58;;;;3745:204;;3511:444;;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;:::o

ipfs://805fb36dc798e0cd5a3aa14c47ceb1c8b1d42a720e245d586c48e9a7b9fbf5cd