// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;

import {ImmutableController} from "oval/src/controllers/ImmutableController.sol";
import {ChainlinkSourceAdapter} from "oval/src/adapters/source-adapters/ChainlinkSourceAdapter.sol";
import {ChainlinkDestinationAdapter} from "oval/src/adapters/destination-adapters/ChainlinkDestinationAdapter.sol";
import {IAggregatorV3Source} from "oval/src/interfaces/chainlink/IAggregatorV3Source.sol";

/**
 * @title OvalOracle instance that has input and output adapters of Chainlink and ImmutableController.
 */
contract ChainlinkOvalImmutable is ImmutableController, ChainlinkSourceAdapter, ChainlinkDestinationAdapter {
    constructor(
        IAggregatorV3Source source, // The input chainlink source
        uint8 decimals, // The number of decimals the input should provide.
        uint256 lockWindow, // How long the permissioned actor has after each update to run an OEV auction.
        uint256 maxTraversal, // The maximum lookback traversal limit when looking for historic data.
        address[] memory unlockers // A set of unlockers who can initiate OEV auctions.
    )
        ChainlinkSourceAdapter(source)
        ImmutableController(lockWindow, maxTraversal, unlockers)
        ChainlinkDestinationAdapter(decimals)
    {}
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.17;

import {OVAL} from "../Oval.sol";

/**
 * @title ImmutableController providing an immutable controller.
 * @dev The benefit of this controller is two-fold:
 * 1. Permissioning and parameters _cannot_ be updated after deployment. Ownership doesn't exist.
 * 2. Because LOCK_WINDOW and MAX_TRAVERSAL are immutable, the read costs are much lower in the "hot" path (end
 *    oracle users).
 */

abstract contract ImmutableController is OVAL {
    uint256 private immutable LOCK_WINDOW; // The lockWindow in seconds.
    uint256 private immutable MAX_TRAVERSAL; // The maximum number of rounds to traverse when looking for historical data.

    mapping(address => bool) public unlockers;

    constructor(uint256 _lockWindow, uint256 _maxTraversal, address[] memory _unlockers) {
        LOCK_WINDOW = _lockWindow;
        MAX_TRAVERSAL = _maxTraversal;
        for (uint256 i = 0; i < _unlockers.length; i++) {
            unlockers[_unlockers[i]] = true;

            emit UnlockerSet(_unlockers[i], true);
        }

        emit LockWindowSet(_lockWindow);
        emit MaxTraversalSet(_maxTraversal);
    }

    /**
     * @notice Returns true if the caller is allowed to unlock the OVAL.
     * @dev This implementation simply checks if the caller is in the unlockers mapping. Custom Controllers can override
     * this function to provide more granular control over who can unlock the OVAL.
     * @param caller The address to check.
     * @param _lastUnlockTime The timestamp of the latest unlock to the OVAL. Might be useful in verification.
     */
    function canUnlock(address caller, uint256 _lastUnlockTime) public view override returns (bool) {
        return unlockers[caller];
    }

    /**
     * @notice Time window that bounds how long the permissioned actor has to call the unlockLatestValue function after
     * a new source update is posted. If the permissioned actor does not call unlockLatestValue within this window of a
     * new source price, the latest value will be made available to everyone without going through an MEV-Share auction.
     * @return lockWindow time in seconds.
     */
    function lockWindow() public view override returns (uint256) {
        return LOCK_WINDOW;
    }

    /**
     * @notice Max number of historical source updates to traverse when looking for a historic value in the past.
     * @return maxTraversal max number of historical source updates to traverse.
     */
    function maxTraversal() public view override returns (uint256) {
        return MAX_TRAVERSAL;
    }
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.17;

import {DecimalLib} from "../lib/DecimalLib.sol";
import {IAggregatorV3Source} from "../../interfaces/chainlink/IAggregatorV3Source.sol";
import {DiamondRootOVAL} from "../../DiamondRootOval.sol";

/**
 * @title ChainlinkSourceAdapter contract to read data from Chainlink aggregator and standardize it for OVAL.
 * @dev Can fetch information from Chainlink source at a desired timestamp for historic lookups.
 */

abstract contract ChainlinkSourceAdapter is DiamondRootOVAL {
    IAggregatorV3Source public immutable CHAINLINK_SOURCE;
    uint8 private immutable SOURCE_DECIMALS;

    // As per Chainlink documentation https://docs.chain.link/data-feeds/historical-data#roundid-in-proxy
    // roundId on the aggregator proxy is comprised of phaseId (higher 16 bits) and roundId from phase aggregator
    // (lower 64 bits). PHASE_MASK is used to calculate first roundId of current phase aggregator.
    uint80 private constant PHASE_MASK = uint80(0xFFFF) << 64;

    event SourceSet(address indexed sourceOracle, uint8 indexed sourceDecimals);

    constructor(IAggregatorV3Source source) {
        CHAINLINK_SOURCE = source;
        SOURCE_DECIMALS = source.decimals();

        emit SourceSet(address(source), SOURCE_DECIMALS);
    }

    /**
     * @notice Tries getting latest data as of requested timestamp. If this is not possible, returns the earliest data
     * available past the requested timestamp within provided traversal limitations.
     * @param timestamp The timestamp to try getting latest data at.
     * @param maxTraversal The maximum number of rounds to traverse when looking for historical data.
     * @return answer The answer as of requested timestamp, or earliest available data if not available, in 18 decimals.
     * @return updatedAt The timestamp of the answer.
     */
    function tryLatestDataAt(uint256 timestamp, uint256 maxTraversal)
        public
        view
        virtual
        override
        returns (int256, uint256)
    {
        (int256 answer, uint256 updatedAt) = _tryLatestRoundDataAt(timestamp, maxTraversal);
        return (DecimalLib.convertDecimals(answer, SOURCE_DECIMALS, 18), updatedAt);
    }

    /**
     * @notice Initiate a snapshot of the source data. This is a no-op for Chainlink.
     */
    function snapshotData() public virtual override {}

    /**
     * @notice Returns the latest data from the source.
     * @return answer The latest answer in 18 decimals.
     * @return updatedAt The timestamp of the answer.
     */
    function getLatestSourceData() public view virtual override returns (int256, uint256) {
        (, int256 sourceAnswer,, uint256 updatedAt,) = CHAINLINK_SOURCE.latestRoundData();
        return (DecimalLib.convertDecimals(sourceAnswer, SOURCE_DECIMALS, 18), updatedAt);
    }

    // Tries getting latest data as of requested timestamp. If this is not possible, returns the earliest data available
    // past the requested timestamp considering the maxTraversal limitations.
    function _tryLatestRoundDataAt(uint256 timestamp, uint256 maxTraversal) internal view returns (int256, uint256) {
        (uint80 roundId, int256 answer,, uint256 updatedAt,) = CHAINLINK_SOURCE.latestRoundData();

        // In the happy path there have been no source updates since requested time, so we can return the latest data.
        // We can use updatedAt property as it matches the block timestamp of the latest source transmission.
        if (updatedAt <= timestamp) return (answer, updatedAt);

        // Attempt traversing historical round data backwards from roundId. This might still be newer or uninitialized.
        (int256 historicalAnswer, uint256 historicalUpdatedAt) = _searchRoundDataAt(timestamp, roundId, maxTraversal);

        // Validate returned data. If it is uninitialized we fallback to returning the current latest round data.
        if (historicalUpdatedAt > 0) return (historicalAnswer, historicalUpdatedAt);
        return (answer, updatedAt);
    }

    // Tries finding latest historical data (ignoring current roundId) not newer than requested timestamp. Might return
    // newer data than requested if exceeds traversal or hold uninitialized data that should be handled by the caller.
    function _searchRoundDataAt(uint256 timestamp, uint80 targetRoundId, uint256 maxTraversal)
        internal
        view
        returns (int256, uint256)
    {
        uint80 roundId;
        int256 answer;
        uint256 updatedAt;
        uint80 traversedRounds = 0;
        uint80 startRoundId = (targetRoundId & PHASE_MASK) + 1; // Phase aggregators are starting at round 1.

        while (traversedRounds < uint80(maxTraversal) && targetRoundId > startRoundId) {
            targetRoundId--; // We started from latest roundId that should be ignored.
            // The aggregator proxy does not keep track when its phase aggregators got switched. This means that we can
            // only traverse rounds of the current phase aggregator. When phase aggregators are switched there is
            // normally an overlap period when both new and old phase aggregators receive updates. Without knowing exact
            // time when the aggregator proxy switched them we might end up returning historical data from the new phase
            // aggregator that was not yet available on the aggregator proxy at the requested timestamp.

            (roundId, answer,, updatedAt,) = CHAINLINK_SOURCE.getRoundData(targetRoundId);
            if (!(roundId == targetRoundId && updatedAt > 0)) return (0, 0);
            if (updatedAt <= timestamp) return (answer, updatedAt);
            traversedRounds++;
        }

        return (answer, updatedAt); // Did not find requested round. Return earliest round or uninitialized data.
    }
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.17;

import {DecimalLib} from "../lib/DecimalLib.sol";
import {IAggregatorV3} from "../../interfaces/chainlink/IAggregatorV3.sol";
import {DiamondRootOVAL} from "../../DiamondRootOval.sol";

/**
 * @title ChainlinkDestinationAdapter contract to expose OVAL data via the standard Chainlink Aggregator interface.
 */

abstract contract ChainlinkDestinationAdapter is DiamondRootOVAL, IAggregatorV3 {
    uint8 public immutable override decimals;

    event DecimalsSet(uint8 indexed decimals);

    constructor(uint8 _decimals) {
        decimals = _decimals;

        emit DecimalsSet(_decimals);
    }

    /**
     * @notice Returns the latest data from the source.
     * @return answer The latest answer in the configured number of decimals.
     */
    function latestAnswer() public view override returns (int256) {
        (int256 answer,) = internalLatestData();
        return DecimalLib.convertDecimals(answer, 18, decimals);
    }

    /**
     * @notice Returns when the latest answer was updated.
     * @return timestamp The timestamp of the latest answer.
     */
    function latestTimestamp() public view override returns (uint256) {
        (, uint256 timestamp) = internalLatestData();
        return timestamp;
    }

    /**
     * @notice Returns an approximate form of the latest Round data. This does not implement the notion of "roundId" that
     * the normal chainlink aggregator does and returns hardcoded values for those fields.
     * @return roundId The roundId of the latest answer, hardcoded to 1.
     * @return answer The latest answer in the configured number of decimals.
     * @return startedAt The timestamp when the value was updated.
     * @return updatedAt The timestamp when the value was updated.
     * @return answeredInRound The roundId of the round in which the answer was computed, hardcoded to 1.
     */
    function latestRoundData() external view returns (uint80, int256, uint256, uint256, uint80) {
        (int256 answer, uint256 updatedAt) = internalLatestData();
        return (1, DecimalLib.convertDecimals(answer, 18, decimals), updatedAt, updatedAt, 1);
    }
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.17;

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

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

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

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.17;

import {Math} from "openzeppelin-contracts/contracts/utils/math/Math.sol";
import {DiamondRootOVAL} from "./DiamondRootOval.sol";

/**
 * @title OVAL contract to provide permissioned updating at the execution of an MEV-share auction.
 * @dev This contract works by conditionally returning a stale value oracle price from the source adapter until a
 * permissioned actor calls the unlockLatestValue function. The call to unlockLatestValue is submitted via an MEV-share
 * auction and will be backrun by the winner of the auction. The backrunner has access to the most recent newly unlocked
 * source price. If someone tries to front-run the call to unlockLatestValue, the caller will receive a stale value. If
 * the permissioned actor does not call unlockLatestValue within the lockWindow, the latest value that is at least
 * lockWindow seconds old will be returned. This contract is intended to be used in conjunction with a Controller
 * contract that governs who can call unlockLatestValue.
 * @custom:security-contact bugs@umaproject.org
 */

abstract contract OVAL is DiamondRootOVAL {
    uint256 public lastUnlockTime; // Timestamp of the latest unlock to the OVAL.

    /**
     * @notice Function called by permissioned actor to unlock the latest value as part of the MEV-share auction flow.
     * @dev The call to this function is expected to be sent to flashbots via eth_sendPrivateTransaction. This is the
     * transaction that is backrun by the winner of the auction. The backrunner has access to the most recent newly
     * unlocked source price as a result and therefore can extract the MEV associated with the unlock.
     */
    function unlockLatestValue() public {
        require(canUnlock(msg.sender, lastUnlockTime), "Controller blocked: canUnlock");

        snapshotData(); // If the source connected to this OVAL needs to snapshot data, do it here. Else, no op.

        lastUnlockTime = block.timestamp;

        emit LatestValueUnlocked(block.timestamp);
    }

    /**
     * @notice Returns latest data from source, governed by lockWindow controlling if returned data is stale.
     * @return answer The latest answer in 18 decimals.
     * @return timestamp The timestamp of the answer.
     */
    function internalLatestData() public view override returns (int256, uint256) {
        // Case work:
        //-> If unlockLatestValue has been called within lockWindow, then return most recent price as of unlockLatestValue call.
        //-> If unlockLatestValue has not been called in lockWindow, then return most recent value that is at least lockWindow old.
        return tryLatestDataAt(Math.max(lastUnlockTime, block.timestamp - lockWindow()), maxTraversal());
    }
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.17;

import {Math} from "openzeppelin-contracts/contracts/utils/math/Math.sol";

/**
 * @title DecimalLib library to perform decimal math operations.
 */
library DecimalLib {
    /**
     * Converts int256 answer scaled at iDecimals to scale at oDecimals.
     * Source oracle adapters should pass 18 for oDecimals, while destination adapters should pass 18 for iDecimals.
     * Warning: When downscaling (i.e., when iDecimals > oDecimals), the conversion can lead to a loss of precision.
     * In the worst case, if the answer is small enough, the conversion can return zero.
     * Warning: When upscaling (i.e., when iDecimals < oDecimals), if answer * 10^(oDecimals - iDecimals) exceeds
     * the maximum int256 value, this function will revert. Ensure the provided values will not cause an overflow.
     */
    function convertDecimals(int256 answer, uint8 iDecimals, uint8 oDecimals) internal pure returns (int256) {
        if (iDecimals == oDecimals) return answer;
        if (iDecimals < oDecimals) return answer * int256(10 ** (oDecimals - iDecimals));
        return answer / int256(10 ** (iDecimals - oDecimals));
    }

    /**
     * Converts uint256 answer scaled at iDecimals to scale at oDecimals.
     * Source oracle adapters should pass 18 for oDecimals, while destination adapters should pass 18 for iDecimals.
     * Warning: When downscaling (i.e., when iDecimals > oDecimals), the conversion can lead to a loss of precision.
     * In the worst case, if the answer is small enough, the conversion can return zero.
     * Warning: When upscaling (i.e., when iDecimals < oDecimals), if answer * 10^(oDecimals - iDecimals) exceeds
     * the maximum uint256 value, this function will revert. Ensure the provided values will not cause an overflow.
     */
    function convertDecimals(uint256 answer, uint8 iDecimals, uint8 oDecimals) internal pure returns (uint256) {
        if (iDecimals == oDecimals) return answer;
        if (iDecimals < oDecimals) return answer * 10 ** (oDecimals - iDecimals);
        return answer / 10 ** (iDecimals - oDecimals);
    }

    // Derives token decimals from its scaling factor.
    function deriveDecimals(uint256 scalingFactor) internal pure returns (uint8) {
        uint256 decimals = Math.log10(scalingFactor);

        // Verify that the inverse operation yields the expected result.
        require(10 ** decimals == scalingFactor, "Invalid scalingFactor");

        // Note: decimals must fit within uint8 because:
        // 2^8 = 256, which is uint8 max.
        // This would imply an input scaling factor of 1e256. The max value of uint256 is \(2^{256} - 1\), which is approximately
        // 1.2e77, but not equal to 1e256. Therefore, decimals will always fit within uint8 or the check above will fail.
        return uint8(decimals);
    }
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.17;

import {IBaseOracleAdapter} from "./interfaces/IBaseOracleAdapter.sol";
import {IBaseController} from "./interfaces/IBaseController.sol";
import {IOVAL} from "./interfaces/IOval.sol";

/**
 * @title DiamondRootOVAL contract to provide base functions that the three components of the OVAL contract system
 * need. They are exposed here to simplify the inheritance structure of the OVAL contract system and to enable easier
 * composability and extensibility at the integration layer, enabling arbitrary combinations of sources and destinations.
 */

abstract contract DiamondRootOVAL is IBaseController, IOVAL, IBaseOracleAdapter {
    /**
     * @notice Returns the latest data from the source.
     * @return answer The latest answer in 18 decimals.
     * @return updatedAt The timestamp of the answer.
     */
    function getLatestSourceData() public view virtual returns (int256, uint256);

    /**
     * @notice Tries getting latest data as of requested timestamp. If this is not possible, returns the earliest data
     * available past the requested timestamp within provided traversal limitations.
     * @param timestamp The timestamp to try getting latest data at.
     * @param maxTraversal The maximum number of rounds to traverse when looking for historical data.
     * @return answer The answer as of requested timestamp, or earliest available data if not available, in 18 decimals.
     * @return updatedAt The timestamp of the answer.
     */
    function tryLatestDataAt(uint256 timestamp, uint256 maxTraversal) public view virtual returns (int256, uint256);

    /**
     * @notice Returns the latest data from the source. Depending on when the OVAL was last unlocked this might
     * return an slightly stale value to protect the OEV from being stolen by a front runner.
     * @return answer The latest answer in 18 decimals.
     * @return updatedAt The timestamp of the answer.
     */
    function internalLatestData() public view virtual returns (int256, uint256);

    /**
     * @notice Snapshot the current source data. Is a no-op if the source does not require snapshotting.
     */
    function snapshotData() public virtual;

    /**
     * @notice Permissioning function to control who can unlock the OVAL.
     */
    function canUnlock(address caller, uint256 cachedLatestTimestamp) public view virtual returns (bool);

    /**
     * @notice Time window that bounds how long the permissioned actor has to call the unlockLatestValue function after
     * a new source update is posted. If the permissioned actor does not call unlockLatestValue within this window of a
     * new source price, the latest value will be made available to everyone without going through an MEV-Share auction.
     * @return lockWindow time in seconds.
     */
    function lockWindow() public view virtual returns (uint256);

    /**
     * @notice Max number of historical source updates to traverse when looking for a historic value in the past.
     * @return maxTraversal max number of historical source updates to traverse.
     */
    function maxTraversal() public view virtual returns (uint256);
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.17;

interface IAggregatorV3 {
    function latestAnswer() external view returns (int256);

    function latestTimestamp() external view returns (uint256);

    function decimals() external view returns (uint8);

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

    // Other Chainlink functions we don't need.

    // function latestRound() external view returns (uint256);

    // function getAnswer(uint256 roundId) external view returns (int256);

    // function getTimestamp(uint256 roundId) external view returns (uint256);

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

    // function version() external view returns (uint256);

    // function getRoundData(uint80 _roundId)
    //     external
    //     view
    //     returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);

    // event AnswerUpdated(int256 indexed current, uint256 indexed roundId, uint256 updatedAt);

    // event NewRound(uint256 indexed roundId, address indexed startedBy, uint256 startedAt);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 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) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1, "Math: mulDiv overflow");

            ///////////////////////////////////////////////
            // 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.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

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

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

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

            // 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 x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.17;

interface IBaseOracleAdapter {
    function tryLatestDataAt(uint256 _timestamp, uint256 _maxTraversal)
        external
        view
        returns (int256 answer, uint256 timestamp);

    function getLatestSourceData() external view returns (int256 answer, uint256 timestamp);
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.17;

interface IBaseController {
    event LockWindowSet(uint256 indexed lockWindow);
    event MaxTraversalSet(uint256 indexed maxTraversal);
    event UnlockerSet(address indexed unlocker, bool indexed allowed);

    function canUnlock(address caller, uint256 cachedLatestTimestamp) external view returns (bool);
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity 0.8.17;

interface IOVAL {
    event LatestValueUnlocked(uint256 indexed timestamp);

    function internalLatestData() external view returns (int256 answer, uint256 timestamp);
}

{
  "remappings": [
    "oval/=lib/oval-contracts/",
    "openzeppelin-contracts/=lib/oval-contracts/lib/openzeppelin-contracts/",
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/oval-contracts/lib/openzeppelin-contracts/lib/erc4626-tests/",
    "forge-std/=lib/forge-std/src/",
    "openzeppelin/=lib/oval-contracts/lib/openzeppelin-contracts/contracts/",
    "oval-contracts/=lib/oval-contracts/src/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs"
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "london",
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IAggregatorV3Source","name":"source","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint256","name":"lockWindow","type":"uint256"},{"internalType":"uint256","name":"maxTraversal","type":"uint256"},{"internalType":"address[]","name":"unlockers","type":"address[]"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint8","name":"decimals","type":"uint8"}],"name":"DecimalsSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"LatestValueUnlocked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"lockWindow","type":"uint256"}],"name":"LockWindowSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"maxTraversal","type":"uint256"}],"name":"MaxTraversalSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sourceOracle","type":"address"},{"indexed":true,"internalType":"uint8","name":"sourceDecimals","type":"uint8"}],"name":"SourceSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"unlocker","type":"address"},{"indexed":true,"internalType":"bool","name":"allowed","type":"bool"}],"name":"UnlockerSet","type":"event"},{"inputs":[],"name":"CHAINLINK_SOURCE","outputs":[{"internalType":"contract IAggregatorV3Source","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"caller","type":"address"},{"internalType":"uint256","name":"_lastUnlockTime","type":"uint256"}],"name":"canUnlock","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLatestSourceData","outputs":[{"internalType":"int256","name":"","type":"int256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"internalLatestData","outputs":[{"internalType":"int256","name":"","type":"int256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastUnlockTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"latestAnswer","outputs":[{"internalType":"int256","name":"","type":"int256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"latestRoundData","outputs":[{"internalType":"uint80","name":"","type":"uint80"},{"internalType":"int256","name":"","type":"int256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint80","name":"","type":"uint80"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"latestTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockWindow","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxTraversal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"snapshotData","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"timestamp","type":"uint256"},{"internalType":"uint256","name":"maxTraversal","type":"uint256"}],"name":"tryLatestDataAt","outputs":[{"internalType":"int256","name":"","type":"int256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unlockLatestValue","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"unlockers","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

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