Forkchoice Ethereum Mainnet

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

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

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

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

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

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

contract Upgradeable is Ownable {
    address public implementation;

    constructor() Ownable(msg.sender) {}

    function replaceImplementation(address impl_) public onlyOwner {
        implementation = impl_;
    }
}

contract Proxy is Upgradeable {

    constructor(address impl_) {
        replaceImplementation(impl_);
    }

    fallback() external payable {
        assembly {
            calldatacopy(0, 0, calldatasize())
            let result := delegatecall(gas(), sload(implementation.slot), 0, calldatasize(), 0, 0)
            returndatacopy(0, 0, returndatasize())
            switch result
            case 0 { revert(0, returndatasize()) }
            default { return(0, returndatasize()) }
        }
    }
}

contract FungifyPriceFeed is Upgradeable {
    event RateUpdated(string description, int256 oldRate, int256 newRate, int256 inputRate);
    error OverPriceDeviationMaximum();
    error Unauthorized();
    error AdditionOverflow();
    error SubtractionOverflow();
    error LessThanTwoPeriods();

    // --- Auth ---
    mapping (address => uint256) public wards;
    function rely(address guy) external onlyOwner { wards[guy] = 1; }
    function deny(address guy) external onlyOwner { wards[guy] = 0; }
    modifier auth {
        if (wards[msg.sender] == 0) {
            revert Unauthorized();
        }
        _;
    }

    int256 public constant ONE_IN_BIP = 10000;
    uint8 internal immutable _decimals;

    int256 public latestAnswer;
    uint256 public latestUpdateTime;

    // Variables for price updating assertions
    int256 internal minPriceDeviationBip_unused; // Defined in basis points: 1 Bip = .01%
    uint256 internal stalePriceTime_unused;

    int256 public emaPeriods; // averaging periods for EMA calculation
    int public maxPriceDeviationBip; // Defined in basis points: 1 Bip = .01%

    string public description;

    constructor(uint8 decimals_) {
        _decimals = decimals_;
    }

    function initialize(int256 startingRate_, string memory description_) external onlyOwner {
        latestAnswer = startingRate_;
        description = description_;
        latestUpdateTime = block.timestamp;
        maxPriceDeviationBip = 2500;
        emaPeriods = 3;
        emit RateUpdated(description_, 0, startingRate_, startingRate_);
    }

    function decimals() public view returns (uint8) {
        return _decimals;
    }

    function latestRoundData()
        public
        view
        returns (
            uint80 roundId,
            int256 answer,
            uint256 startedAt,
            uint256 updatedAt,
            uint80 answeredInRound
        ) {
        return (0, latestAnswer, 0, latestUpdateTime, 0);
    }

    // Verifies that a newRate is within the maxPriceDeviationBip of oldRate
    function overMaxPriceDeviation(int256 newRate, int256 oldRate) public view returns(bool) {

        int allowedDeviation = oldRate * maxPriceDeviationBip / ONE_IN_BIP;

        if (newRate > oldRate + allowedDeviation || newRate < oldRate - allowedDeviation) {
            return true;
        } else {
            return false;
        }
    }

    function updateRate(int256 newRate_) public auth {

        int256 oldEMA = latestAnswer;

        if (overMaxPriceDeviation(newRate_, oldEMA)) {
            revert OverPriceDeviationMaximum();
        }

        int256 newEMA = updateEMA(oldEMA, newRate_);

        latestAnswer = newEMA;
        latestUpdateTime = block.timestamp;
        emit RateUpdated(description, oldEMA, newEMA, newRate_);
    }

    function updateEMA(int256 currentEMA, int256 newValue) internal view returns (int256) {
        /*
            Multiplier: 2 / (emaPeriods + 1)
            EMA: (LastestValue - PreviousEMA) * Multiplier + PreviousEMA
        */

        int256 emaPeriods_ = emaPeriods;

        int256 newEMA =
            sub(
                add(
                    newValue * 2 / (emaPeriods_ + 1),
                    currentEMA
                ),
                currentEMA * 2 / (emaPeriods_ + 1)
            );

        return newEMA;
    }

    // Defined in basis points: 1 Bip = .01%
    function setMaxPriceDeviationBip(int _maxPriceDeviationBip) external onlyOwner {
        maxPriceDeviationBip = _maxPriceDeviationBip;
    }

    function setEMAPeriods(int _emaPeriods) external onlyOwner {
        if (_emaPeriods < 2) {
            revert LessThanTwoPeriods();
        }
        emaPeriods = _emaPeriods;
    }

    function adminUpdateRate(int256 newRate_) external onlyOwner {
        int256 oldRate = latestAnswer;
        latestAnswer = newRate_;
        latestUpdateTime = block.timestamp;
        emit RateUpdated(description, oldRate, newRate_, newRate_);
    }

    function add(int256 a, int256 b) internal pure returns (int256) {
        int256 c;
        unchecked { c = a + b; }
        if (!((b >= 0 && c >= a) || (b < 0 && c < a))) {
            revert AdditionOverflow();
        }

        return c;
    }
    function sub(int256 a, int256 b) internal pure returns (int256) {
        int256 c;
        unchecked { c = a - b; }
        if (!((b >= 0 && c <= a) || (b < 0 && c > a))) {
            revert SubtractionOverflow();
        }

        return c;
    }
}