chai-link 0.8.2

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

@@ -0,0 +1,411 @@
+pragma solidity 0.5.0;
+
+import "./CoordinatorInterface.sol";
+import "../interfaces/ChainlinkRequestInterface.sol";
+import "../interfaces/LinkTokenInterface.sol";
+import "../vendor/SafeMath.sol";
+import "./ServiceAgreementDecoder.sol";
+import "./OracleSignaturesDecoder.sol";
+
+
+/**
+ * @title The Chainlink Coordinator handles oracle service aggreements between one or more oracles
+ */
+contract Coordinator is ChainlinkRequestInterface, CoordinatorInterface, ServiceAgreementDecoder, OracleSignaturesDecoder {
+  using SafeMath for uint256;
+
+  uint256 constant public EXPIRY_TIME = 5 minutes;
+  LinkTokenInterface internal LINK;
+
+  struct Callback {
+    bytes32 sAId;
+    uint256 amount;
+    address addr;
+    bytes4 functionId;
+    uint64 cancelExpiration;
+    uint8 responseCount;
+    mapping(address => uint256) responses;
+  }
+
+  mapping(bytes32 => Callback) private callbacks;
+  mapping(bytes32 => mapping(address => bool)) private allowedOracles;
+  mapping(bytes32 => ServiceAgreement) public serviceAgreements;
+  mapping(address => uint256) public withdrawableTokens;
+
+  /**
+   * @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 {
+    LINK = LinkTokenInterface(_link);
+  }
+
+  event OracleRequest(
+    bytes32 indexed sAId,
+    address requester,
+    bytes32 requestId,
+    uint256 payment,
+    address callbackAddr,
+    bytes4 callbackFunctionId,
+    uint256 cancelExpiration,
+    uint256 dataVersion,
+    bytes data
+  );
+
+  event NewServiceAgreement(
+    bytes32 indexed said,
+    bytes32 indexed requestDigest
+  );
+
+  event CancelOracleRequest(
+    bytes32 internalId
+  );
+
+  /**
+   * @notice Creates the Chainlink request
+   * @dev Stores the params on-chain in a callback for the request.
+   * Emits OracleRequest event for Chainlink nodes to detect.
+   * @param _sender The sender of the request
+   * @param _amount The amount of payment given (specified in wei)
+   * @param _sAId The Service Agreement 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 _amount,
+    bytes32 _sAId,
+    address _callbackAddress,
+    bytes4 _callbackFunctionId,
+    uint256 _nonce,
+    uint256 _dataVersion,
+    bytes calldata _data
+  )
+    external
+    onlyLINK
+    sufficientLINK(_amount, _sAId)
+    checkCallbackAddress(_callbackAddress)
+    // checkServiceAgreementPresence(_sAId) // TODO: exhausts the stack
+  {
+    bytes32 requestId = keccak256(abi.encodePacked(_sender, _nonce));
+    require(callbacks[requestId].cancelExpiration == 0, "Must use a unique ID");
+    callbacks[requestId].sAId = _sAId;
+    callbacks[requestId].amount = _amount;
+    callbacks[requestId].addr = _callbackAddress;
+    callbacks[requestId].functionId = _callbackFunctionId;
+    // solhint-disable-next-line not-rely-on-time
+    callbacks[requestId].cancelExpiration = uint64(now.add(EXPIRY_TIME));
+
+    emit OracleRequest(
+      _sAId,
+      _sender,
+      requestId,
+      _amount,
+      _callbackAddress,
+      _callbackFunctionId,
+      now.add(EXPIRY_TIME), // solhint-disable-line not-rely-on-time
+      _dataVersion,
+      _data);
+  }
+
+  /**
+   * @notice Stores a Service Agreement which has been signed by the given oracles
+   * @dev Validates that each oracle has a valid signature.
+   * Emits NewServiceAgreement event.
+   * @return The Service Agreement ID
+   */
+  function initiateServiceAgreement(
+    bytes memory _serviceAgreementData,
+    bytes memory _oracleSignaturesData
+  )
+    public
+    returns (bytes32 serviceAgreementID)
+  {
+
+    ServiceAgreement memory _agreement = decodeServiceAgreement(_serviceAgreementData);
+    OracleSignatures memory _signatures = decodeOracleSignatures(_oracleSignaturesData);
+
+    require(
+      _agreement.oracles.length == _signatures.vs.length &&
+      _signatures.vs.length == _signatures.rs.length &&
+      _signatures.rs.length == _signatures.ss.length,
+      "Must pass in as many signatures as oracles"
+    );
+    // solhint-disable-next-line not-rely-on-time
+    require(_agreement.endAt > block.timestamp,
+      "ServiceAgreement must end in the future");
+    require(serviceAgreements[serviceAgreementID].endAt == 0,
+      "serviceAgreement already initiated");
+    serviceAgreementID = getId(_agreement);
+
+    registerOracleSignatures(
+      serviceAgreementID,
+      _agreement.oracles,
+      _signatures
+    );
+
+    serviceAgreements[serviceAgreementID] = _agreement;
+    emit NewServiceAgreement(serviceAgreementID, _agreement.requestDigest);
+    // solhint-disable-next-line avoid-low-level-calls
+    (bool ok, bytes memory response) = _agreement.aggregator.call(
+      abi.encodeWithSelector(
+        _agreement.aggInitiateJobSelector,
+        serviceAgreementID,
+        _serviceAgreementData
+      )
+    );
+    require(ok, "Aggregator failed to initiate Service Agreement");
+    require(response.length > 0, "probably wrong address/selector");
+    (bool success, bytes memory message) = abi.decode(response, (bool, bytes));
+    if ((!success) && message.length == 0) {
+      // Revert with a non-empty message to give user a hint where to look
+      require(success, "initiation failed; empty message");
+    }
+    require(success, string(message));
+  }
+
+  /**
+   * @dev Validates that each signer address matches for the given oracles
+   * @param _serviceAgreementID Service agreement ID
+   * @param _oracles Array of oracle addresses which agreed to the service agreement
+   * @param _signatures contains the collected parts(v, r, and s) of each oracle's signature.
+   */
+  function registerOracleSignatures(
+    bytes32 _serviceAgreementID,
+    address[] memory _oracles,
+    OracleSignatures memory _signatures
+  )
+    private
+  {
+    for (uint i = 0; i < _oracles.length; i++) {
+      address signer = getOracleAddressFromSASignature(
+        _serviceAgreementID,
+        _signatures.vs[i],
+        _signatures.rs[i],
+        _signatures.ss[i]
+      );
+      require(_oracles[i] == signer, "Invalid oracle signature specified in SA");
+      allowedOracles[_serviceAgreementID][_oracles[i]] = true;
+    }
+
+  }
+
+  /**
+   * @dev Recovers the address of the signer for a service agreement
+   * @param _serviceAgreementID Service agreement ID
+   * @param _v Recovery ID of the oracle signature
+   * @param _r First 32 bytes of the oracle signature
+   * @param _s Second 32 bytes of the oracle signature
+   * @return The address of the signer
+   */
+  function getOracleAddressFromSASignature(
+    bytes32 _serviceAgreementID,
+    uint8 _v,
+    bytes32 _r,
+    bytes32 _s
+  )
+    private pure returns (address)
+  {
+    bytes32 prefixedHash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", _serviceAgreementID));
+    return ecrecover(prefixedHash, _v, _r, _s);
+  }
+
+  /**
+   * @notice Called by the Chainlink node to fulfill requests
+   * @dev Response must have a valid callback, and will delete the associated callback storage
+   * before calling the external contract.
+   * @param _requestId The fulfillment request ID that must match the requester's
+   * @param _data The data to return to the consuming contract
+   * @return Status if the external call was successful
+   */
+  function fulfillOracleRequest(
+    bytes32 _requestId,
+    bytes32 _data
+  ) external isValidRequest(_requestId) returns (bool) {
+    Callback memory callback = callbacks[_requestId];
+    ServiceAgreement memory sA = serviceAgreements[callback.sAId];
+    // solhint-disable-next-line avoid-low-level-calls
+    (bool ok, bytes memory aggResponse) = sA.aggregator.call(
+      abi.encodeWithSelector(
+        sA.aggFulfillSelector, _requestId, callback.sAId, msg.sender, _data));
+    require(ok, "aggregator.fulfill failed");
+    require(aggResponse.length > 0, "probably wrong address/selector");
+    (bool aggSuccess, bool aggComplete, bytes memory response, int256[] memory paymentAmounts) = abi.decode( // solhint-disable-line
+      aggResponse, (bool, bool, bytes, int256[]));
+    require(aggSuccess, string(response));
+    if (aggComplete) {
+      require(paymentAmounts.length == sA.oracles.length, "wrong paymentAmounts.length");
+      for (uint256 oIdx = 0; oIdx < sA.oracles.length; oIdx++) { // pay oracles
+        withdrawableTokens[sA.oracles[oIdx]] = uint256(int256(
+          withdrawableTokens[sA.oracles[oIdx]]) + paymentAmounts[oIdx]);
+      } // solhint-disable-next-line avoid-low-level-calls
+      (bool success,) = callback.addr.call(abi.encodeWithSelector( // report final result
+        callback.functionId, _requestId, abi.decode(response, (bytes32))));
+      return success;
+    }
+    return true;
+  }
+
+  /**
+   * @dev Allows the oracle operator to withdraw their LINK
+   * @param _recipient is the address the funds will be sent to
+   * @param _amount is the amount of LINK transfered from the Coordinator contract
+   */
+  function withdraw(address _recipient, uint256 _amount)
+    external
+    hasAvailableFunds(_amount)
+  {
+    withdrawableTokens[msg.sender] = withdrawableTokens[msg.sender].sub(_amount);
+    assert(LINK.transfer(_recipient, _amount));
+  }
+
+  /**
+   * @dev Necessary to implement ChainlinkRequestInterface
+   */
+  function cancelOracleRequest(bytes32, uint256, bytes4, uint256)
+    external
+  {} // solhint-disable-line no-empty-blocks
+
+  /**
+   * @notice Called when LINK is sent to the contract via `transferAndCall`
+   * @dev The data payload's first 2 words will be overwritten by the `_sender` and `_amount`
+   * values to ensure correctness. Calls oracleRequest.
+   * @param _sender Address of the sender
+   * @param _amount Amount of LINK sent (specified in wei)
+   * @param _data Payload of the transaction
+   */
+  function onTokenTransfer(
+    address _sender,
+    uint256 _amount,
+    bytes memory _data
+  )
+    public
+    onlyLINK
+    permittedFunctionsForLINK
+  {
+    assembly { // solhint-disable-line no-inline-assembly
+      mstore(add(_data, 36), _sender) // ensure correct sender is passed
+      mstore(add(_data, 68), _amount) // ensure correct amount is passed
+    }
+    // solhint-disable-next-line avoid-low-level-calls
+    (bool success,) = address(this).delegatecall(_data); // calls oracleRequest or depositFunds
+    require(success, "Unable to create request");
+  }
+
+  /**
+   * @notice Retrieve the Service Agreement ID for the given parameters
+   * @param _agreementData contains all of the terms of the service agreement that can be verified on-chain.
+   * @return The Service Agreement ID, a keccak256 hash of the input params
+   */
+  function getId(bytes memory _agreementData) public pure returns (bytes32)
+  {
+    ServiceAgreement memory _agreement = decodeServiceAgreement(_agreementData);
+    return getId(_agreement);
+  }
+
+  function getId(ServiceAgreement memory _agreement) internal pure returns (bytes32)
+  {
+    return keccak256(
+      abi.encodePacked(
+        _agreement.payment,
+        _agreement.expiration,
+        _agreement.endAt,
+        _agreement.oracles,
+        _agreement.requestDigest,
+        _agreement.aggregator,
+        _agreement.aggInitiateJobSelector,
+        _agreement.aggFulfillSelector
+    ));
+  }
+
+  /**
+   * @notice Called when LINK is sent to the contract via `transferAndCall`
+   * @param _sender Address of the sender
+   * @param _amount Amount of LINK sent (specified in wei)
+   */
+  function depositFunds(address _sender, uint256 _amount) external onlyLINK
+  {
+    withdrawableTokens[_sender] = withdrawableTokens[_sender].add(_amount);
+  }
+
+  /**
+   * @param _account Address to check balance of
+   * @return Balance of account (specified in wei)
+   */
+  function balanceOf(address _account) public view returns (uint256)
+  {
+    return withdrawableTokens[_account];
+  }
+
+  /**
+   * @dev Reverts if the callback address is the LINK token
+   * @param _to The callback address
+   */
+  modifier checkCallbackAddress(address _to) {
+    require(_to != address(LINK), "Cannot callback to LINK");
+    _;
+  }
+
+  /**
+   * @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[msg.sender] >= _amount, "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 `callbacks`
+   */
+  modifier isValidRequest(bytes32 _requestId) {
+    require(callbacks[_requestId].addr != address(0), "Must have a valid requestId");
+    require(allowedOracles[callbacks[_requestId].sAId][msg.sender], "Oracle not recognized on service agreement");
+    _;
+  }
+
+  /**
+   * @dev Reverts if amount is not at least what was agreed upon in the service agreement
+   * @param _amount The payment for the request
+   * @param _sAId The service agreement ID which the request is for
+   */
+  modifier sufficientLINK(uint256 _amount, bytes32 _sAId) {
+    require(_amount >= serviceAgreements[_sAId].payment, "Below agreed payment");
+    _;
+  }
+
+  /**
+   * @dev Reverts if the given data does not begin with the `oracleRequest` or
+   * `depositFunds` function selector
+   */
+  modifier permittedFunctionsForLINK() {
+    bytes4[1] memory funcSelector;
+    assembly { // solhint-disable-line no-inline-assembly
+      calldatacopy(funcSelector, 132, 4) // grab function selector from calldata
+    }
+    require(
+      funcSelector[0] == this.oracleRequest.selector || funcSelector[0] == this.depositFunds.selector,
+      "Must use whitelisted functions"
+    );
+    _;
+  }
+
+  modifier checkServiceAgreementPresence(bytes32 _sAId) {
+    require(uint256(serviceAgreements[_sAId].requestDigest) != 0,
+            "Must reference an existing ServiceAgreement");
+    _;
+  }
+
+  /**
+   * @dev Reverts if not sent from the LINK token
+   */
+  modifier onlyLINK() {
+    require(msg.sender == address(LINK), "Must use LINK token");
+    _;
+  }
+}

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

@@ -0,0 +1,14 @@
+pragma solidity 0.5.0;
+
+contract CoordinatorInterface {
+
+  function initiateServiceAgreement(
+    bytes memory _serviceAgreementData,
+    bytes memory _oracleSignaturesData)
+    public returns (bytes32);
+
+  function fulfillOracleRequest(
+    bytes32 _requestId,
+    bytes32 _aggregatorArgs)
+    external returns (bool);
+}

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

@@ -0,0 +1,24 @@
+pragma solidity 0.5.0;
+
+contract OracleSignaturesDecoder {
+
+  struct OracleSignatures {
+    uint8[] vs;
+    bytes32[] rs;
+    bytes32[] ss;
+  }
+
+  function decodeOracleSignatures(
+    bytes memory _oracleSignaturesData
+  )
+    internal
+    pure
+    returns(OracleSignatures memory)
+  {
+    // solhint-disable indent
+    OracleSignatures memory signatures;
+    ( signatures.vs, signatures.rs, signatures.ss) =
+      abi.decode(_oracleSignaturesData, ( uint8[], bytes32[], bytes32[] ));
+    return signatures;
+  }
+}

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

@@ -0,0 +1,61 @@
+pragma solidity 0.5.0;
+
+/**
+ * @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 OwnershipTransfered(
+    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 OwnershipTransfered(oldOwner, msg.sender);
+  }
+
+  /**
+   * @dev Reverts if called by anyone other than the contract owner.
+   */
+  modifier onlyOwner() {
+    require(msg.sender == owner, "Only callable by owner");
+    _;
+  }
+
+}