chanlink 0.0.1-security → 0.8.2

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

@@ -0,0 +1,301 @@
+pragma solidity ^0.5.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.5/contracts/vendor/CBOR.sol

@@ -0,0 +1,71 @@
+pragma solidity ^0.5.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.5/contracts/vendor/ENSResolver.sol

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

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

@@ -0,0 +1,65 @@
+pragma solidity ^0.5.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.5/contracts/vendor/SafeMath.sol

@@ -0,0 +1,107 @@
+pragma solidity ^0.5.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/v0.5/contracts/vendor/SignedSafeMath.sol

@@ -0,0 +1,22 @@
+pragma solidity ^0.5.0;
+
+library SignedSafeMath {
+
+  /**
+   * @dev Adds two int256s and makes sure the result doesn't overflow. Signed
+   * integers aren't supported by the SafeMath library, thus this method
+   * @param _a The first number to be added
+   * @param _a The second number to be added
+   */
+  function add(int256 _a, int256 _b)
+    internal
+    pure
+    returns (int256)
+  {
+    // solium-disable-next-line zeppelin/no-arithmetic-operations
+    int256 c = _a + _b;
+    require((_b >= 0 && c >= _a) || (_b < 0 && c < _a), "SignedSafeMath: addition overflow");
+
+    return c;
+  }
+}

package/v0.6/contracts/Chainlink.sol

@@ -0,0 +1,125 @@
+pragma solidity ^0.6.0;
+
+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 memory _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 memory _key, string memory _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 memory _key, bytes memory _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 memory _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 memory _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 memory _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();
+  }
+}