Feat: First approach to WitnetBytecodes

.eslintrc

@@ -32,6 +32,6 @@
     "import/export": 0,
     "no-useless-constructor": 1,
     "handle-callback-err": 1,
-    "max-len" : ["error", { "code": 120 }]
+    "max-len" : ["error", { "code": 130 }]
   }
 }

.github/workflows/nodejs.yml

@@ -12,7 +12,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [14.x, 16.x]
+        node-version: [16.x]
 
     steps:
     - uses: actions/checkout@v1

.solhint.json

@@ -16,6 +16,7 @@
     "modifier-name-mixedcase": "warn",
     "no-empty-blocks": "off",
     "no-inline-assembly": "off",
+    "var-name-mixedcase": "off",
     "reason-string": [
       "warn",
       {

contracts/WitnetRequestBoard.sol

@@ -17,8 +17,4 @@ abstract contract WitnetRequestBoard is
     IWitnetRequestBoardRequestor,
     IWitnetRequestBoardView,
     IWitnetRequestParser
-{
-    receive() external payable {
-        revert("WitnetRequestBoard: no transfers accepted");
-    }
-}
+{}

contracts/apps/WitnetRandomness.sol

@@ -249,19 +249,18 @@ contract WitnetRandomness
 
 
     // ================================================================================================================
-    // --- 'Clonable' overriden functions -----------------------------------------------------------------------------
+    // --- 'Clonable' extension ---------------------------------------------------------------------------------------
 
     /// Deploys and returns the address of a minimal proxy clone that replicates contract
     /// behaviour while using its own EVM storage.
     /// @dev This function should always provide a new address, no matter how many times 
     /// @dev is actually called from the same `msg.sender`.
     function clone()
-        public
-        virtual override
-        returns (Clonable _newInstance)
+        virtual public
+        wasInitialized
+        returns (WitnetRandomness)
     {
-        _newInstance = super.clone();
-        _clone(_newInstance);
+        return _afterClone(_clone());
     }
 
     /// Deploys and returns the address of a minimal proxy clone that replicates contract 
@@ -270,24 +269,37 @@ contract WitnetRandomness
     /// @dev the clone. Using the same `_salt` multiple time will revert, since
     /// @dev no contract can be deployed more than once at the same address.
     function cloneDeterministic(bytes32 _salt)
-        public
-        virtual override
-        returns (Clonable _newInstance)
+        virtual public
+        wasInitialized
+        returns (WitnetRandomness)
     {
-        _newInstance = super.cloneDeterministic(_salt);
-        _clone(_newInstance);
+        return _afterClone(_cloneDeterministic(_salt));
     }
 
+    /// @notice Initializes a cloned instance. 
+    /// @dev Every cloned instance can only get initialized once.
+    function initializeClone(bytes memory _initData)
+        virtual external
+        initializer // => ensure a cloned instance can only be initialized once
+        onlyDelegateCalls // => this method can only be called upon cloned instances
+    {
+        _initialize(_initData);
+    }
 
-    // ================================================================================================================
-    // --- 'Initializable' overriden functions ------------------------------------------------------------------------
+    /// @notice Tells whether this instance has been initialized.
+    function initialized()
+        override
+        public view
+        returns (bool)
+    {
+        return address(witnetRandomnessRequest) != address(0);
+    }
 
-    /// @dev Initializes contract's storage context.
-    function initialize(bytes memory _initData)
-        public
-        virtual override
+    /// @notice Re-initialize contract's storage context upon a new upgrade from a proxy.    
+    /// @dev Must fail when trying to upgrade to same logic contract more than once.
+    function _initialize(bytes memory _initData)
+        virtual internal
     {
-        require(address(witnetRandomnessRequest) == address(0), "WitnetRandomness: already initialized");
         witnetRandomnessRequest = WitnetRequestRandomness(
             abi.decode(
                 _initData,
@@ -301,10 +313,14 @@ contract WitnetRandomness
     // --- INTERNAL FUNCTIONS -----------------------------------------------------------------------------------------
 
     /// @dev Common steps for both deterministic and non-deterministic cloning.
-    function _clone(Clonable _instance) internal {
-        address _request = address(witnetRandomnessRequest.clone());
-        Ownable(_request).transferOwnership(msg.sender);
-        _instance.initialize(abi.encode(_request));
+    function _afterClone(address _instance)
+        virtual internal
+        returns (WitnetRandomness)
+    {
+        address _randomnessRequest = address(witnetRandomnessRequest.clone());
+        Ownable(_randomnessRequest).transferOwnership(msg.sender);
+        WitnetRandomness(_instance).initializeClone(abi.encode(_randomnessRequest));
+        return WitnetRandomness(_instance);
     }
 
     /// @dev Returns index of the Most Significant Bit of the given number, applying De Bruijn O(1) algorithm.