chainlinnk 0.8.2

package/v0.5/contracts/Oracle.sol

@@ -0,0 +1,273 @@
+pragma solidity ^0.5.0;
+
+import "./LinkTokenReceiver.sol";
+import "./interfaces/ChainlinkRequestInterface.sol";
+import "./interfaces/OracleInterface.sol";
+import "./interfaces/LinkTokenInterface.sol";
+import "./interfaces/WithdrawalInterface.sol";
+import "./vendor/Ownable.sol";
+import "./vendor/SafeMath.sol";
+
+/**
+ * @title The Chainlink Oracle contract
+ * @notice Node operators can deploy this contract to fulfill requests sent to them
+ */
+contract Oracle is ChainlinkRequestInterface, OracleInterface, Ownable, LinkTokenReceiver, WithdrawalInterface {
+  using SafeMath for uint256;
+
+  uint256 constant public EXPIRY_TIME = 5 minutes;
+  uint256 constant private MINIMUM_CONSUMER_GAS_LIMIT = 400000;
+  // We initialize fields to 1 instead of 0 so that the first invocation
+  // does not cost more gas.
+  uint256 constant private ONE_FOR_CONSISTENT_GAS_COST = 1;
+
+  LinkTokenInterface internal LinkToken;
+  mapping(bytes32 => bytes32) private commitments;
+  mapping(address => bool) private authorizedNodes;
+  uint256 private withdrawableTokens = ONE_FOR_CONSISTENT_GAS_COST;
+
+  event OracleRequest(
+    bytes32 indexed specId,
+    address requester,
+    bytes32 requestId,
+    uint256 payment,
+    address callbackAddr,
+    bytes4 callbackFunctionId,
+    uint256 cancelExpiration,
+    uint256 dataVersion,
+    bytes data
+  );
+
+  event CancelOracleRequest(
+    bytes32 indexed requestId
+  );
+
+  /**
+   * @notice Deploy with the address of the LINK token
+   * @dev Sets the LinkToken address for the imported LinkTokenInterface
+   * @param _link The address of the LINK token
+   */
+  constructor(address _link) public Ownable() {
+    LinkToken = LinkTokenInterface(_link); // external but already deployed and unalterable
+  }
+
+  /**
+   * @notice Creates the Chainlink request
+   * @dev Stores the hash of the params as the on-chain commitment for the request.
+   * Emits OracleRequest event for the Chainlink node to detect.
+   * @param _sender The sender of the request
+   * @param _payment The amount of payment given (specified in wei)
+   * @param _specId The Job Specification ID
+   * @param _callbackAddress The callback address for the response
+   * @param _callbackFunctionId The callback function ID for the response
+   * @param _nonce The nonce sent by the requester
+   * @param _dataVersion The specified data version
+   * @param _data The CBOR payload of the request
+   */
+  function oracleRequest(
+    address _sender,
+    uint256 _payment,
+    bytes32 _specId,
+    address _callbackAddress,
+    bytes4 _callbackFunctionId,
+    uint256 _nonce,
+    uint256 _dataVersion,
+    bytes calldata _data
+  )
+    external
+    onlyLINK
+    checkCallbackAddress(_callbackAddress)
+  {
+    bytes32 requestId = keccak256(abi.encodePacked(_sender, _nonce));
+    require(commitments[requestId] == 0, "Must use a unique ID");
+    // solhint-disable-next-line not-rely-on-time
+    uint256 expiration = now.add(EXPIRY_TIME);
+
+    commitments[requestId] = keccak256(
+      abi.encodePacked(
+        _payment,
+        _callbackAddress,
+        _callbackFunctionId,
+        expiration
+      )
+    );
+
+    emit OracleRequest(
+      _specId,
+      _sender,
+      requestId,
+      _payment,
+      _callbackAddress,
+      _callbackFunctionId,
+      expiration,
+      _dataVersion,
+      _data);
+  }
+
+  /**
+   * @notice Called by the Chainlink node to fulfill requests
+   * @dev Given params must hash back to the commitment stored from `oracleRequest`.
+   * Will call the callback address' callback function without bubbling up error
+   * checking in a `require` so that the node can get paid.
+   * @param _requestId The fulfillment request ID that must match the requester's
+   * @param _payment The payment amount that will be released for the oracle (specified in wei)
+   * @param _callbackAddress The callback address to call for fulfillment
+   * @param _callbackFunctionId The callback function ID to use for fulfillment
+   * @param _expiration The expiration that the node should respond by before the requester can cancel
+   * @param _data The data to return to the consuming contract
+   * @return Status if the external call was successful
+   */
+  function fulfillOracleRequest(
+    bytes32 _requestId,
+    uint256 _payment,
+    address _callbackAddress,
+    bytes4 _callbackFunctionId,
+    uint256 _expiration,
+    bytes32 _data
+  )
+    external
+    onlyAuthorizedNode
+    isValidRequest(_requestId)
+    returns (bool)
+  {
+    bytes32 paramsHash = keccak256(
+      abi.encodePacked(
+        _payment,
+        _callbackAddress,
+        _callbackFunctionId,
+        _expiration
+      )
+    );
+    require(commitments[_requestId] == paramsHash, "Params do not match request ID");
+    withdrawableTokens = withdrawableTokens.add(_payment);
+    delete commitments[_requestId];
+    require(gasleft() >= MINIMUM_CONSUMER_GAS_LIMIT, "Must provide consumer enough gas");
+    // All updates to the oracle's fulfillment should come before calling the
+    // callback(addr+functionId) as it is untrusted.
+    // See: https://solidity.readthedocs.io/en/develop/security-considerations.html#use-the-checks-effects-interactions-pattern
+    (bool success, ) = _callbackAddress.call(abi.encodeWithSelector(_callbackFunctionId, _requestId, _data)); // solhint-disable-line avoid-low-level-calls
+    return success;
+  }
+
+  /**
+   * @notice Use this to check if a node is authorized for fulfilling requests
+   * @param _node The address of the Chainlink node
+   * @return The authorization status of the node
+   */
+  function getAuthorizationStatus(address _node) external view returns (bool) {
+    return authorizedNodes[_node];
+  }
+
+  /**
+   * @notice Sets the fulfillment permission for a given node. Use `true` to allow, `false` to disallow.
+   * @param _node The address of the Chainlink node
+   * @param _allowed Bool value to determine if the node can fulfill requests
+   */
+  function setFulfillmentPermission(address _node, bool _allowed) external onlyOwner {
+    authorizedNodes[_node] = _allowed;
+  }
+
+  /**
+   * @notice Allows the node operator to withdraw earned LINK to a given address
+   * @dev The owner of the contract can be another wallet and does not have to be a Chainlink node
+   * @param _recipient The address to send the LINK token to
+   * @param _amount The amount to send (specified in wei)
+   */
+  function withdraw(address _recipient, uint256 _amount)
+    external
+    onlyOwner
+    hasAvailableFunds(_amount)
+  {
+    withdrawableTokens = withdrawableTokens.sub(_amount);
+    assert(LinkToken.transfer(_recipient, _amount));
+  }
+
+  /**
+   * @notice Displays the amount of LINK that is available for the node operator to withdraw
+   * @dev We use `ONE_FOR_CONSISTENT_GAS_COST` in place of 0 in storage
+   * @return The amount of withdrawable LINK on the contract
+   */
+  function withdrawable() external view onlyOwner returns (uint256) {
+    return withdrawableTokens.sub(ONE_FOR_CONSISTENT_GAS_COST);
+  }
+
+  /**
+   * @notice Allows requesters to cancel requests sent to this oracle contract. Will transfer the LINK
+   * sent for the request back to the requester's address.
+   * @dev Given params must hash to a commitment stored on the contract in order for the request to be valid
+   * Emits CancelOracleRequest event.
+   * @param _requestId The request ID
+   * @param _payment The amount of payment given (specified in wei)
+   * @param _callbackFunc The requester's specified callback address
+   * @param _expiration The time of the expiration for the request
+   */
+  function cancelOracleRequest(
+    bytes32 _requestId,
+    uint256 _payment,
+    bytes4 _callbackFunc,
+    uint256 _expiration
+  ) external {
+    bytes32 paramsHash = keccak256(
+      abi.encodePacked(
+        _payment,
+        msg.sender,
+        _callbackFunc,
+        _expiration)
+    );
+    require(paramsHash == commitments[_requestId], "Params do not match request ID");
+    // solhint-disable-next-line not-rely-on-time
+    require(_expiration <= now, "Request is not expired");
+
+    delete commitments[_requestId];
+    emit CancelOracleRequest(_requestId);
+
+    assert(LinkToken.transfer(msg.sender, _payment));
+  }
+
+  /**
+   * @notice Returns the address of the LINK token
+   * @dev This is the public implementation for chainlinkTokenAddress, which is
+   * an internal method of the ChainlinkClient contract
+   */
+  function getChainlinkToken() public view returns (address) {
+    return address(LinkToken);
+  }
+
+  // MODIFIERS
+
+  /**
+   * @dev Reverts if amount requested is greater than withdrawable balance
+   * @param _amount The given amount to compare to `withdrawableTokens`
+   */
+  modifier hasAvailableFunds(uint256 _amount) {
+    require(withdrawableTokens >= _amount.add(ONE_FOR_CONSISTENT_GAS_COST), "Amount requested is greater than withdrawable balance");
+    _;
+  }
+
+  /**
+   * @dev Reverts if request ID does not exist
+   * @param _requestId The given request ID to check in stored `commitments`
+   */
+  modifier isValidRequest(bytes32 _requestId) {
+    require(commitments[_requestId] != 0, "Must have a valid requestId");
+    _;
+  }
+
+  /**
+   * @dev Reverts if `msg.sender` is not authorized to fulfill requests
+   */
+  modifier onlyAuthorizedNode() {
+    require(authorizedNodes[msg.sender] || msg.sender == owner(), "Not an authorized node to fulfill requests");
+    _;
+  }
+
+  /**
+   * @dev Reverts if the callback address is the LINK token
+   * @param _to The callback address
+   */
+  modifier checkCallbackAddress(address _to) {
+    require(_to != address(LinkToken), "Cannot callback to LINK");
+    _;
+  }
+
+}

package/v0.5/contracts/PreCoordinator.sol

@@ -0,0 +1,305 @@
+pragma solidity 0.5.0;
+
+import "./ChainlinkClient.sol";
+import "./LinkTokenReceiver.sol";
+import "./Median.sol";
+import "./vendor/Ownable.sol";
+import "./vendor/SafeMath.sol";
+
+/**
+ * @title PreCoordinator is a contract that builds on-chain service agreements
+ * using the current architecture of 1 request to 1 oracle contract.
+ * @dev This contract accepts requests as service agreement IDs and loops over
+ * the corresponding list of oracles to create distinct requests to each one.
+ */
+contract PreCoordinator is ChainlinkClient, Ownable, ChainlinkRequestInterface, LinkTokenReceiver {
+  using SafeMath for uint256;
+
+  uint256 constant private MAX_ORACLE_COUNT = 45;
+
+  uint256 private globalNonce;
+
+  struct ServiceAgreement {
+    uint256 totalPayment;
+    uint256 minResponses;
+    uint256 activeRequests;
+    address[] oracles;
+    bytes32[] jobIds;
+    uint256[] payments;
+  }
+
+  struct Requester {
+    bytes4 callbackFunctionId;
+    address sender;
+    address callbackAddress;
+    int256[] responses;
+  }
+
+  // Service Agreement ID => ServiceAgreement
+  mapping(bytes32 => ServiceAgreement) internal serviceAgreements;
+  // Local Request ID => Service Agreement ID
+  mapping(bytes32 => bytes32) internal serviceAgreementRequests;
+  // Requester's Request ID => Requester
+  mapping(bytes32 => Requester) internal requesters;
+  // Local Request ID => Requester's Request ID
+  mapping(bytes32 => bytes32) internal requests;
+
+  event NewServiceAgreement(bytes32 indexed saId, uint256 payment, uint256 minresponses);
+  event ServiceAgreementRequested(bytes32 indexed saId, bytes32 indexed requestId, uint256 payment);
+  event ServiceAgreementResponseReceived(bytes32 indexed saId, bytes32 indexed requestId, address indexed oracle, int256 answer);
+  event ServiceAgreementAnswerUpdated(bytes32 indexed saId, bytes32 indexed requestId, int256 answer);
+  event ServiceAgreementDeleted(bytes32 indexed saId);
+
+  /**
+   * @notice Deploy the contract with a specified address for the LINK
+   * and Oracle contract addresses
+   * @dev Sets the storage for the specified addresses
+   * @param _link The address of the LINK token contract
+   */
+  constructor(address _link) public {
+    if(_link == address(0)) {
+      setPublicChainlinkToken();
+    } else {
+      setChainlinkToken(_link);
+    }
+  }
+
+  /**
+   * @notice Allows the owner of the contract to create new service agreements
+   * with multiple oracles. Each oracle will have their own Job ID and can have
+   * their own payment amount.
+   * @dev The globalNonce keeps service agreement IDs unique. Assume one cannot
+   * create the max uint256 number of service agreements in the same block.
+   * @param _minResponses The minimum number of responses before the requesting
+   * contract is called with the response data.
+   * @param _oracles The list of oracle contract addresses.
+   * @param _jobIds The corresponding list of Job IDs.
+   * @param _payments The corresponding list of payment amounts.
+   */
+  function createServiceAgreement(
+    uint256 _minResponses,
+    address[] calldata _oracles,
+    bytes32[] calldata _jobIds,
+    uint256[] calldata _payments
+  )
+    external onlyOwner returns (bytes32 saId)
+  {
+    require(_minResponses > 0, "Min responses must be > 0");
+    require(_oracles.length == _jobIds.length && _oracles.length == _payments.length, "Unmet length");
+    require(_oracles.length <= MAX_ORACLE_COUNT, "Cannot have more than 45 oracles");
+    require(_oracles.length >= _minResponses, "Invalid min responses");
+    uint256 totalPayment;
+    for (uint i = 0; i < _payments.length; i++) {
+      totalPayment = totalPayment.add(_payments[i]);
+    }
+    saId = keccak256(abi.encodePacked(globalNonce, now));
+    globalNonce++; // yes, let it overflow
+    serviceAgreements[saId] = ServiceAgreement(totalPayment, _minResponses, 0, _oracles, _jobIds, _payments);
+
+    emit NewServiceAgreement(saId, totalPayment, _minResponses);
+  }
+
+  /**
+   * @notice This is a helper function to retrieve the details of a service agreement
+   * by its given service agreement ID.
+   * @dev This function is used instead of the public mapping to return the values
+   * of the arrays: oracles, jobIds, and payments.
+   */
+  function getServiceAgreement(bytes32 _saId)
+    external view returns
+  (
+    uint256 totalPayment,
+    uint256 minResponses,
+    uint256 activeRequests,
+    address[] memory oracles,
+    bytes32[] memory jobIds,
+    uint256[] memory payments
+  )
+  {
+    return
+    (
+      serviceAgreements[_saId].totalPayment,
+      serviceAgreements[_saId].minResponses,
+      serviceAgreements[_saId].activeRequests,
+      serviceAgreements[_saId].oracles,
+      serviceAgreements[_saId].jobIds,
+      serviceAgreements[_saId].payments
+    );
+  }
+
+  /**
+   * @notice Deletes a service agreement from storage
+   * @dev Use this with caution since there may be responses waiting to come
+   * back for a service agreement. This can be monitored off-chain by looking
+   * for the ServiceAgreementRequested event.
+   * @param _saId The service agreement ID
+   */
+  function deleteServiceAgreement(bytes32 _saId)
+    external
+    onlyOwner
+    whenNotActive(_saId)
+  {
+    delete serviceAgreements[_saId];
+    emit ServiceAgreementDeleted(_saId);
+  }
+
+  /**
+   * @notice Returns the address of the LINK token
+   * @dev This is the public implementation for chainlinkTokenAddress, which is
+   * an internal method of the ChainlinkClient contract
+   */
+  function getChainlinkToken() public view returns (address) {
+    return chainlinkTokenAddress();
+  }
+
+  /**
+   * @notice Creates the Chainlink request
+   * @dev Stores the hash of the params as the on-chain commitment for the request.
+   * Emits OracleRequest event for the Chainlink node to detect.
+   * @param _sender The sender of the request
+   * @param _payment The amount of payment given (specified in wei)
+   * @param _saId The Job Specification ID
+   * @param _callbackAddress The callback address for the response
+   * @param _callbackFunctionId The callback function ID for the response
+   * @param _nonce The nonce sent by the requester
+   * @param _data The CBOR payload of the request
+   */
+  function oracleRequest(
+    address _sender,
+    uint256 _payment,
+    bytes32 _saId,
+    address _callbackAddress,
+    bytes4 _callbackFunctionId,
+    uint256 _nonce,
+    uint256,
+    bytes calldata _data
+  )
+    external
+    onlyLINK
+    checkCallbackAddress(_callbackAddress)
+  {
+    uint256 totalPayment = serviceAgreements[_saId].totalPayment;
+    // this revert message does not bubble up
+    require(_payment >= totalPayment, "Insufficient payment");
+    bytes32 callbackRequestId = keccak256(abi.encodePacked(_sender, _nonce));
+    require(requesters[callbackRequestId].sender == address(0), "Nonce already in-use");
+    requesters[callbackRequestId].callbackFunctionId = _callbackFunctionId;
+    requesters[callbackRequestId].callbackAddress = _callbackAddress;
+    requesters[callbackRequestId].sender = _sender;
+    createRequests(_saId, callbackRequestId, _data);
+    if (_payment > totalPayment) {
+      uint256 overage = _payment.sub(totalPayment);
+      LinkTokenInterface _link = LinkTokenInterface(chainlinkTokenAddress());
+      assert(_link.transfer(_sender, overage));
+    }
+  }
+
+  /**
+   * @dev Creates Chainlink requests to each oracle in the service agreement with the
+   * same data payload supplied by the requester
+   * @param _saId The service agreement ID
+   * @param _incomingRequestId The requester-supplied request ID
+   * @param _data The data payload (request parameters) to send to each oracle
+   */
+  function createRequests(bytes32 _saId, bytes32 _incomingRequestId, bytes memory _data) private {
+    ServiceAgreement memory sa = serviceAgreements[_saId];
+    require(sa.minResponses > 0, "Invalid service agreement");
+    Chainlink.Request memory request;
+    bytes32 outgoingRequestId;
+    serviceAgreements[_saId].activeRequests = serviceAgreements[_saId].activeRequests.add(1);
+    emit ServiceAgreementRequested(_saId, _incomingRequestId, sa.totalPayment);
+    for (uint i = 0; i < sa.oracles.length; i++) {
+      request = buildChainlinkRequest(sa.jobIds[i], address(this), this.chainlinkCallback.selector);
+      request.setBuffer(_data);
+      outgoingRequestId = sendChainlinkRequestTo(sa.oracles[i], request, sa.payments[i]);
+      requests[outgoingRequestId] = _incomingRequestId;
+      serviceAgreementRequests[outgoingRequestId] = _saId;
+    }
+  }
+
+  /**
+   * @notice The fulfill method from requests created by this contract
+   * @dev The recordChainlinkFulfillment protects this function from being called
+   * by anyone other than the oracle address that the request was sent to
+   * @param _requestId The ID that was generated for the request
+   * @param _data The answer provided by the oracle
+   */
+  function chainlinkCallback(bytes32 _requestId, int256 _data)
+    external
+    recordChainlinkFulfillment(_requestId)
+    returns (bool)
+  {
+    uint256 minResponses = serviceAgreements[serviceAgreementRequests[_requestId]].minResponses;
+    bytes32 cbRequestId = requests[_requestId];
+    bytes32 saId = serviceAgreementRequests[_requestId];
+    delete requests[_requestId];
+    delete serviceAgreementRequests[_requestId];
+    emit ServiceAgreementResponseReceived(saId, cbRequestId, msg.sender, _data);
+    if (requesters[cbRequestId].responses.push(_data) == minResponses) {
+      serviceAgreements[saId].activeRequests = serviceAgreements[saId].activeRequests.sub(1);
+      Requester memory req = requesters[cbRequestId];
+      delete requesters[cbRequestId];
+      int256 result = Median.calculate(req.responses);
+      emit ServiceAgreementAnswerUpdated(saId, cbRequestId, result);
+      // solhint-disable-next-line avoid-low-level-calls
+      (bool success, ) = req.callbackAddress.call(abi.encodeWithSelector(req.callbackFunctionId, cbRequestId, result));
+      return success;
+    }
+    return true;
+  }
+
+  /**
+   * @notice Allows the owner to withdraw any LINK balance on the contract
+   * @dev The only valid case for there to be remaining LINK on this contract
+   * is if a user accidentally sent LINK directly to this contract's address.
+   */
+  function withdrawLink() external onlyOwner {
+    LinkTokenInterface _link = LinkTokenInterface(chainlinkTokenAddress());
+    require(_link.transfer(msg.sender, _link.balanceOf(address(this))), "Unable to transfer");
+  }
+
+  /**
+   * @notice Call this method if no response is received within 5 minutes
+   * @param _requestId The ID that was generated for the request to cancel
+   * @param _payment The payment specified for the request to cancel
+   * @param _callbackFunctionId The bytes4 callback function ID specified for
+   * the request to cancel
+   * @param _expiration The expiration generated for the request to cancel
+   */
+  function cancelOracleRequest(
+    bytes32 _requestId,
+    uint256 _payment,
+    bytes4 _callbackFunctionId,
+    uint256 _expiration
+  )
+    external
+  {
+    bytes32 cbRequestId = requests[_requestId];
+    delete requests[_requestId];
+    delete serviceAgreementRequests[_requestId];
+    Requester memory req = requesters[cbRequestId];
+    require(req.sender == msg.sender, "Only requester can cancel");
+    delete requesters[cbRequestId];
+    cancelChainlinkRequest(_requestId, _payment, _callbackFunctionId, _expiration);
+    LinkTokenInterface _link = LinkTokenInterface(chainlinkTokenAddress());
+    require(_link.transfer(req.sender, _payment), "Unable to transfer");
+  }
+
+  /**
+   * @dev Reverts if the Service Agreement has active callbacks
+   * @param _saId The service agreement ID
+   */
+  modifier whenNotActive(bytes32 _saId) {
+    require(serviceAgreements[_saId].activeRequests == 0, "Cannot delete while active");
+    _;
+  }
+
+  /**
+   * @dev Reverts if the callback address is the LINK token
+   * @param _to The callback address
+   */
+  modifier checkCallbackAddress(address _to) {
+    require(_to != chainlinkTokenAddress(), "Cannot callback to LINK");
+    _;
+  }
+}

package/v0.5/contracts/dev/AggregatorInterface.sol

@@ -0,0 +1,12 @@
+pragma solidity ^0.5.0;
+
+interface AggregatorInterface {
+  function latestAnswer() external view returns (int256);
+  function latestTimestamp() external view returns (uint256);
+  function latestRound() external view returns (uint256);
+  function getAnswer(uint256 roundId) external view returns (int256);
+  function getTimestamp(uint256 roundId) external view returns (uint256);
+
+  event AnswerUpdated(int256 indexed current, uint256 indexed roundId, uint256 timestamp);
+  event NewRound(uint256 indexed roundId, address indexed startedBy);
+}