Disable sai swap to dai

contracts/upgradeable_contracts/erc20_to_native/ForeignBridgeErcToNative.sol

@@ -104,30 +104,14 @@ contract ForeignBridgeErcToNative is BasicForeignBridge, ERC20Bridge, OtherSideB
         revert();
     }
 
-    function migrateToMCD() external {
-        bytes32 storageAddress = 0x3378953eb16363e06fd9ea9701d36ed7285d206d9de7df55b778462d74596a89; // keccak256(abi.encodePacked("migrationToMcdCompleted"))
-        require(!boolStorage[storageAddress]);
-
-        address mcdContract = IDaiAdapter(migrationContract().daiJoin()).dai();
-        setErc20token(mcdContract);
-
-        uintStorage[MIN_HDTOKEN_BALANCE] = 10 ether;
-
-        swapTokens();
-
-        boolStorage[storageAddress] = true;
-    }
-
     function saiTopContract() internal pure returns (ISaiTop) {
         return ISaiTop(0x9b0ccf7C8994E19F39b2B4CF708e0A7DF65fA8a3);
     }
 
-    function isTokenSwapAllowed(uint256 _ts) public view returns (bool) {
-        uint256 esTs = saiTopContract().caged();
-        if (esTs > 0 && _ts > esTs) {
-            return false;
-        }
-        return true;
+    function isTokenSwapAllowed(
+        uint256 /* _ts */
+    ) public pure returns (bool) {
+        return false;
     }
 
     function halfDuplexErc20token() public pure returns (ERC20) {

test/erc_to_native/foreign_bridge.test.js

@@ -24,7 +24,6 @@ const {
   signatureToVRS,
   ether,
   expectEventInLogs,
-  getEvents,
   createFullAccounts,
   delay,
   packSignatures
@@ -1149,58 +1148,6 @@ contract('ForeignBridge_ERC20_to_Native', async accounts => {
       expect(await token.balanceOf(foreignBridge.address)).to.be.bignumber.equal(minDaiLimit)
     })
   })
-  describe('migrateToMCD', () => {
-    let foreignBridge
-    beforeEach(async () => {
-      foreignBridge = await ForeignBridgeErcToNativeMock.new()
-
-      await foreignBridge.initialize(
-        validatorContract.address,
-        sai.address,
-        requireBlockConfirmations,
-        gasPrice,
-        [dailyLimit, maxPerTx, minPerTx],
-        [homeDailyLimit, homeMaxPerTx],
-        owner,
-        decimalShiftZero,
-        otherSideBridge.address
-      )
-
-      // Mint the bridge some sai tokens
-      await sai.mint(foreignBridge.address, oneEther)
-    })
-    it('should be able to swap tokens', async () => {
-      // Given
-      expect(await sai.balanceOf(foreignBridge.address)).to.be.bignumber.equal(oneEther)
-      expect(await dai.balanceOf(foreignBridge.address)).to.be.bignumber.equal(ZERO)
-      expect(await foreignBridge.erc20token()).to.be.equal(sai.address)
-
-      // When
-
-      const { logs } = await foreignBridge.migrateToMCD({ from: owner }).should.be.fulfilled
-
-      // can't migrate token again
-      await foreignBridge.migrateToMCD({ from: owner }).should.be.rejectedWith(ERROR_MSG)
-
-      // Then
-      expect(await sai.balanceOf(foreignBridge.address)).to.be.bignumber.equal(ZERO)
-      expect(await dai.balanceOf(foreignBridge.address)).to.be.bignumber.equal(oneEther)
-      expect(await foreignBridge.erc20token()).to.be.equal(dai.address)
-      expect(await foreignBridge.minHDTokenBalance()).to.be.bignumber.equal(ether('10'))
-      expectEventInLogs(logs, 'TokensSwapped', {
-        from: sai.address,
-        to: dai.address,
-        value: oneEther
-      })
-      const transferEvent = await getEvents(dai, { event: 'Transfer' })
-
-      // first transfer event was for minting to user in the top Before section
-      expect(transferEvent.length).to.be.equal(2)
-      expect(transferEvent[1].returnValues.from).to.be.equal(ZERO_ADDRESS)
-      expect(transferEvent[1].returnValues.to).to.be.equal(foreignBridge.address)
-      expect(transferEvent[1].returnValues.value).to.be.equal(oneEther.toString())
-    })
-  })
   describe('support two tokens', () => {
     let foreignBridge
     const recipient = accounts[8]
@@ -1223,16 +1170,16 @@ contract('ForeignBridge_ERC20_to_Native', async accounts => {
       await sai.mint(user, twoEthers)
     })
     describe('isTokenSwapAllowed', () => {
-      it('isTokenSwapAllowed should return true if SCD ES was executed', async () => {
+      it('isTokenSwapAllowed should return always false', async () => {
         // Given
-        expect(await foreignBridge.isTokenSwapAllowed(100)).to.be.equal(true)
+        expect(await foreignBridge.isTokenSwapAllowed(100)).to.be.equal(false)
 
         // When
         await saiTop.setCaged(150)
 
         // Then
-        expect(await foreignBridge.isTokenSwapAllowed(100)).to.be.equal(true)
-        expect(await foreignBridge.isTokenSwapAllowed(150)).to.be.equal(true)
+        expect(await foreignBridge.isTokenSwapAllowed(100)).to.be.equal(false)
+        expect(await foreignBridge.isTokenSwapAllowed(150)).to.be.equal(false)
         expect(await foreignBridge.isTokenSwapAllowed(200)).to.be.equal(false)
 
         // reset the caged value
@@ -1264,7 +1211,7 @@ contract('ForeignBridge_ERC20_to_Native', async accounts => {
       })
     })
     describe('swapTokens', () => {
-      it('should be able to swap tokens calling swapTokens', async () => {
+      it('should not be able to swap tokens calling swapTokens', async () => {
         expect(await saiTop.caged()).to.be.bignumber.equal(ZERO)
         expect(await sai.balanceOf(foreignBridge.address)).to.be.bignumber.equal(ZERO)
         expect(await dai.balanceOf(foreignBridge.address)).to.be.bignumber.equal(ZERO)
@@ -1278,43 +1225,7 @@ contract('ForeignBridge_ERC20_to_Native', async accounts => {
         expect(await sai.balanceOf(foreignBridge.address)).to.be.bignumber.equal(oneEther)
         expect(await dai.balanceOf(foreignBridge.address)).to.be.bignumber.equal(ZERO)
 
-        const { logs } = await foreignBridge.swapTokens()
-
-        expect(await sai.balanceOf(foreignBridge.address)).to.be.bignumber.equal(ZERO)
-        expect(await dai.balanceOf(foreignBridge.address)).to.be.bignumber.equal(oneEther)
-        expect(await foreignBridge.erc20token()).to.be.equal(dai.address)
-        expectEventInLogs(logs, 'TokensSwapped', {
-          from: sai.address,
-          to: dai.address,
-          value: oneEther
-        })
-
-        // mint more sai tokens to bridge
-        await sai.mint(foreignBridge.address, oneEther)
-
-        expect(await sai.balanceOf(foreignBridge.address)).to.be.bignumber.equal(oneEther)
-        expect(await dai.balanceOf(foreignBridge.address)).to.be.bignumber.equal(oneEther)
-
-        await foreignBridge.swapTokens().should.be.fulfilled
-
-        expect(await sai.balanceOf(foreignBridge.address)).to.be.bignumber.equal(ZERO)
-        expect(await dai.balanceOf(foreignBridge.address)).to.be.bignumber.equal(twoEthers)
-
-        const block = await web3.eth.getBlock('latest')
-        // Trigger Emergency Shutdown
-        await saiTop.setCaged(block.number)
-
-        // mint sai tokens to bridge
-        await sai.mint(foreignBridge.address, oneEther)
-
-        expect(await sai.balanceOf(foreignBridge.address)).to.be.bignumber.equal(oneEther)
-        expect(await dai.balanceOf(foreignBridge.address)).to.be.bignumber.equal(twoEthers)
-
-        // should not be able to swap tokens after Emergency Shutdown
         await foreignBridge.swapTokens().should.be.rejectedWith(ERROR_MSG)
-
-        // reset the caged value
-        await saiTop.setCaged(0)
       })
     })
     describe('relayTokens', () => {
@@ -1367,11 +1278,10 @@ contract('ForeignBridge_ERC20_to_Native', async accounts => {
         })
         expect(await dai.balanceOf(user)).to.be.bignumber.equal(balance.sub(value))
       })
-      it('should swap token if half duplex token is used', async () => {
+      it('should not swap token if half duplex token is used', async () => {
         // Given
         const relayTokens = foreignBridge.methods['relayTokens(address,uint256,address)']
 
-        const userBalance = await sai.balanceOf(user)
         expect(await sai.balanceOf(foreignBridge.address)).to.be.bignumber.equal(ZERO)
         expect(await dai.balanceOf(foreignBridge.address)).to.be.bignumber.equal(ZERO)
         const currentDay = await foreignBridge.getCurrentDay()
@@ -1380,22 +1290,7 @@ contract('ForeignBridge_ERC20_to_Native', async accounts => {
         await sai.approve(foreignBridge.address, value, { from: user }).should.be.fulfilled
 
         // When
-        const { logs } = await relayTokens(recipient, value, sai.address, { from: user }).should.be.fulfilled
-
-        // Then
-        expect(await foreignBridge.totalSpentPerDay(currentDay)).to.be.bignumber.equal(value)
-        expectEventInLogs(logs, 'UserRequestForAffirmation', {
-          recipient,
-          value
-        })
-        expectEventInLogs(logs, 'TokensSwapped', {
-          from: sai.address,
-          to: dai.address,
-          value
-        })
-        expect(await sai.balanceOf(user)).to.be.bignumber.equal(userBalance.sub(value))
-        expect(await sai.balanceOf(foreignBridge.address)).to.be.bignumber.equal(ZERO)
-        expect(await dai.balanceOf(foreignBridge.address)).to.be.bignumber.equal(value)
+        await relayTokens(recipient, value, sai.address, { from: user }).should.be.rejectedWith(ERROR_MSG)
       })
       it('should fail if token address is unknown', async () => {
         const otherToken = await ERC20Mock.new('token', 'TOK', 18)
@@ -1528,7 +1423,7 @@ contract('ForeignBridge_ERC20_to_Native', async accounts => {
       })
     })
     describe('onExecuteMessage', () => {
-      it('should swapTokens in executeSignatures', async () => {
+      it('should not swap Tokens in executeSignatures', async () => {
         const value = ether('0.25')
         const recipientAccount = accounts[3]
         const balanceBefore = await dai.balanceOf(recipientAccount)
@@ -1552,14 +1447,9 @@ contract('ForeignBridge_ERC20_to_Native', async accounts => {
           recipient: recipientAccount,
           value
         })
-        expectEventInLogs(logs, 'TokensSwapped', {
-          from: sai.address,
-          to: dai.address,
-          value: halfEther
-        })
         expect(await dai.balanceOf(recipientAccount)).to.be.bignumber.equal(balanceBefore.add(value))
-        expect(await sai.balanceOf(foreignBridge.address)).to.be.bignumber.equal(ZERO)
-        expect(await dai.balanceOf(foreignBridge.address)).to.be.bignumber.equal(halfEther)
+        expect(await sai.balanceOf(foreignBridge.address)).to.be.bignumber.equal(halfEther)
+        expect(await dai.balanceOf(foreignBridge.address)).to.be.bignumber.equal(ZERO)
         expect(await foreignBridge.relayedMessages(transactionHash)).to.be.equal(true)
       })
     })
@@ -1587,12 +1477,6 @@ contract('ForeignBridge_ERC20_to_Native', async accounts => {
         // Mint sai tokens to the bridge
         await sai.mint(foreignBridge.address, halfEther)
 
-        await foreignBridge.claimTokens(sai.address, accounts[3], { from: owner }).should.be.rejectedWith(ERROR_MSG)
-
-        const block = await web3.eth.getBlock('latest')
-        // Trigger Emergency Shutdown
-        await saiTop.setCaged(block.number)
-
         expect(await sai.balanceOf(foreignBridge.address)).to.be.bignumber.equal(halfEther)
         expect(await sai.balanceOf(accounts[3])).to.be.bignumber.equal(ZERO)
 

upgrade/.env.example

@@ -1,9 +1,3 @@
-HOME_RPC_URL=https://dai.poa.network
-HOME_PRIVKEY=0x...
-HOME_BRIDGE_ADDRESS=0x7301CFA0e1756B71869E93d4e4Dca5c7d0eb0AA6
-HOME_START_BLOCK=7384314
-HOME_GAS_PRICE=1000000000
-
 FOREIGN_RPC_URL=https://mainnet.infura.io/v3/API_KEY
 FOREIGN_PRIVKEY=0x...
 FOREING_BRIDGE_ADDRESS=0x4aa42145Aa6Ebf72e164C9bBC74fbD3788045016
@@ -13,7 +7,4 @@ FOREIGN_GAS_PRICE=1000000000
 # leader or confirm
 ROLE=confirm
 
-# Optional parameters, depends on the script used
-NEW_IMPLEMENTATION_XDAI_BRIDGE=
 NEW_IMPLEMENTATION_ETH_BRIDGE=
-CHAI_INTEREST_RECEIVER=

upgrade/README.md

@@ -21,6 +21,4 @@ cp .env.example .env
 Complete the variables in `.env` file. The `ROLE` variable indicates if the validator will send the creation transaction on the multisig wallet or if it will send the confirmation.
 
 Run the script. The following are available:
-* `npm run upgradeBridgeOnForeign` (Requires `NEW_IMPLEMENTATION_ETH_BRIDGE` .env param)
-* `npm run initializeChai` (Requires `CHAI_INTEREST_RECEIVER` .env param)
-* `npm run upgradeBridgeOnHome` (Requires `NEW_IMPLEMENTATION_XDAI_BRIDGE` .env param)
+* `npm run upgradeBridgeOnForeign`

upgrade/package.json

@@ -5,8 +5,6 @@
     "license": "GPLv3",
     "scripts": {
         "upgradeBridgeOnForeign": "node src/upgradeBridgeOnForeign.js",
-        "upgradeBridgeOnHome": "node src/upgradeBridgeOnHome.js",
-        "initializeChai": "node src/initializeChai.js",
         "lint": "eslint ."
     },
     "dependencies": {

upgrade/src/upgradeBridgeOnForeign.js

@@ -26,7 +26,7 @@ const upgradeBridgeOnForeign = async () => {
 
     await validatorState(web3, address, multiSigWallet)
 
-    const data = proxy.methods.upgradeTo('4', NEW_IMPLEMENTATION_ETH_BRIDGE).encodeABI()
+    const data = proxy.methods.upgradeTo('5', NEW_IMPLEMENTATION_ETH_BRIDGE).encodeABI()
 
     await callMultiSigWallet({
       role: ROLE,