chanlink 0.0.1-security → 0.8.2

package/contracts/Oracle.sol

@@ -0,0 +1,320 @@
+pragma solidity 0.4.24;
+
+import "./vendor/Ownable.sol";
+import "./vendor/SafeMath.sol";
+import "./interfaces/ChainlinkRequestInterface.sol";
+import "./interfaces/OracleInterface.sol";
+import "./interfaces/LinkTokenInterface.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 {
+  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;
+  uint256 constant private SELECTOR_LENGTH = 4;
+  uint256 constant private EXPECTED_REQUEST_WORDS = 2;
+  uint256 constant private MINIMUM_REQUEST_LENGTH = SELECTOR_LENGTH + (32 * EXPECTED_REQUEST_WORDS);
+
+  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 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 _data
+  )
+    public
+    onlyLINK
+    validRequestLength(_data)
+    permittedFunctionsForLINK(_data)
+  {
+    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
+    require(address(this).delegatecall(_data), "Unable to create request"); // calls oracleRequest
+  }
+
+  /**
+   * @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 _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
+    return _callbackAddress.call(_callbackFunctionId, _requestId, _data); // solhint-disable-line avoid-low-level-calls
+  }
+
+  /**
+   * @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));
+  }
+
+  // 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 not sent from the LINK token
+   */
+  modifier onlyLINK() {
+    require(msg.sender == address(LinkToken), "Must use LINK token");
+    _;
+  }
+
+  /**
+   * @dev Reverts if the given data does not begin with the `oracleRequest` function selector
+   * @param _data The data payload of the request
+   */
+  modifier permittedFunctionsForLINK(bytes _data) {
+    bytes4 funcSelector;
+    assembly { // solhint-disable-line no-inline-assembly
+      funcSelector := mload(add(_data, 32))
+    }
+    require(funcSelector == this.oracleRequest.selector, "Must use whitelisted functions");
+    _;
+  }
+
+  /**
+   * @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");
+    _;
+  }
+
+  /**
+   * @dev Reverts if the given payload is less than needed to create a request
+   * @param _data The request payload
+   */
+  modifier validRequestLength(bytes _data) {
+    require(_data.length >= MINIMUM_REQUEST_LENGTH, "Invalid request length");
+    _;
+  }
+
+}

package/contracts/Pointer.sol

@@ -0,0 +1,9 @@
+pragma solidity 0.4.24;
+
+contract Pointer {
+  address public getAddress;
+
+  constructor(address _addr) public {
+    getAddress = _addr;
+  }
+}

package/contracts/interfaces/AggregatorInterface.sol

@@ -0,0 +1,12 @@
+pragma solidity ^0.4.24;
+
+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);
+}

package/contracts/interfaces/ChainlinkRequestInterface.sol

@@ -0,0 +1,21 @@
+pragma solidity ^0.4.24;
+
+interface ChainlinkRequestInterface {
+  function oracleRequest(
+    address sender,
+    uint256 payment,
+    bytes32 id,
+    address callbackAddress,
+    bytes4 callbackFunctionId,
+    uint256 nonce,
+    uint256 version,
+    bytes data
+  ) external;
+
+  function cancelOracleRequest(
+    bytes32 requestId,
+    uint256 payment,
+    bytes4 callbackFunctionId,
+    uint256 expiration
+  ) external;
+}

package/contracts/interfaces/ENSInterface.sol

@@ -0,0 +1,26 @@
+pragma solidity ^0.4.24;
+
+interface ENSInterface {
+
+  // Logged when the owner of a node assigns a new owner to a subnode.
+  event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);
+
+  // Logged when the owner of a node transfers ownership to a new account.
+  event Transfer(bytes32 indexed node, address owner);
+
+  // Logged when the resolver for a node changes.
+  event NewResolver(bytes32 indexed node, address resolver);
+
+  // Logged when the TTL of a node changes
+  event NewTTL(bytes32 indexed node, uint64 ttl);
+
+
+  function setSubnodeOwner(bytes32 node, bytes32 label, address owner) external;
+  function setResolver(bytes32 node, address resolver) external;
+  function setOwner(bytes32 node, address owner) external;
+  function setTTL(bytes32 node, uint64 ttl) external;
+  function owner(bytes32 node) external view returns (address);
+  function resolver(bytes32 node) external view returns (address);
+  function ttl(bytes32 node) external view returns (uint64);
+
+}

package/contracts/interfaces/LinkTokenInterface.sol

@@ -0,0 +1,16 @@
+pragma solidity ^0.4.24;
+
+interface LinkTokenInterface {
+  function allowance(address owner, address spender) external returns (uint256 remaining);
+  function approve(address spender, uint256 value) external returns (bool success);
+  function balanceOf(address owner) external returns (uint256 balance);
+  function decimals() external returns (uint8 decimalPlaces);
+  function decreaseApproval(address spender, uint256 addedValue) external returns (bool success);
+  function increaseApproval(address spender, uint256 subtractedValue) external;
+  function name() external returns (string tokenName);
+  function symbol() external returns (string tokenSymbol);
+  function totalSupply() external returns (uint256 totalTokensIssued);
+  function transfer(address to, uint256 value) external returns (bool success);
+  function transferAndCall(address to, uint256 value, bytes data) external returns (bool success);
+  function transferFrom(address from, address to, uint256 value) external returns (bool success);
+}

package/contracts/interfaces/OracleInterface.sol

@@ -0,0 +1,16 @@
+pragma solidity ^0.4.24;
+
+interface OracleInterface {
+  function fulfillOracleRequest(
+    bytes32 requestId,
+    uint256 payment,
+    address callbackAddress,
+    bytes4 callbackFunctionId,
+    uint256 expiration,
+    bytes32 data
+  ) external returns (bool);
+  function getAuthorizationStatus(address node) external view returns (bool);
+  function setFulfillmentPermission(address node, bool allowed) external;
+  function withdraw(address recipient, uint256 amount) external;
+  function withdrawable() external view returns (uint256);
+}

package/contracts/interfaces/PointerInterface.sol

@@ -0,0 +1,5 @@
+pragma solidity ^0.4.24;
+
+interface PointerInterface {
+  function getAddress() external view returns (address);
+}

package/contracts/tests/BasicConsumer.sol

@@ -0,0 +1,13 @@
+pragma solidity 0.4.24;
+
+import "./Consumer.sol";
+
+contract BasicConsumer is Consumer {
+
+  constructor(address _link, address _oracle, bytes32 _specId) public {
+    setChainlinkToken(_link);
+    setChainlinkOracle(_oracle);
+    specId = _specId;
+  }
+
+}

package/contracts/tests/ConcreteChainlink.sol

@@ -0,0 +1,76 @@
+pragma solidity 0.4.24;
+
+import "../Chainlink.sol";
+import "../vendor/CBOR.sol";
+
+contract ConcreteChainlink {
+  using Chainlink for Chainlink.Request;
+  using CBOR for Buffer.buffer;
+
+  Chainlink.Request private req;
+
+  event RequestData(bytes payload);
+
+  function closeEvent() public {
+    emit RequestData(req.buf.buf);
+  }
+
+  function setBuffer(bytes data) public {
+    Chainlink.Request memory r2 = req;
+    r2.setBuffer(data);
+    req = r2;
+  }
+
+  function add(string _key, string _value) public {
+    Chainlink.Request memory r2 = req;
+    r2.add(_key, _value);
+    req = r2;
+  }
+
+  function addBytes(string _key, bytes _value) public {
+    Chainlink.Request memory r2 = req;
+    r2.addBytes(_key, _value);
+    req = r2;
+  }
+
+  function addInt(string _key, int256 _value) public {
+    Chainlink.Request memory r2 = req;
+    r2.addInt(_key, _value);
+    req = r2;
+  }
+
+  function addUint(string _key, uint256 _value) public {
+    Chainlink.Request memory r2 = req;
+    r2.addUint(_key, _value);
+    req = r2;
+  }
+
+  // Temporarily have method receive bytes32[] memory until experimental
+  // string[] memory can be invoked from truffle tests.
+  function addStringArray(string _key, bytes32[] memory _values) public {
+    string[] memory strings = new string[](_values.length);
+    for (uint256 i = 0; i < _values.length; i++) {
+      strings[i] = bytes32ToString(_values[i]);
+    }
+    Chainlink.Request memory r2 = req;
+    r2.addStringArray(_key, strings);
+    req = r2;
+  }
+
+  function bytes32ToString(bytes32 x) private pure returns (string) {
+    bytes memory bytesString = new bytes(32);
+    uint charCount = 0;
+    for (uint j = 0; j < 32; j++) {
+      byte char = byte(bytes32(uint(x) * 2 ** (8 * j)));
+      if (char != 0) {
+        bytesString[charCount] = char;
+        charCount++;
+      }
+    }
+    bytes memory bytesStringTrimmed = new bytes(charCount);
+    for (j = 0; j < charCount; j++) {
+      bytesStringTrimmed[j] = bytesString[j];
+    }
+    return string(bytesStringTrimmed);
+  }
+}

package/contracts/tests/ConcreteChainlinked.sol

@@ -0,0 +1,100 @@
+pragma solidity 0.4.24;
+
+import "../Chainlinked.sol";
+
+
+contract ConcreteChainlinked is Chainlinked {
+
+  constructor(address _link, address _oracle) public {
+    setLinkToken(_link);
+    setOracle(_oracle);
+  }
+
+  event Request(
+    bytes32 id,
+    address callbackAddress,
+    bytes4 callbackfunctionSelector,
+    bytes data
+  );
+
+  function publicNewRequest(
+    bytes32 _id,
+    address _address,
+    bytes _fulfillmentSignature
+  )
+    public
+  {
+    Chainlink.Request memory req = newRequest(
+      _id, _address, bytes4(keccak256(_fulfillmentSignature)));
+    emit Request(
+      req.id,
+      req.callbackAddress,
+      req.callbackFunctionId,
+      req.buf.buf
+    );
+  }
+
+  function publicRequest(
+    bytes32 _id,
+    address _address,
+    bytes _fulfillmentSignature,
+    uint256 _wei
+  )
+    public
+  {
+    Chainlink.Request memory req = newRequest(
+      _id, _address, bytes4(keccak256(_fulfillmentSignature)));
+    chainlinkRequest(req, _wei);
+  }
+
+  function publicRequestRunTo(
+    address _oracle,
+    bytes32 _id,
+    address _address,
+    bytes _fulfillmentSignature,
+    uint256 _wei
+  )
+    public
+  {
+    Chainlink.Request memory run = newRequest(_id, _address, bytes4(keccak256(_fulfillmentSignature)));
+    chainlinkRequestTo(_oracle, run, _wei);
+  }
+
+  function publicCancelRequest(
+    bytes32 _requestId,
+    uint256 _payment,
+    bytes4 _callbackFunctionId,
+    uint256 _expiration
+  ) public {
+    cancelChainlinkRequest(_requestId, _payment, _callbackFunctionId, _expiration);
+  }
+
+  function publicChainlinkToken() public view returns (address) {
+    return chainlinkToken();
+  }
+
+  function fulfillRequest(bytes32 _requestId, bytes32)
+    public
+    recordChainlinkFulfillment(_requestId)
+  {} // solhint-disable-line no-empty-blocks
+
+  function publicFulfillChainlinkRequest(bytes32 _requestId, bytes32) public {
+    fulfillChainlinkRequest(_requestId);
+  }
+
+  event LinkAmount(uint256 amount);
+
+  function publicLINK(uint256 _amount) public {
+    emit LinkAmount(LINK.mul(_amount));
+  }
+
+  function publicOracleAddress() public view returns (address) {
+    return oracleAddress();
+  }
+
+  function publicAddExternalRequest(address _oracle, bytes32 _requestId)
+    public
+  {
+    addExternalRequest(_oracle, _requestId);
+  }
+}

package/contracts/tests/ConcreteSignedSafeMath.sol

@@ -0,0 +1,16 @@
+pragma solidity 0.4.24;
+
+import "../vendor/SignedSafeMath.sol";
+
+contract ConcreteSignedSafeMath {
+  using SignedSafeMath for int256;
+
+  function testAdd(int256 _a, int256 _b)
+    external
+    pure
+    returns (int256)
+  {
+    return _a.add(_b);
+  }
+
+}

package/contracts/tests/Consumer.sol

@@ -0,0 +1,47 @@
+pragma solidity 0.4.24;
+
+import "../ChainlinkClient.sol";
+
+contract Consumer is ChainlinkClient {
+  bytes32 internal specId;
+  bytes32 public currentPrice;
+
+  uint256 constant private ORACLE_PAYMENT = 1 * LINK;
+
+  event RequestFulfilled(
+    bytes32 indexed requestId,  // User-defined ID
+    bytes32 indexed price
+  );
+
+  function requestEthereumPrice(string _currency) public {
+    Chainlink.Request memory req = buildChainlinkRequest(specId, this, this.fulfill.selector);
+    req.add("get", "https://min-api.cryptocompare.com/data/price?fsym=ETH&tsyms=USD,EUR,JPY");
+    string[] memory path = new string[](1);
+    path[0] = _currency;
+    req.addStringArray("path", path);
+    sendChainlinkRequest(req, ORACLE_PAYMENT);
+  }
+
+  function cancelRequest(
+    bytes32 _requestId,
+    uint256 _payment,
+    bytes4 _callbackFunctionId,
+    uint256 _expiration
+  ) public {
+    cancelChainlinkRequest(_requestId, _payment, _callbackFunctionId, _expiration);
+  }
+
+  function withdrawLink() public {
+    LinkTokenInterface link = LinkTokenInterface(chainlinkTokenAddress());
+    require(link.transfer(msg.sender, link.balanceOf(address(this))), "Unable to transfer");
+  }
+
+  function fulfill(bytes32 _requestId, bytes32 _price)
+    public
+    recordChainlinkFulfillment(_requestId)
+  {
+    emit RequestFulfilled(_requestId, _price);
+    currentPrice = _price;
+  }
+
+}