Add ERC165Query library

contracts/introspection/ERC165Checker.sol

@@ -0,0 +1,86 @@
+pragma solidity ^0.4.24;
+
+
+/**
+ * @title ERC165Checker
+ * @dev Use `using ERC165Checker for address`; to include this library
+ *      https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md
+ */
+library ERC165Checker {
+  // As per the EIP-165 spec, no interface should ever match 0xffffffff
+  bytes4 private constant InterfaceId_Invalid = 0xffffffff;
+
+  // As per the EIP-165 spec, ERC165_ID == bytes4(keccak256('supportsInterface(bytes4)')
+  bytes4 private constant InterfaceId_ERC165 = 0x01ffc9a7;
+
+
+  function supportsERC165(address _address)
+    internal 
+    view 
+    returns (bool)
+  {
+    // Any contract that implements ERC165 must explicitly indicate support of
+    // InterfaceId_ERC165 and explicitly indicate non-support of InterfaceId_Invalid
+    return supportsInterface(_address, InterfaceId_ERC165) &&
+      !supportsInterface(_address, InterfaceId_Invalid);
+  }
+
+  /**
+   * @notice Query if a contract implements an interface
+   * @param _address The address of the contract to query for support of an interface
+   * @param _interfaceId The interface identifier, as specified in ERC-165
+   * @return true if the contract at _address indicates support of the interface with
+   * identifier _interfaceId, false otherwise
+   * @dev Assumes that _address contains a contract that supports ERC165, otherwise
+   *      the behavior of this method is undefined. This precondition can be checked 
+   *      with the `supportsERC165` method in this library. 
+   *      Interface identification is specified in ERC-165.
+   */
+  function supportsInterface(address _address, bytes4 _interfaceId)
+    internal
+    view
+    returns (bool)
+  {
+    // success determines whether the staticcall succeeded and result determines
+    // whether the contract at _address indicates support of _interfaceId
+    (bool success, bool result) = noThrowCall(_address, _interfaceId);
+
+    return (success && result);
+  }
+
+  /**
+   * @notice Calls the function with selector 0x01ffc9a7 (ERC165) and suppresses throw
+   * @param _address The address of the contract to query for support of an interface
+   * @param _interfaceId The interface identifier, as specified in ERC-165
+   * @return success true if the STATICCALL succeeded, false otherwise
+   * @return result true if the STATICCALL succeeded and the contract at _address
+   * indicates support of the interface with identifier _interfaceId, false otherwise
+   */
+  function noThrowCall (
+    address _address,
+    bytes4 _interfaceId
+  ) 
+    internal
+    view
+    returns (bool success, bool result)
+  {
+    bytes4 erc165ID = InterfaceId_ERC165;
+
+    // solium-disable-next-line security/no-inline-assembly
+    assembly {
+        let x := mload(0x40)               // Find empty storage location using "free memory pointer"
+        mstore(x, erc165ID)                // Place signature at begining of empty storage
+        mstore(add(x, 0x04), _interfaceId) // Place first argument directly next to signature
+
+        success := staticcall(
+                  30000,     // 30k gas
+                  _address, // To addr
+                  x,         // Inputs are stored at location x
+                  0x20,      // Inputs are 32 bytes long
+                  x,         // Store output over input (saves space)
+                  0x20)      // Outputs are 32 bytes long
+
+        result := mload(x)   // Load the result
+    }
+  }
+}

contracts/mocks/ERC165/ERC165GenerallySupported.sol

@@ -0,0 +1,8 @@
+pragma solidity ^0.4.24;
+
+import "../../introspection/SupportsInterfaceWithLookup.sol";
+
+
+contract ERC165GenerallySupported is SupportsInterfaceWithLookup {
+
+}

contracts/mocks/ERC165/ERC165InterfaceSupported.sol

@@ -0,0 +1,12 @@
+pragma solidity ^0.4.24;
+
+import "../../introspection/SupportsInterfaceWithLookup.sol";
+
+
+contract ERC165InterfaceSupported is SupportsInterfaceWithLookup {
+  constructor (bytes4 _interfaceId)
+    public
+  {
+    _registerInterface(_interfaceId);
+  }
+}

contracts/mocks/ERC165/ERC165NotSupported.sol

@@ -0,0 +1,6 @@
+pragma solidity ^0.4.24;
+
+
+contract ERC165NotSupported {
+
+}

contracts/mocks/ERC165CheckerMock.sol

@@ -0,0 +1,24 @@
+pragma solidity ^0.4.24;
+
+import "../introspection/ERC165Checker.sol";
+
+
+contract ERC165CheckerMock {
+  using ERC165Checker for address;
+
+  function supportsERC165(address _address)
+    public
+    view
+    returns (bool)
+  {
+    return _address.supportsERC165();
+  }
+
+  function supportsInterface(address _address, bytes4 _interfaceId)
+    public
+    view
+    returns (bool)
+  {
+    return _address.supportsInterface(_interfaceId);
+  }
+}

test/introspection/ERC165Checker.test.js

@@ -0,0 +1,59 @@
+const ERC165Checker = artifacts.require('ERC165CheckerMock');
+const ERC165NotSupported = artifacts.require('ERC165NotSupported');
+const ERC165GenerallySupported = artifacts.require('ERC165GenerallySupported');
+const ERC165InterfaceSupported = artifacts.require('ERC165InterfaceSupported');
+
+const DUMMY_ID = '0xdeadbeef';
+
+require('chai')
+  .use(require('chai-as-promised'))
+  .should();
+
+contract('ERC165Checker', function (accounts) {
+  before(async function () {
+    this.mock = await ERC165Checker.new();
+  });
+
+  context('not supported', () => {
+    beforeEach(async function () {
+      this.target = await ERC165NotSupported.new();
+    });
+
+    it('does not support ERC165', async function () {
+      const supported = await this.mock.supportsERC165(this.target.address);
+      supported.should.eq(false);
+    });
+  });
+
+  context('generally supported', () => {
+    beforeEach(async function () {
+      this.target = await ERC165GenerallySupported.new();
+    });
+
+    it('supports ERC165', async function () {
+      const supported = await this.mock.supportsERC165(this.target.address);
+      supported.should.eq(true);
+    });
+
+    it(`does not support ${DUMMY_ID}`, async function () {
+      const supported = await this.mock.supportsInterface(this.target.address, DUMMY_ID);
+      supported.should.eq(false);
+    });
+  });
+
+  context('interface supported', () => {
+    beforeEach(async function () {
+      this.target = await ERC165InterfaceSupported.new(DUMMY_ID);
+    });
+
+    it('supports ERC165', async function () {
+      const supported = await this.mock.supportsERC165(this.target.address);
+      supported.should.eq(true);
+    });
+
+    it(`supports ${DUMMY_ID}`, async function () {
+      const supported = await this.mock.supportsInterface(this.target.address, DUMMY_ID);
+      supported.should.eq(true);
+    });
+  });
+});