[Protocol3] Add OwnedUpgradeabilityProxy from OpenZeppelin (#322)

Author: dong77

packages/loopring_v3/README.md

@@ -1,6 +1,7 @@
 # Loopring Protocol (V3) using zkSNARKs
 
 ## About
+
 This is a very early version of Loopring's order-based DEX protocol (version 3.0). The code base is still being tested and is not production ready.
 
 To understand several concepts introduced by the Loopring Protocol, such as order-ring, ring-matching, dual-authoring, free-burning, please read our [whitepaper](https://loopring.org/resources/en_whitepaper.pdf) for Loopring Protocol 2.x.
@@ -34,7 +35,6 @@ To understand the overall design for Loopring 3.0, including Ethereum smart cont
 - Can switch to better hash function
 - and more...
 
-
 ## Build
 
 `npm run build // first time` or `npm run compile` or `npm run watch`.
@@ -48,12 +48,17 @@ make
 ```
 
 ## Run Unit Tests
-* run `npm run ganache` from project's root directory in terminal.
-* run `npm run test` from project's root directory in another terminal window.
-* run single test: `npm run test -- transpiled/test/xxx.js`
-* print info logs in tests: `npm run test -- -i`
-* print more detailed debug logs in tests: `npm run test -- -x`
+
+- run `npm run ganache` from project's root directory in terminal.
+- run `npm run test` from project's root directory in another terminal window.
+- run single test: `npm run test -- transpiled/test/xxx.js`
+- print info logs in tests: `npm run test -- -i`
+- print more detailed debug logs in tests: `npm run test -- -x`
 
 Running all tests takes around 3 hours on a modern PC with a CPU with 4 cores. Creating proofs is computationaly heavy and takes time even when multi-threading is used. Run individual tests when you can.
 
 Verifier/Prover keys are cached in the `keys` folder. When updating the circuits make sure to delete the keys of older circuit versions because this is not automatically detected.
+
+## Contract Deployment
+
+It's recommended to deploy the protocol with **UpgradeabilityProxy**. For more information, please see https://blog.openzeppelin.com/upgradeability-using-unstructured-storage and https://github.com/OpenZeppelin/openzeppelin-labs/tree/master/upgradeability_using_unstructured_storage.

packages/loopring_v3/contracts/thirdparty/OwnedUpgradeabilityProxy.sol

@@ -0,0 +1,89 @@
+// This code is taken from https://github.com/OpenZeppelin/openzeppelin-labs
+// with minor modifications.
+
+pragma solidity 0.5.10;
+
+import './UpgradeabilityProxy.sol';
+
+/**
+ * @title OwnedUpgradeabilityProxy
+ * @dev This contract combines an upgradeability proxy with basic authorization control functionalities
+ */
+contract OwnedUpgradeabilityProxy is UpgradeabilityProxy {
+  /**
+  * @dev Event to show ownership has been transferred
+  * @param previousOwner representing the address of the previous owner
+  * @param newOwner representing the address of the new owner
+  */
+  event ProxyOwnershipTransferred(address previousOwner, address newOwner);
+
+  // Storage position of the owner of the contract
+  bytes32 private constant proxyOwnerPosition = keccak256("org.zeppelinos.proxy.owner");
+
+  /**
+  * @dev the constructor sets the original owner of the contract to the sender account.
+  */
+  constructor() public {
+    setUpgradeabilityOwner(msg.sender);
+  }
+
+  /**
+  * @dev Throws if called by any account other than the owner.
+  */
+  modifier onlyProxyOwner() {
+    require(msg.sender == proxyOwner());
+    _;
+  }
+
+  /**
+   * @dev Tells the address of the owner
+   * @return the address of the owner
+   */
+  function proxyOwner() public view returns (address owner) {
+    bytes32 position = proxyOwnerPosition;
+    assembly {
+      owner := sload(position)
+    }
+  }
+
+  /**
+   * @dev Sets the address of the owner
+   */
+  function setUpgradeabilityOwner(address newProxyOwner) internal {
+    bytes32 position = proxyOwnerPosition;
+    assembly {
+      sstore(position, newProxyOwner)
+    }
+  }
+
+  /**
+   * @dev Allows the current owner to transfer control of the contract to a newOwner.
+   * @param newOwner The address to transfer ownership to.
+   */
+  function transferProxyOwnership(address newOwner) public onlyProxyOwner {
+    require(newOwner != address(0));
+    emit ProxyOwnershipTransferred(proxyOwner(), newOwner);
+    setUpgradeabilityOwner(newOwner);
+  }
+
+  /**
+   * @dev Allows the proxy owner to upgrade the current version of the proxy.
+   * @param implementation representing the address of the new implementation to be set.
+   */
+  function upgradeTo(address implementation) public onlyProxyOwner {
+    _upgradeTo(implementation);
+  }
+
+  /**
+   * @dev Allows the proxy owner to upgrade the current version of the proxy and call the new implementation
+   * to initialize whatever is needed through a low level call.
+   * @param implementation representing the address of the new implementation to be set.
+   * @param data represents the msg.data to bet sent in the low level call. This parameter may include the function
+   * signature of the implementation to be called with the needed payload
+   */
+  function upgradeToAndCall(address implementation, bytes memory data) payable public onlyProxyOwner {
+    upgradeTo(implementation);
+    (bool success, ) = address(this).call.value(msg.value)(data);
+    require(success);
+  }
+}