Merge pull request #13 from violetprotocol/dev

v1.2.0 Andromeda

Author: 0xpApaSmURf

README.md

@@ -49,7 +49,7 @@ All contracts must inherit the _Extendable_ contract.
 
 _Extendable_ contracts have a unique interaction with the _ExtendLogic_ contract where Extensions are added. _Extendable_ contracts access the state written by the _ExtendLogic_ extension in order to perform delegate calls to each extension. All calls are done from the context of the _Extendable_ contract which is handled by `delegatecall`.
 
-_Extendable_ contracts have an evolving interface which is accessible through the `getCurrentInterface` function supplied by the _ExtendLogic_ extension. This allows developers to easily determine the current interface of an evolving _Extendable_ contract directly on-chain without having to query separate processes that may not be in sync (GitHub, Documentation, Twitter etc.).
+_Extendable_ contracts have an evolving interface which is accessible through the `getFullInterface` function supplied by the _ExtendLogic_ extension. This allows developers to easily determine the current interface of an evolving _Extendable_ contract directly on-chain without having to query separate processes that may not be in sync (GitHub, Documentation, Twitter etc.).
 
 ### Extensions
 
@@ -85,7 +85,7 @@ struct YourState {
 library YourStorage {
     bytes32 constant private STORAGE_NAME = keccak256("your_unique_storage_identifier");
 
-    function _getStorage()
+    function _getState()
         internal 
         view
         returns (YourState storage state) 
@@ -104,7 +104,7 @@ import "./YourStorage.sol";
 
 contract YourExtension is IYourExtension, Extension {
     function readStorage() public view {
-        YourState storage state = YourStorage._getStorage();
+        YourState storage state = YourStorage._getState();
 
         // access properties of state with `state.yourVar`
         // re-assign state properties with `state.yourVar = <value>`

contracts/erc165/ERC165Logic.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.4;
+
+import "./IERC165Logic.sol";
+import { ERC165State, ERC165Storage } from "../storage/ERC165Storage.sol";
+
+/**
+ * @dev Standalone implementation of a global ERC165 interface detector.
+ *
+ * Deployed as singleton using EIP-2470: https://eips.ethereum.org/EIPS/eip-2470
+ *
+ * Provides ERC165 functionalities to any contract without it needing to
+ * implement ERC165 itself.
+ * 
+ * Allows it to be re-used by both Extensions and Extendables.
+ */
+contract ERC165Logic is IERC165, IERC165Register {
+    /**
+     * @dev Records its own contract address during construction
+     */
+    address private self;
+    constructor() {
+        self = address(this);
+    }
+
+    /**
+     * @dev Restricts calls to functions using this modifier to only come from
+     * delegatecalls.
+     */
+    modifier onlyDelegated {
+        require(address(this) != self, "ERC165Logic: undelegated calls disallowed");
+        _;
+    }
+
+    /**
+     * @dev See {IERC165-supportsInterface}.
+     */
+    function supportsInterface(bytes4 interfaceId) override(IERC165) public onlyDelegated virtual returns (bool) {
+        ERC165State storage state = ERC165Storage._getState();
+        return state._supportedInterfaces[interfaceId] || interfaceId == type(IERC165).interfaceId;
+    }
+
+    /**
+     * @dev Registers the contract as an implementer of the interface defined by
+     * `interfaceId`. Support of the actual ERC165 interface is automatic and
+     * registering its interface id is not required.
+     *
+     * See {IERC165Register-registerInterface}.
+     *
+     * Requirements:
+     *
+     * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).
+     * - should only be callable by other extensions of the same contract
+     */
+    function registerInterface(bytes4 interfaceId) override(IERC165Register) public onlyDelegated {
+        require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
+
+        ERC165State storage state = ERC165Storage._getState();
+        state._supportedInterfaces[interfaceId] = true;
+    }
+}

contracts/erc165/IERC165Logic.sol

@@ -0,0 +1,42 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.4;
+
+/**
+ * @dev Interface of the ERC165 standard, as defined in the
+ * https://eips.ethereum.org/EIPS/eip-165[EIP].
+ *
+ * Implementers can declare support of contract interfaces, which can then be
+ * queried by others ({ERC165Checker}).
+ *
+ * For an implementation, see {ERC165}.
+ */
+interface IERC165 {
+    /**
+     * @dev Returns true if this contract implements the interface defined by
+     * `interfaceId`. See the corresponding
+     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
+     * to learn more about how these ids are created.
+     *
+     * This function call must use less than 30 000 gas.
+     */
+    function supportsInterface(bytes4 interfaceId) external returns (bool);
+}
+
+
+/**
+ * @dev Storage based implementation of the {IERC165} interface.
+ *
+ * Uses Extendable storage pattern to populate the registered interfaces storage variable.
+ */
+interface IERC165Register {
+    /**
+     * @dev Registers the contract as an implementer of the interface defined by
+     * `interfaceId`. Support of the actual ERC165 interface is automatic and
+     * registering its interface id is not required.
+     *
+     * Requirements:
+     *
+     * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).
+     */
+    function registerInterface(bytes4 interfaceId) external;
+}

contracts/extendable/Extendable.sol

@@ -4,8 +4,6 @@ pragma solidity ^0.8.4;
 import "../errors/Errors.sol";
 import {CallerState, CallerContextStorage} from "../storage/CallerContextStorage.sol";
 import {ExtendableState, ExtendableStorage} from "../storage/ExtendableStorage.sol";
-import {RoleState, Permissions} from "../storage/PermissionStorage.sol";
-import "../extensions/permissioning/PermissioningLogic.sol";
 import "../extensions/extend/ExtendLogic.sol";
 
 /**
@@ -74,9 +72,13 @@ contract Extendable {
      * logic and returns as such.
      */
     function _delegate(address delegatee) internal virtual returns(bool) {
+        _beforeFallback();
+        
         bytes memory out;
         (bool success, bytes memory result) = delegatee.delegatecall(msg.data);
 
+        _afterFallback();
+
         // copy all returndata to `out` once instead of duplicating copy for each conditional branch
         assembly {
             returndatacopy(out, 0, returndatasize())
@@ -96,9 +98,6 @@ contract Extendable {
             }
         } else {
             // otherwise end execution and return the copied full returndata
-
-            // make sure to call _afterFallback before ending execution
-            _afterFallback();
             assembly {
                 return(out, returndatasize())
             }
@@ -111,32 +110,20 @@ contract Extendable {
      *
      * Initially attempts to locate an interfaceId match with a function selector
      * which are extensions that house single functions (singleton extensions)
-     * If none is found then attempt execution by cycling through extensions and
-     * calling.
      *
      * If no implementations are found that match the requested function signature,
      * returns ExtensionNotImplemented error
      */
     function _fallback() internal virtual {
-        _beforeFallback();
-        ExtendableState storage state = ExtendableStorage._getStorage();
+        ExtendableState storage state = ExtendableStorage._getState();
 
-        bool ok = false;
         // if an extension exists that matches in the functionsig
         if (state.extensionContracts[msg.sig] != address(0x0)) {
             // call it
             _delegate(state.extensionContracts[msg.sig]);
         } else {                                                 
-            // else cycle through all extensions to find it if exists
-            // this is not the preferred method for usage and only acts as a fallback
-            for (uint i = 0; i < state.interfaceIds.length; i++) {
-                ok = _delegate(state.extensionContracts[state.interfaceIds[i]]);
-                if (ok) break; // exit after first successful execution
-            }
+            revert ExtensionNotImplemented();
         }
-
-        if (!ok) revert ExtensionNotImplemented(); // if there are no successful delegatecalls we assume no implementation.
-        _afterFallback();
     }
 
     /**
@@ -163,15 +150,15 @@ contract Extendable {
      * @dev Virtual hook that is called before _fallback().
      */
     function _beforeFallback() internal virtual {
-        CallerState storage state = CallerContextStorage._getStorage();
+        CallerState storage state = CallerContextStorage._getState();
         state.callerStack.push(msg.sender);
     }
 
     /**
      * @dev Virtual hook that is called after _fallback().
      */
     function _afterFallback() internal virtual {
-        CallerState storage state = CallerContextStorage._getStorage();
+        CallerState storage state = CallerContextStorage._getState();
         state.callerStack.pop();
     }
 }

contracts/extensions/Extension.sol

@@ -3,8 +3,8 @@ pragma solidity ^0.8.4;
 
 import "./IExtension.sol";
 import "../errors/Errors.sol";
-import "@openzeppelin/contracts/utils/introspection/ERC165Storage.sol";
 import "../utils/CallerContext.sol";
+import "../erc165/IERC165Logic.sol";
 
 /**
  *  ______  __  __  ______  ______  __   __  _____   ______  ______  __      ______    
@@ -13,24 +13,61 @@ import "../utils/CallerContext.sol";
  *  \ \_____\/\_\/\_\ \ \_\ \ \_____\ \_\\"\_\ \____-\ \_\ \_\ \_____\ \_____\ \_____\
  *   \/_____/\/_/\/_/  \/_/  \/_____/\/_/ \/_/\/____/ \/_/\/_/\/_____/\/_____/\/_____/
  *
- *  Base contract for all Extensions in the Extendable Framework
+ *  Base contract for Extensions in the Extendable Framework
  *  
  *  Inherit and implement this contract to create Extension contracts!
  *
  *  Implements the EIP-165 standard for interface detection of implementations during runtime.
+ *  Uses the ERC165 singleton pattern where the actual implementation logic of the interface is
+ *  deployed in a separate contract. See ERC165Logic. Deterministic deployment guarantees the
+ *  ERC165Logic contract to always exist as static address 0x16C940672fA7820C36b2123E657029d982629070
  *
  *  Define your custom Extension interface and implement it whilst inheriting this contract:
  *      contract YourExtension is IYourExtension, Extension {...}
  *
  */
-abstract contract Extension is ERC165Storage, CallerContext, IExtension {
+abstract contract Extension is CallerContext, IExtension, IERC165, IERC165Register {
+    address constant ERC165LogicAddress = 0x16C940672fA7820C36b2123E657029d982629070;
+
     /**
      * @dev Constructor registers your custom Extension interface under EIP-165:
      *      https://eips.ethereum.org/EIPS/eip-165
     */
     constructor() {
-        _registerInterface(getInterfaceId());
-        _registerInterface(type(IExtension).interfaceId);
+        Interface[] memory interfaces = getInterface();
+        for (uint256 i = 0; i < interfaces.length; i++) {
+            Interface memory iface = interfaces[i];
+            registerInterface(iface.interfaceId);
+
+            for (uint256 j = 0; j < iface.functions.length; j++) {
+                registerInterface(iface.functions[j]);
+            }
+        }
+
+        registerInterface(type(IExtension).interfaceId);
+    }
+
+    function supportsInterface(bytes4 interfaceId) external override virtual returns(bool) {
+        (bool success, bytes memory result) = ERC165LogicAddress.delegatecall(abi.encodeWithSignature("supportsInterface(bytes4)", interfaceId));
+
+        if (!success) {
+            assembly {
+                revert(result, returndatasize())
+            }
+        }
+
+        return abi.decode(result, (bool));
+    }
+
+    function registerInterface(bytes4 interfaceId) public override virtual {
+        (bool success, ) = ERC165LogicAddress.delegatecall(abi.encodeWithSignature("registerInterface(bytes4)", interfaceId));
+
+        if (!success) {
+            assembly {
+                returndatacopy(0, 0, returndatasize())
+                revert(0, returndatasize())
+            }
+        }
     }
 
     /**
@@ -56,9 +93,9 @@ abstract contract Extension is ERC165Storage, CallerContext, IExtension {
     }
 
     /**
-     * @dev Virtual override declaration of getInterfaceId() function
+     * @dev Virtual override declaration of getFunctionSelectors() function to silence compiler
      *
      * Must be implemented in inherited contract.
     */
-    function getInterfaceId() override public virtual pure returns(bytes4);
+    function getInterface() override public virtual returns(Interface[] memory);
 }

contracts/extensions/IExtension.sol

@@ -1,6 +1,11 @@
 //SPDX-License-Identifier: MIT
 pragma solidity ^0.8.4;
 
+struct Interface {
+    bytes4 interfaceId;
+    bytes4[] functions;
+}
+
 /**
  * @dev Interface for Extension
 */
@@ -20,18 +25,25 @@ interface IExtension {
      * to be able to easily inspect and query for the current state of the interface and
      * integrate with it.
      *
-     * See {ExtendLogic-getInterface} for an example.
+     * See {ExtendLogic-getSolidityInterface} for an example.
     */
-    function getInterface() external pure returns(string memory);
+    function getSolidityInterface() external pure returns(string memory);
 
     /**
-     * @dev Returns the interfaceId of current custom Extension interface
+     * @dev Returns the interface IDs that are implemented by the Extension
+     *
+     * These are full interface IDs and ARE NOT function selectors. Full interface IDs are
+     * XOR'd function selectors of an interface. For example the interface ID of the ERC721
+     * interface is 0x80ac58cd determined by the XOR or all function selectors of the interface.
+     * 
+     * If an interface only consists of a single function, then the interface ID is identical
+     * to that function selector.
      * 
      * Provides a simple abstraction from the developer for any custom Extension to 
-     * be EIP-165 compliant out-of-the-box simply by implementing this function.
+     * be EIP-165 compliant out-of-the-box simply by implementing this function. 
      *
      * Excludes any functions either already described by other interface definitions
      * that are not developed on top of this backbone i.e. EIP-165, IExtension
     */
-    function getInterfaceId() external pure returns(bytes4);
+    function getInterface() external returns(Interface[] memory interfaces);
 }

contracts/extensions/InternalExtension.sol

@@ -14,7 +14,7 @@ import "../errors/Errors.sol";
  *
  *  Base contract for Internal Extensions in the Extendable Framework
  *  
- *  Internal Extensions are used to house common functions that are used by other contract functions.
+ *  Internal Extensions are used to house common functions that are used by other contract extensions.
  *  This is used to make internal functions usable across all your extensions without exposing it
  *  to the external world.
  *