For some “standard interfaces” like the OIP-20 token interface, it is sometimes useful to query whether a contract supports the interface and if yes, which version of the interface, in order to adapt the way in which the contract is to be interacted with. Specifically for OIP-20, a version identifier has already been proposed. This proposal standardizes the concept of interfaces and standardizes the identification (naming) of interfaces.
For this standard, an interface is a set of function selectors as defined by the Ethereum ABI. This a subset of Solidity’s concept of interfaces and the interface keyword definition which also defines return types, mutability and events.
We define the interface identifier as the XOR of all function selectors in the interface. This code example shows how to calculate an interface identifier:
pragma solidity ^0.4.20;
interface Solidity101 {
function hello() external pure;
function world(int) external pure;
}
contract Selector {
function calculateSelector() public pure returns (bytes4) {
Solidity101 i;
return i.hello.selector ^ i.world.selector;
}
}
Note: interfaces do not permit optional functions, therefore, the interface identity will not include them.
#How a Contract will Publish the Interfaces it Implements
A contract that is compliant with OIP-165 shall implement the following interface (referred as OIP165.sol):
pragma solidity ^0.4.20;
interface OIP165 {
/// @notice Query if a contract implements an interface
/// @param interfaceID The interface identifier, as specified in OIP-165
/// @dev Interface identification is specified in OIP-165. This function
/// uses less than 30,000 gas.
/// @return `true` if the contract implements `interfaceID` and
/// `interfaceID` is not 0xffffffff, `false` otherwise
function supportsInterface(bytes4 interfaceID) external view returns (bool);
}
The interface identifier for this interface is 0x01ffc9a7. You can calculate this by running bytes4(keccak256('supportsInterface(bytes4)')); or using the Selector contract above.
Therefore the implementing contract will have a supportsInterface function that returns:
true when interfaceID is 0x01ffc9a7 (EIP165 interface)
false when interfaceID is 0xffffffff
true for any other interfaceID this contract implements
false for any other interfaceID
This function must return a bool and use at most 30,000 gas.
Implementation note, there are several logical ways to implement this function. Please see the example implementations and the discussion on gas usage.
The source contract makes a STATICCALL to the destination address with input data: 0x01ffc9a701ffc9a700000000000000000000000000000000000000000000000000000000 and gas 30,000. This corresponds to contract. supportsInterface(0x01ffc9a7).
If the call fails or return false, the destination contract does not implement OIP-165.
If the call returns true, a second call is made with input data 0x01ffc9a7ffffffff00000000000000000000000000000000000000000000000000000000.
If the second call fails or returns true, the destination contract does not implement OIP-165.
Otherwise it implements OIP-165.
#How to Detect if a Contract Implements any Given Interface
If you are not sure if the contract implements OIP-165, use the above procedure to confirm.
If it does not implement OIP-165, then you will have to see what methods it uses the old-fashioned way.
If it implements OIP-165 then just call supportsInterface(interfaceID) to determine if it implements an interface you can use.
This approach uses a view function implementation of supportsInterface. The execution cost is 586 gas for any input. But contract initialization requires storing each interface (SSTORE is 20,000 gas). The OIP165MappingImplementation contract is generic and reusable.
pragma solidity ^0.4.20;
import "./OIP165.sol";
contract OIP165MappingImplementation is OIP165 {
/// @dev You must not set element 0xffffffff to true
mapping(bytes4 => bool) internal supportedInterfaces;
function OIP165MappingImplementation() internal {
supportedInterfaces[this.supportsInterface.selector] = true;
}
function supportsInterface(bytes4 interfaceID) external view returns (bool) {
return supportedInterfaces[interfaceID];
}
}
interface Simpson {
function is2D() external returns (bool);
function skinColor() external returns (string);
}
contract Lisa is OIP165MappingImplementation, Simpson {
function Lisa() public {
supportedInterfaces[this.is2D.selector ^ this.skinColor.selector] = true;
}
function is2D() external returns (bool){}
function skinColor() external returns (string){}
}
Following is a pure function implementation of supportsInterface. The worst-case execution cost is 236 gas, but increases linearly with a higher number of supported interfaces.
pragma solidity ^0.4.20;
import "./OIP165.sol";
interface Simpson {
function is2D() external returns (bool);
function skinColor() external returns (string);
}
contract Homer is OIP165, Simpson {
function supportsInterface(bytes4 interfaceID) external view returns (bool) {
returninterfaceID == this.supportsInterface.selector || // OIP165
interfaceID == this.is2D.selector^ this.skinColor.selector; // Simpson
}
function is2D() external returns (bool){}function skinColor() external returns (string){}
}
With three or more supported interfaces (including OIP165 itself as a required supported interface), the mapping approach (in every case) costs less gas than the pure approach (at worst case).
