Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at fraxscan.com on 2024-04-26
*/

pragma solidity ^0.8.19;

contract ExponentialPriceOracle {
    using PRBMathUD60x18 for uint256;

    uint256 public immutable timeStart;
    uint256 public immutable timeEnd;
    uint256 public immutable priceStart;
    uint256 public immutable priceEnd;
    uint256 immutable lnChange;
    uint256 immutable duration;

    constructor(uint256 _priceStart, uint256 _priceEnd, uint256 _timeEnd) {
        require(_timeEnd > block.timestamp);
        require(_priceEnd > _priceStart);
        priceStart = _priceStart;
        priceEnd = _priceEnd;
        timeStart = block.timestamp;
        timeEnd = _timeEnd;
        duration = _timeEnd - block.timestamp;
        lnChange = ((_priceEnd * 1e18) / _priceStart).ln();
    }
    
    // For Curve
    function pricePerShare() public view returns (uint256 _price) {
        uint256 _timePassed = block.timestamp - timeStart;
        if (_timePassed > duration) _price = priceEnd;
        else _price = priceStart.mul(((_timePassed * lnChange) / duration).exp());
    }
    
    // For Fraxlend
    function getPrices() external view returns (bool _isBadData, uint256 _priceLow, uint256 _priceHigh) {
        _isBadData=false;
        _priceLow = _priceHigh = 1e36/pricePerShare();
    }
}

/// @title PRBMathUD60x18
/// @author Paul Razvan Berg
/// @notice Smart contract library for advanced fixed-point math that works with uint256 numbers considered to have 18
/// trailing decimals. We call this number representation unsigned 60.18-decimal fixed-point, since there can be up to 60
/// digits in the integer part and up to 18 decimals in the fractional part. The numbers are bound by the minimum and the
/// maximum values permitted by the Solidity type uint256.
library PRBMathUD60x18 {
    /// @dev Half the SCALE number.
    uint256 internal constant HALF_SCALE = 5e17;

    /// @dev log2(e) as an unsigned 60.18-decimal fixed-point number.
    uint256 internal constant LOG2_E = 1_442695040888963407;

    /// @dev The maximum value an unsigned 60.18-decimal fixed-point number can have.
    uint256 internal constant MAX_UD60x18 =
        115792089237316195423570985008687907853269984665640564039457_584007913129639935;

    /// @dev The maximum whole value an unsigned 60.18-decimal fixed-point number can have.
    uint256 internal constant MAX_WHOLE_UD60x18 =
        115792089237316195423570985008687907853269984665640564039457_000000000000000000;

    /// @dev How many trailing decimals can be represented.
    uint256 internal constant SCALE = 1e18;

    /// @notice Calculates the arithmetic average of x and y, rounding down.
    /// @param x The first operand as an unsigned 60.18-decimal fixed-point number.
    /// @param y The second operand as an unsigned 60.18-decimal fixed-point number.
    /// @return result The arithmetic average as an unsigned 60.18-decimal fixed-point number.
    function avg(uint256 x, uint256 y) internal pure returns (uint256 result) {
        // The operations can never overflow.
        unchecked {
            // The last operand checks if both x and y are odd and if that is the case, we add 1 to the result. We need
            // to do this because if both numbers are odd, the 0.5 remainder gets truncated twice.
            result = (x >> 1) + (y >> 1) + (x & y & 1);
        }
    }

    /// @notice Yields the least unsigned 60.18 decimal fixed-point number greater than or equal to x.
    ///
    /// @dev Optimized for fractional value inputs, because for every whole value there are (1e18 - 1) fractional counterparts.
    /// See https://en.wikipedia.org/wiki/Floor_and_ceiling_functions.
    ///
    /// Requirements:
    /// - x must be less than or equal to MAX_WHOLE_UD60x18.
    ///
    /// @param x The unsigned 60.18-decimal fixed-point number to ceil.
    /// @param result The least integer greater than or equal to x, as an unsigned 60.18-decimal fixed-point number.
    function ceil(uint256 x) internal pure returns (uint256 result) {
        if (x > MAX_WHOLE_UD60x18) {
            revert PRBMathUD60x18__CeilOverflow(x);
        }
        assembly {
            // Equivalent to "x % SCALE" but faster.
            let remainder := mod(x, SCALE)

            // Equivalent to "SCALE - remainder" but faster.
            let delta := sub(SCALE, remainder)

            // Equivalent to "x + delta * (remainder > 0 ? 1 : 0)" but faster.
            result := add(x, mul(delta, gt(remainder, 0)))
        }
    }

    /// @notice Divides two unsigned 60.18-decimal fixed-point numbers, returning a new unsigned 60.18-decimal fixed-point number.
    ///
    /// @dev Uses mulDiv to enable overflow-safe multiplication and division.
    ///
    /// Requirements:
    /// - The denominator cannot be zero.
    ///
    /// @param x The numerator as an unsigned 60.18-decimal fixed-point number.
    /// @param y The denominator as an unsigned 60.18-decimal fixed-point number.
    /// @param result The quotient as an unsigned 60.18-decimal fixed-point number.
    function div(uint256 x, uint256 y) internal pure returns (uint256 result) {
        result = PRBMath.mulDiv(x, SCALE, y);
    }

    /// @notice Returns Euler's number as an unsigned 60.18-decimal fixed-point number.
    /// @dev See https://en.wikipedia.org/wiki/E_(mathematical_constant).
    function e() internal pure returns (uint256 result) {
        result = 2_718281828459045235;
    }

    /// @notice Calculates the natural exponent of x.
    ///
    /// @dev Based on the insight that e^x = 2^(x * log2(e)).
    ///
    /// Requirements:
    /// - All from "log2".
    /// - x must be less than 133.084258667509499441.
    ///
    /// @param x The exponent as an unsigned 60.18-decimal fixed-point number.
    /// @return result The result as an unsigned 60.18-decimal fixed-point number.
    function exp(uint256 x) internal pure returns (uint256 result) {
        // Without this check, the value passed to "exp2" would be greater than 192.
        if (x >= 133_084258667509499441) {
            revert PRBMathUD60x18__ExpInputTooBig(x);
        }

        // Do the fixed-point multiplication inline to save gas.
        unchecked {
            uint256 doubleScaleProduct = x * LOG2_E;
            result = exp2((doubleScaleProduct + HALF_SCALE) / SCALE);
        }
    }

    /// @notice Calculates the binary exponent of x using the binary fraction method.
    ///
    /// @dev See https://ethereum.stackexchange.com/q/79903/24693.
    ///
    /// Requirements:
    /// - x must be 192 or less.
    /// - The result must fit within MAX_UD60x18.
    ///
    /// @param x The exponent as an unsigned 60.18-decimal fixed-point number.
    /// @return result The result as an unsigned 60.18-decimal fixed-point number.
    function exp2(uint256 x) internal pure returns (uint256 result) {
        // 2^192 doesn't fit within the 192.64-bit format used internally in this function.
        if (x >= 192e18) {
            revert PRBMathUD60x18__Exp2InputTooBig(x);
        }

        unchecked {
            // Convert x to the 192.64-bit fixed-point format.
            uint256 x192x64 = (x << 64) / SCALE;

            // Pass x to the PRBMath.exp2 function, which uses the 192.64-bit fixed-point number representation.
            result = PRBMath.exp2(x192x64);
        }
    }

    /// @notice Yields the greatest unsigned 60.18 decimal fixed-point number less than or equal to x.
    /// @dev Optimized for fractional value inputs, because for every whole value there are (1e18 - 1) fractional counterparts.
    /// See https://en.wikipedia.org/wiki/Floor_and_ceiling_functions.
    /// @param x The unsigned 60.18-decimal fixed-point number to floor.
    /// @param result The greatest integer less than or equal to x, as an unsigned 60.18-decimal fixed-point number.
    function floor(uint256 x) internal pure returns (uint256 result) {
        assembly {
            // Equivalent to "x % SCALE" but faster.
            let remainder := mod(x, SCALE)

            // Equivalent to "x - remainder * (remainder > 0 ? 1 : 0)" but faster.
            result := sub(x, mul(remainder, gt(remainder, 0)))
        }
    }

    /// @notice Yields the excess beyond the floor of x.
    /// @dev Based on the odd function definition https://en.wikipedia.org/wiki/Fractional_part.
    /// @param x The unsigned 60.18-decimal fixed-point number to get the fractional part of.
    /// @param result The fractional part of x as an unsigned 60.18-decimal fixed-point number.
    function frac(uint256 x) internal pure returns (uint256 result) {
        assembly {
            result := mod(x, SCALE)
        }
    }

    /// @notice Converts a number from basic integer form to unsigned 60.18-decimal fixed-point representation.
    ///
    /// @dev Requirements:
    /// - x must be less than or equal to MAX_UD60x18 divided by SCALE.
    ///
    /// @param x The basic integer to convert.
    /// @param result The same number in unsigned 60.18-decimal fixed-point representation.
    function fromUint(uint256 x) internal pure returns (uint256 result) {
        unchecked {
            if (x > MAX_UD60x18 / SCALE) {
                revert PRBMathUD60x18__FromUintOverflow(x);
            }
            result = x * SCALE;
        }
    }

    /// @notice Calculates geometric mean of x and y, i.e. sqrt(x * y), rounding down.
    ///
    /// @dev Requirements:
    /// - x * y must fit within MAX_UD60x18, lest it overflows.
    ///
    /// @param x The first operand as an unsigned 60.18-decimal fixed-point number.
    /// @param y The second operand as an unsigned 60.18-decimal fixed-point number.
    /// @return result The result as an unsigned 60.18-decimal fixed-point number.
    function gm(uint256 x, uint256 y) internal pure returns (uint256 result) {
        if (x == 0) {
            return 0;
        }

        unchecked {
            // Checking for overflow this way is faster than letting Solidity do it.
            uint256 xy = x * y;
            if (xy / x != y) {
                revert PRBMathUD60x18__GmOverflow(x, y);
            }

            // We don't need to multiply by the SCALE here because the x*y product had already picked up a factor of SCALE
            // during multiplication. See the comments within the "sqrt" function.
            result = PRBMath.sqrt(xy);
        }
    }

    /// @notice Calculates 1 / x, rounding toward zero.
    ///
    /// @dev Requirements:
    /// - x cannot be zero.
    ///
    /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the inverse.
    /// @return result The inverse as an unsigned 60.18-decimal fixed-point number.
    function inv(uint256 x) internal pure returns (uint256 result) {
        unchecked {
            // 1e36 is SCALE * SCALE.
            result = 1e36 / x;
        }
    }

    /// @notice Calculates the natural logarithm of x.
    ///
    /// @dev Based on the insight that ln(x) = log2(x) / log2(e).
    ///
    /// Requirements:
    /// - All from "log2".
    ///
    /// Caveats:
    /// - All from "log2".
    /// - This doesn't return exactly 1 for 2.718281828459045235, for that we would need more fine-grained precision.
    ///
    /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the natural logarithm.
    /// @return result The natural logarithm as an unsigned 60.18-decimal fixed-point number.
    function ln(uint256 x) internal pure returns (uint256 result) {
        // Do the fixed-point multiplication inline to save gas. This is overflow-safe because the maximum value that log2(x)
        // can return is 196205294292027477728.
        unchecked {
            result = (log2(x) * SCALE) / LOG2_E;
        }
    }

    /// @notice Calculates the common logarithm of x.
    ///
    /// @dev First checks if x is an exact power of ten and it stops if yes. If it's not, calculates the common
    /// logarithm based on the insight that log10(x) = log2(x) / log2(10).
    ///
    /// Requirements:
    /// - All from "log2".
    ///
    /// Caveats:
    /// - All from "log2".
    ///
    /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the common logarithm.
    /// @return result The common logarithm as an unsigned 60.18-decimal fixed-point number.
    function log10(uint256 x) internal pure returns (uint256 result) {
        if (x < SCALE) {
            revert PRBMathUD60x18__LogInputTooSmall(x);
        }

        // Note that the "mul" in this block is the assembly multiplication operation, not the "mul" function defined
        // in this contract.
        // prettier-ignore
        assembly {
            switch x
            case 1 { result := mul(SCALE, sub(0, 18)) }
            case 10 { result := mul(SCALE, sub(1, 18)) }
            case 100 { result := mul(SCALE, sub(2, 18)) }
            case 1000 { result := mul(SCALE, sub(3, 18)) }
            case 10000 { result := mul(SCALE, sub(4, 18)) }
            case 100000 { result := mul(SCALE, sub(5, 18)) }
            case 1000000 { result := mul(SCALE, sub(6, 18)) }
            case 10000000 { result := mul(SCALE, sub(7, 18)) }
            case 100000000 { result := mul(SCALE, sub(8, 18)) }
            case 1000000000 { result := mul(SCALE, sub(9, 18)) }
            case 10000000000 { result := mul(SCALE, sub(10, 18)) }
            case 100000000000 { result := mul(SCALE, sub(11, 18)) }
            case 1000000000000 { result := mul(SCALE, sub(12, 18)) }
            case 10000000000000 { result := mul(SCALE, sub(13, 18)) }
            case 100000000000000 { result := mul(SCALE, sub(14, 18)) }
            case 1000000000000000 { result := mul(SCALE, sub(15, 18)) }
            case 10000000000000000 { result := mul(SCALE, sub(16, 18)) }
            case 100000000000000000 { result := mul(SCALE, sub(17, 18)) }
            case 1000000000000000000 { result := 0 }
            case 10000000000000000000 { result := SCALE }
            case 100000000000000000000 { result := mul(SCALE, 2) }
            case 1000000000000000000000 { result := mul(SCALE, 3) }
            case 10000000000000000000000 { result := mul(SCALE, 4) }
            case 100000000000000000000000 { result := mul(SCALE, 5) }
            case 1000000000000000000000000 { result := mul(SCALE, 6) }
            case 10000000000000000000000000 { result := mul(SCALE, 7) }
            case 100000000000000000000000000 { result := mul(SCALE, 8) }
            case 1000000000000000000000000000 { result := mul(SCALE, 9) }
            case 10000000000000000000000000000 { result := mul(SCALE, 10) }
            case 100000000000000000000000000000 { result := mul(SCALE, 11) }
            case 1000000000000000000000000000000 { result := mul(SCALE, 12) }
            case 10000000000000000000000000000000 { result := mul(SCALE, 13) }
            case 100000000000000000000000000000000 { result := mul(SCALE, 14) }
            case 1000000000000000000000000000000000 { result := mul(SCALE, 15) }
            case 10000000000000000000000000000000000 { result := mul(SCALE, 16) }
            case 100000000000000000000000000000000000 { result := mul(SCALE, 17) }
            case 1000000000000000000000000000000000000 { result := mul(SCALE, 18) }
            case 10000000000000000000000000000000000000 { result := mul(SCALE, 19) }
            case 100000000000000000000000000000000000000 { result := mul(SCALE, 20) }
            case 1000000000000000000000000000000000000000 { result := mul(SCALE, 21) }
            case 10000000000000000000000000000000000000000 { result := mul(SCALE, 22) }
            case 100000000000000000000000000000000000000000 { result := mul(SCALE, 23) }
            case 1000000000000000000000000000000000000000000 { result := mul(SCALE, 24) }
            case 10000000000000000000000000000000000000000000 { result := mul(SCALE, 25) }
            case 100000000000000000000000000000000000000000000 { result := mul(SCALE, 26) }
            case 1000000000000000000000000000000000000000000000 { result := mul(SCALE, 27) }
            case 10000000000000000000000000000000000000000000000 { result := mul(SCALE, 28) }
            case 100000000000000000000000000000000000000000000000 { result := mul(SCALE, 29) }
            case 1000000000000000000000000000000000000000000000000 { result := mul(SCALE, 30) }
            case 10000000000000000000000000000000000000000000000000 { result := mul(SCALE, 31) }
            case 100000000000000000000000000000000000000000000000000 { result := mul(SCALE, 32) }
            case 1000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 33) }
            case 10000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 34) }
            case 100000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 35) }
            case 1000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 36) }
            case 10000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 37) }
            case 100000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 38) }
            case 1000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 39) }
            case 10000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 40) }
            case 100000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 41) }
            case 1000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 42) }
            case 10000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 43) }
            case 100000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 44) }
            case 1000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 45) }
            case 10000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 46) }
            case 100000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 47) }
            case 1000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 48) }
            case 10000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 49) }
            case 100000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 50) }
            case 1000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 51) }
            case 10000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 52) }
            case 100000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 53) }
            case 1000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 54) }
            case 10000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 55) }
            case 100000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 56) }
            case 1000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 57) }
            case 10000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 58) }
            case 100000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 59) }
            default {
                result := MAX_UD60x18
            }
        }

        if (result == MAX_UD60x18) {
            // Do the fixed-point division inline to save gas. The denominator is log2(10).
            unchecked {
                result = (log2(x) * SCALE) / 3_321928094887362347;
            }
        }
    }

    /// @notice Calculates the binary logarithm of x.
    ///
    /// @dev Based on the iterative approximation algorithm.
    /// https://en.wikipedia.org/wiki/Binary_logarithm#Iterative_approximation
    ///
    /// Requirements:
    /// - x must be greater than or equal to SCALE, otherwise the result would be negative.
    ///
    /// Caveats:
    /// - The results are nor perfectly accurate to the last decimal, due to the lossy precision of the iterative approximation.
    ///
    /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the binary logarithm.
    /// @return result The binary logarithm as an unsigned 60.18-decimal fixed-point number.
    function log2(uint256 x) internal pure returns (uint256 result) {
        if (x < SCALE) {
            revert PRBMathUD60x18__LogInputTooSmall(x);
        }
        unchecked {
            // Calculate the integer part of the logarithm and add it to the result and finally calculate y = x * 2^(-n).
            uint256 n = PRBMath.mostSignificantBit(x / SCALE);

            // The integer part of the logarithm as an unsigned 60.18-decimal fixed-point number. The operation can't overflow
            // because n is maximum 255 and SCALE is 1e18.
            result = n * SCALE;

            // This is y = x * 2^(-n).
            uint256 y = x >> n;

            // If y = 1, the fractional part is zero.
            if (y == SCALE) {
                return result;
            }

            // Calculate the fractional part via the iterative approximation.
            // The "delta >>= 1" part is equivalent to "delta /= 2", but shifting bits is faster.
            for (uint256 delta = HALF_SCALE; delta > 0; delta >>= 1) {
                y = (y * y) / SCALE;

                // Is y^2 > 2 and so in the range [2,4)?
                if (y >= 2 * SCALE) {
                    // Add the 2^(-m) factor to the logarithm.
                    result += delta;

                    // Corresponds to z/2 on Wikipedia.
                    y >>= 1;
                }
            }
        }
    }

    /// @notice Multiplies two unsigned 60.18-decimal fixed-point numbers together, returning a new unsigned 60.18-decimal
    /// fixed-point number.
    /// @dev See the documentation for the "PRBMath.mulDivFixedPoint" function.
    /// @param x The multiplicand as an unsigned 60.18-decimal fixed-point number.
    /// @param y The multiplier as an unsigned 60.18-decimal fixed-point number.
    /// @return result The product as an unsigned 60.18-decimal fixed-point number.
    function mul(uint256 x, uint256 y) internal pure returns (uint256 result) {
        result = PRBMath.mulDivFixedPoint(x, y);
    }

    /// @notice Returns PI as an unsigned 60.18-decimal fixed-point number.
    function pi() internal pure returns (uint256 result) {
        result = 3_141592653589793238;
    }

    /// @notice Raises x to the power of y.
    ///
    /// @dev Based on the insight that x^y = 2^(log2(x) * y).
    ///
    /// Requirements:
    /// - All from "exp2", "log2" and "mul".
    ///
    /// Caveats:
    /// - All from "exp2", "log2" and "mul".
    /// - Assumes 0^0 is 1.
    ///
    /// @param x Number to raise to given power y, as an unsigned 60.18-decimal fixed-point number.
    /// @param y Exponent to raise x to, as an unsigned 60.18-decimal fixed-point number.
    /// @return result x raised to power y, as an unsigned 60.18-decimal fixed-point number.
    function pow(uint256 x, uint256 y) internal pure returns (uint256 result) {
        if (x == 0) {
            result = y == 0 ? SCALE : uint256(0);
        } else {
            result = exp2(mul(log2(x), y));
        }
    }

    /// @notice Raises x (unsigned 60.18-decimal fixed-point number) to the power of y (basic unsigned integer) using the
    /// famous algorithm "exponentiation by squaring".
    ///
    /// @dev See https://en.wikipedia.org/wiki/Exponentiation_by_squaring
    ///
    /// Requirements:
    /// - The result must fit within MAX_UD60x18.
    ///
    /// Caveats:
    /// - All from "mul".
    /// - Assumes 0^0 is 1.
    ///
    /// @param x The base as an unsigned 60.18-decimal fixed-point number.
    /// @param y The exponent as an uint256.
    /// @return result The result as an unsigned 60.18-decimal fixed-point number.
    function powu(uint256 x, uint256 y) internal pure returns (uint256 result) {
        // Calculate the first iteration of the loop in advance.
        result = y & 1 > 0 ? x : SCALE;

        // Equivalent to "for(y /= 2; y > 0; y /= 2)" but faster.
        for (y >>= 1; y > 0; y >>= 1) {
            x = PRBMath.mulDivFixedPoint(x, x);

            // Equivalent to "y % 2 == 1" but faster.
            if (y & 1 > 0) {
                result = PRBMath.mulDivFixedPoint(result, x);
            }
        }
    }

    /// @notice Returns 1 as an unsigned 60.18-decimal fixed-point number.
    function scale() internal pure returns (uint256 result) {
        result = SCALE;
    }

    /// @notice Calculates the square root of x, rounding down.
    /// @dev Uses the Babylonian method https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method.
    ///
    /// Requirements:
    /// - x must be less than MAX_UD60x18 / SCALE.
    ///
    /// @param x The unsigned 60.18-decimal fixed-point number for which to calculate the square root.
    /// @return result The result as an unsigned 60.18-decimal fixed-point .
    function sqrt(uint256 x) internal pure returns (uint256 result) {
        unchecked {
            if (x > MAX_UD60x18 / SCALE) {
                revert PRBMathUD60x18__SqrtOverflow(x);
            }
            // Multiply x by the SCALE to account for the factor of SCALE that is picked up when multiplying two unsigned
            // 60.18-decimal fixed-point numbers together (in this case, those two numbers are both the square root).
            result = PRBMath.sqrt(x * SCALE);
        }
    }

    /// @notice Converts a unsigned 60.18-decimal fixed-point number to basic integer form, rounding down in the process.
    /// @param x The unsigned 60.18-decimal fixed-point number to convert.
    /// @return result The same number in basic integer form.
    function toUint(uint256 x) internal pure returns (uint256 result) {
        unchecked {
            result = x / SCALE;
        }
    }
}

/// @notice Emitted when the result overflows uint256.
error PRBMath__MulDivFixedPointOverflow(uint256 prod1);

/// @notice Emitted when the result overflows uint256.
error PRBMath__MulDivOverflow(uint256 prod1, uint256 denominator);

/// @notice Emitted when one of the inputs is type(int256).min.
error PRBMath__MulDivSignedInputTooSmall();

/// @notice Emitted when the intermediary absolute result overflows int256.
error PRBMath__MulDivSignedOverflow(uint256 rAbs);

/// @notice Emitted when the input is MIN_SD59x18.
error PRBMathSD59x18__AbsInputTooSmall();

/// @notice Emitted when ceiling a number overflows SD59x18.
error PRBMathSD59x18__CeilOverflow(int256 x);

/// @notice Emitted when one of the inputs is MIN_SD59x18.
error PRBMathSD59x18__DivInputTooSmall();

/// @notice Emitted when one of the intermediary unsigned results overflows SD59x18.
error PRBMathSD59x18__DivOverflow(uint256 rAbs);

/// @notice Emitted when the input is greater than 133.084258667509499441.
error PRBMathSD59x18__ExpInputTooBig(int256 x);

/// @notice Emitted when the input is greater than 192.
error PRBMathSD59x18__Exp2InputTooBig(int256 x);

/// @notice Emitted when flooring a number underflows SD59x18.
error PRBMathSD59x18__FloorUnderflow(int256 x);

/// @notice Emitted when converting a basic integer to the fixed-point format overflows SD59x18.
error PRBMathSD59x18__FromIntOverflow(int256 x);

/// @notice Emitted when converting a basic integer to the fixed-point format underflows SD59x18.
error PRBMathSD59x18__FromIntUnderflow(int256 x);

/// @notice Emitted when the product of the inputs is negative.
error PRBMathSD59x18__GmNegativeProduct(int256 x, int256 y);

/// @notice Emitted when multiplying the inputs overflows SD59x18.
error PRBMathSD59x18__GmOverflow(int256 x, int256 y);

/// @notice Emitted when the input is less than or equal to zero.
error PRBMathSD59x18__LogInputTooSmall(int256 x);

/// @notice Emitted when one of the inputs is MIN_SD59x18.
error PRBMathSD59x18__MulInputTooSmall();

/// @notice Emitted when the intermediary absolute result overflows SD59x18.
error PRBMathSD59x18__MulOverflow(uint256 rAbs);

/// @notice Emitted when the intermediary absolute result overflows SD59x18.
error PRBMathSD59x18__PowuOverflow(uint256 rAbs);

/// @notice Emitted when the input is negative.
error PRBMathSD59x18__SqrtNegativeInput(int256 x);

/// @notice Emitted when the calculating the square root overflows SD59x18.
error PRBMathSD59x18__SqrtOverflow(int256 x);

/// @notice Emitted when addition overflows UD60x18.
error PRBMathUD60x18__AddOverflow(uint256 x, uint256 y);

/// @notice Emitted when ceiling a number overflows UD60x18.
error PRBMathUD60x18__CeilOverflow(uint256 x);

/// @notice Emitted when the input is greater than 133.084258667509499441.
error PRBMathUD60x18__ExpInputTooBig(uint256 x);

/// @notice Emitted when the input is greater than 192.
error PRBMathUD60x18__Exp2InputTooBig(uint256 x);

/// @notice Emitted when converting a basic integer to the fixed-point format format overflows UD60x18.
error PRBMathUD60x18__FromUintOverflow(uint256 x);

/// @notice Emitted when multiplying the inputs overflows UD60x18.
error PRBMathUD60x18__GmOverflow(uint256 x, uint256 y);

/// @notice Emitted when the input is less than 1.
error PRBMathUD60x18__LogInputTooSmall(uint256 x);

/// @notice Emitted when the calculating the square root overflows UD60x18.
error PRBMathUD60x18__SqrtOverflow(uint256 x);

/// @notice Emitted when subtraction underflows UD60x18.
error PRBMathUD60x18__SubUnderflow(uint256 x, uint256 y);

/// @dev Common mathematical functions used in both PRBMathSD59x18 and PRBMathUD60x18. Note that this shared library
/// does not always assume the signed 59.18-decimal fixed-point or the unsigned 60.18-decimal fixed-point
/// representation. When it does not, it is explicitly mentioned in the NatSpec documentation.
library PRBMath {
    /// STRUCTS ///

    struct SD59x18 {
        int256 value;
    }

    struct UD60x18 {
        uint256 value;
    }

    /// STORAGE ///

    /// @dev How many trailing decimals can be represented.
    uint256 internal constant SCALE = 1e18;

    /// @dev Largest power of two divisor of SCALE.
    uint256 internal constant SCALE_LPOTD = 262144;

    /// @dev SCALE inverted mod 2^256.
    uint256 internal constant SCALE_INVERSE =
        78156646155174841979727994598816262306175212592076161876661_508869554232690281;

    /// FUNCTIONS ///

    /// @notice Calculates the binary exponent of x using the binary fraction method.
    /// @dev Has to use 192.64-bit fixed-point numbers.
    /// See https://ethereum.stackexchange.com/a/96594/24693.
    /// @param x The exponent as an unsigned 192.64-bit fixed-point number.
    /// @return result The result as an unsigned 60.18-decimal fixed-point number.
    function exp2(uint256 x) internal pure returns (uint256 result) {
        unchecked {
            // Start from 0.5 in the 192.64-bit fixed-point format.
            result = 0x800000000000000000000000000000000000000000000000;

            // Multiply the result by root(2, 2^-i) when the bit at position i is 1. None of the intermediary results overflows
            // because the initial result is 2^191 and all magic factors are less than 2^65.
            if (x & 0x8000000000000000 > 0) {
                result = (result * 0x16A09E667F3BCC909) >> 64;
            }
            if (x & 0x4000000000000000 > 0) {
                result = (result * 0x1306FE0A31B7152DF) >> 64;
            }
            if (x & 0x2000000000000000 > 0) {
                result = (result * 0x1172B83C7D517ADCE) >> 64;
            }
            if (x & 0x1000000000000000 > 0) {
                result = (result * 0x10B5586CF9890F62A) >> 64;
            }
            if (x & 0x800000000000000 > 0) {
                result = (result * 0x1059B0D31585743AE) >> 64;
            }
            if (x & 0x400000000000000 > 0) {
                result = (result * 0x102C9A3E778060EE7) >> 64;
            }
            if (x & 0x200000000000000 > 0) {
                result = (result * 0x10163DA9FB33356D8) >> 64;
            }
            if (x & 0x100000000000000 > 0) {
                result = (result * 0x100B1AFA5ABCBED61) >> 64;
            }
            if (x & 0x80000000000000 > 0) {
                result = (result * 0x10058C86DA1C09EA2) >> 64;
            }
            if (x & 0x40000000000000 > 0) {
                result = (result * 0x1002C605E2E8CEC50) >> 64;
            }
            if (x & 0x20000000000000 > 0) {
                result = (result * 0x100162F3904051FA1) >> 64;
            }
            if (x & 0x10000000000000 > 0) {
                result = (result * 0x1000B175EFFDC76BA) >> 64;
            }
            if (x & 0x8000000000000 > 0) {
                result = (result * 0x100058BA01FB9F96D) >> 64;
            }
            if (x & 0x4000000000000 > 0) {
                result = (result * 0x10002C5CC37DA9492) >> 64;
            }
            if (x & 0x2000000000000 > 0) {
                result = (result * 0x1000162E525EE0547) >> 64;
            }
            if (x & 0x1000000000000 > 0) {
                result = (result * 0x10000B17255775C04) >> 64;
            }
            if (x & 0x800000000000 > 0) {
                result = (result * 0x1000058B91B5BC9AE) >> 64;
            }
            if (x & 0x400000000000 > 0) {
                result = (result * 0x100002C5C89D5EC6D) >> 64;
            }
            if (x & 0x200000000000 > 0) {
                result = (result * 0x10000162E43F4F831) >> 64;
            }
            if (x & 0x100000000000 > 0) {
                result = (result * 0x100000B1721BCFC9A) >> 64;
            }
            if (x & 0x80000000000 > 0) {
                result = (result * 0x10000058B90CF1E6E) >> 64;
            }
            if (x & 0x40000000000 > 0) {
                result = (result * 0x1000002C5C863B73F) >> 64;
            }
            if (x & 0x20000000000 > 0) {
                result = (result * 0x100000162E430E5A2) >> 64;
            }
            if (x & 0x10000000000 > 0) {
                result = (result * 0x1000000B172183551) >> 64;
            }
            if (x & 0x8000000000 > 0) {
                result = (result * 0x100000058B90C0B49) >> 64;
            }
            if (x & 0x4000000000 > 0) {
                result = (result * 0x10000002C5C8601CC) >> 64;
            }
            if (x & 0x2000000000 > 0) {
                result = (result * 0x1000000162E42FFF0) >> 64;
            }
            if (x & 0x1000000000 > 0) {
                result = (result * 0x10000000B17217FBB) >> 64;
            }
            if (x & 0x800000000 > 0) {
                result = (result * 0x1000000058B90BFCE) >> 64;
            }
            if (x & 0x400000000 > 0) {
                result = (result * 0x100000002C5C85FE3) >> 64;
            }
            if (x & 0x200000000 > 0) {
                result = (result * 0x10000000162E42FF1) >> 64;
            }
            if (x & 0x100000000 > 0) {
                result = (result * 0x100000000B17217F8) >> 64;
            }
            if (x & 0x80000000 > 0) {
                result = (result * 0x10000000058B90BFC) >> 64;
            }
            if (x & 0x40000000 > 0) {
                result = (result * 0x1000000002C5C85FE) >> 64;
            }
            if (x & 0x20000000 > 0) {
                result = (result * 0x100000000162E42FF) >> 64;
            }
            if (x & 0x10000000 > 0) {
                result = (result * 0x1000000000B17217F) >> 64;
            }
            if (x & 0x8000000 > 0) {
                result = (result * 0x100000000058B90C0) >> 64;
            }
            if (x & 0x4000000 > 0) {
                result = (result * 0x10000000002C5C860) >> 64;
            }
            if (x & 0x2000000 > 0) {
                result = (result * 0x1000000000162E430) >> 64;
            }
            if (x & 0x1000000 > 0) {
                result = (result * 0x10000000000B17218) >> 64;
            }
            if (x & 0x800000 > 0) {
                result = (result * 0x1000000000058B90C) >> 64;
            }
            if (x & 0x400000 > 0) {
                result = (result * 0x100000000002C5C86) >> 64;
            }
            if (x & 0x200000 > 0) {
                result = (result * 0x10000000000162E43) >> 64;
            }
            if (x & 0x100000 > 0) {
                result = (result * 0x100000000000B1721) >> 64;
            }
            if (x & 0x80000 > 0) {
                result = (result * 0x10000000000058B91) >> 64;
            }
            if (x & 0x40000 > 0) {
                result = (result * 0x1000000000002C5C8) >> 64;
            }
            if (x & 0x20000 > 0) {
                result = (result * 0x100000000000162E4) >> 64;
            }
            if (x & 0x10000 > 0) {
                result = (result * 0x1000000000000B172) >> 64;
            }
            if (x & 0x8000 > 0) {
                result = (result * 0x100000000000058B9) >> 64;
            }
            if (x & 0x4000 > 0) {
                result = (result * 0x10000000000002C5D) >> 64;
            }
            if (x & 0x2000 > 0) {
                result = (result * 0x1000000000000162E) >> 64;
            }
            if (x & 0x1000 > 0) {
                result = (result * 0x10000000000000B17) >> 64;
            }
            if (x & 0x800 > 0) {
                result = (result * 0x1000000000000058C) >> 64;
            }
            if (x & 0x400 > 0) {
                result = (result * 0x100000000000002C6) >> 64;
            }
            if (x & 0x200 > 0) {
                result = (result * 0x10000000000000163) >> 64;
            }
            if (x & 0x100 > 0) {
                result = (result * 0x100000000000000B1) >> 64;
            }
            if (x & 0x80 > 0) {
                result = (result * 0x10000000000000059) >> 64;
            }
            if (x & 0x40 > 0) {
                result = (result * 0x1000000000000002C) >> 64;
            }
            if (x & 0x20 > 0) {
                result = (result * 0x10000000000000016) >> 64;
            }
            if (x & 0x10 > 0) {
                result = (result * 0x1000000000000000B) >> 64;
            }
            if (x & 0x8 > 0) {
                result = (result * 0x10000000000000006) >> 64;
            }
            if (x & 0x4 > 0) {
                result = (result * 0x10000000000000003) >> 64;
            }
            if (x & 0x2 > 0) {
                result = (result * 0x10000000000000001) >> 64;
            }
            if (x & 0x1 > 0) {
                result = (result * 0x10000000000000001) >> 64;
            }

            // We're doing two things at the same time:
            //
            //   1. Multiply the result by 2^n + 1, where "2^n" is the integer part and the one is added to account for
            //      the fact that we initially set the result to 0.5. This is accomplished by subtracting from 191
            //      rather than 192.
            //   2. Convert the result to the unsigned 60.18-decimal fixed-point format.
            //
            // This works because 2^(191-ip) = 2^ip / 2^191, where "ip" is the integer part "2^n".
            result *= SCALE;
            result >>= (191 - (x >> 64));
        }
    }

    /// @notice Finds the zero-based index of the first one in the binary representation of x.
    /// @dev See the note on msb in the "Find First Set" Wikipedia article https://en.wikipedia.org/wiki/Find_first_set
    /// @param x The uint256 number for which to find the index of the most significant bit.
    /// @return msb The index of the most significant bit as an uint256.
    function mostSignificantBit(uint256 x) internal pure returns (uint256 msb) {
        if (x >= 2**128) {
            x >>= 128;
            msb += 128;
        }
        if (x >= 2**64) {
            x >>= 64;
            msb += 64;
        }
        if (x >= 2**32) {
            x >>= 32;
            msb += 32;
        }
        if (x >= 2**16) {
            x >>= 16;
            msb += 16;
        }
        if (x >= 2**8) {
            x >>= 8;
            msb += 8;
        }
        if (x >= 2**4) {
            x >>= 4;
            msb += 4;
        }
        if (x >= 2**2) {
            x >>= 2;
            msb += 2;
        }
        if (x >= 2**1) {
            // No need to shift x any more.
            msb += 1;
        }
    }

    /// @notice Calculates floor(x*y÷denominator) with full precision.
    ///
    /// @dev Credit to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv.
    ///
    /// Requirements:
    /// - The denominator cannot be zero.
    /// - The result must fit within uint256.
    ///
    /// Caveats:
    /// - This function does not work with fixed-point numbers.
    ///
    /// @param x The multiplicand as an uint256.
    /// @param y The multiplier as an uint256.
    /// @param denominator The divisor as an uint256.
    /// @return result The result as an uint256.
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
        // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
        // variables such that product = prod1 * 2^256 + prod0.
        uint256 prod0; // Least significant 256 bits of the product
        uint256 prod1; // Most significant 256 bits of the product
        assembly {
            let mm := mulmod(x, y, not(0))
            prod0 := mul(x, y)
            prod1 := sub(sub(mm, prod0), lt(mm, prod0))
        }

        // Handle non-overflow cases, 256 by 256 division.
        if (prod1 == 0) {
            unchecked {
                result = prod0 / denominator;
            }
            return result;
        }

        // Make sure the result is less than 2^256. Also prevents denominator == 0.
        if (prod1 >= denominator) {
            revert PRBMath__MulDivOverflow(prod1, denominator);
        }

        ///////////////////////////////////////////////
        // 512 by 256 division.
        ///////////////////////////////////////////////

        // Make division exact by subtracting the remainder from [prod1 prod0].
        uint256 remainder;
        assembly {
            // Compute remainder using mulmod.
            remainder := mulmod(x, y, denominator)

            // Subtract 256 bit number from 512 bit number.
            prod1 := sub(prod1, gt(remainder, prod0))
            prod0 := sub(prod0, remainder)
        }

        // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
        // See https://cs.stackexchange.com/q/138556/92363.
        unchecked {
            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 lpotdod = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by lpotdod.
                denominator := div(denominator, lpotdod)

                // Divide [prod1 prod0] by lpotdod.
                prod0 := div(prod0, lpotdod)

                // Flip lpotdod such that it is 2^256 / lpotdod. If lpotdod is zero, then it becomes one.
                lpotdod := add(div(sub(0, lpotdod), lpotdod), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * lpotdod;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /// @notice Calculates floor(x*y÷1e18) with full precision.
    ///
    /// @dev Variant of "mulDiv" with constant folding, i.e. in which the denominator is always 1e18. Before returning the
    /// final result, we add 1 if (x * y) % SCALE >= HALF_SCALE. Without this, 6.6e-19 would be truncated to 0 instead of
    /// being rounded to 1e-18.  See "Listing 6" and text above it at https://accu.org/index.php/journals/1717.
    ///
    /// Requirements:
    /// - The result must fit within uint256.
    ///
    /// Caveats:
    /// - The body is purposely left uncommented; see the NatSpec comments in "PRBMath.mulDiv" to understand how this works.
    /// - It is assumed that the result can never be type(uint256).max when x and y solve the following two equations:
    ///     1. x * y = type(uint256).max * SCALE
    ///     2. (x * y) % SCALE >= SCALE / 2
    ///
    /// @param x The multiplicand as an unsigned 60.18-decimal fixed-point number.
    /// @param y The multiplier as an unsigned 60.18-decimal fixed-point number.
    /// @return result The result as an unsigned 60.18-decimal fixed-point number.
    function mulDivFixedPoint(uint256 x, uint256 y) internal pure returns (uint256 result) {
        uint256 prod0;
        uint256 prod1;
        assembly {
            let mm := mulmod(x, y, not(0))
            prod0 := mul(x, y)
            prod1 := sub(sub(mm, prod0), lt(mm, prod0))
        }

        if (prod1 >= SCALE) {
            revert PRBMath__MulDivFixedPointOverflow(prod1);
        }

        uint256 remainder;
        uint256 roundUpUnit;
        assembly {
            remainder := mulmod(x, y, SCALE)
            roundUpUnit := gt(remainder, 499999999999999999)
        }

        if (prod1 == 0) {
            unchecked {
                result = (prod0 / SCALE) + roundUpUnit;
                return result;
            }
        }

        assembly {
            result := add(
                mul(
                    or(
                        div(sub(prod0, remainder), SCALE_LPOTD),
                        mul(sub(prod1, gt(remainder, prod0)), add(div(sub(0, SCALE_LPOTD), SCALE_LPOTD), 1))
                    ),
                    SCALE_INVERSE
                ),
                roundUpUnit
            )
        }
    }

    /// @notice Calculates floor(x*y÷denominator) with full precision.
    ///
    /// @dev An extension of "mulDiv" for signed numbers. Works by computing the signs and the absolute values separately.
    ///
    /// Requirements:
    /// - None of the inputs can be type(int256).min.
    /// - The result must fit within int256.
    ///
    /// @param x The multiplicand as an int256.
    /// @param y The multiplier as an int256.
    /// @param denominator The divisor as an int256.
    /// @return result The result as an int256.
    function mulDivSigned(
        int256 x,
        int256 y,
        int256 denominator
    ) internal pure returns (int256 result) {
        if (x == type(int256).min || y == type(int256).min || denominator == type(int256).min) {
            revert PRBMath__MulDivSignedInputTooSmall();
        }

        // Get hold of the absolute values of x, y and the denominator.
        uint256 ax;
        uint256 ay;
        uint256 ad;
        unchecked {
            ax = x < 0 ? uint256(-x) : uint256(x);
            ay = y < 0 ? uint256(-y) : uint256(y);
            ad = denominator < 0 ? uint256(-denominator) : uint256(denominator);
        }

        // Compute the absolute value of (x*y)÷denominator. The result must fit within int256.
        uint256 rAbs = mulDiv(ax, ay, ad);
        if (rAbs > uint256(type(int256).max)) {
            revert PRBMath__MulDivSignedOverflow(rAbs);
        }

        // Get the signs of x, y and the denominator.
        uint256 sx;
        uint256 sy;
        uint256 sd;
        assembly {
            sx := sgt(x, sub(0, 1))
            sy := sgt(y, sub(0, 1))
            sd := sgt(denominator, sub(0, 1))
        }

        // XOR over sx, sy and sd. This is checking whether there are one or three negative signs in the inputs.
        // If yes, the result should be negative.
        result = sx ^ sy ^ sd == 0 ? -int256(rAbs) : int256(rAbs);
    }

    /// @notice Calculates the square root of x, rounding down.
    /// @dev Uses the Babylonian method https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method.
    ///
    /// Caveats:
    /// - This function does not work with fixed-point numbers.
    ///
    /// @param x The uint256 number for which to calculate the square root.
    /// @return result The result as an uint256.
    function sqrt(uint256 x) internal pure returns (uint256 result) {
        if (x == 0) {
            return 0;
        }

        // Set the initial guess to the least power of two that is greater than or equal to sqrt(x).
        uint256 xAux = uint256(x);
        result = 1;
        if (xAux >= 0x100000000000000000000000000000000) {
            xAux >>= 128;
            result <<= 64;
        }
        if (xAux >= 0x10000000000000000) {
            xAux >>= 64;
            result <<= 32;
        }
        if (xAux >= 0x100000000) {
            xAux >>= 32;
            result <<= 16;
        }
        if (xAux >= 0x10000) {
            xAux >>= 16;
            result <<= 8;
        }
        if (xAux >= 0x100) {
            xAux >>= 8;
            result <<= 4;
        }
        if (xAux >= 0x10) {
            xAux >>= 4;
            result <<= 2;
        }
        if (xAux >= 0x8) {
            result <<= 1;
        }

        // The operations can never overflow because the result is max 2^127 when it enters this block.
        unchecked {
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1; // Seven iterations should be enough
            uint256 roundedDownResult = x / result;
            return result >= roundedDownResult ? roundedDownResult : result;
        }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"_priceStart","type":"uint256"},{"internalType":"uint256","name":"_priceEnd","type":"uint256"},{"internalType":"uint256","name":"_timeEnd","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"x","type":"uint256"}],"name":"PRBMathUD60x18__Exp2InputTooBig","type":"error"},{"inputs":[{"internalType":"uint256","name":"x","type":"uint256"}],"name":"PRBMathUD60x18__ExpInputTooBig","type":"error"},{"inputs":[{"internalType":"uint256","name":"x","type":"uint256"}],"name":"PRBMathUD60x18__LogInputTooSmall","type":"error"},{"inputs":[{"internalType":"uint256","name":"prod1","type":"uint256"}],"name":"PRBMath__MulDivFixedPointOverflow","type":"error"},{"inputs":[],"name":"getPrices","outputs":[{"internalType":"bool","name":"_isBadData","type":"bool"},{"internalType":"uint256","name":"_priceLow","type":"uint256"},{"internalType":"uint256","name":"_priceHigh","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"priceEnd","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pricePerShare","outputs":[{"internalType":"uint256","name":"_price","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"priceStart","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"timeEnd","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"timeStart","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

0000000000000000000000000000000000000000000000000b1a2bc2ec5000000000000000000000000000000000000000000000000000000de0b6b3a7640000000000000000000000000000000000000000000000000000000000006b36ec80

-----Decoded View---------------
Arg [0] : _priceStart (uint256): 800000000000000000
Arg [1] : _priceEnd (uint256): 1000000000000000000
Arg [2] : _timeEnd (uint256): 1798761600

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000b1a2bc2ec500000
Arg [1] : 0000000000000000000000000000000000000000000000000de0b6b3a7640000
Arg [2] : 000000000000000000000000000000000000000000000000000000006b36ec80

28:1246:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;188:35;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;230:33;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;777:270;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1080:191;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;108:34;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;149:32;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;188:35;;;:::o;230:33::-;;;:::o;777:270::-;823:14;850:19;890:9;872:15;:27;;;;:::i;:::-;850:49;;928:8;914:11;:22;910:129;;;947:8;938:17;;910:129;;;980:59;995:43;1023:8;1011;997:11;:22;;;;:::i;:::-;996:35;;;;:::i;:::-;995:41;:43::i;:::-;980:10;:14;;:59;;;;:::i;:::-;971:68;;910:129;839:208;777:270;:::o;1080:191::-;1124:15;1141:17;1160:18;1202:5;1191:16;;1248:15;:13;:15::i;:::-;1243:4;:20;;;;:::i;:::-;1230:33;;;1218:45;;1080:191;;;:::o;108:34::-;;;:::o;149:32::-;;;:::o;5925:492::-;5972:14;6094:22;6089:1;:27;6085:100;;6171:1;6140:33;;;;;;;;;;;:::i;:::-;;;;;;;;6085:100;6288:26;1986:20;6317:1;:10;6288:39;;6351:47;2570:4;1867;6357:18;:31;6356:41;;;;;:::i;:::-;;;6351:4;:47::i;:::-;6342:56;;6263:147;5925:492;;;:::o;22862:132::-;22920:14;22956:30;22981:1;22984;22956:24;:30::i;:::-;22947:39;;22862:132;;;;:::o;6879:569::-;6927:14;7056:6;7051:1;:11;7047:85;;7118:1;7086:34;;;;;;;;;;;:::i;:::-;;;;;;;;7047:85;7233:15;2570:4;7257:2;7252:1;:7;;7251:17;;;;;:::i;:::-;;;7233:35;;7408:21;7421:7;7408:12;:21::i;:::-;7399:30;;7144:297;6879:569;;;:::o;47382:1188::-;47453:14;47480:13;47504;47579:1;47575:6;47572:1;47569;47562:20;47612:1;47609;47605:9;47596:18;;47664:5;47660:2;47657:13;47649:5;47645:2;47641:14;47637:34;47628:43;;47537:145;31010:4;47698:5;:14;47694:94;;47770:5;47736:40;;;;;;;;;;;:::i;:::-;;;;;;;;47694:94;47800:17;47828:19;47908:5;47905:1;47902;47895:19;47882:32;;47957:18;47946:9;47943:33;47928:48;;48012:1;48003:5;:10;47999:157;;48086:11;31010:4;48069:5;:13;;;;;:::i;:::-;;;48068:29;48059:38;;48116:13;;;;;;47999:157;48526:11;48475:13;48426:1;48412:11;48398;48395:1;48391:19;48387:37;48383:45;48374:5;48363:9;48360:20;48353:5;48349:32;48345:84;48306:11;48294:9;48287:5;48283:21;48279:39;48250:202;48224:283;48202:350;48192:360;;48177:386;;;;47382:1188;;;;;:::o;31702:8685::-;31750:14;31880:50;31871:59;;32199:1;32178:18;32174:1;:22;:26;32170:112;;;32264:2;32240:19;32231:6;:28;32230:36;;32221:45;;32170:112;32325:1;32304:18;32300:1;:22;:26;32296:112;;;32390:2;32366:19;32357:6;:28;32356:36;;32347:45;;32296:112;32451:1;32430:18;32426:1;:22;:26;32422:112;;;32516:2;32492:19;32483:6;:28;32482:36;;32473:45;;32422:112;32577:1;32556:18;32552:1;:22;:26;32548:112;;;32642:2;32618:19;32609:6;:28;32608:36;;32599:45;;32548:112;32702:1;32682:17;32678:1;:21;:25;32674:111;;;32767:2;32743:19;32734:6;:28;32733:36;;32724:45;;32674:111;32827:1;32807:17;32803:1;:21;:25;32799:111;;;32892:2;32868:19;32859:6;:28;32858:36;;32849:45;;32799:111;32952:1;32932:17;32928:1;:21;:25;32924:111;;;33017:2;32993:19;32984:6;:28;32983:36;;32974:45;;32924:111;33077:1;33057:17;33053:1;:21;:25;33049:111;;;33142:2;33118:19;33109:6;:28;33108:36;;33099:45;;33049:111;33201:1;33182:16;33178:1;:20;:24;33174:110;;;33266:2;33242:19;33233:6;:28;33232:36;;33223:45;;33174:110;33325:1;33306:16;33302:1;:20;:24;33298:110;;;33390:2;33366:19;33357:6;:28;33356:36;;33347:45;;33298:110;33449:1;33430:16;33426:1;:20;:24;33422:110;;;33514:2;33490:19;33481:6;:28;33480:36;;33471:45;;33422:110;33573:1;33554:16;33550:1;:20;:24;33546:110;;;33638:2;33614:19;33605:6;:28;33604:36;;33595:45;;33546:110;33696:1;33678:15;33674:1;:19;:23;33670:109;;;33761:2;33737:19;33728:6;:28;33727:36;;33718:45;;33670:109;33819:1;33801:15;33797:1;:19;:23;33793:109;;;33884:2;33860:19;33851:6;:28;33850:36;;33841:45;;33793:109;33942:1;33924:15;33920:1;:19;:23;33916:109;;;34007:2;33983:19;33974:6;:28;33973:36;;33964:45;;33916:109;34065:1;34047:15;34043:1;:19;:23;34039:109;;;34130:2;34106:19;34097:6;:28;34096:36;;34087:45;;34039:109;34187:1;34170:14;34166:1;:18;:22;34162:108;;;34252:2;34228:19;34219:6;:28;34218:36;;34209:45;;34162:108;34309:1;34292:14;34288:1;:18;:22;34284:108;;;34374:2;34350:19;34341:6;:28;34340:36;;34331:45;;34284:108;34431:1;34414:14;34410:1;:18;:22;34406:108;;;34496:2;34472:19;34463:6;:28;34462:36;;34453:45;;34406:108;34553:1;34536:14;34532:1;:18;:22;34528:108;;;34618:2;34594:19;34585:6;:28;34584:36;;34575:45;;34528:108;34674:1;34658:13;34654:1;:17;:21;34650:107;;;34739:2;34715:19;34706:6;:28;34705:36;;34696:45;;34650:107;34795:1;34779:13;34775:1;:17;:21;34771:107;;;34860:2;34836:19;34827:6;:28;34826:36;;34817:45;;34771:107;34916:1;34900:13;34896:1;:17;:21;34892:107;;;34981:2;34957:19;34948:6;:28;34947:36;;34938:45;;34892:107;35037:1;35021:13;35017:1;:17;:21;35013:107;;;35102:2;35078:19;35069:6;:28;35068:36;;35059:45;;35013:107;35157:1;35142:12;35138:1;:16;:20;35134:106;;;35222:2;35198:19;35189:6;:28;35188:36;;35179:45;;35134:106;35277:1;35262:12;35258:1;:16;:20;35254:106;;;35342:2;35318:19;35309:6;:28;35308:36;;35299:45;;35254:106;35397:1;35382:12;35378:1;:16;:20;35374:106;;;35462:2;35438:19;35429:6;:28;35428:36;;35419:45;;35374:106;35517:1;35502:12;35498:1;:16;:20;35494:106;;;35582:2;35558:19;35549:6;:28;35548:36;;35539:45;;35494:106;35636:1;35622:11;35618:1;:15;:19;35614:105;;;35701:2;35677:19;35668:6;:28;35667:36;;35658:45;;35614:105;35755:1;35741:11;35737:1;:15;:19;35733:105;;;35820:2;35796:19;35787:6;:28;35786:36;;35777:45;;35733:105;35874:1;35860:11;35856:1;:15;:19;35852:105;;;35939:2;35915:19;35906:6;:28;35905:36;;35896:45;;35852:105;35993:1;35979:11;35975:1;:15;:19;35971:105;;;36058:2;36034:19;36025:6;:28;36024:36;;36015:45;;35971:105;36111:1;36098:10;36094:1;:14;:18;36090:104;;;36176:2;36152:19;36143:6;:28;36142:36;;36133:45;;36090:104;36229:1;36216:10;36212:1;:14;:18;36208:104;;;36294:2;36270:19;36261:6;:28;36260:36;;36251:45;;36208:104;36347:1;36334:10;36330:1;:14;:18;36326:104;;;36412:2;36388:19;36379:6;:28;36378:36;;36369:45;;36326:104;36465:1;36452:10;36448:1;:14;:18;36444:104;;;36530:2;36506:19;36497:6;:28;36496:36;;36487:45;;36444:104;36582:1;36570:9;36566:1;:13;:17;36562:103;;;36647:2;36623:19;36614:6;:28;36613:36;;36604:45;;36562:103;36699:1;36687:9;36683:1;:13;:17;36679:103;;;36764:2;36740:19;36731:6;:28;36730:36;;36721:45;;36679:103;36816:1;36804:9;36800:1;:13;:17;36796:103;;;36881:2;36857:19;36848:6;:28;36847:36;;36838:45;;36796:103;36933:1;36921:9;36917:1;:13;:17;36913:103;;;36998:2;36974:19;36965:6;:28;36964:36;;36955:45;;36913:103;37049:1;37038:8;37034:1;:12;:16;37030:102;;;37114:2;37090:19;37081:6;:28;37080:36;;37071:45;;37030:102;37165:1;37154:8;37150:1;:12;:16;37146:102;;;37230:2;37206:19;37197:6;:28;37196:36;;37187:45;;37146:102;37281:1;37270:8;37266:1;:12;:16;37262:102;;;37346:2;37322:19;37313:6;:28;37312:36;;37303:45;;37262:102;37397:1;37386:8;37382:1;:12;:16;37378:102;;;37462:2;37438:19;37429:6;:28;37428:36;;37419:45;;37378:102;37512:1;37502:7;37498:1;:11;:15;37494:101;;;37577:2;37553:19;37544:6;:28;37543:36;;37534:45;;37494:101;37627:1;37617:7;37613:1;:11;:15;37609:101;;;37692:2;37668:19;37659:6;:28;37658:36;;37649:45;;37609:101;37742:1;37732:7;37728:1;:11;:15;37724:101;;;37807:2;37783:19;37774:6;:28;37773:36;;37764:45;;37724:101;37857:1;37847:7;37843:1;:11;:15;37839:101;;;37922:2;37898:19;37889:6;:28;37888:36;;37879:45;;37839:101;37971:1;37962:6;37958:1;:10;:14;37954:100;;;38036:2;38012:19;38003:6;:28;38002:36;;37993:45;;37954:100;38085:1;38076:6;38072:1;:10;:14;38068:100;;;38150:2;38126:19;38117:6;:28;38116:36;;38107:45;;38068:100;38199:1;38190:6;38186:1;:10;:14;38182:100;;;38264:2;38240:19;38231:6;:28;38230:36;;38221:45;;38182:100;38313:1;38304:6;38300:1;:10;:14;38296:100;;;38378:2;38354:19;38345:6;:28;38344:36;;38335:45;;38296:100;38426:1;38418:5;38414:1;:9;:13;38410:99;;;38491:2;38467:19;38458:6;:28;38457:36;;38448:45;;38410:99;38539:1;38531:5;38527:1;:9;:13;38523:99;;;38604:2;38580:19;38571:6;:28;38570:36;;38561:45;;38523:99;38652:1;38644:5;38640:1;:9;:13;38636:99;;;38717:2;38693:19;38684:6;:28;38683:36;;38674:45;;38636:99;38765:1;38757:5;38753:1;:9;:13;38749:99;;;38830:2;38806:19;38797:6;:28;38796:36;;38787:45;;38749:99;38877:1;38870:4;38866:1;:8;:12;38862:98;;;38942:2;38918:19;38909:6;:28;38908:36;;38899:45;;38862:98;38989:1;38982:4;38978:1;:8;:12;38974:98;;;39054:2;39030:19;39021:6;:28;39020:36;;39011:45;;38974:98;39101:1;39094:4;39090:1;:8;:12;39086:98;;;39166:2;39142:19;39133:6;:28;39132:36;;39123:45;;39086:98;39213:1;39206:4;39202:1;:8;:12;39198:98;;;39278:2;39254:19;39245:6;:28;39244:36;;39235:45;;39198:98;39324:1;39318:3;39314:1;:7;:11;39310:97;;;39389:2;39365:19;39356:6;:28;39355:36;;39346:45;;39310:97;39435:1;39429:3;39425:1;:7;:11;39421:97;;;39500:2;39476:19;39467:6;:28;39466:36;;39457:45;;39421:97;39546:1;39540:3;39536:1;:7;:11;39532:97;;;39611:2;39587:19;39578:6;:28;39577:36;;39568:45;;39532:97;39657:1;39651:3;39647:1;:7;:11;39643:97;;;39722:2;39698:19;39689:6;:28;39688:36;;39679:45;;39643:97;31010:4;40310:15;;;;40364:2;40359:1;:7;;40352:3;:15;40340:28;;;;;31702:8685;;;:::o;7:77:1:-;44:7;73:5;62:16;;7:77;;;:::o;90:118::-;177:24;195:5;177:24;:::i;:::-;172:3;165:37;90:118;;:::o;214:222::-;307:4;345:2;334:9;330:18;322:26;;358:71;426:1;415:9;411:17;402:6;358:71;:::i;:::-;214:222;;;;:::o;442:90::-;476:7;519:5;512:13;505:21;494:32;;442:90;;;:::o;538:109::-;619:21;634:5;619:21;:::i;:::-;614:3;607:34;538:109;;:::o;653:430::-;796:4;834:2;823:9;819:18;811:26;;847:65;909:1;898:9;894:17;885:6;847:65;:::i;:::-;922:72;990:2;979:9;975:18;966:6;922:72;:::i;:::-;1004;1072:2;1061:9;1057:18;1048:6;1004:72;:::i;:::-;653:430;;;;;;:::o;1089:180::-;1137:77;1134:1;1127:88;1234:4;1231:1;1224:15;1258:4;1255:1;1248:15;1275:194;1315:4;1335:20;1353:1;1335:20;:::i;:::-;1330:25;;1369:20;1387:1;1369:20;:::i;:::-;1364:25;;1413:1;1410;1406:9;1398:17;;1437:1;1431:4;1428:11;1425:37;;;1442:18;;:::i;:::-;1425:37;1275:194;;;;:::o;1475:410::-;1515:7;1538:20;1556:1;1538:20;:::i;:::-;1533:25;;1572:20;1590:1;1572:20;:::i;:::-;1567:25;;1627:1;1624;1620:9;1649:30;1667:11;1649:30;:::i;:::-;1638:41;;1828:1;1819:7;1815:15;1812:1;1809:22;1789:1;1782:9;1762:83;1739:139;;1858:18;;:::i;:::-;1739:139;1523:362;1475:410;;;;:::o;1891:180::-;1939:77;1936:1;1929:88;2036:4;2033:1;2026:15;2060:4;2057:1;2050:15;2077:185;2117:1;2134:20;2152:1;2134:20;:::i;:::-;2129:25;;2168:20;2186:1;2168:20;:::i;:::-;2163:25;;2207:1;2197:35;;2212:18;;:::i;:::-;2197:35;2254:1;2251;2247:9;2242:14;;2077:185;;;;:::o

ipfs://dbca14405fd78276bb3cab9bd4d3e9ab78c636365332700ff6e4f0393930a5c7