Refactor onlyProxyOwner modifier

contracts/IOwnedUpgradeabilityProxy.sol

@@ -0,0 +1,6 @@
+pragma solidity 0.4.24;
+
+
+interface IOwnedUpgradeabilityProxy {
+    function proxyOwner() public view returns (address);
+}

contracts/upgradeable_contracts/BasicBridge.sol

@@ -1,6 +1,6 @@
 pragma solidity 0.4.24;
 import "../IBridgeValidators.sol";
-import "../upgradeability/OwnedUpgradeabilityProxy.sol";
+import "./OwnedUpgradeability.sol";
 import "../upgradeability/EternalStorage.sol";
 import "../libraries/SafeMath.sol";
 import "./Validatable.sol";
@@ -8,7 +8,7 @@ import "./Ownable.sol";
 import "openzeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol";
 
 
-contract BasicBridge is OwnedUpgradeabilityProxy, EternalStorage, Validatable, Ownable {
+contract BasicBridge is EternalStorage, Validatable, Ownable, OwnedUpgradeability {
     using SafeMath for uint256;
 
     event GasPriceChanged(uint256 gasPrice);

contracts/upgradeable_contracts/OverdrawManagement.sol

@@ -2,10 +2,10 @@ pragma solidity 0.4.24;
 
 import "../upgradeability/EternalStorage.sol";
 import "../libraries/SafeMath.sol";
-import "../upgradeability/OwnedUpgradeabilityProxy.sol";
+import "./OwnedUpgradeability.sol";
 
 
-contract OverdrawManagement is OwnedUpgradeabilityProxy, EternalStorage {
+contract OverdrawManagement is EternalStorage, OwnedUpgradeability {
     using SafeMath for uint256;
 
     event UserRequestForSignature(address recipient, uint256 value);

contracts/upgradeable_contracts/OwnedUpgradeability.sol

@@ -0,0 +1,16 @@
+pragma solidity 0.4.24;
+
+import "../IOwnedUpgradeabilityProxy.sol";
+
+
+contract OwnedUpgradeability {
+
+    function upgradeabilityAdmin() public view returns (address) {
+        return IOwnedUpgradeabilityProxy(this).proxyOwner();
+    }
+
+    modifier onlyProxyOwner() {
+        require(msg.sender == upgradeabilityAdmin());
+        _;
+    }
+}

test/erc_to_erc/foreign_bridge.test.js

@@ -272,7 +272,10 @@ contract('ForeignBridge_ERC20_to_ERC20', async (accounts) => {
     it('can send erc20', async () => {
       const owner = accounts[0];
       token = await ERC677BridgeToken.new("Some ERC20", "RSZT", 18);
-      foreignBridge = await ForeignBridge.new();
+      const foreignBridgeImpl = await ForeignBridge.new();
+      const storageProxy = await EternalStorageProxy.new().should.be.fulfilled;
+      await storageProxy.upgradeTo('1', foreignBridgeImpl.address).should.be.fulfilled
+      const foreignBridge = await ForeignBridge.at(storageProxy.address);
       await foreignBridge.initialize(validatorContract.address, token.address, requireBlockConfirmations, gasPrice, owner);
 
       let tokenSecond = await ERC677BridgeToken.new("Roman Token", "RST", 18);

test/erc_to_native/foreign_bridge.test.js

@@ -325,7 +325,10 @@ contract('ForeignBridge_ERC20_to_Native', async (accounts) => {
     it('can send erc20', async () => {
       const owner = accounts[0];
       token = await ERC677BridgeToken.new("Some ERC20", "RSZT", 18);
-      const foreignBridge = await ForeignBridge.new();
+      const foreignBridgeImpl = await ForeignBridge.new();
+      const storageProxy = await EternalStorageProxy.new().should.be.fulfilled;
+      await storageProxy.upgradeTo('1', foreignBridgeImpl.address).should.be.fulfilled
+      const foreignBridge = await ForeignBridge.at(storageProxy.address);
 
       await foreignBridge.initialize(validatorContract.address, token.address, requireBlockConfirmations, gasPrice, maxPerTx, homeDailyLimit, homeMaxPerTx, owner);
       const tokenSecond = await ERC677BridgeToken.new("Roman Token", "RST", 18);

test/erc_to_native/home_bridge.test.js

@@ -102,6 +102,36 @@ contract('HomeBridge_ERC20_to_Native', async (accounts) => {
       "2".should.be.bignumber.equal(await finalContract.maxPerTx())
       "1".should.be.bignumber.equal(await finalContract.minPerTx())
     })
+    it('can be upgraded keeping the state', async () => {
+      const homeOwner = accounts[8]
+      const storageProxy = await EternalStorageProxy.new().should.be.fulfilled;
+      const proxyOwner = await storageProxy.proxyOwner()
+      const data = homeContract.initialize.request(validatorContract.address, "3", "2", "1", gasPrice, requireBlockConfirmations, blockRewardContract.address, foreignDailyLimit, foreignMaxPerTx, homeOwner).params[0].data
+
+      await storageProxy.upgradeToAndCall('1', homeContract.address, data).should.be.fulfilled
+      const finalContract = await HomeBridge.at(storageProxy.address);
+
+      true.should.be.equal(await finalContract.isInitialized())
+      validatorContract.address.should.be.equal(await finalContract.validatorContract())
+      blockRewardContract.address.should.be.equal(await finalContract.blockRewardContract())
+      "3".should.be.bignumber.equal(await finalContract.dailyLimit())
+      "2".should.be.bignumber.equal(await finalContract.maxPerTx())
+      "1".should.be.bignumber.equal(await finalContract.minPerTx())
+      const upgradeabilityAdmin =  await finalContract.upgradeabilityAdmin()
+      upgradeabilityAdmin.should.be.equal(proxyOwner)
+
+      const homeContractV2 = await HomeBridge.new()
+      await storageProxy.upgradeTo('2', homeContractV2.address).should.be.fulfilled
+      const finalContractV2 = await HomeBridge.at(storageProxy.address);
+
+      validatorContract.address.should.be.equal(await finalContractV2.validatorContract())
+      blockRewardContract.address.should.be.equal(await finalContractV2.blockRewardContract())
+      "3".should.be.bignumber.equal(await finalContractV2.dailyLimit())
+      "2".should.be.bignumber.equal(await finalContractV2.maxPerTx())
+      "1".should.be.bignumber.equal(await finalContractV2.minPerTx())
+      const upgradeabilityAdminV2 =  await finalContractV2.upgradeabilityAdmin()
+      upgradeabilityAdminV2.should.be.equal(proxyOwner)
+    })
     it('cant initialize with invalid arguments', async () => {
       false.should.be.equal(await homeContract.isInitialized())
       await homeContract.initialize(validatorContract.address, '3', '2', '1', gasPrice, 0, blockRewardContract.address, foreignDailyLimit, foreignMaxPerTx, owner).should.be.rejectedWith(ERROR_MSG);
@@ -615,7 +645,10 @@ contract('HomeBridge_ERC20_to_Native', async (accounts) => {
     let homeBridge;
     const zeroValue = web3.toBigNumber(web3.toWei(0, "ether"))
     beforeEach(async () => {
-      homeBridge = await HomeBridge.new();
+      const homeBridgeImpl = await HomeBridge.new();
+      const storageProxy = await EternalStorageProxy.new().should.be.fulfilled;
+      await storageProxy.upgradeTo('1', homeBridgeImpl.address).should.be.fulfilled
+      homeBridge = await HomeBridge.at(storageProxy.address);
       await homeBridge.initialize(validatorContract.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, blockRewardContract.address, foreignDailyLimit, foreignMaxPerTx, owner);
     })
     it('Should reduce outOfLimitAmount and not emit any event', async () => {
@@ -709,4 +742,18 @@ contract('HomeBridge_ERC20_to_Native', async (accounts) => {
       await homeBridge.fixAssetsAboveLimits(transactionHash, true, { from: owner}).should.be.fulfilled
     })
   })
+  describe('#OwnedUpgradeability', async () => {
+
+    it('upgradeabilityAdmin should return the proxy owner', async () => {
+      const homeBridgeImpl = await HomeBridge.new();
+      const storageProxy = await EternalStorageProxy.new().should.be.fulfilled;
+      await storageProxy.upgradeTo('1', homeBridgeImpl.address).should.be.fulfilled
+      const homeBridge = await HomeBridge.at(storageProxy.address);
+
+      const proxyOwner = await storageProxy.proxyOwner()
+      const upgradeabilityAdmin = await homeBridge.upgradeabilityAdmin()
+
+      upgradeabilityAdmin.should.be.equal(proxyOwner)
+    })
+  })
 })

test/native_to_erc/foreign_bridge_test.js

@@ -428,7 +428,10 @@ contract('ForeignBridge', async (accounts) => {
     it('can send erc20', async () => {
       const owner = accounts[0];
       token = await POA20.new("POA ERC20 Foundation", "POA20", 18);
-      foreignBridge = await ForeignBridge.new();
+      const foreignBridgeImpl = await ForeignBridge.new();
+      const storageProxy = await EternalStorageProxy.new().should.be.fulfilled;
+      await storageProxy.upgradeTo('1', foreignBridgeImpl.address).should.be.fulfilled
+      const foreignBridge = await ForeignBridge.at(storageProxy.address);
       await foreignBridge.initialize(validatorContract.address, token.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, owner);
       await token.transferOwnership(foreignBridge.address)
 
@@ -448,7 +451,10 @@ contract('ForeignBridge', async (accounts) => {
     it('also calls claimTokens on tokenAddress', async () => {
       const owner = accounts[0];
       token = await POA20.new("POA ERC20 Foundation", "POA20", 18);
-      foreignBridge = await ForeignBridge.new();
+      const foreignBridgeImpl = await ForeignBridge.new();
+      const storageProxy = await EternalStorageProxy.new().should.be.fulfilled;
+      await storageProxy.upgradeTo('1', foreignBridgeImpl.address).should.be.fulfilled
+      const foreignBridge = await ForeignBridge.at(storageProxy.address);
       await foreignBridge.initialize(validatorContract.address, token.address, oneEther, halfEther, minPerTx, gasPrice, requireBlockConfirmations, owner);
       await token.transferOwnership(foreignBridge.address)