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

import "FungifyPriceFeed.sol";
import "Ownable.sol";

// This is intended to reduce the number of transactions made.
contract BatchUpdateRate is Ownable {
    // --- Auth ---
    mapping (address => uint) 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();
        }
        _;
    }

    event FailedToUpdate(FungifyPriceFeed feed, int256 answer);

    error UnequalParamLengths();
    error Unauthorized();

    constructor() Ownable(msg.sender) {}

    // Sets the price answer to multiple price feeds at once
    function batchSetAnswer(FungifyPriceFeed[] memory priceFeeds, int256[] calldata newAnswers) external auth {
        uint numFeeds = priceFeeds.length;

        if (numFeeds != newAnswers.length) {
            revert UnequalParamLengths();
        }

        // Loops through all the provided feeds and attempts to set their answers
        for (uint i = 0; i < numFeeds;) {
            try priceFeeds[i].updateRate(newAnswers[i]) {
            } catch {
                emit FailedToUpdate(priceFeeds[i], newAnswers[i]);
            }
            unchecked { i++; }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Context.sol)

pragma solidity ^0.8.20;

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

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

import "Upgradeable.sol";

contract FungifyPriceFeed is Upgradeable {
    event RateUpdated(int256 oldRate, int256 newRate, int256 inputRate);
    error UnderTimeAndPriceDeviationMinimums();
    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 public immutable _decimals;

    int256 public latestAnswer;
    uint256 public latestUpdateTime;

    // Variables for price updating assertions
    int256 public minPriceDeviationBip; // Defined in basis points: 1 Bip = .01%
    uint256 public stalePriceTime;

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

    constructor(uint8 decimals_) {
        _decimals = decimals_;
    }

    function initialize(int256 startingRate_) external {
        if (msg.sender != owner()) {
            revert Unauthorized();
        }

        latestAnswer = startingRate_;
        latestUpdateTime = block.timestamp;
        stalePriceTime = 7200;
        minPriceDeviationBip = 200;
        maxPriceDeviationBip = 3500;
        emaPeriods = 3;
        emit RateUpdated(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 if a newRate is within the priceDeviationBip of oldRate
    function underMinPriceDeviation(int256 newRate, int256 oldRate) public view returns(bool) {

        int256 allowedDeviation = oldRate * minPriceDeviationBip / ONE_IN_BIP;

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

    // 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();
        }
        
        // Performs Price Update Minimum Deviation Time and Price Checks
        if (underMinPriceDeviation(newRate_, oldEMA) && block.timestamp < latestUpdateTime + stalePriceTime) {
            revert UnderTimeAndPriceDeviationMinimums();
        }

        int256 newEMA = updateEMA(oldEMA, newRate_);

        latestAnswer = newEMA;
        latestUpdateTime = block.timestamp;
        emit RateUpdated(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;
    }

    function setStalePriceTime(uint _stalePriceTime) external onlyOwner {
        stalePriceTime = _stalePriceTime;
    }

    // Defined in basis points: 1 Bip = .01%
    function setMinPriceDeviationBip(int _minPriceDeviationBip) external onlyOwner {
        minPriceDeviationBip = _minPriceDeviationBip;
    }

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

import {Context} from "Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * 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);
    }
}

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

import {Ownable} from "Ownable.sol";

contract Upgradeable is Ownable {
    address public implementation;

    constructor() Ownable(msg.sender) {}
}

{
  "compilationTarget": {
    "BatchUpdateRate.sol": "BatchUpdateRate"
  },
  "evmVersion": "shanghai",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}