feat: deploy libraries and proxy contract as singletons

.gitignore

@@ -9,4 +9,6 @@ contracts/flattened
 .vscode
 
 yarn.lock
-package-lock.json
+package-lock.json
+
+.old

contracts/UsingWitnet.sol

@@ -3,9 +3,8 @@
 pragma solidity >=0.6.0 <0.7.0;
 
 import "./Request.sol";
-import "./Witnet.sol";
 import "./WitnetRequestBoardProxy.sol";
-
+import "./libs/Witnet.sol";
 
 /**
  * @title The UsingWitnet contract

contracts/WitnetRequestBoardProxy.sol

@@ -29,19 +29,23 @@ contract WitnetRequestBoardProxy {
   // Array with the controllers that have been used in the Proxy
   ControllerInfo[] internal controllers;
 
+
+  /// =======================================================================
+  /// --- Modifiers ---------------------------------------------------------
+
   modifier notIdentical(address _newAddress) {
     require(_newAddress != address(currentWitnetRequestBoard), "The provided Witnet Requests Board instance address is already in use");
     _;
   }
 
- /**
-  * @notice Include an address to specify the Witnet Request Board.
-  * @param _witnetRequestBoardAddress WitnetRequestBoard address.
-  */
-  constructor(address _witnetRequestBoardAddress) public {
+
+  /// =======================================================================
+  /// --- Constructor -------------------------------------------------------
+
+  /// @notice Constructor: initialize controllers list
+    constructor() public {
     // Initialize the first epoch pointing to the first controller
-    controllers.push(ControllerInfo({controllerAddress: _witnetRequestBoardAddress, lastId: 0}));
-    currentWitnetRequestBoard = WitnetRequestBoardInterface(_witnetRequestBoardAddress);
+    controllers.push(ControllerInfo({controllerAddress: address(0), lastId: 0}));
   }
 
   /// @dev Posts a data request into the WRB in expectation that it will be relayed and resolved in Witnet with a total reward that equals to msg.value.
@@ -106,11 +110,17 @@ contract WitnetRequestBoardProxy {
 
   /// @notice Upgrades the Witnet Requests Board if the current one is upgradeable.
   /// @param _newAddress address of the new block relay to upgrade.
-  function upgradeWitnetRequestBoard(address _newAddress) external notIdentical(_newAddress) {
-    // Require the WRB is upgradable
-    require(currentWitnetRequestBoard.isUpgradable(msg.sender), "The upgrade has been rejected by the current implementation");
+  function upgradeWitnetRequestBoard(address _newAddress) public notIdentical(_newAddress) {
+    // Require current WRB to be upgradable:
+    require(
+        address(currentWitnetRequestBoard) == address(0) 
+          || currentWitnetRequestBoard.isUpgradable(msg.sender)
+        , "The upgrade has been rejected by the current implementation"
+      );
+
     // Map the currentLastId to the corresponding witnetRequestBoardAddress and add it to controllers
     controllers.push(ControllerInfo({controllerAddress: _newAddress, lastId: currentLastId}));
+
     // Upgrade the WRB
     currentWitnetRequestBoard = WitnetRequestBoardInterface(_newAddress);
   }

contracts/utils/SingletonFactory.sol

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: CC0-1.0
+
+pragma solidity ^0.6.2;
+
+
+/**
+ * @title Based on Singleton Factory (EIP-2470), authored by Guilherme Schmidt (Status Research & Development GmbH)
+ * @notice Exposes CREATE2 (EIP-1014) to deploy bytecode on deterministic addresses based on initialization code and salt.
+ * @dev Exposes also helper method to pre-determine contract address gieve
+ * @author Ricardo Guilherme Schmidt (Status Research & Development GmbH)
+ */
+contract SingletonFactory {
+    /**
+     * @notice Deploys `_initCode` using `_salt` for defining the deterministic address.
+     * @param _initCode Initialization code.
+     * @param _salt Arbitrary value to modify resulting address.
+     * @return createdContract Created contract address.
+     */
+    function deploy(bytes memory _initCode, bytes32 _salt)
+        public
+        returns (address payable createdContract)
+    {
+        assembly {
+            createdContract := create2(0, add(_initCode, 0x20), mload(_initCode), _salt)
+        }
+    }
+
+    /**
+     * @notice Deploys a deterministic address based on `_initCode` and `_salt`.
+      using `_salt` for defining the deterministic address.
+     * @param _initCode Initialization code.
+     * @param _initCall Calldata to be made to created contract.
+     * @param _salt Arbitrary value to modify resulting address.
+     * @return createdContract Created contract address.
+     */
+    function deployAndInit(bytes memory _initCode, bytes memory _initCall, bytes32 _salt)
+        public
+        returns (address payable createdContract)
+    {
+        assembly {
+            createdContract := create2(0, add(_initCode, 0x20), mload(_initCode), _salt)
+        }
+        if (_initCall.length > 0) {
+            // solhint-disable-next-line avoid-low-level-calls
+            (bool success, bytes memory reason) = createdContract.call(_initCall);
+            require(success, string(reason));
+        }
+    }
+
+
+    /**
+     * @notice Determine singleton contract address that might be created from this factory, given its `_initCode` and a `_salt`.
+     * @param _initCode Initialization code.
+     * @param _salt Arbitrary value to modify resulting address.
+     * @return expectedAddr Expected contract address.
+     */
+     function determineAddr(bytes memory _initCode, bytes32 _salt)
+        public
+        view
+        returns (address)
+    {
+        return address(
+            uint160(uint(keccak256(
+                abi.encodePacked(
+                    bytes1(0xff),
+                    address(this),
+                    _salt,
+                    keccak256(_initCode)
+                )
+            )))
+        );
+    }
+}

migrations/01_initial.js

@@ -0,0 +1,44 @@
+const fs = require("fs")
+const Migrations = artifacts.require("Migrations")
+
+module.exports = async function (deployer, network) {
+  if (!fs.existsSync("./migrations/addresses.json")) {
+    await fs.open("./migrations/addresses.json", "w", function (err, file) {
+      if (err) throw new Error("Fatal: cannot create ./migrations/addreses.json")
+      console.log("> Created ./migrations/addresses.json file.")
+    })
+  }
+
+  // Prepare "addresses.json" structure if necessary:
+  let addresses = await fs.readFileSync("./migrations/addresses.json")
+  if (addresses.length === 0) addresses = "{}"
+  addresses = JSON.parse(addresses)
+
+  let changes = false
+  if (!("networks" in addresses)) {
+    addresses.networks = {}
+    changes = true
+  }
+  if (!(network in addresses.networks)) {
+    addresses.networks[network] = {}
+    changes = true
+  }
+  if (!("singletons" in addresses)) {
+    addresses.singletons = {}
+    changes = true
+  }
+  if (!("libraries" in addresses.singletons)) {
+    addresses.singletons.libraries = {}
+    changes = true
+  }
+  if (!("contracts" in addresses.singletons)) {
+    addresses.singletons.contracts = {}
+    changes = true
+  }
+  if (changes) {
+    await fs.writeFileSync("./migrations/addresses.json", JSON.stringify(addresses, null, 2))
+  }
+
+  // Deploy "Migrations" contract:
+  await deployer.deploy(Migrations)
+}

migrations/02_singleton_libs.js

@@ -0,0 +1,115 @@
+const ethUtils = require("ethereumjs-util")
+const fs = require("fs")
+const utils = require("../utils")
+
+const SingletonFactory = artifacts.require("SingletonFactory")
+
+module.exports = async function (deployer, network, accounts) {
+  const addresses = require("./addresses.json")
+  const singletons = require("./singletons.json")
+
+  const from = singletons.from || deployer.networks[network].from || accounts[0]
+
+  // Generate SingletonFactory deployment transaction:
+  const res = utils.generateDeployTx(
+    SingletonFactory.toJSON(),
+    singletons.sender.r,
+    singletons.sender.s,
+    singletons.sender.gasprice,
+    singletons.sender.gas
+  )
+
+  const deployedCode = await web3.eth.getCode(res.contractAddr)
+
+  if (deployedCode.length <= 3) {
+    // Deploy SingletonFactory instance, if not yet deployed on this `network`:
+    utils.traceHeader("Inception of 'SingletonFactory':")
+
+    const balance = await web3.eth.getBalance(from)
+    const estimatedGas = res.gasLimit
+    const value = estimatedGas * res.gasPrice
+    let makerBalance = await web3.eth.getBalance(res.sender)
+
+    if (makerBalance < value) {
+      // transfer ETH funds to sender address, if currently not enough:
+      await web3.eth.sendTransaction({
+        from: from,
+        to: res.sender,
+        value: value - makerBalance,
+      })
+      makerBalance = await web3.eth.getBalance(res.sender)
+    }
+
+    const tx = await web3.eth.sendSignedTransaction(res.rawTx)
+    utils.traceTx(tx, web3.utils.fromWei((balance - await web3.eth.getBalance(from)).toString()))
+  } else {
+    utils.traceHeader("Singleton factory: 'SingletonFactory")
+  }
+
+  // Set SingletonFactory address on current network:
+  SingletonFactory.address = res.contractAddr
+  const factory = await SingletonFactory.deployed()
+
+  // Trace factory relevant data:
+  console.log("  ", "> sender's balance:\t",
+    `${web3.utils.fromWei((await web3.eth.getBalance(res.sender)).toString(), "ether")} ETH`
+  )
+  console.log("  ", "> factory codehash:\t", web3.utils.soliditySha3(await web3.eth.getCode(res.contractAddr)))
+  console.log("  ", "> factory sender:\t", res.sender)
+  console.log("  ", "> factory address:\t", factory.address)
+  console.log("  ", "> factory nonce:\t", await web3.eth.getTransactionCount(factory.address))
+  console.log("")
+
+  // Process all singleton libraries referred in config file:
+  for (const lib in singletons.libs) {
+    const artifact = artifacts.require(lib)
+    const salt = singletons.libs[lib].salt
+      ? "0x" + ethUtils.setLengthLeft(ethUtils.toBuffer(singletons.libs[lib].salt), 32).toString("hex")
+      : "0x0"
+
+    let bytecode = artifact.toJSON().bytecode
+    if (singletons.libs[lib].links) {
+      singletons.libs[lib].links.forEach(
+        // Join dependent library address(es) into the library bytecode to be deployed:
+        // Please note: dependent libraries should have been previously deployed,
+        //   so order in which libraries are declared in the config file actually matters.
+        sublib => {
+          const sublibArtifact = artifacts.require(sublib)
+          const sublibAddr = sublibArtifact.address.slice(2).toLowerCase()
+          const sublibMark = `__${sublibArtifact.contractName}${"_".repeat(38 - sublibArtifact.contractName.length)}`
+          bytecode = bytecode.split(sublibMark).join(sublibAddr)
+        }
+      )
+    }
+    artifact.bytecode = bytecode
+
+    const libAddr = await factory.determineAddr.call(bytecode, salt)
+
+    if ((await web3.eth.getCode(libAddr)).length <= 3) {
+      // Deploy library instance, if not yet deployed on this `network`:
+      utils.traceHeader(`Singleton inception of library '${lib}':`)
+
+      const balance = await web3.eth.getBalance(from)
+      const gas = singletons.libs[lib].gas || 10 ** 6
+      const tx = await factory.deploy(bytecode, salt, { from: from, gas: gas })
+      utils.traceTx(tx.receipt, web3.utils.fromWei((balance - await web3.eth.getBalance(from)).toString()))
+    } else {
+      utils.traceHeader(`Singleton library: '${lib}'`)
+    }
+
+    artifact.address = libAddr
+
+    const libCodehash = web3.utils.soliditySha3(await web3.eth.getCode(artifact.address))
+    if (!libCodehash) {
+      throw new Error(`Fatal: unable to deploy library '${lib}' as singleton. Try providing more gas.`)
+    }
+
+    console.log("  ", "> library codehash:\t", libCodehash)
+    console.log("  ", "> library address:\t", artifact.address)
+    console.log()
+
+    addresses.singletons.libraries[lib] = libAddr
+  }
+
+  fs.writeFileSync("./migrations/addresses.json", JSON.stringify(addresses, null, 2))
+}

migrations/03_new_wrb.js

@@ -0,0 +1,17 @@
+const fs = require("fs")
+const WitnetRequestBoard = artifacts.require("WitnetRequestBoard")
+
+module.exports = async function (deployer, network, accounts) {
+  network = network.split("-")[0]
+
+  const addresses = require("./addresses.json")
+  if (network in addresses.networks && addresses.networks[network].WitnetRequestBoard) {
+    WitnetRequestBoard.address = addresses.networks[network].WitnetRequestBoard
+  } else {
+    console.log(`> Deploying new instance of 'WitnetRequestBoard' into '${network}' network...`)
+    await deployer.deploy(WitnetRequestBoard, [accounts[0]], { from: accounts[0] })
+    addresses.networks[network].WitnetRequestBoard = WitnetRequestBoard.address
+  }
+
+  fs.writeFileSync("./migrations/addresses.json", JSON.stringify(addresses, null, 2))
+}