// SPDX-License-Identifier: MIT
// File: @chainlink/contracts/src/v0.6/Owned.sol

pragma solidity 0.6.12;

/**
 * @title The Owned contract
 * @notice A contract with helpers for basic contract ownership.
 */
contract Owned {

  address public owner;
  address private pendingOwner;

  event OwnershipTransferRequested(
    address indexed from,
    address indexed to
  );
  event OwnershipTransferred(
    address indexed from,
    address indexed to
  );

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

  /**
   * @dev Allows an owner to begin transferring ownership to a new address,
   * pending.
   */
  function transferOwnership(address _to)
    external
    onlyOwner()
  {
    pendingOwner = _to;

    emit OwnershipTransferRequested(owner, _to);
  }

  /**
   * @dev Allows an ownership transfer to be completed by the recipient.
   */
  function acceptOwnership()
    external
  {
    require(msg.sender == pendingOwner, "Must be proposed owner");

    address oldOwner = owner;
    owner = msg.sender;
    pendingOwner = address(0);

    emit OwnershipTransferred(oldOwner, msg.sender);
  }

  /**
   * @dev Reverts if called by anyone other than the contract owner.
   */
  modifier onlyOwner() {
    require(msg.sender == owner, "Only callable by owner");
    _;
  }

}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// File: contracts/IKeep3rV1.sol

interface IKeep3rV1 {
  function activate(address bonding) external;
  function bond(address bonding, uint amount) external;
  function unbond(address bonding, uint amount) external;
  function withdraw(address bonding) external;
}

// File: contracts/IKeep3rV1Oracle.sol

interface IKeep3rV1Oracle {
  function work() external;
  function workForFree() external;
  function workable() external view returns (bool);
  function workable(address pair) external view returns (bool);
}

// File: contracts/ChainlinkKeep3rV1Oracle.sol

contract ChainlinkKeep3rV1Oracle is Owned {
  IKeep3rV1 public KP3R;
  IKeep3rV1Oracle public KP3RV1Oracle;
  mapping(address => bool) private authorizedNodes;

  constructor(address _keep3r, address _keep3rV1Oracle) public {
    updateKeep3r(_keep3r);
    updateKeep3rOracle(_keep3rV1Oracle);
  }

  function work() external onlyAuthorized() {
    KP3RV1Oracle.work();
  }

  function workForFree() external onlyAuthorized() {
    KP3RV1Oracle.workForFree();
  }

  function workable() external view returns (bool) {
    return KP3RV1Oracle.workable();
  }

  function workable(address _pair) external view returns (bool) {
    return KP3RV1Oracle.workable(_pair);
  }

  function bond(address _bonding, uint256 _amount) external onlyOwner() {
    KP3R.bond(_bonding, _amount);
  }

  function activate(address _bonding) external onlyOwner() {
    KP3R.activate(_bonding);
  }

  function unbond(address _bonding, uint256 _amount) external onlyOwner() {
    KP3R.unbond(_bonding, _amount);
  }

  function withdraw(address _bonding) external onlyOwner() {
    KP3R.withdraw(_bonding);
  }

  function withdrawFrom(IERC20 _token, address _recipient, uint256 _amount) external onlyOwner() {
    _token.transfer(_recipient, _amount);
  }

  function setAuthorization(address _node, bool _authorized) external onlyOwner() {
    authorizedNodes[_node] = _authorized;
  }

  function updateKeep3r(address _keep3r) public onlyOwner() {
    KP3R = IKeep3rV1(_keep3r);
  }

  function updateKeep3rOracle(address _keep3rV1Oracle) public onlyOwner() {
    KP3RV1Oracle = IKeep3rV1Oracle(_keep3rV1Oracle);
  }

  modifier onlyAuthorized() {
    require(authorizedNodes[msg.sender] || msg.sender == owner, "Not an authorized node");
    _;
  }
}

{
  "compilationTarget": {
    "browser/ChainlinkKeep3rV1Oracle.sol": "ChainlinkKeep3rV1Oracle"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}