Contract 0x3934cA8b69D05533769B0D96d1A11C44c1D2fA3B

/**
 *Submitted for verification at Arbiscan on 2022-08-20
*/

// Sources flattened with hardhat v2.9.3 https://hardhat.org

// File contracts/libraries/math/SafeMath.sol

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}


// File contracts/oracle/interfaces/IFastPriceEvents.sol


pragma solidity 0.6.12;

interface IFastPriceEvents {
    function emitPriceEvent(address _token, uint256 _price) external;
}


// File contracts/access/Governable.sol


pragma solidity 0.6.12;

contract Governable {
    address public gov;

    constructor() public {
        gov = msg.sender;
    }

    modifier onlyGov() {
        require(msg.sender == gov, "Governable: forbidden");
        _;
    }

    function setGov(address _gov) external onlyGov {
        gov = _gov;
    }
}


// File contracts/oracle/FastPriceEvents.sol



pragma solidity 0.6.12;

contract FastPriceEvents is IFastPriceEvents, Governable {
    mapping(address => bool) public isPriceFeed;
    event PriceUpdate(address token, uint256 price, address priceFeed);

    function setIsPriceFeed(address _priceFeed, bool _isPriceFeed) external onlyGov {
        isPriceFeed[_priceFeed] = _isPriceFeed;
    }

    function emitPriceEvent(address _token, uint256 _price) external override {
        require(isPriceFeed[msg.sender], "FastPriceEvents: invalid sender");
        emit PriceUpdate(_token, _price, msg.sender);
    }
}

[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"price","type":"uint256"},{"indexed":false,"internalType":"address","name":"priceFeed","type":"address"}],"name":"PriceUpdate","type":"event"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_price","type":"uint256"}],"name":"emitPriceEvent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"gov","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isPriceFeed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_gov","type":"address"}],"name":"setGov","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_priceFeed","type":"address"},{"internalType":"bool","name":"_isPriceFeed","type":"bool"}],"name":"setIsPriceFeed","outputs":[],"stateMutability":"nonpayable","type":"function"}]

608060405234801561001057600080fd5b50600080546001600160a01b03191633179055610341806100326000396000f3fe608060405234801561001057600080fd5b50600436106100575760003560e01c806312d43a511461005c57806357a94beb1461008057806369d4c924146100ba578063cfad57a2146100ea578063e0409c7114610110575b600080fd5b61006461013c565b604080516001600160a01b039092168252519081900360200190f35b6100a66004803603602081101561009657600080fd5b50356001600160a01b031661014b565b604080519115158252519081900360200190f35b6100e8600480360360408110156100d057600080fd5b506001600160a01b0381351690602001351515610160565b005b6100e86004803603602081101561010057600080fd5b50356001600160a01b03166101e2565b6100e86004803603604081101561012657600080fd5b506001600160a01b03813516906020013561025b565b6000546001600160a01b031681565b60016020526000908152604090205460ff1681565b6000546001600160a01b031633146101b7576040805162461bcd60e51b815260206004820152601560248201527423b7bb32b93730b136329d103337b93134b23232b760591b604482015290519081900360640190fd5b6001600160a01b03919091166000908152600160205260409020805460ff1916911515919091179055565b6000546001600160a01b03163314610239576040805162461bcd60e51b815260206004820152601560248201527423b7bb32b93730b136329d103337b93134b23232b760591b604482015290519081900360640190fd5b600080546001600160a01b0319166001600160a01b0392909216919091179055565b3360009081526001602052604090205460ff166102bf576040805162461bcd60e51b815260206004820152601f60248201527f4661737450726963654576656e74733a20696e76616c69642073656e64657200604482015290519081900360640190fd5b604080516001600160a01b038416815260208101839052338183015290517fc37a77b91cc3fc2d0e4b43fd2f347ec67adda10e39215de4742836cc3e42c97a9181900360600190a1505056fea2646970667358221220609ed89ee99836e54558e34e30d8e11fa931fa2cb1bd05ae209b58ab9876078b64736f6c634300060c0033

6239:552:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5875:18;;;:::i;:::-;;;;-1:-1:-1;;;;;5875:18:0;;;;;;;;;;;;;;6303:43;;;;;;;;;;;;;;;;-1:-1:-1;6303:43:0;-1:-1:-1;;;;;6303:43:0;;:::i;:::-;;;;;;;;;;;;;;;;;;6428:137;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;6428:137:0;;;;;;;;;;:::i;:::-;;6075:76;;;;;;;;;;;;;;;;-1:-1:-1;6075:76:0;-1:-1:-1;;;;;6075:76:0;;:::i;6573:215::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;6573:215:0;;;;;;;;:::i;5875:18::-;;;-1:-1:-1;;;;;5875:18:0;;:::o;6303:43::-;;;;;;;;;;;;;;;:::o;6428:137::-;6018:3;;-1:-1:-1;;;;;6018:3:0;6004:10;:17;5996:51;;;;;-1:-1:-1;;;5996:51:0;;;;;;;;;;;;-1:-1:-1;;;5996:51:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;6519:23:0;;;::::1;;::::0;;;:11:::1;:23;::::0;;;;:38;;-1:-1:-1;;6519:38:0::1;::::0;::::1;;::::0;;;::::1;::::0;;6428:137::o;6075:76::-;6018:3;;-1:-1:-1;;;;;6018:3:0;6004:10;:17;5996:51;;;;;-1:-1:-1;;;5996:51:0;;;;;;;;;;;;-1:-1:-1;;;5996:51:0;;;;;;;;;;;;;;;6133:3:::1;:10:::0;;-1:-1:-1;;;;;;6133:10:0::1;-1:-1:-1::0;;;;;6133:10:0;;;::::1;::::0;;;::::1;::::0;;6075:76::o;6573:215::-;6678:10;6666:23;;;;:11;:23;;;;;;;;6658:67;;;;;-1:-1:-1;;;6658:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;6741:39;;;-1:-1:-1;;;;;6741:39:0;;;;;;;;;;6769:10;6741:39;;;;;;;;;;;;;;;6573:215;;:::o

609ed89ee99836e54558e34e30d8e11fa931fa2cb1bd05ae209b58ab9876078b