Merge the develop branch to the master branch, preparation to v5.0.1

contracts/mocks/AMBMock.sol

@@ -42,6 +42,7 @@ contract AMBMock {
     }
 
     function requireToPassMessage(address _contract, bytes _data, uint256 _gas) external returns (bytes32) {
+        require(messageId == bytes32(0));
         bytes32 bridgeId = keccak256(abi.encodePacked(uint16(1337), address(this))) &
             0x00000000ffffffffffffffffffffffffffffffffffffffff0000000000000000;
 

contracts/upgradeable_contracts/arbitrary_message/BasicForeignAMB.sol

@@ -4,10 +4,9 @@ import "../../libraries/Message.sol";
 import "../../libraries/ArbitraryMessage.sol";
 import "./BasicAMB.sol";
 import "./MessageDelivery.sol";
-import "./MessageProcessor.sol";
 import "../MessageRelay.sol";
 
-contract BasicForeignAMB is BasicAMB, MessageRelay, MessageDelivery, MessageProcessor {
+contract BasicForeignAMB is BasicAMB, MessageRelay, MessageDelivery {
     /**
     * @dev Validates provided signatures and relays a given message
     * @param _data bytes to be relayed

contracts/upgradeable_contracts/arbitrary_message/BasicHomeAMB.sol

@@ -4,9 +4,8 @@ import "../../libraries/Message.sol";
 import "../../libraries/ArbitraryMessage.sol";
 import "./BasicAMB.sol";
 import "./MessageDelivery.sol";
-import "./MessageProcessor.sol";
 
-contract BasicHomeAMB is BasicAMB, MessageDelivery, MessageProcessor {
+contract BasicHomeAMB is BasicAMB, MessageDelivery {
     event SignedForUserRequest(address indexed signer, bytes32 messageHash);
     event SignedForAffirmation(address indexed signer, bytes32 messageHash);
 

contracts/upgradeable_contracts/arbitrary_message/MessageDelivery.sol

@@ -2,10 +2,11 @@ pragma solidity 0.4.24;
 
 import "openzeppelin-solidity/contracts/math/SafeMath.sol";
 import "./BasicAMB.sol";
+import "./MessageProcessor.sol";
 import "../../libraries/ArbitraryMessage.sol";
 import "../../libraries/Bytes.sol";
 
-contract MessageDelivery is BasicAMB {
+contract MessageDelivery is BasicAMB, MessageProcessor {
     using SafeMath for uint256;
 
     /**
@@ -15,20 +16,23 @@ contract MessageDelivery is BasicAMB {
     * @param _gas gas limit used on the other network for executing a message
     */
     function requireToPassMessage(address _contract, bytes _data, uint256 _gas) public returns (bytes32) {
+        // it is not allowed to pass messages while other messages are processed
+        require(messageId() == bytes32(0));
+
         require(_gas >= getMinimumGasUsage(_data) && _gas <= maxGasPerTx());
 
-        bytes32 messageId;
+        bytes32 _messageId;
         bytes memory header = _packHeader(_contract, _gas);
         _setNonce(_nonce() + 1);
 
         assembly {
-            messageId := mload(add(header, 32))
+            _messageId := mload(add(header, 32))
         }
 
         bytes memory eventData = abi.encodePacked(header, _data);
 
-        emitEventOnMessageRequest(messageId, eventData);
-        return messageId;
+        emitEventOnMessageRequest(_messageId, eventData);
+        return _messageId;
     }
 
     /**

contracts/upgradeable_contracts/arbitrary_message/VersionableAMB.sol

@@ -17,6 +17,6 @@ contract VersionableAMB is VersionableBridge {
      * @return (major, minor, patch) version triple
      */
     function getBridgeInterfacesVersion() external pure returns (uint64 major, uint64 minor, uint64 patch) {
-        return (5, 0, 0);
+        return (5, 0, 1);
     }
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "token-bridge-contracts",
-  "version": "5.0.0",
+  "version": "5.0.1",
   "description": "Bridge",
   "main": "index.js",
   "scripts": {

test/amb_native_to_erc20/foreign_mediator.test.js

@@ -1541,6 +1541,7 @@ contract('ForeignAMBNativeToErc20', async accounts => {
 
       const initialBalanceRewardAddress1 = await token.balanceOf(rewardAccountList[0])
       const initialBalanceRewardAddress2 = await token.balanceOf(rewardAccountList[1])
+      const initialBalanceRewardAddress3 = await token.balanceOf(rewardAccountList[2])
 
       await ambBridgeContract.executeMessageCall(
         contract.address,
@@ -1561,17 +1562,15 @@ contract('ForeignAMBNativeToErc20', async accounts => {
       const erc20Token = await ERC20Mock.at(token.address)
       const transferEvents = await getEvents(erc20Token, { event: 'Transfer' })
       // 5 transfer events: 1 Mint to user, 1 Mint to fee manager, fee manager 1 transfer to each reward account,
-      // 1 feeReceiver contract transfer to mediator, 1 transfer to 0 to burn the tokens
-      expect(transferEvents.length).to.be.equal(7)
+      // bridge should not allow to send messages in backward direction, so fee manager should not be able to send tokens through the bridge
+      expect(transferEvents.length).to.be.equal(5)
 
       const burnEvents = await getEvents(token, { event: 'Burn' })
-      expect(burnEvents.length).to.be.equal(1)
+      expect(burnEvents.length).to.be.equal(0)
 
       const totalSupply = await token.totalSupply()
 
-      expect(totalSupply.eq(value.sub(feePerValidator)) || totalSupply.eq(value.sub(feePerValidatorPlusDiff))).to.equal(
-        true
-      )
+      expect(totalSupply).to.be.bignumber.equal(value)
 
       expect(await token.balanceOf(user)).to.be.bignumber.equal(finalUserValue)
 
@@ -1587,7 +1586,10 @@ contract('ForeignAMBNativeToErc20', async accounts => {
         updatedBalanceRewardAddress2.eq(initialBalanceRewardAddress2.add(feePerValidator)) ||
           updatedBalanceRewardAddress2.eq(initialBalanceRewardAddress2.add(feePerValidatorPlusDiff))
       ).to.equal(true)
-      expect(updatedBalanceRewardAddress3).to.be.bignumber.equal(ZERO)
+      expect(
+        updatedBalanceRewardAddress3.eq(initialBalanceRewardAddress3.add(feePerValidator)) ||
+          updatedBalanceRewardAddress3.eq(initialBalanceRewardAddress3.add(feePerValidatorPlusDiff))
+      ).to.equal(true)
 
       const feeEvents = await getEvents(contract, { event: 'FeeDistributed' })
       expect(feeEvents.length).to.be.equal(1)
@@ -1661,6 +1663,7 @@ contract('ForeignAMBNativeToErc20', async accounts => {
 
       expect(await ambBridgeContract.messageCallStatus(failedMessageId)).to.be.equal(false)
 
+      const initialBalanceRewardAddress1 = await token.balanceOf(rewardAccountList[0])
       const initialBalanceRewardAddress2 = await token.balanceOf(rewardAccountList[1])
       const initialBalanceRewardAddress3 = await token.balanceOf(rewardAccountList[2])
 
@@ -1684,24 +1687,25 @@ contract('ForeignAMBNativeToErc20', async accounts => {
       const transferEvents = await getEvents(erc20Token, { event: 'Transfer' })
       // 5 transfer events: 1 Mint to user, 1 Mint to fee manager, fee manager 1 transfer to each reward account,
       // 1 feeReceiver contract transfer to mediator, 1 transfer to 0 to burn the tokens
-      expect(transferEvents.length).to.be.equal(7)
+      expect(transferEvents.length).to.be.equal(5)
 
       const burnEvents = await getEvents(token, { event: 'Burn' })
-      expect(burnEvents.length).to.be.equal(1)
+      expect(burnEvents.length).to.be.equal(0)
 
       const totalSupply = await token.totalSupply()
 
-      expect(totalSupply.eq(value.sub(feePerValidator)) || totalSupply.eq(value.sub(feePerValidatorPlusDiff))).to.equal(
-        true
-      )
+      expect(totalSupply).to.be.bignumber.equal(value)
 
       expect(await token.balanceOf(user)).to.be.bignumber.equal(finalUserValue)
 
       const updatedBalanceRewardAddress1 = await token.balanceOf(rewardAccountList[0])
       const updatedBalanceRewardAddress2 = await token.balanceOf(rewardAccountList[1])
       const updatedBalanceRewardAddress3 = await token.balanceOf(rewardAccountList[2])
 
-      expect(updatedBalanceRewardAddress1).to.be.bignumber.equal(ZERO)
+      expect(
+        updatedBalanceRewardAddress1.eq(initialBalanceRewardAddress1.add(feePerValidator)) ||
+          updatedBalanceRewardAddress1.eq(initialBalanceRewardAddress1.add(feePerValidatorPlusDiff))
+      ).to.equal(true)
       expect(
         updatedBalanceRewardAddress2.eq(initialBalanceRewardAddress2.add(feePerValidator)) ||
           updatedBalanceRewardAddress2.eq(initialBalanceRewardAddress2.add(feePerValidatorPlusDiff))

test/arbitrary_message/foreign_bridge.test.js

@@ -700,6 +700,31 @@ contract('ForeignAMB', async accounts => {
         gasPrice
       }).should.be.rejected
     })
+    it('should not allow to pass message back through the bridge', async () => {
+      const user = accounts[8]
+
+      const data = await foreignBridge.contract.methods
+        .requireToPassMessage(box.address, setValueData, 100000)
+        .encodeABI()
+      // Use these calls to simulate home bridge on home network
+      const resultPassMessageTx = await homeBridge.requireToPassMessage(foreignBridge.address, data, 821254, {
+        from: user
+      })
+
+      const { encodedData: message, messageId } = resultPassMessageTx.logs[0].args
+
+      const signature = await sign(authorities[0], message)
+      const vrs = signatureToVRS(signature)
+      const signatures = packSignatures([vrs])
+
+      await foreignBridge.executeSignatures(message, signatures, {
+        from: authorities[0],
+        gasPrice
+      }).should.be.fulfilled
+
+      // means that call to requireToPassMessage inside MessageProcessor reverted, since messageId flag was set up
+      expect(await foreignBridge.messageCallStatus(messageId)).to.be.equal(false)
+    })
   })
 
   describe('gasToken functionality', async () => {

test/arbitrary_message/home_bridge.test.js

@@ -632,6 +632,25 @@ contract('HomeAMB', async accounts => {
 
       await homeBridge.executeAffirmation(message, { from: authorities[0], gasPrice }).should.be.rejected
     })
+    it('should not allow to pass message back through the bridge', async () => {
+      const user = accounts[8]
+
+      const data = await homeBridge.contract.methods.requireToPassMessage(box.address, setValueData, 100000).encodeABI()
+      // Use these calls to simulate home bridge on home network
+      const resultPassMessageTx = await foreignBridge.requireToPassMessage(homeBridge.address, data, 821254, {
+        from: user
+      })
+
+      const { encodedData: message, messageId } = resultPassMessageTx.logs[0].args
+
+      await homeBridge.executeAffirmation(message, {
+        from: authorities[0],
+        gasPrice
+      }).should.be.fulfilled
+
+      // means that call to requireToPassMessage inside MessageProcessor reverted, since messageId flag was set up
+      expect(await homeBridge.messageCallStatus(messageId)).to.be.equal(false)
+    })
   })
   describe('submitSignature', () => {
     let homeBridge