chai-link 0.8.2

package/v0.6/contracts/ChainlinkClient.sol

@@ -0,0 +1,263 @@
+pragma solidity ^0.6.0;
+
+import "./Chainlink.sol";
+import "./interfaces/ENSInterface.sol";
+import "./interfaces/LinkTokenInterface.sol";
+import "./interfaces/ChainlinkRequestInterface.sol";
+import "./interfaces/PointerInterface.sol";
+import { ENSResolver as ENSResolver_Chainlink } from "./vendor/ENSResolver.sol";
+import { SafeMath as SafeMath_Chainlink } from "./vendor/SafeMath.sol";
+
+/**
+ * @title The ChainlinkClient contract
+ * @notice Contract writers can inherit this contract in order to create requests for the
+ * Chainlink network
+ */
+contract ChainlinkClient {
+  using Chainlink for Chainlink.Request;
+  using SafeMath_Chainlink for uint256;
+
+  uint256 constant internal LINK = 10**18;
+  uint256 constant private AMOUNT_OVERRIDE = 0;
+  address constant private SENDER_OVERRIDE = address(0);
+  uint256 constant private ARGS_VERSION = 1;
+  bytes32 constant private ENS_TOKEN_SUBNAME = keccak256("link");
+  bytes32 constant private ENS_ORACLE_SUBNAME = keccak256("oracle");
+  address constant private LINK_TOKEN_POINTER = 0xC89bD4E1632D3A43CB03AAAd5262cbe4038Bc571;
+
+  ENSInterface private ens;
+  bytes32 private ensNode;
+  LinkTokenInterface private link;
+  ChainlinkRequestInterface private oracle;
+  uint256 private requestCount = 1;
+  mapping(bytes32 => address) private pendingRequests;
+
+  event ChainlinkRequested(bytes32 indexed id);
+  event ChainlinkFulfilled(bytes32 indexed id);
+  event ChainlinkCancelled(bytes32 indexed id);
+
+  /**
+   * @notice Creates a request that can hold additional parameters
+   * @param _specId The Job Specification ID that the request will be created for
+   * @param _callbackAddress The callback address that the response will be sent to
+   * @param _callbackFunctionSignature The callback function signature to use for the callback address
+   * @return A Chainlink Request struct in memory
+   */
+  function buildChainlinkRequest(
+    bytes32 _specId,
+    address _callbackAddress,
+    bytes4 _callbackFunctionSignature
+  ) internal pure returns (Chainlink.Request memory) {
+    Chainlink.Request memory req;
+    return req.initialize(_specId, _callbackAddress, _callbackFunctionSignature);
+  }
+
+  /**
+   * @notice Creates a Chainlink request to the stored oracle address
+   * @dev Calls `chainlinkRequestTo` with the stored oracle address
+   * @param _req The initialized Chainlink Request
+   * @param _payment The amount of LINK to send for the request
+   * @return requestId The request ID
+   */
+  function sendChainlinkRequest(Chainlink.Request memory _req, uint256 _payment)
+    internal
+    returns (bytes32)
+  {
+    return sendChainlinkRequestTo(address(oracle), _req, _payment);
+  }
+
+  /**
+   * @notice Creates a Chainlink request to the specified oracle address
+   * @dev Generates and stores a request ID, increments the local nonce, and uses `transferAndCall` to
+   * send LINK which creates a request on the target oracle contract.
+   * Emits ChainlinkRequested event.
+   * @param _oracle The address of the oracle for the request
+   * @param _req The initialized Chainlink Request
+   * @param _payment The amount of LINK to send for the request
+   * @return requestId The request ID
+   */
+  function sendChainlinkRequestTo(address _oracle, Chainlink.Request memory _req, uint256 _payment)
+    internal
+    returns (bytes32 requestId)
+  {
+    requestId = keccak256(abi.encodePacked(this, requestCount));
+    _req.nonce = requestCount;
+    pendingRequests[requestId] = _oracle;
+    emit ChainlinkRequested(requestId);
+    require(link.transferAndCall(_oracle, _payment, encodeRequest(_req)), "unable to transferAndCall to oracle");
+    requestCount += 1;
+
+    return requestId;
+  }
+
+  /**
+   * @notice Allows a request to be cancelled if it has not been fulfilled
+   * @dev Requires keeping track of the expiration value emitted from the oracle contract.
+   * Deletes the request from the `pendingRequests` mapping.
+   * Emits ChainlinkCancelled event.
+   * @param _requestId The request ID
+   * @param _payment The amount of LINK sent for the request
+   * @param _callbackFunc The callback function specified for the request
+   * @param _expiration The time of the expiration for the request
+   */
+  function cancelChainlinkRequest(
+    bytes32 _requestId,
+    uint256 _payment,
+    bytes4 _callbackFunc,
+    uint256 _expiration
+  )
+    internal
+  {
+    ChainlinkRequestInterface requested = ChainlinkRequestInterface(pendingRequests[_requestId]);
+    delete pendingRequests[_requestId];
+    emit ChainlinkCancelled(_requestId);
+    requested.cancelOracleRequest(_requestId, _payment, _callbackFunc, _expiration);
+  }
+
+  /**
+   * @notice Sets the stored oracle address
+   * @param _oracle The address of the oracle contract
+   */
+  function setChainlinkOracle(address _oracle) internal {
+    oracle = ChainlinkRequestInterface(_oracle);
+  }
+
+  /**
+   * @notice Sets the LINK token address
+   * @param _link The address of the LINK token contract
+   */
+  function setChainlinkToken(address _link) internal {
+    link = LinkTokenInterface(_link);
+  }
+
+  /**
+   * @notice Sets the Chainlink token address for the public
+   * network as given by the Pointer contract
+   */
+  function setPublicChainlinkToken() internal {
+    setChainlinkToken(PointerInterface(LINK_TOKEN_POINTER).getAddress());
+  }
+
+  /**
+   * @notice Retrieves the stored address of the LINK token
+   * @return The address of the LINK token
+   */
+  function chainlinkTokenAddress()
+    internal
+    view
+    returns (address)
+  {
+    return address(link);
+  }
+
+  /**
+   * @notice Retrieves the stored address of the oracle contract
+   * @return The address of the oracle contract
+   */
+  function chainlinkOracleAddress()
+    internal
+    view
+    returns (address)
+  {
+    return address(oracle);
+  }
+
+  /**
+   * @notice Allows for a request which was created on another contract to be fulfilled
+   * on this contract
+   * @param _oracle The address of the oracle contract that will fulfill the request
+   * @param _requestId The request ID used for the response
+   */
+  function addChainlinkExternalRequest(address _oracle, bytes32 _requestId)
+    internal
+    notPendingRequest(_requestId)
+  {
+    pendingRequests[_requestId] = _oracle;
+  }
+
+  /**
+   * @notice Sets the stored oracle and LINK token contracts with the addresses resolved by ENS
+   * @dev Accounts for subnodes having different resolvers
+   * @param _ens The address of the ENS contract
+   * @param _node The ENS node hash
+   */
+  function useChainlinkWithENS(address _ens, bytes32 _node)
+    internal
+  {
+    ens = ENSInterface(_ens);
+    ensNode = _node;
+    bytes32 linkSubnode = keccak256(abi.encodePacked(ensNode, ENS_TOKEN_SUBNAME));
+    ENSResolver_Chainlink resolver = ENSResolver_Chainlink(ens.resolver(linkSubnode));
+    setChainlinkToken(resolver.addr(linkSubnode));
+    updateChainlinkOracleWithENS();
+  }
+
+  /**
+   * @notice Sets the stored oracle contract with the address resolved by ENS
+   * @dev This may be called on its own as long as `useChainlinkWithENS` has been called previously
+   */
+  function updateChainlinkOracleWithENS()
+    internal
+  {
+    bytes32 oracleSubnode = keccak256(abi.encodePacked(ensNode, ENS_ORACLE_SUBNAME));
+    ENSResolver_Chainlink resolver = ENSResolver_Chainlink(ens.resolver(oracleSubnode));
+    setChainlinkOracle(resolver.addr(oracleSubnode));
+  }
+
+  /**
+   * @notice Encodes the request to be sent to the oracle contract
+   * @dev The Chainlink node expects values to be in order for the request to be picked up. Order of types
+   * will be validated in the oracle contract.
+   * @param _req The initialized Chainlink Request
+   * @return The bytes payload for the `transferAndCall` method
+   */
+  function encodeRequest(Chainlink.Request memory _req)
+    private
+    view
+    returns (bytes memory)
+  {
+    return abi.encodeWithSelector(
+      oracle.oracleRequest.selector,
+      SENDER_OVERRIDE, // Sender value - overridden by onTokenTransfer by the requesting contract's address
+      AMOUNT_OVERRIDE, // Amount value - overridden by onTokenTransfer by the actual amount of LINK sent
+      _req.id,
+      _req.callbackAddress,
+      _req.callbackFunctionId,
+      _req.nonce,
+      ARGS_VERSION,
+      _req.buf.buf);
+  }
+
+  /**
+   * @notice Ensures that the fulfillment is valid for this contract
+   * @dev Use if the contract developer prefers methods instead of modifiers for validation
+   * @param _requestId The request ID for fulfillment
+   */
+  function validateChainlinkCallback(bytes32 _requestId)
+    internal
+    recordChainlinkFulfillment(_requestId)
+    // solhint-disable-next-line no-empty-blocks
+  {}
+
+  /**
+   * @dev Reverts if the sender is not the oracle of the request.
+   * Emits ChainlinkFulfilled event.
+   * @param _requestId The request ID for fulfillment
+   */
+  modifier recordChainlinkFulfillment(bytes32 _requestId) {
+    require(msg.sender == pendingRequests[_requestId],
+            "Source must be the oracle of the request");
+    delete pendingRequests[_requestId];
+    emit ChainlinkFulfilled(_requestId);
+    _;
+  }
+
+  /**
+   * @dev Reverts if the request is already pending
+   * @param _requestId The request ID for fulfillment
+   */
+  modifier notPendingRequest(bytes32 _requestId) {
+    require(pendingRequests[_requestId] == address(0), "Request is already pending");
+    _;
+  }
+}

package/v0.6/contracts/LinkTokenReceiver.sol

@@ -0,0 +1,70 @@
+pragma solidity ^0.6.0;
+
+abstract contract LinkTokenReceiver {
+
+  bytes4 constant private ORACLE_REQUEST_SELECTOR = 0x40429946;
+  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);
+  /**
+   * @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
+    validRequestLength(_data)
+    permittedFunctionsForLINK(_data)
+  {
+    assembly {
+      // solhint-disable-next-line avoid-low-level-calls
+      mstore(add(_data, 36), _sender) // ensure correct sender is passed
+      // solhint-disable-next-line avoid-low-level-calls
+      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
+    require(success, "Unable to create request");
+  }
+
+  function getChainlinkToken() public view virtual returns (address);
+
+  /**
+   * @dev Reverts if not sent from the LINK token
+   */
+  modifier onlyLINK() {
+    require(msg.sender == getChainlinkToken(), "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 memory _data) {
+    bytes4 funcSelector;
+    assembly {
+      // solhint-disable-next-line avoid-low-level-calls
+      funcSelector := mload(add(_data, 32))
+    }
+    require(funcSelector == ORACLE_REQUEST_SELECTOR, "Must use whitelisted functions");
+    _;
+  }
+
+  /**
+   * @dev Reverts if the given payload is less than needed to create a request
+   * @param _data The request payload
+   */
+  modifier validRequestLength(bytes memory _data) {
+    require(_data.length >= MINIMUM_REQUEST_LENGTH, "Invalid request length");
+    _;
+  }
+}

package/v0.6/contracts/Oracle.sol

@@ -0,0 +1,276 @@
+pragma solidity ^0.6.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
+    override
+    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
+    override
+    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 override 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 override 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
+    override(OracleInterface, WithdrawalInterface)
+    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 override(OracleInterface, WithdrawalInterface) 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 override {
+    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 override 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.6/contracts/interfaces/ChainlinkRequestInterface.sol

@@ -0,0 +1,21 @@
+pragma solidity ^0.6.0;
+
+interface ChainlinkRequestInterface {
+  function oracleRequest(
+    address sender,
+    uint256 requestPrice,
+    bytes32 serviceAgreementID,
+    address callbackAddress,
+    bytes4 callbackFunctionId,
+    uint256 nonce,
+    uint256 dataVersion, // Currently unused, always "1"
+    bytes calldata data
+  ) external;
+
+  function cancelOracleRequest(
+    bytes32 requestId,
+    uint256 payment,
+    bytes4 callbackFunctionId,
+    uint256 expiration
+  ) external;
+}

package/v0.6/contracts/interfaces/ENSInterface.sol

@@ -0,0 +1,26 @@
+pragma solidity ^0.6.0;
+
+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/v0.6/contracts/interfaces/LinkTokenInterface.sol

@@ -0,0 +1,16 @@
+pragma solidity ^0.6.0;
+
+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 memory tokenName);
+  function symbol() external returns (string memory tokenSymbol);
+  function totalSupply() external returns (uint256 totalTokensIssued);
+  function transfer(address to, uint256 value) external returns (bool success);
+  function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool success);
+  function transferFrom(address from, address to, uint256 value) external returns (bool success);
+}

package/v0.6/contracts/interfaces/OracleInterface.sol

@@ -0,0 +1,16 @@
+pragma solidity ^0.6.0;
+
+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/v0.6/contracts/interfaces/PointerInterface.sol

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