chanlink 0.0.1-security → 0.8.2

package/contracts/vendor/CBOR.sol

@@ -0,0 +1,71 @@
+pragma solidity ^0.4.19;
+
+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 value) internal pure {
+    encodeType(buf, MAJOR_TYPE_BYTES, value.length);
+    buf.append(value);
+  }
+
+  function encodeString(Buffer.buffer memory buf, string 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/contracts/vendor/ENS.sol

@@ -0,0 +1,26 @@
+pragma solidity ^0.4.24;
+
+interface ENS {
+
+  // Logged when the owner of a node assigns a new owner to a subnode.
+  event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);
+
+  // Logged when the owner of a node transfers ownership to a new account.
+  event Transfer(bytes32 indexed node, address owner);
+
+  // Logged when the resolver for a node changes.
+  event NewResolver(bytes32 indexed node, address resolver);
+
+  // Logged when the TTL of a node changes
+  event NewTTL(bytes32 indexed node, uint64 ttl);
+
+
+  function setSubnodeOwner(bytes32 node, bytes32 label, address owner) public;
+  function setResolver(bytes32 node, address resolver) public;
+  function setOwner(bytes32 node, address owner) public;
+  function setTTL(bytes32 node, uint64 ttl) public;
+  function owner(bytes32 node) public view returns (address);
+  function resolver(bytes32 node) public view returns (address);
+  function ttl(bytes32 node) public view returns (uint64);
+
+}

package/contracts/vendor/ENSRegistry.sol

@@ -0,0 +1,99 @@
+pragma solidity ^0.4.24;
+
+import "./ENS.sol";
+
+/**
+ * The ENS registry contract.
+ */
+contract ENSRegistry is ENS {
+  struct Record {
+    address owner;
+    address resolver;
+    uint64 ttl;
+  }
+
+  mapping (bytes32 => Record) records;
+
+  // Permits modifications only by the owner of the specified node.
+  modifier only_owner(bytes32 node) {
+    require(records[node].owner == msg.sender);
+    _;
+  }
+
+  /**
+   * @dev Constructs a new ENS registrar.
+   */
+  constructor() public {
+    records[0x0].owner = msg.sender;
+  }
+
+  /**
+   * @dev Transfers ownership of a node to a new address. May only be called by the current owner of the node.
+   * @param node The node to transfer ownership of.
+   * @param owner The address of the new owner.
+   */
+  function setOwner(bytes32 node, address owner) public only_owner(node) {
+    emit Transfer(node, owner);
+    records[node].owner = owner;
+  }
+
+  /**
+   * @dev Transfers ownership of a subnode keccak256(node, label) to a new address. May only be called by the owner of the parent node.
+   * @param node The parent node.
+   * @param label The hash of the label specifying the subnode.
+   * @param owner The address of the new owner.
+   */
+  function setSubnodeOwner(bytes32 node, bytes32 label, address owner) public only_owner(node) {
+    bytes32 subnode = keccak256(abi.encodePacked(node, label));
+    emit NewOwner(node, label, owner);
+    records[subnode].owner = owner;
+  }
+
+  /**
+   * @dev Sets the resolver address for the specified node.
+   * @param node The node to update.
+   * @param resolver The address of the resolver.
+   */
+  function setResolver(bytes32 node, address resolver) public only_owner(node) {
+    emit NewResolver(node, resolver);
+    records[node].resolver = resolver;
+  }
+
+  /**
+   * @dev Sets the TTL for the specified node.
+   * @param node The node to update.
+   * @param ttl The TTL in seconds.
+   */
+  function setTTL(bytes32 node, uint64 ttl) public only_owner(node) {
+    emit NewTTL(node, ttl);
+    records[node].ttl = ttl;
+  }
+
+  /**
+   * @dev Returns the address that owns the specified node.
+   * @param node The specified node.
+   * @return address of the owner.
+   */
+  function owner(bytes32 node) public view returns (address) {
+    return records[node].owner;
+  }
+
+  /**
+   * @dev Returns the address of the resolver for the specified node.
+   * @param node The specified node.
+   * @return address of the resolver.
+   */
+  function resolver(bytes32 node) public view returns (address) {
+    return records[node].resolver;
+  }
+
+  /**
+   * @dev Returns the TTL of a node, and any records associated with it.
+   * @param node The specified node.
+   * @return ttl of the node.
+   */
+  function ttl(bytes32 node) public view returns (uint64) {
+    return records[node].ttl;
+  }
+
+}

package/contracts/vendor/ENSResolver.sol

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

package/contracts/vendor/Ownable.sol

@@ -0,0 +1,64 @@
+pragma solidity ^0.4.24;
+
+
+/**
+ * @title Ownable
+ * @dev The Ownable contract has an owner address, and provides basic authorization control
+ * functions, this simplifies the implementation of "user permissions".
+ */
+contract Ownable {
+  address public owner;
+
+
+  event OwnershipRenounced(address indexed previousOwner);
+  event OwnershipTransferred(
+    address indexed previousOwner,
+    address indexed newOwner
+  );
+
+
+  /**
+   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
+   * account.
+   */
+  constructor() public {
+    owner = msg.sender;
+  }
+
+  /**
+   * @dev Throws if called by any account other than the owner.
+   */
+  modifier onlyOwner() {
+    require(msg.sender == owner);
+    _;
+  }
+
+  /**
+   * @dev Allows the current owner to relinquish control of the contract.
+   * @notice Renouncing to ownership will leave the contract without an owner.
+   * It will not be possible to call the functions with the `onlyOwner`
+   * modifier anymore.
+   */
+  function renounceOwnership() public onlyOwner {
+    emit OwnershipRenounced(owner);
+    owner = address(0);
+  }
+
+  /**
+   * @dev Allows the current owner to transfer control of the contract to a newOwner.
+   * @param _newOwner The address to transfer ownership to.
+   */
+  function transferOwnership(address _newOwner) public onlyOwner {
+    _transferOwnership(_newOwner);
+  }
+
+  /**
+   * @dev Transfers control of the contract to a newOwner.
+   * @param _newOwner The address to transfer ownership to.
+   */
+  function _transferOwnership(address _newOwner) internal {
+    require(_newOwner != address(0));
+    emit OwnershipTransferred(owner, _newOwner);
+    owner = _newOwner;
+  }
+}

package/contracts/vendor/PublicResolver.sol

@@ -0,0 +1,238 @@
+pragma solidity ^0.4.24;
+
+import "./ENS.sol";
+
+/**
+ * A simple resolver anyone can use; only allows the owner of a node to set its
+ * address.
+ */
+contract PublicResolver {
+
+  bytes4 constant INTERFACE_META_ID = 0x01ffc9a7;
+  bytes4 constant ADDR_INTERFACE_ID = 0x3b3b57de;
+  bytes4 constant CONTENT_INTERFACE_ID = 0xd8389dc5;
+  bytes4 constant NAME_INTERFACE_ID = 0x691f3431;
+  bytes4 constant ABI_INTERFACE_ID = 0x2203ab56;
+  bytes4 constant PUBKEY_INTERFACE_ID = 0xc8690233;
+  bytes4 constant TEXT_INTERFACE_ID = 0x59d1d43c;
+  bytes4 constant MULTIHASH_INTERFACE_ID = 0xe89401a1;
+
+  event AddrChanged(bytes32 indexed node, address a);
+  event ContentChanged(bytes32 indexed node, bytes32 hash);
+  event NameChanged(bytes32 indexed node, string name);
+  event ABIChanged(bytes32 indexed node, uint256 indexed contentType);
+  event PubkeyChanged(bytes32 indexed node, bytes32 x, bytes32 y);
+  event TextChanged(bytes32 indexed node, string indexedKey, string key);
+  event MultihashChanged(bytes32 indexed node, bytes hash);
+
+  struct PublicKey {
+    bytes32 x;
+    bytes32 y;
+  }
+
+  struct Record {
+    address addr;
+    bytes32 content;
+    string name;
+    PublicKey pubkey;
+    mapping(string=>string) text;
+    mapping(uint256=>bytes) abis;
+    bytes multihash;
+  }
+
+  ENS ens;
+
+  mapping (bytes32 => Record) records;
+
+  modifier only_owner(bytes32 node) {
+    require(ens.owner(node) == msg.sender);
+    _;
+  }
+
+  /**
+   * Constructor.
+   * @param ensAddr The ENS registrar contract.
+   */
+  constructor(ENS ensAddr) public {
+    ens = ensAddr;
+  }
+
+  /**
+   * Sets the address associated with an ENS node.
+   * May only be called by the owner of that node in the ENS registry.
+   * @param node The node to update.
+   * @param addr The address to set.
+   */
+  function setAddr(bytes32 node, address addr) public only_owner(node) {
+    records[node].addr = addr;
+    emit AddrChanged(node, addr);
+  }
+
+  /**
+   * Sets the content hash associated with an ENS node.
+   * May only be called by the owner of that node in the ENS registry.
+   * Note that this resource type is not standardized, and will likely change
+   * in future to a resource type based on multihash.
+   * @param node The node to update.
+   * @param hash The content hash to set
+   */
+  function setContent(bytes32 node, bytes32 hash) public only_owner(node) {
+    records[node].content = hash;
+    emit ContentChanged(node, hash);
+  }
+
+  /**
+   * Sets the multihash associated with an ENS node.
+   * May only be called by the owner of that node in the ENS registry.
+   * @param node The node to update.
+   * @param hash The multihash to set
+   */
+  function setMultihash(bytes32 node, bytes hash) public only_owner(node) {
+    records[node].multihash = hash;
+    emit MultihashChanged(node, hash);
+  }
+
+  /**
+   * Sets the name associated with an ENS node, for reverse records.
+   * May only be called by the owner of that node in the ENS registry.
+   * @param node The node to update.
+   * @param name The name to set.
+   */
+  function setName(bytes32 node, string name) public only_owner(node) {
+    records[node].name = name;
+    emit NameChanged(node, name);
+  }
+
+  /**
+   * Sets the ABI associated with an ENS node.
+   * Nodes may have one ABI of each content type. To remove an ABI, set it to
+   * the empty string.
+   * @param node The node to update.
+   * @param contentType The content type of the ABI
+   * @param data The ABI data.
+   */
+  function setABI(bytes32 node, uint256 contentType, bytes data) public only_owner(node) {
+    // Content types must be powers of 2
+    require(((contentType - 1) & contentType) == 0);
+
+    records[node].abis[contentType] = data;
+    emit ABIChanged(node, contentType);
+  }
+
+  /**
+   * Sets the SECP256k1 public key associated with an ENS node.
+   * @param node The ENS node to query
+   * @param x the X coordinate of the curve point for the public key.
+   * @param y the Y coordinate of the curve point for the public key.
+   */
+  function setPubkey(bytes32 node, bytes32 x, bytes32 y) public only_owner(node) {
+    records[node].pubkey = PublicKey(x, y);
+    emit PubkeyChanged(node, x, y);
+  }
+
+  /**
+   * Sets the text data associated with an ENS node and key.
+   * May only be called by the owner of that node in the ENS registry.
+   * @param node The node to update.
+   * @param key The key to set.
+   * @param value The text data value to set.
+   */
+  function setText(bytes32 node, string key, string value) public only_owner(node) {
+    records[node].text[key] = value;
+    emit TextChanged(node, key, key);
+  }
+
+  /**
+   * Returns the text data associated with an ENS node and key.
+   * @param node The ENS node to query.
+   * @param key The text data key to query.
+   * @return The associated text data.
+   */
+  function text(bytes32 node, string key) public view returns (string) {
+    return records[node].text[key];
+  }
+
+  /**
+   * Returns the SECP256k1 public key associated with an ENS node.
+   * Defined in EIP 619.
+   * @param node The ENS node to query
+   * @return x, y the X and Y coordinates of the curve point for the public key.
+   */
+  function pubkey(bytes32 node) public view returns (bytes32 x, bytes32 y) {
+    return (records[node].pubkey.x, records[node].pubkey.y);
+  }
+
+  /**
+   * Returns the ABI associated with an ENS node.
+   * Defined in EIP205.
+   * @param node The ENS node to query
+   * @param contentTypes A bitwise OR of the ABI formats accepted by the caller.
+   * @return contentType The content type of the return value
+   * @return data The ABI data
+   */
+  function ABI(bytes32 node, uint256 contentTypes) public view returns (uint256 contentType, bytes data) {
+    Record storage record = records[node];
+    for (contentType = 1; contentType <= contentTypes; contentType <<= 1) {
+      if ((contentType & contentTypes) != 0 && record.abis[contentType].length > 0) {
+        data = record.abis[contentType];
+        return;
+      }
+    }
+    contentType = 0;
+  }
+
+  /**
+   * Returns the name associated with an ENS node, for reverse records.
+   * Defined in EIP181.
+   * @param node The ENS node to query.
+   * @return The associated name.
+   */
+  function name(bytes32 node) public view returns (string) {
+    return records[node].name;
+  }
+
+  /**
+   * Returns the content hash associated with an ENS node.
+   * Note that this resource type is not standardized, and will likely change
+   * in future to a resource type based on multihash.
+   * @param node The ENS node to query.
+   * @return The associated content hash.
+   */
+  function content(bytes32 node) public view returns (bytes32) {
+    return records[node].content;
+  }
+
+  /**
+   * Returns the multihash associated with an ENS node.
+   * @param node The ENS node to query.
+   * @return The associated multihash.
+   */
+  function multihash(bytes32 node) public view returns (bytes) {
+    return records[node].multihash;
+  }
+
+  /**
+   * Returns the address associated with an ENS node.
+   * @param node The ENS node to query.
+   * @return The associated address.
+   */
+  function addr(bytes32 node) public view returns (address) {
+    return records[node].addr;
+  }
+
+  /**
+   * Returns true if the resolver implements the interface specified by the provided hash.
+   * @param interfaceID The ID of the interface to check for.
+   * @return True if the contract implements the requested interface.
+   */
+  function supportsInterface(bytes4 interfaceID) public pure returns (bool) {
+    return interfaceID == ADDR_INTERFACE_ID ||
+    interfaceID == CONTENT_INTERFACE_ID ||
+    interfaceID == NAME_INTERFACE_ID ||
+    interfaceID == ABI_INTERFACE_ID ||
+    interfaceID == PUBKEY_INTERFACE_ID ||
+    interfaceID == TEXT_INTERFACE_ID ||
+    interfaceID == MULTIHASH_INTERFACE_ID ||
+    interfaceID == INTERFACE_META_ID;
+  }
+}

package/contracts/vendor/SafeMath.sol

@@ -0,0 +1,52 @@
+pragma solidity ^0.4.24;
+
+
+/**
+ * @title SafeMath
+ * @dev Math operations with safety checks that throw on error
+ */
+library SafeMath {
+
+  /**
+  * @dev Multiplies two numbers, throws on overflow.
+  */
+  function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
+    // Gas optimization: this is cheaper than asserting '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;
+    }
+
+    c = _a * _b;
+    assert(c / _a == _b);
+    return c;
+  }
+
+  /**
+  * @dev Integer division of two numbers, truncating the quotient.
+  */
+  function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
+    // assert(_b > 0); // Solidity automatically throws when dividing by 0
+    // uint256 c = _a / _b;
+    // assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
+    return _a / _b;
+  }
+
+  /**
+  * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
+  */
+  function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
+    assert(_b <= _a);
+    return _a - _b;
+  }
+
+  /**
+  * @dev Adds two numbers, throws on overflow.
+  */
+  function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
+    c = _a + _b;
+    assert(c >= _a);
+    return c;
+  }
+}

package/contracts/vendor/SignedSafeMath.sol

@@ -0,0 +1,21 @@
+pragma solidity 0.4.24;
+
+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)
+  {
+    int256 c = _a + _b;
+    require((_b >= 0 && c >= _a) || (_b < 0 && c < _a), "SignedSafeMath: addition overflow");
+
+    return c;
+  }
+}