chai-link 0.8.2

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

@@ -0,0 +1,16 @@
+pragma solidity ^0.6.0;
+
+interface WithdrawalInterface {
+  /**
+   * @notice transfer LINK held by the contract belonging to msg.sender to
+   * another address
+   * @param recipient is the address to send the LINK to
+   * @param amount is the amount of LINK to send
+   */
+  function withdraw(address recipient, uint256 amount) external;
+
+  /**
+   * @notice query the available amount of LINK to withdraw by msg.sender
+   */
+  function withdrawable() external view returns (uint256);
+}

package/v0.6/contracts/tests/BasicConsumer.sol

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

package/v0.6/contracts/tests/Consumer.sol

@@ -0,0 +1,55 @@
+pragma solidity ^0.6.0;
+
+import "../ChainlinkClient.sol";
+
+contract Consumer is ChainlinkClient {
+  bytes32 internal specId;
+  bytes32 public currentPrice;
+
+  event RequestFulfilled(
+    bytes32 indexed requestId,  // User-defined ID
+    bytes32 indexed price
+  );
+
+  function requestEthereumPrice(string memory _currency, uint256 _payment) public {
+    requestEthereumPriceByCallback(_currency, _payment, address(this));
+  }
+
+  function requestEthereumPriceByCallback(string memory _currency, uint256 _payment, address _callback) public {
+    Chainlink.Request memory req = buildChainlinkRequest(specId, _callback, 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, _payment);
+  }
+
+  function cancelRequest(
+    address _oracle,
+    bytes32 _requestId,
+    uint256 _payment,
+    bytes4 _callbackFunctionId,
+    uint256 _expiration
+  ) public {
+    ChainlinkRequestInterface requested = ChainlinkRequestInterface(_oracle);
+    requested.cancelOracleRequest(_requestId, _payment, _callbackFunctionId, _expiration);
+  }
+
+  function withdrawLink() public {
+    LinkTokenInterface _link = LinkTokenInterface(chainlinkTokenAddress());
+    require(_link.transfer(msg.sender, _link.balanceOf(address(this))), "Unable to transfer");
+  }
+
+  function addExternalRequest(address _oracle, bytes32 _requestId) external {
+    addChainlinkExternalRequest(_oracle, _requestId);
+  }
+
+  function fulfill(bytes32 _requestId, bytes32 _price)
+    public
+    recordChainlinkFulfillment(_requestId)
+  {
+    emit RequestFulfilled(_requestId, _price);
+    currentPrice = _price;
+  }
+
+}

package/v0.6/contracts/vendor/Buffer.sol

@@ -0,0 +1,301 @@
+pragma solidity ^0.6.0;
+
+/**
+* @dev A library for working with mutable byte buffers in Solidity.
+*
+* Byte buffers are mutable and expandable, and provide a variety of primitives
+* for writing to them. At any time you can fetch a bytes object containing the
+* current contents of the buffer. The bytes object should not be stored between
+* operations, as it may change due to resizing of the buffer.
+*/
+library Buffer {
+  /**
+  * @dev Represents a mutable buffer. Buffers have a current value (buf) and
+  *      a capacity. The capacity may be longer than the current value, in
+  *      which case it can be extended without the need to allocate more memory.
+  */
+  struct buffer {
+    bytes buf;
+    uint capacity;
+  }
+
+  /**
+  * @dev Initializes a buffer with an initial capacity.
+  * @param buf The buffer to initialize.
+  * @param capacity The number of bytes of space to allocate the buffer.
+  * @return The buffer, for chaining.
+  */
+  function init(buffer memory buf, uint capacity) internal pure returns(buffer memory) {
+    if (capacity % 32 != 0) {
+      capacity += 32 - (capacity % 32);
+    }
+    // Allocate space for the buffer data
+    buf.capacity = capacity;
+    assembly {
+      let ptr := mload(0x40)
+      mstore(buf, ptr)
+      mstore(ptr, 0)
+      mstore(0x40, add(32, add(ptr, capacity)))
+    }
+    return buf;
+  }
+
+  /**
+  * @dev Initializes a new buffer from an existing bytes object.
+  *      Changes to the buffer may mutate the original value.
+  * @param b The bytes object to initialize the buffer with.
+  * @return A new buffer.
+  */
+  function fromBytes(bytes memory b) internal pure returns(buffer memory) {
+    buffer memory buf;
+    buf.buf = b;
+    buf.capacity = b.length;
+    return buf;
+  }
+
+  function resize(buffer memory buf, uint capacity) private pure {
+    bytes memory oldbuf = buf.buf;
+    init(buf, capacity);
+    append(buf, oldbuf);
+  }
+
+  function max(uint a, uint b) private pure returns(uint) {
+    if (a > b) {
+      return a;
+    }
+    return b;
+  }
+
+  /**
+  * @dev Sets buffer length to 0.
+  * @param buf The buffer to truncate.
+  * @return The original buffer, for chaining..
+  */
+  function truncate(buffer memory buf) internal pure returns (buffer memory) {
+    assembly {
+      let bufptr := mload(buf)
+      mstore(bufptr, 0)
+    }
+    return buf;
+  }
+
+  /**
+  * @dev Writes a byte string to a buffer. Resizes if doing so would exceed
+  *      the capacity of the buffer.
+  * @param buf The buffer to append to.
+  * @param off The start offset to write to.
+  * @param data The data to append.
+  * @param len The number of bytes to copy.
+  * @return The original buffer, for chaining.
+  */
+  function write(buffer memory buf, uint off, bytes memory data, uint len) internal pure returns(buffer memory) {
+    require(len <= data.length);
+
+    if (off + len > buf.capacity) {
+      resize(buf, max(buf.capacity, len + off) * 2);
+    }
+
+    uint dest;
+    uint src;
+    assembly {
+      // Memory address of the buffer data
+      let bufptr := mload(buf)
+      // Length of existing buffer data
+      let buflen := mload(bufptr)
+      // Start address = buffer address + offset + sizeof(buffer length)
+      dest := add(add(bufptr, 32), off)
+      // Update buffer length if we're extending it
+      if gt(add(len, off), buflen) {
+        mstore(bufptr, add(len, off))
+      }
+      src := add(data, 32)
+    }
+
+    // Copy word-length chunks while possible
+    for (; len >= 32; len -= 32) {
+      assembly {
+        mstore(dest, mload(src))
+      }
+      dest += 32;
+      src += 32;
+    }
+
+    // Copy remaining bytes
+    uint mask = 256 ** (32 - len) - 1;
+    assembly {
+      let srcpart := and(mload(src), not(mask))
+      let destpart := and(mload(dest), mask)
+      mstore(dest, or(destpart, srcpart))
+    }
+
+    return buf;
+  }
+
+  /**
+  * @dev Appends a byte string to a buffer. Resizes if doing so would exceed
+  *      the capacity of the buffer.
+  * @param buf The buffer to append to.
+  * @param data The data to append.
+  * @param len The number of bytes to copy.
+  * @return The original buffer, for chaining.
+  */
+  function append(buffer memory buf, bytes memory data, uint len) internal pure returns (buffer memory) {
+    return write(buf, buf.buf.length, data, len);
+  }
+
+  /**
+  * @dev Appends a byte string to a buffer. Resizes if doing so would exceed
+  *      the capacity of the buffer.
+  * @param buf The buffer to append to.
+  * @param data The data to append.
+  * @return The original buffer, for chaining.
+  */
+  function append(buffer memory buf, bytes memory data) internal pure returns (buffer memory) {
+    return write(buf, buf.buf.length, data, data.length);
+  }
+
+  /**
+  * @dev Writes a byte to the buffer. Resizes if doing so would exceed the
+  *      capacity of the buffer.
+  * @param buf The buffer to append to.
+  * @param off The offset to write the byte at.
+  * @param data The data to append.
+  * @return The original buffer, for chaining.
+  */
+  function writeUint8(buffer memory buf, uint off, uint8 data) internal pure returns(buffer memory) {
+    if (off >= buf.capacity) {
+      resize(buf, buf.capacity * 2);
+    }
+
+    assembly {
+      // Memory address of the buffer data
+      let bufptr := mload(buf)
+      // Length of existing buffer data
+      let buflen := mload(bufptr)
+      // Address = buffer address + sizeof(buffer length) + off
+      let dest := add(add(bufptr, off), 32)
+      mstore8(dest, data)
+      // Update buffer length if we extended it
+      if eq(off, buflen) {
+        mstore(bufptr, add(buflen, 1))
+      }
+    }
+    return buf;
+  }
+
+  /**
+  * @dev Appends a byte to the buffer. Resizes if doing so would exceed the
+  *      capacity of the buffer.
+  * @param buf The buffer to append to.
+  * @param data The data to append.
+  * @return The original buffer, for chaining.
+  */
+  function appendUint8(buffer memory buf, uint8 data) internal pure returns(buffer memory) {
+    return writeUint8(buf, buf.buf.length, data);
+  }
+
+  /**
+  * @dev Writes up to 32 bytes to the buffer. Resizes if doing so would
+  *      exceed the capacity of the buffer.
+  * @param buf The buffer to append to.
+  * @param off The offset to write at.
+  * @param data The data to append.
+  * @param len The number of bytes to write (left-aligned).
+  * @return The original buffer, for chaining.
+  */
+  function write(buffer memory buf, uint off, bytes32 data, uint len) private pure returns(buffer memory) {
+    if (len + off > buf.capacity) {
+      resize(buf, (len + off) * 2);
+    }
+
+    uint mask = 256 ** len - 1;
+    // Right-align data
+    data = data >> (8 * (32 - len));
+    assembly {
+      // Memory address of the buffer data
+      let bufptr := mload(buf)
+      // Address = buffer address + sizeof(buffer length) + off + len
+      let dest := add(add(bufptr, off), len)
+      mstore(dest, or(and(mload(dest), not(mask)), data))
+      // Update buffer length if we extended it
+      if gt(add(off, len), mload(bufptr)) {
+        mstore(bufptr, add(off, len))
+      }
+    }
+    return buf;
+  }
+
+  /**
+  * @dev Writes a bytes20 to the buffer. Resizes if doing so would exceed the
+  *      capacity of the buffer.
+  * @param buf The buffer to append to.
+  * @param off The offset to write at.
+  * @param data The data to append.
+  * @return The original buffer, for chaining.
+  */
+  function writeBytes20(buffer memory buf, uint off, bytes20 data) internal pure returns (buffer memory) {
+    return write(buf, off, bytes32(data), 20);
+  }
+
+  /**
+  * @dev Appends a bytes20 to the buffer. Resizes if doing so would exceed
+  *      the capacity of the buffer.
+  * @param buf The buffer to append to.
+  * @param data The data to append.
+  * @return The original buffer, for chhaining.
+  */
+  function appendBytes20(buffer memory buf, bytes20 data) internal pure returns (buffer memory) {
+    return write(buf, buf.buf.length, bytes32(data), 20);
+  }
+
+  /**
+  * @dev Appends a bytes32 to the buffer. Resizes if doing so would exceed
+  *      the capacity of the buffer.
+  * @param buf The buffer to append to.
+  * @param data The data to append.
+  * @return The original buffer, for chaining.
+  */
+  function appendBytes32(buffer memory buf, bytes32 data) internal pure returns (buffer memory) {
+    return write(buf, buf.buf.length, data, 32);
+  }
+
+  /**
+  * @dev Writes an integer to the buffer. Resizes if doing so would exceed
+  *      the capacity of the buffer.
+  * @param buf The buffer to append to.
+  * @param off The offset to write at.
+  * @param data The data to append.
+  * @param len The number of bytes to write (right-aligned).
+  * @return The original buffer, for chaining.
+  */
+  function writeInt(buffer memory buf, uint off, uint data, uint len) private pure returns(buffer memory) {
+    if (len + off > buf.capacity) {
+      resize(buf, (len + off) * 2);
+    }
+
+    uint mask = 256 ** len - 1;
+    assembly {
+      // Memory address of the buffer data
+      let bufptr := mload(buf)
+      // Address = buffer address + off + sizeof(buffer length) + len
+      let dest := add(add(bufptr, off), len)
+      mstore(dest, or(and(mload(dest), not(mask)), data))
+      // Update buffer length if we extended it
+      if gt(add(off, len), mload(bufptr)) {
+        mstore(bufptr, add(off, len))
+      }
+    }
+    return buf;
+  }
+
+  /**
+    * @dev Appends a byte to the end of the buffer. Resizes if doing so would
+    * exceed the capacity of the buffer.
+    * @param buf The buffer to append to.
+    * @param data The data to append.
+    * @return The original buffer.
+    */
+  function appendInt(buffer memory buf, uint data, uint len) internal pure returns(buffer memory) {
+    return writeInt(buf, buf.buf.length, data, len);
+  }
+}

package/v0.6/contracts/vendor/CBOR.sol

@@ -0,0 +1,71 @@
+pragma solidity ^0.6.0;
+
+import "./Buffer.sol";
+
+library CBOR {
+  using Buffer for Buffer.buffer;
+
+  uint8 private constant MAJOR_TYPE_INT = 0;
+  uint8 private constant MAJOR_TYPE_NEGATIVE_INT = 1;
+  uint8 private constant MAJOR_TYPE_BYTES = 2;
+  uint8 private constant MAJOR_TYPE_STRING = 3;
+  uint8 private constant MAJOR_TYPE_ARRAY = 4;
+  uint8 private constant MAJOR_TYPE_MAP = 5;
+  uint8 private constant MAJOR_TYPE_CONTENT_FREE = 7;
+
+  function encodeType(Buffer.buffer memory buf, uint8 major, uint value) private pure {
+    if(value <= 23) {
+      buf.appendUint8(uint8((major << 5) | value));
+    } else if(value <= 0xFF) {
+      buf.appendUint8(uint8((major << 5) | 24));
+      buf.appendInt(value, 1);
+    } else if(value <= 0xFFFF) {
+      buf.appendUint8(uint8((major << 5) | 25));
+      buf.appendInt(value, 2);
+    } else if(value <= 0xFFFFFFFF) {
+      buf.appendUint8(uint8((major << 5) | 26));
+      buf.appendInt(value, 4);
+    } else if(value <= 0xFFFFFFFFFFFFFFFF) {
+      buf.appendUint8(uint8((major << 5) | 27));
+      buf.appendInt(value, 8);
+    }
+  }
+
+  function encodeIndefiniteLengthType(Buffer.buffer memory buf, uint8 major) private pure {
+    buf.appendUint8(uint8((major << 5) | 31));
+  }
+
+  function encodeUInt(Buffer.buffer memory buf, uint value) internal pure {
+    encodeType(buf, MAJOR_TYPE_INT, value);
+  }
+
+  function encodeInt(Buffer.buffer memory buf, int value) internal pure {
+    if(value >= 0) {
+      encodeType(buf, MAJOR_TYPE_INT, uint(value));
+    } else {
+      encodeType(buf, MAJOR_TYPE_NEGATIVE_INT, uint(-1 - value));
+    }
+  }
+
+  function encodeBytes(Buffer.buffer memory buf, bytes memory value) internal pure {
+    encodeType(buf, MAJOR_TYPE_BYTES, value.length);
+    buf.append(value);
+  }
+
+  function encodeString(Buffer.buffer memory buf, string memory value) internal pure {
+    encodeType(buf, MAJOR_TYPE_STRING, bytes(value).length);
+    buf.append(bytes(value));
+  }
+
+  function startArray(Buffer.buffer memory buf) internal pure {
+    encodeIndefiniteLengthType(buf, MAJOR_TYPE_ARRAY);
+  }
+
+  function startMap(Buffer.buffer memory buf) internal pure {
+    encodeIndefiniteLengthType(buf, MAJOR_TYPE_MAP);
+  }
+
+  function endSequence(Buffer.buffer memory buf) internal pure {
+    encodeIndefiniteLengthType(buf, MAJOR_TYPE_CONTENT_FREE);
+  }
+}

package/v0.6/contracts/vendor/ENSResolver.sol

@@ -0,0 +1,5 @@
+pragma solidity ^0.6.0;
+
+abstract contract ENSResolver {
+  function addr(bytes32 node) public view virtual returns (address);
+}

package/v0.6/contracts/vendor/Ownable.sol

@@ -0,0 +1,65 @@
+pragma solidity ^0.6.0;
+
+/**
+ * @dev Contract module which provides a basic access control mechanism, where
+ * there is an account (an owner) that can be granted exclusive access to
+ * specific functions.
+ *
+ * This module is used through inheritance. It will make available the modifier
+ * `onlyOwner`, which can be aplied to your functions to restrict their use to
+ * the owner.
+ *
+ * This contract has been modified to remove the revokeOwnership function
+ */
+contract Ownable {
+  address private _owner;
+
+  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+  /**
+   * @dev Initializes the contract setting the deployer as the initial owner.
+   */
+  constructor () internal {
+    _owner = msg.sender;
+    emit OwnershipTransferred(address(0), _owner);
+  }
+
+  /**
+   * @dev Returns the address of the current owner.
+   */
+  function owner() public view returns (address) {
+    return _owner;
+  }
+
+  /**
+   * @dev Throws if called by any account other than the owner.
+   */
+  modifier onlyOwner() {
+    require(isOwner(), "Ownable: caller is not the owner");
+    _;
+  }
+
+  /**
+   * @dev Returns true if the caller is the current owner.
+   */
+  function isOwner() public view returns (bool) {
+    return msg.sender == _owner;
+  }
+
+  /**
+   * @dev Transfers ownership of the contract to a new account (`newOwner`).
+   * Can only be called by the current owner.
+   */
+  function transferOwnership(address newOwner) public onlyOwner {
+    _transferOwnership(newOwner);
+  }
+
+  /**
+   * @dev Transfers ownership of the contract to a new account (`newOwner`).
+   */
+  function _transferOwnership(address newOwner) internal {
+    require(newOwner != address(0), "Ownable: new owner is the zero address");
+    emit OwnershipTransferred(_owner, newOwner);
+    _owner = newOwner;
+  }
+}

package/v0.6/contracts/vendor/SafeMath.sol

@@ -0,0 +1,107 @@
+pragma solidity ^0.6.0;
+
+/**
+ * @dev Wrappers over Solidity's arithmetic operations with added overflow
+ * checks.
+ *
+ * Arithmetic operations in Solidity wrap on overflow. This can easily result
+ * in bugs, because programmers usually assume that an overflow raises an
+ * error, which is the standard behavior in high level programming languages.
+ * `SafeMath` restores this intuition by reverting the transaction when an
+ * operation overflows.
+ *
+ * Using this library instead of the unchecked operations eliminates an entire
+ * class of bugs, so it's recommended to use it always.
+ */
+library SafeMath {
+  /**
+    * @dev Returns the addition of two unsigned integers, reverting on
+    * overflow.
+    *
+    * Counterpart to Solidity's `+` operator.
+    *
+    * Requirements:
+    * - Addition cannot overflow.
+    */
+  function add(uint256 a, uint256 b) internal pure returns (uint256) {
+    uint256 c = a + b;
+    require(c >= a, "SafeMath: addition overflow");
+
+    return c;
+  }
+
+  /**
+    * @dev Returns the subtraction of two unsigned integers, reverting on
+    * overflow (when the result is negative).
+    *
+    * Counterpart to Solidity's `-` operator.
+    *
+    * Requirements:
+    * - Subtraction cannot overflow.
+    */
+  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+    require(b <= a, "SafeMath: subtraction overflow");
+    uint256 c = a - b;
+
+    return c;
+  }
+
+  /**
+    * @dev Returns the multiplication of two unsigned integers, reverting on
+    * overflow.
+    *
+    * Counterpart to Solidity's `*` operator.
+    *
+    * Requirements:
+    * - Multiplication cannot overflow.
+    */
+  function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+    // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
+    // benefit is lost if 'b' is also tested.
+    // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
+    if (a == 0) {
+      return 0;
+    }
+
+    uint256 c = a * b;
+    require(c / a == b, "SafeMath: multiplication overflow");
+
+    return c;
+  }
+
+  /**
+    * @dev Returns the integer division of two unsigned integers. Reverts on
+    * division by zero. The result is rounded towards zero.
+    *
+    * Counterpart to Solidity's `/` operator. Note: this function uses a
+    * `revert` opcode (which leaves remaining gas untouched) while Solidity
+    * uses an invalid opcode to revert (consuming all remaining gas).
+    *
+    * Requirements:
+    * - The divisor cannot be zero.
+    */
+  function div(uint256 a, uint256 b) internal pure returns (uint256) {
+    // Solidity only automatically asserts when dividing by 0
+    require(b > 0, "SafeMath: division by zero");
+    uint256 c = a / b;
+    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
+
+    return c;
+  }
+
+  /**
+    * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
+    * Reverts when dividing by zero.
+    *
+    * Counterpart to Solidity's `%` operator. This function uses a `revert`
+    * opcode (which leaves remaining gas untouched) while Solidity uses an
+    * invalid opcode to revert (consuming all remaining gas).
+    *
+    * Requirements:
+    * - The divisor cannot be zero.
+    */
+  function mod(uint256 a, uint256 b) internal pure returns (uint256) {
+    require(b != 0, "SafeMath: modulo by zero");
+    return a % b;
+  }
+}

package/zos.json

@@ -0,0 +1,8 @@
+{
+  "zosversion": "2",
+  "name": "github:smartcontractkit/chainlink",
+  "version": "0.1.0",
+  "contracts": {
+    "Chainlinked": "Chainlinked"
+  }
+}