diff --git a/contracts/upgradeable_contracts/arbitrary_message/BalanceHandler.sol b/contracts/upgradeable_contracts/arbitrary_message/BalanceHandler.sol
deleted file mode 100644
index 1fef66da3..000000000
--- a/contracts/upgradeable_contracts/arbitrary_message/BalanceHandler.sol
+++ /dev/null
@@ -1,55 +0,0 @@
-pragma solidity 0.4.24;
-
-import "../../upgradeability/EternalStorage.sol";
-import "openzeppelin-solidity/contracts/math/SafeMath.sol";
-
-contract BalanceHandler is EternalStorage {
-    using SafeMath for uint256;
-
-    bytes32 internal constant ACCOUNT_FOR_ACTION = keccak256(abi.encodePacked("accountForAction"));
-
-    function depositForContractSender(address _contract) public payable {
-        require(_contract != address(0));
-        setBalanceOf(_contract, balanceOf(_contract).add(msg.value));
-    }
-
-    function withdrawFromDeposit(address _recipient) public {
-        require(msg.sender == address(this));
-        address account = accountForAction();
-        require(account != address(0));
-        require(balanceOf(account) > 0);
-        uint256 withdrawValue = balanceOf(account);
-        setBalanceOf(account, 0);
-        _recipient.transfer(withdrawValue);
-        setAccountForAction(address(0));
-    }
-
-    function balanceOf(address _balanceHolder) public view returns (uint256) {
-        return uintStorage[keccak256(abi.encodePacked("balances", _balanceHolder))];
-    }
-
-    function setBalanceOf(address _balanceHolder, uint256 _amount) internal {
-        uintStorage[keccak256(abi.encodePacked("balances", _balanceHolder))] = _amount;
-    }
-
-    function accountForAction() internal view returns (address) {
-        return addressStorage[ACCOUNT_FOR_ACTION];
-    }
-
-    function setAccountForAction(address _account) internal {
-        addressStorage[ACCOUNT_FOR_ACTION] = _account;
-    }
-
-    function isWithdrawFromDepositSelector(bytes _data) internal pure returns (bool) {
-        bytes4 selector = this.withdrawFromDeposit.selector;
-        if (
-            (_data[0] == selector[0]) &&
-            (_data[1] == selector[1]) &&
-            (_data[2] == selector[2]) &&
-            (_data[3] == selector[3])
-        ) {
-            return true;
-        }
-        return false;
-    }
-}
diff --git a/contracts/upgradeable_contracts/arbitrary_message/BasicAMB.sol b/contracts/upgradeable_contracts/arbitrary_message/BasicAMB.sol
index 9e81c0693..84eb575c8 100644
--- a/contracts/upgradeable_contracts/arbitrary_message/BasicAMB.sol
+++ b/contracts/upgradeable_contracts/arbitrary_message/BasicAMB.sol
@@ -1,19 +1,8 @@
 pragma solidity 0.4.24;
 
-import "../../upgradeability/EternalStorage.sol";
-import "openzeppelin-solidity/contracts/math/SafeMath.sol";
-import "openzeppelin-solidity/contracts/AddressUtils.sol";
-import "../Validatable.sol";
 import "../BasicBridge.sol";
 
 contract BasicAMB is BasicBridge {
-    event HomeToForeignModeChanged(uint256 mode);
-    event ForeignToHomeModeChanged(uint256 mode);
-
-    uint256 internal constant SUBSIDIZED_MODE = 0;
-    uint256 internal constant DEFRAYAL_MODE = 1;
-    bytes32 internal constant HOME_TO_FOREIGN_MODE = keccak256(abi.encodePacked("homeToForeignMode"));
-    bytes32 internal constant FOREIGN_TO_HOME_MODE = keccak256(abi.encodePacked("foreignToHomeMode"));
     bytes32 internal constant MAX_GAS_PER_TX = keccak256(abi.encodePacked("maxGasPerTx"));
 
     function initialize(
@@ -33,15 +22,11 @@ contract BasicAMB is BasicBridge {
         uintStorage[MAX_GAS_PER_TX] = _maxGasPerTx;
         uintStorage[GAS_PRICE] = _gasPrice;
         uintStorage[REQUIRED_BLOCK_CONFIRMATIONS] = _requiredBlockConfirmations;
-        uintStorage[HOME_TO_FOREIGN_MODE] = SUBSIDIZED_MODE;
-        uintStorage[FOREIGN_TO_HOME_MODE] = SUBSIDIZED_MODE;
         setOwner(_owner);
         setInitialize();
 
         emit RequiredBlockConfirmationChanged(_requiredBlockConfirmations);
         emit GasPriceChanged(_gasPrice);
-        emit HomeToForeignModeChanged(SUBSIDIZED_MODE);
-        emit ForeignToHomeModeChanged(SUBSIDIZED_MODE);
 
         return isInitialized();
     }
@@ -50,34 +35,6 @@ contract BasicAMB is BasicBridge {
         return bytes4(keccak256(abi.encodePacked("arbitrary-message-bridge-core")));
     }
 
-    function setSubsidizedModeForHomeToForeign() external onlyOwner {
-        uintStorage[HOME_TO_FOREIGN_MODE] = SUBSIDIZED_MODE;
-        emit HomeToForeignModeChanged(SUBSIDIZED_MODE);
-    }
-
-    function setDefrayalModeForHomeToForeign() external onlyOwner {
-        uintStorage[HOME_TO_FOREIGN_MODE] = DEFRAYAL_MODE;
-        emit HomeToForeignModeChanged(DEFRAYAL_MODE);
-    }
-
-    function setSubsidizedModeForForeignToHome() external onlyOwner {
-        uintStorage[FOREIGN_TO_HOME_MODE] = SUBSIDIZED_MODE;
-        emit ForeignToHomeModeChanged(SUBSIDIZED_MODE);
-    }
-
-    function setDefrayalModeForForeignToHome() external onlyOwner {
-        uintStorage[FOREIGN_TO_HOME_MODE] = DEFRAYAL_MODE;
-        emit ForeignToHomeModeChanged(DEFRAYAL_MODE);
-    }
-
-    function homeToForeignMode() public view returns (uint256) {
-        return uintStorage[HOME_TO_FOREIGN_MODE];
-    }
-
-    function foreignToHomeMode() public view returns (uint256) {
-        return uintStorage[FOREIGN_TO_HOME_MODE];
-    }
-
     function maxGasPerTx() public view returns (uint256) {
         return uintStorage[MAX_GAS_PER_TX];
     }
diff --git a/contracts/upgradeable_contracts/arbitrary_message/ForeignAMB.sol b/contracts/upgradeable_contracts/arbitrary_message/ForeignAMB.sol
index cd373181d..e442d24e2 100644
--- a/contracts/upgradeable_contracts/arbitrary_message/ForeignAMB.sol
+++ b/contracts/upgradeable_contracts/arbitrary_message/ForeignAMB.sol
@@ -6,14 +6,6 @@ contract ForeignAMB is BasicForeignAMB {
     event UserRequestForAffirmation(bytes encodedData);
     event RelayedMessage(address sender, address executor, bytes32 transactionHash, bool status);
 
-    function isMessageDeliverySubsidizedMode() internal returns (bool) {
-        return foreignToHomeMode() == SUBSIDIZED_MODE;
-    }
-
-    function isMessageProcessorSubsidizedMode() internal returns (bool) {
-        return homeToForeignMode() == SUBSIDIZED_MODE;
-    }
-
     function emitEventOnMessageRequest(bytes encodedData) internal {
         emit UserRequestForAffirmation(encodedData);
     }
diff --git a/contracts/upgradeable_contracts/arbitrary_message/HomeAMB.sol b/contracts/upgradeable_contracts/arbitrary_message/HomeAMB.sol
index 8ea7b56fa..ba5369321 100644
--- a/contracts/upgradeable_contracts/arbitrary_message/HomeAMB.sol
+++ b/contracts/upgradeable_contracts/arbitrary_message/HomeAMB.sol
@@ -6,18 +6,10 @@ contract HomeAMB is BasicHomeAMB {
     event UserRequestForSignature(bytes encodedData);
     event AffirmationCompleted(address sender, address executor, bytes32 transactionHash, bool status);
 
-    function isMessageDeliverySubsidizedMode() internal returns (bool) {
-        return homeToForeignMode() == SUBSIDIZED_MODE;
-    }
-
     function emitEventOnMessageRequest(bytes encodedData) internal {
         emit UserRequestForSignature(encodedData);
     }
 
-    function isMessageProcessorSubsidizedMode() internal returns (bool) {
-        return foreignToHomeMode() == SUBSIDIZED_MODE;
-    }
-
     function emitEventOnMessageProcessed(address sender, address executor, bytes32 txHash, bool status) internal {
         emit AffirmationCompleted(sender, executor, txHash, status);
     }
diff --git a/contracts/upgradeable_contracts/arbitrary_message/MessageDelivery.sol b/contracts/upgradeable_contracts/arbitrary_message/MessageDelivery.sol
index b3b7a6c30..4aaacd7e3 100644
--- a/contracts/upgradeable_contracts/arbitrary_message/MessageDelivery.sol
+++ b/contracts/upgradeable_contracts/arbitrary_message/MessageDelivery.sol
@@ -7,36 +7,16 @@ contract MessageDelivery is BasicAMB {
     using SafeMath for uint256;
 
     function requireToPassMessage(address _contract, bytes _data, uint256 _gas) public {
-        require(isMessageDeliverySubsidizedMode());
         require(_gas >= getMinimumGasUsage(_data) && _gas <= maxGasPerTx());
         emitEventOnMessageRequest(abi.encodePacked(msg.sender, _contract, _gas, uint8(0x00), _data));
     }
 
-    function requireToPassMessage(address _contract, bytes _data, uint256 _gas, uint256 _gasPrice) public {
-        if (isMessageDeliverySubsidizedMode()) requireToPassMessage(_contract, _data, _gas);
-        else {
-            require(_gas >= getMinimumGasUsage(_data) && _gas <= maxGasPerTx());
-            emitEventOnMessageRequest(abi.encodePacked(msg.sender, _contract, _gas, uint8(0x01), _gasPrice, _data));
-        }
-    }
-
-    function requireToPassMessage(address _contract, bytes _data, uint256 _gas, bytes1 _oracleGasPriceSpeed) public {
-        if (isMessageDeliverySubsidizedMode()) requireToPassMessage(_contract, _data, _gas);
-        else {
-            require(_gas >= getMinimumGasUsage(_data) && _gas <= maxGasPerTx());
-            emitEventOnMessageRequest(
-                abi.encodePacked(msg.sender, _contract, _gas, uint8(0x02), _oracleGasPriceSpeed, _data)
-            );
-        }
-    }
-
     function getMinimumGasUsage(bytes _data) public pure returns (uint256 gas) {
         //From Ethereum Yellow Paper
         // 68 gas is paid for every non-zero byte of data or code for a transaction
         return _data.length.mul(68);
     }
 
-    function isMessageDeliverySubsidizedMode() internal returns (bool);
-
+    /* solcov ignore next */
     function emitEventOnMessageRequest(bytes encodedData) internal;
 }
diff --git a/contracts/upgradeable_contracts/arbitrary_message/MessageProcessor.sol b/contracts/upgradeable_contracts/arbitrary_message/MessageProcessor.sol
index 3de56d773..4befbfce9 100644
--- a/contracts/upgradeable_contracts/arbitrary_message/MessageProcessor.sol
+++ b/contracts/upgradeable_contracts/arbitrary_message/MessageProcessor.sol
@@ -1,9 +1,8 @@
 pragma solidity 0.4.24;
 
-import "./BalanceHandler.sol";
+import "../../upgradeability/EternalStorage.sol";
 
-contract MessageProcessor is BalanceHandler {
-    uint256 internal constant PASS_MESSAGE_GAS = 100000;
+contract MessageProcessor is EternalStorage {
     bytes32 internal constant MESSAGE_SENDER = keccak256(abi.encodePacked("messageSender"));
     bytes32 internal constant TRANSACTION_HASH = keccak256(abi.encodePacked("transactionHash"));
 
@@ -34,56 +33,19 @@ contract MessageProcessor is BalanceHandler {
         address executor,
         bytes32 txHash,
         uint256 gasLimit,
-        bytes1 dataType,
-        uint256 gasPrice,
+        bytes1, /* dataType */
+        uint256, /* gasPrice */
         bytes memory data
     ) internal {
-        bool status;
-
-        if (dataType == 0x00) {
-            require(isMessageProcessorSubsidizedMode());
-            status = _passMessage(sender, executor, data, gasLimit, txHash);
-        } else if (dataType == 0x01) {
-            require(!isMessageProcessorSubsidizedMode());
-            require(gasPrice == tx.gasprice);
-            status = _defrayAndPassMessage(sender, executor, data, gasLimit, txHash);
-        } else if (dataType == 0x02) {
-            require(!isMessageProcessorSubsidizedMode());
-            status = _defrayAndPassMessage(sender, executor, data, gasLimit, txHash);
-        } else {
-            status = false;
-        }
+        bool status = _passMessage(sender, executor, data, gasLimit, txHash);
 
         emitEventOnMessageProcessed(sender, executor, txHash, status);
     }
 
-    function _defrayAndPassMessage(address _sender, address _contract, bytes _data, uint256 _gas, bytes32 _txHash)
-        internal
-        returns (bool)
-    {
-        uint256 fee = PASS_MESSAGE_GAS.add(_gas).mul(tx.gasprice);
-        require(balanceOf(_sender) >= fee);
-        require(address(this).balance >= fee);
-
-        setBalanceOf(_sender, balanceOf(_sender).sub(fee));
-
-        bool status = _passMessage(_sender, _contract, _data, _gas, _txHash);
-
-        msg.sender.transfer(fee);
-
-        return status;
-    }
-
     function _passMessage(address _sender, address _contract, bytes _data, uint256 _gas, bytes32 _txHash)
         internal
         returns (bool)
     {
-        if (_contract == address(this)) {
-            //Special check to handle invocation of withdrawFromDeposit
-            if (isWithdrawFromDepositSelector(_data)) {
-                setAccountForAction(_sender);
-            }
-        }
         setMessageSender(_sender);
         setTransactionHash(_txHash);
         bool status = _contract.call.gas(_gas)(_data);
@@ -92,7 +54,6 @@ contract MessageProcessor is BalanceHandler {
         return status;
     }
 
-    function isMessageProcessorSubsidizedMode() internal returns (bool);
-
+    /* solcov ignore next */
     function emitEventOnMessageProcessed(address sender, address executor, bytes32 txHash, bool status) internal;
 }
diff --git a/deploy/.env.example b/deploy/.env.example
index 5de435ac5..e25c3c980 100644
--- a/deploy/.env.example
+++ b/deploy/.env.example
@@ -26,8 +26,6 @@ HOME_MAX_AMOUNT_PER_TX=1500000000000000000000000
 HOME_MIN_AMOUNT_PER_TX=500000000000000000
 HOME_REQUIRED_BLOCK_CONFIRMATIONS=1
 HOME_GAS_PRICE=1000000000
-# only for ARBITRARY_MESSAGE mode
-HOME_AMB_SUBSIDIZED_MODE=false
 
 BLOCK_REWARD_ADDRESS=
 
@@ -40,8 +38,7 @@ FOREIGN_MAX_AMOUNT_PER_TX=750000000000000000000000
 FOREIGN_MIN_AMOUNT_PER_TX=500000000000000000
 FOREIGN_REQUIRED_BLOCK_CONFIRMATIONS=8
 FOREIGN_GAS_PRICE=10000000000
-# only for ARBITRARY_MESSAGE mode
-FOREIGN_AMB_SUBSIDIZED_MODE=false
+
 #for bridge erc_to_erc and erc_to_native mode
 ERC20_TOKEN_ADDRESS=
 # Only for for erc_to_erc mode
diff --git a/deploy/README.md b/deploy/README.md
index 69b097686..7daa913b0 100644
--- a/deploy/README.md
+++ b/deploy/README.md
@@ -476,9 +476,6 @@ HOME_REQUIRED_BLOCK_CONFIRMATIONS=1
 # transactions for deposit or withdrawal confirmations. This price is used if
 # the Gas price oracle is unreachable.
 HOME_GAS_PRICE=1000000000
-# The mode of economic compensation for Home bridge operations. 
-# If set to true, messages bridged from Foreign Network to Home Network will not pay fees.  
-HOME_AMB_SUBSIDIZED_MODE=false
 
 # The RPC channel to a Foreign node able to handle deployment/configuration
 # transactions.
@@ -501,9 +498,6 @@ FOREIGN_REQUIRED_BLOCK_CONFIRMATIONS=8
 # finalizing asset deposits. This price is used if the Gas price oracle is
 # unreachable.
 FOREIGN_GAS_PRICE=10000000000
-# The mode of economic compensation for Foreign bridge operations. 
-# If set to true, messages bridged from Home Network to Foreign Network will not pay fees.  
-FOREIGN_AMB_SUBSIDIZED_MODE=false
 
 # The minimum number of validators required to send their signatures confirming
 # the relay of assets. The same number of validators is expected on both sides
diff --git a/deploy/src/arbitrary_message/foreign.js b/deploy/src/arbitrary_message/foreign.js
index 10a05c470..314ab32a9 100644
--- a/deploy/src/arbitrary_message/foreign.js
+++ b/deploy/src/arbitrary_message/foreign.js
@@ -27,9 +27,7 @@ const {
   FOREIGN_VALIDATORS_OWNER,
   FOREIGN_UPGRADEABLE_ADMIN,
   FOREIGN_MAX_AMOUNT_PER_TX,
-  FOREIGN_REQUIRED_BLOCK_CONFIRMATIONS,
-  HOME_AMB_SUBSIDIZED_MODE,
-  FOREIGN_AMB_SUBSIDIZED_MODE
+  FOREIGN_REQUIRED_BLOCK_CONFIRMATIONS
 } = env
 
 const DEPLOYMENT_ACCOUNT_ADDRESS = privateKeyToAddress(DEPLOYMENT_ACCOUNT_PRIVATE_KEY)
@@ -66,60 +64,6 @@ async function initializeBridge({ validatorsBridge, bridge, initialNonce }) {
   }
   nonce++
 
-  if (!HOME_AMB_SUBSIDIZED_MODE) {
-    console.log('setting defrayal mode for home side')
-    const homeBridgeDefrayalModeData = await bridge.methods
-      .setDefrayalModeForForeignToHome()
-      .encodeABI()
-    const txHomeBridgeDefrayalModeData = await sendRawTxForeign({
-      data: homeBridgeDefrayalModeData,
-      nonce,
-      to: bridge.options.address,
-      privateKey: deploymentPrivateKey,
-      url: FOREIGN_RPC_URL
-    })
-    if (txHomeBridgeDefrayalModeData.status) {
-      assert.strictEqual(
-        Web3Utils.hexToNumber(txHomeBridgeDefrayalModeData.status),
-        1,
-        'Transaction Failed'
-      )
-    } else {
-      await assertStateWithRetry(
-        bridge.methods.foreignToHomeMode().call,
-        '1'
-      )
-    }
-    nonce++
-  }
-
-  if (!FOREIGN_AMB_SUBSIDIZED_MODE) {
-    console.log('setting defrayal mode for foreign side')
-    const foreignBridgeDefrayalModeData = await bridge.methods
-      .setDefrayalModeForHomeToForeign()
-      .encodeABI()
-    const txForeignBridgeDefrayalModeData = await sendRawTxForeign({
-      data: foreignBridgeDefrayalModeData,
-      nonce,
-      to: bridge.options.address,
-      privateKey: deploymentPrivateKey,
-      url: FOREIGN_RPC_URL
-    })
-    if (txForeignBridgeDefrayalModeData.status) {
-      assert.strictEqual(
-        Web3Utils.hexToNumber(txForeignBridgeDefrayalModeData.status),
-        1,
-        'Transaction Failed'
-      )
-    } else {
-      await assertStateWithRetry(
-        bridge.methods.homeToForeignMode().call,
-        '1'
-      )
-    }
-    nonce++
-  }
-
   return nonce
 }
 
diff --git a/deploy/src/arbitrary_message/home.js b/deploy/src/arbitrary_message/home.js
index a5d8e66a3..4ab98031c 100644
--- a/deploy/src/arbitrary_message/home.js
+++ b/deploy/src/arbitrary_message/home.js
@@ -27,9 +27,7 @@ const {
   HOME_VALIDATORS_OWNER,
   HOME_UPGRADEABLE_ADMIN,
   HOME_MAX_AMOUNT_PER_TX,
-  HOME_REQUIRED_BLOCK_CONFIRMATIONS,
-  HOME_AMB_SUBSIDIZED_MODE,
-  FOREIGN_AMB_SUBSIDIZED_MODE
+  HOME_REQUIRED_BLOCK_CONFIRMATIONS
 } = env
 
 const DEPLOYMENT_ACCOUNT_ADDRESS = privateKeyToAddress(DEPLOYMENT_ACCOUNT_PRIVATE_KEY)
@@ -70,60 +68,6 @@ async function initializeBridge({ validatorsBridge, bridge, initialNonce }) {
   }
   nonce++
 
-  if (!HOME_AMB_SUBSIDIZED_MODE) {
-    console.log('setting defrayal mode for home side')
-    const homeBridgeDefrayalModeData = await bridge.methods
-      .setDefrayalModeForForeignToHome()
-      .encodeABI()
-    const txHomeBridgeDefrayalModeData = await sendRawTxHome({
-      data: homeBridgeDefrayalModeData,
-      nonce,
-      to: bridge.options.address,
-      privateKey: deploymentPrivateKey,
-      url: HOME_RPC_URL
-    })
-    if (txHomeBridgeDefrayalModeData.status) {
-      assert.strictEqual(
-        Web3Utils.hexToNumber(txHomeBridgeDefrayalModeData.status),
-        1,
-        'Transaction Failed'
-      )
-    } else {
-      await assertStateWithRetry(
-        bridge.methods.foreignToHomeMode().call,
-        '1'
-      )
-    }
-    nonce++
-  }
-
-  if (!FOREIGN_AMB_SUBSIDIZED_MODE) {
-    console.log('setting defrayal mode for foreign side')
-    const foreignBridgeDefrayalModeData = await bridge.methods
-      .setDefrayalModeForHomeToForeign()
-      .encodeABI()
-    const txForeignBridgeDefrayalModeData = await sendRawTxHome({
-      data: foreignBridgeDefrayalModeData,
-      nonce,
-      to: bridge.options.address,
-      privateKey: deploymentPrivateKey,
-      url: HOME_RPC_URL
-    })
-    if (txForeignBridgeDefrayalModeData.status) {
-      assert.strictEqual(
-        Web3Utils.hexToNumber(txForeignBridgeDefrayalModeData.status),
-        1,
-        'Transaction Failed'
-      )
-    } else {
-      await assertStateWithRetry(
-        bridge.methods.homeToForeignMode().call,
-        '1'
-      )
-    }
-    nonce++
-  }
-
   return nonce
 }
 
diff --git a/deploy/src/loadEnv.js b/deploy/src/loadEnv.js
index a9883d901..1e92535ad 100644
--- a/deploy/src/loadEnv.js
+++ b/deploy/src/loadEnv.js
@@ -151,13 +151,7 @@ if (BRIDGE_MODE === 'AMB_ERC_TO_ERC') {
   }
 }
 
-if (BRIDGE_MODE === 'ARBITRARY_MESSAGE') {
-  validations = {
-    ...validations,
-    HOME_AMB_SUBSIDIZED_MODE: envalid.bool(),
-    FOREIGN_AMB_SUBSIDIZED_MODE: envalid.bool()
-  }
-} else {
+if (BRIDGE_MODE !== 'ARBITRARY_MESSAGE') {
   validations = {
     ...validations,
     HOME_DAILY_LIMIT: bigNumValidator(),
diff --git a/test/arbitrary_message/foreign_bridge.test.js b/test/arbitrary_message/foreign_bridge.test.js
index dcd63388c..ddb3d35c7 100644
--- a/test/arbitrary_message/foreign_bridge.test.js
+++ b/test/arbitrary_message/foreign_bridge.test.js
@@ -2,7 +2,6 @@ const ForeignBridge = artifacts.require('ForeignAMB.sol')
 const BridgeValidators = artifacts.require('BridgeValidators.sol')
 const Box = artifacts.require('Box.sol')
 const EternalStorageProxy = artifacts.require('EternalStorageProxy.sol')
-const IAMB = artifacts.require('IAMB.sol')
 
 const { expect } = require('chai')
 const {
@@ -23,93 +22,16 @@ const ZERO = toBN(0)
 
 contract('ForeignAMB', async accounts => {
   let validatorContract
-  let boxContract
   let authorities
   let owner
 
   before(async () => {
     validatorContract = await BridgeValidators.new()
-    boxContract = await Box.new()
     authorities = [accounts[1], accounts[2]]
     owner = accounts[0]
     await validatorContract.initialize(1, authorities, owner)
   })
 
-  describe('balance', () => {
-    it('should start with zero balance', async () => {
-      const foreignBridge = await ForeignBridge.new()
-      expect(await foreignBridge.balanceOf(boxContract.address)).to.be.bignumber.equal(ZERO)
-    })
-
-    it('should receive balance for a contract', async () => {
-      const foreignBridge = await ForeignBridge.new()
-      await foreignBridge.depositForContractSender(boxContract.address, {
-        from: accounts[1],
-        value: 1
-      })
-
-      expect(await foreignBridge.balanceOf(boxContract.address)).to.be.bignumber.equal('1')
-      expect(toBN(await web3.eth.getBalance(foreignBridge.address))).to.be.bignumber.equal('1')
-    })
-
-    it('should revert for address 0', async () => {
-      const foreignBridge = await ForeignBridge.new()
-      await foreignBridge
-        .depositForContractSender(ZERO_ADDRESS, {
-          from: accounts[1],
-          value: 1
-        })
-        .should.be.rejectedWith(ERROR_MSG)
-    })
-
-    it('user should be able to withdraw balance', async () => {
-      const user = accounts[8]
-
-      const foreignBridge = await ForeignBridge.new()
-      await foreignBridge.initialize(validatorContract.address, oneEther, gasPrice, requiredBlockConfirmations, owner)
-
-      await foreignBridge.depositForContractSender(user, {
-        from: user,
-        value: oneEther
-      })
-
-      const userBalanceOnBridgeAfterDeposit = await foreignBridge.balanceOf(user)
-      const userBalanceAfterDeposit = toBN(await web3.eth.getBalance(user))
-      expect(userBalanceOnBridgeAfterDeposit).to.be.bignumber.equal(oneEther)
-
-      const amb = await IAMB.at(boxContract.address)
-      const withdrawFromDepositData = await amb.contract.methods.withdrawFromDeposit(user).encodeABI()
-
-      // Use these calls to simulate home bridge on Foreign network
-      const resultPassMessageTx = await foreignBridge.requireToPassMessage(
-        foreignBridge.address,
-        withdrawFromDepositData,
-        821254,
-        gasPrice,
-        { from: user }
-      )
-
-      // Validator on token-bridge add txHash to message
-      const { encodedData } = resultPassMessageTx.logs[0].args
-      const message = addTxHashToAMBData(encodedData, resultPassMessageTx.tx)
-
-      const signature = await sign(authorities[0], message)
-      const vrs = signatureToVRSAMB(signature)
-      const signatures = packSignatures([vrs])
-
-      const { logs } = await foreignBridge.executeSignatures(message, signatures, {
-        from: authorities[0],
-        gasPrice
-      }).should.be.fulfilled
-      logs[0].event.should.be.equal('RelayedMessage')
-
-      const userBalanceOnBridgeAfterWithdraw = await foreignBridge.balanceOf(user)
-      const userBalanceAfterWithdraw = toBN(await web3.eth.getBalance(user))
-      userBalanceOnBridgeAfterWithdraw.should.be.bignumber.equal(ZERO)
-      userBalanceAfterWithdraw.should.be.bignumber.gt(userBalanceAfterDeposit)
-    })
-  })
-
   describe('getBridgeMode', () => {
     it('should return arbitrary message bridging mode', async () => {
       const foreignContract = await ForeignBridge.new()
@@ -118,38 +40,6 @@ contract('ForeignAMB', async accounts => {
       bridgeMode.should.be.equal(bridgeModeHash)
     })
   })
-  describe('compensation mode', () => {
-    it('should return homeToForeignMode', async () => {
-      const foreignBridge = await ForeignBridge.new()
-      await foreignBridge.initialize(validatorContract.address, oneEther, gasPrice, requiredBlockConfirmations, owner)
-        .should.be.fulfilled
-
-      expect(await foreignBridge.homeToForeignMode()).to.be.bignumber.equal('0')
-
-      const { logs } = await foreignBridge.setDefrayalModeForHomeToForeign().should.be.fulfilled
-      expect(await foreignBridge.homeToForeignMode()).to.be.bignumber.equal('1')
-      expectEventInLogs(logs, 'HomeToForeignModeChanged', { mode: toBN(1) })
-
-      const { logs: logs2 } = await foreignBridge.setSubsidizedModeForHomeToForeign().should.be.fulfilled
-      expect(await foreignBridge.homeToForeignMode()).to.be.bignumber.equal('0')
-      expectEventInLogs(logs2, 'HomeToForeignModeChanged', { mode: ZERO })
-    })
-    it('should return foreignToHomeMode', async () => {
-      const foreignBridge = await ForeignBridge.new()
-      await foreignBridge.initialize(validatorContract.address, oneEther, gasPrice, requiredBlockConfirmations, owner)
-        .should.be.fulfilled
-
-      expect(await foreignBridge.foreignToHomeMode()).to.be.bignumber.equal('0')
-
-      const { logs } = await foreignBridge.setDefrayalModeForForeignToHome().should.be.fulfilled
-      expect(await foreignBridge.foreignToHomeMode()).to.be.bignumber.equal('1')
-      expectEventInLogs(logs, 'ForeignToHomeModeChanged', { mode: toBN(1) })
-
-      const { logs: logs2 } = await foreignBridge.setSubsidizedModeForForeignToHome().should.be.fulfilled
-      expect(await foreignBridge.foreignToHomeMode()).to.be.bignumber.equal('0')
-      expectEventInLogs(logs2, 'ForeignToHomeModeChanged', { mode: ZERO })
-    })
-  })
   describe('initialize', () => {
     it('sets variables', async () => {
       const foreignBridge = await ForeignBridge.new()
@@ -182,8 +72,6 @@ contract('ForeignAMB', async accounts => {
         requiredBlockConfirmations: toBN(requiredBlockConfirmations)
       })
       expectEventInLogs(logs, 'GasPriceChanged', { gasPrice })
-      expectEventInLogs(logs, 'HomeToForeignModeChanged', { mode: ZERO })
-      expectEventInLogs(logs, 'ForeignToHomeModeChanged', { mode: ZERO })
     })
     it('should fail with invalid arguments', async () => {
       const foreignBridge = await ForeignBridge.new()
@@ -307,18 +195,7 @@ contract('ForeignAMB', async accounts => {
       foreignBridge = await ForeignBridge.at(proxy.address)
       await foreignBridge.initialize(validatorContract.address, oneEther, gasPrice, requiredBlockConfirmations, owner)
     })
-    it('call requireToPassMessage(address, bytes, uint256, bytes1)', async () => {
-      const { logs } = await foreignBridge.methods['requireToPassMessage(address,bytes,uint256,bytes1)'](
-        '0xf4BEF13F9f4f2B203FAF0C3cBbaAbe1afE056955',
-        '0xb1591967aed668a4b27645ff40c444892d91bf5951b382995d4d4f6ee3a2ce03',
-        1535604485,
-        '0x01'
-      )
-      logs.length.should.be.equal(1)
-      logs[0].event.should.be.equal('UserRequestForAffirmation')
-    })
     it('call requireToPassMessage(address, bytes, uint256)', async () => {
-      await foreignBridge.setSubsidizedModeForForeignToHome().should.be.fulfilled
       const tx = await foreignBridge.methods['requireToPassMessage(address,bytes,uint256)'](
         '0xf4BEF13F9f4f2B203FAF0C3cBbaAbe1afE056955',
         '0xb1591967aed668a4b27645ff40c444892d91bf5951b382995d4d4f6ee3a2ce03',
@@ -326,17 +203,6 @@ contract('ForeignAMB', async accounts => {
         { from: accounts[3] }
       )
 
-      tx.receipt.logs.length.should.be.equal(1)
-    })
-    it('call requireToPassMessage(address, bytes, uint256, uint256)', async () => {
-      const tx = await foreignBridge.methods['requireToPassMessage(address,bytes,uint256,uint256)'](
-        '0xf4BEF13F9f4f2B203FAF0C3cBbaAbe1afE056955',
-        '0xb1591967aed668a4b27645ff40c444892d91bf5951b382995d4d4f6ee3a2ce03',
-        1535604485,
-        1000000000,
-        { from: accounts[3] }
-      )
-
       tx.receipt.logs.length.should.be.equal(1)
     })
   })
@@ -353,25 +219,19 @@ contract('ForeignAMB', async accounts => {
 
       foreignBridge = await ForeignBridge.at(proxy.address)
       await foreignBridge.initialize(validatorContract.address, oneEther, gasPrice, requiredBlockConfirmations, owner)
-      await foreignBridge.setDefrayalModeForHomeToForeign().should.be.fulfilled
-      await foreignBridge.setDefrayalModeForForeignToHome().should.be.fulfilled
 
       box = await Box.new()
       // Generate data for method we want to call on Box contract
       setValueData = await box.contract.methods.setValue(3).encodeABI()
     })
     it('should succeed on Subsidized mode', async () => {
-      // set foreign bridge on subsidized mode
-      await foreignBridge.setSubsidizedModeForHomeToForeign().should.be.fulfilled
-
       const user = accounts[8]
 
       const boxInitialValue = await box.value()
       boxInitialValue.should.be.bignumber.equal(ZERO)
 
       // Use these calls to simulate home bridge on Home network
-      await foreignBridge.setSubsidizedModeForForeignToHome().should.be.fulfilled
-      const resultPassMessageTx = await foreignBridge.requireToPassMessage(box.address, setValueData, 1221254, 1, {
+      const resultPassMessageTx = await foreignBridge.requireToPassMessage(box.address, setValueData, 1221254, {
         from: user
       })
 
@@ -399,102 +259,6 @@ contract('ForeignAMB', async accounts => {
       expect(await box.txHash()).to.be.equal(resultPassMessageTx.tx)
       expect(await foreignBridge.messageSender()).to.be.equal(ZERO_ADDRESS)
     })
-    it('should succeed on defrayal mode using message with oracle gas price', async () => {
-      const user = accounts[8]
-
-      const boxInitialValue = await box.value()
-      boxInitialValue.should.be.bignumber.equal(ZERO)
-
-      // Deposit for user
-      await foreignBridge.depositForContractSender(user, {
-        from: user,
-        value: oneEther
-      })
-
-      // Use these calls to simulate home bridge on home network
-      const resultPassMessageTx = await foreignBridge.methods['requireToPassMessage(address,bytes,uint256,bytes1)'](
-        box.address,
-        setValueData,
-        821254,
-        '0x01',
-        {
-          from: user
-        }
-      )
-
-      // Validator on token-bridge add txHash to message
-      const { encodedData } = resultPassMessageTx.logs[0].args
-      const message = addTxHashToAMBData(encodedData, resultPassMessageTx.tx)
-
-      const signature = await sign(authorities[0], message)
-      const vrs = signatureToVRSAMB(signature)
-      const signatures = packSignatures([vrs])
-
-      const { logs } = await foreignBridge.executeSignatures(message, signatures, {
-        from: authorities[0],
-        gasPrice
-      }).should.be.fulfilled
-
-      expectEventInLogs(logs, 'RelayedMessage', {
-        sender: user,
-        executor: box.address,
-        transactionHash: resultPassMessageTx.tx,
-        status: true
-      })
-
-      // check Box value
-      expect(await box.value()).to.be.bignumber.equal('3')
-      expect(await box.lastSender()).to.be.equal(user)
-      expect(await box.txHash()).to.be.equal(resultPassMessageTx.tx)
-      expect(await foreignBridge.messageSender()).to.be.equal(ZERO_ADDRESS)
-    })
-    it('should succeed on defrayal mode using message with gas price parameter', async () => {
-      const user = accounts[8]
-
-      const boxInitialValue = await box.value()
-      boxInitialValue.should.be.bignumber.equal(ZERO)
-
-      // Deposit for user
-      await foreignBridge.depositForContractSender(user, {
-        from: user,
-        value: oneEther
-      })
-
-      // Use these calls to simulate foreign bridge on Foreign network
-      const tx = await foreignBridge.methods['requireToPassMessage(address,bytes,uint256,uint256)'](
-        box.address,
-        setValueData,
-        821254,
-        gasPrice,
-        { from: user }
-      )
-      const { encodedData } = tx.receipt.logs[0].args
-
-      // Validator on token-bridge add txHash to message
-      const message = addTxHashToAMBData(encodedData, tx.tx)
-
-      const signature = await sign(authorities[0], message)
-      const vrs = signatureToVRSAMB(signature)
-      const signatures = packSignatures([vrs])
-
-      // should fail because a different gas price was used
-      const { logs } = await foreignBridge.executeSignatures(message, signatures, {
-        from: authorities[0],
-        gasPrice
-      }).should.be.fulfilled
-      expectEventInLogs(logs, 'RelayedMessage', {
-        sender: user,
-        executor: box.address,
-        transactionHash: tx.tx,
-        status: true
-      })
-
-      // check Box value
-      expect(await box.value()).to.be.bignumber.equal('3')
-      expect(await box.lastSender()).to.be.equal(user)
-      expect(await box.txHash()).to.be.equal(tx.tx)
-      expect(await foreignBridge.messageSender()).to.be.equal(ZERO_ADDRESS)
-    })
     it('test with 3 signatures required', async () => {
       // set validator
       const validatorContractWith3Signatures = await BridgeValidators.new()
@@ -517,18 +281,11 @@ contract('ForeignAMB', async accounts => {
       const boxInitialValue = await box.value()
       boxInitialValue.should.be.bignumber.equal(ZERO)
 
-      // Deposit for user
-      await foreignBridgeWithThreeSigs.depositForContractSender(user, {
-        from: user,
-        value: oneEther
-      })
-
       // Use these calls to simulate home bridge on home network
       const resultPassMessageTx = await foreignBridgeWithThreeSigs.requireToPassMessage(
         box.address,
         setValueData,
         821254,
-        gasPrice,
         { from: user }
       )
 
@@ -578,22 +335,10 @@ contract('ForeignAMB', async accounts => {
     it('should not allow to double execute signatures', async () => {
       const user = accounts[8]
 
-      // Deposit for user
-      await foreignBridge.depositForContractSender(user, {
-        from: user,
-        value: oneEther
-      })
-
       // Use these calls to simulate home bridge on home network
-      const resultPassMessageTx = await foreignBridge.requireToPassMessage(
-        box.address,
-        setValueData,
-        821254,
-        gasPrice,
-        {
-          from: user
-        }
-      )
+      const resultPassMessageTx = await foreignBridge.requireToPassMessage(box.address, setValueData, 821254, {
+        from: user
+      })
 
       // Validator on token-bridge add txHash to message
       const { encodedData } = resultPassMessageTx.logs[0].args
@@ -624,22 +369,10 @@ contract('ForeignAMB', async accounts => {
     it('should allow non-authorities to execute signatures', async () => {
       const user = accounts[8]
 
-      // Deposit for user
-      await foreignBridge.depositForContractSender(user, {
-        from: user,
-        value: oneEther
-      })
-
       // Use these calls to simulate home bridge on home network
-      const resultPassMessageTx = await foreignBridge.requireToPassMessage(
-        box.address,
-        setValueData,
-        821254,
-        gasPrice,
-        {
-          from: user
-        }
-      )
+      const resultPassMessageTx = await foreignBridge.requireToPassMessage(box.address, setValueData, 821254, {
+        from: user
+      })
 
       // Validator on token-bridge add txHash to message
       const { encodedData } = resultPassMessageTx.logs[0].args
@@ -664,24 +397,12 @@ contract('ForeignAMB', async accounts => {
     it('status of RelayedMessage should be false on contract failed call', async () => {
       const user = accounts[8]
 
-      // Deposit for user
-      await foreignBridge.depositForContractSender(user, {
-        from: user,
-        value: oneEther
-      })
-
       const methodWillFailData = box.contract.methods.methodWillFail().encodeABI()
 
       // Use these calls to simulate home bridge on home network
-      const resultPassMessageTx = await foreignBridge.requireToPassMessage(
-        box.address,
-        methodWillFailData,
-        821254,
-        gasPrice,
-        {
-          from: user
-        }
-      )
+      const resultPassMessageTx = await foreignBridge.requireToPassMessage(box.address, methodWillFailData, 821254, {
+        from: user
+      })
 
       // Validator on token-bridge add txHash to message
       const { encodedData } = resultPassMessageTx.logs[0].args
@@ -712,24 +433,12 @@ contract('ForeignAMB', async accounts => {
     it('status of RelayedMessage should be false on contract out of gas call', async () => {
       const user = accounts[8]
 
-      // Deposit for user
-      await foreignBridge.depositForContractSender(user, {
-        from: user,
-        value: oneEther
-      })
-
       const methodOutOfGasData = box.contract.methods.methodOutOfGas().encodeABI()
 
       // Use these calls to simulate home bridge on home network
-      const resultPassMessageTx = await foreignBridge.requireToPassMessage(
-        box.address,
-        methodOutOfGasData,
-        1000,
-        gasPrice,
-        {
-          from: user
-        }
-      )
+      const resultPassMessageTx = await foreignBridge.requireToPassMessage(box.address, methodOutOfGasData, 1000, {
+        from: user
+      })
 
       // Validator on token-bridge add txHash to message
       const { encodedData } = resultPassMessageTx.logs[0].args
@@ -757,39 +466,5 @@ contract('ForeignAMB', async accounts => {
         .executeSignatures(message, signatures, { from: authorities[1], gasPrice })
         .should.be.rejectedWith(ERROR_MSG)
     })
-    it('status of RelayedMessage should be false if invalid dataType', async () => {
-      // set foreign bridge on subsidized mode
-      await foreignBridge.setSubsidizedModeForHomeToForeign().should.be.fulfilled
-
-      const user = accounts[8]
-
-      const boxInitialValue = await box.value()
-      boxInitialValue.should.be.bignumber.equal(ZERO)
-
-      // Use these calls to simulate home bridge on Home network
-      await foreignBridge.setSubsidizedModeForForeignToHome().should.be.fulfilled
-      const resultPassMessageTx = await foreignBridge.requireToPassMessage(box.address, setValueData, 1221254, 1, {
-        from: user
-      })
-
-      // Validator on token-bridge add txHash to message
-      const { encodedData } = resultPassMessageTx.logs[0].args
-      const message = addTxHashToAMBData(encodedData, resultPassMessageTx.tx)
-      const updatedMessage = `${message.slice(0, 210)}06${message.slice(212, message.length)}`
-
-      const signature = await sign(authorities[0], updatedMessage)
-      const vrs = signatureToVRSAMB(signature)
-      const signatures = packSignatures([vrs])
-
-      const { logs } = await foreignBridge.executeSignatures(updatedMessage, signatures, {
-        from: authorities[0]
-      }).should.be.fulfilled
-      expectEventInLogs(logs, 'RelayedMessage', {
-        sender: user,
-        executor: box.address,
-        transactionHash: resultPassMessageTx.tx,
-        status: false
-      })
-    })
   })
 })
diff --git a/test/arbitrary_message/home_bridge.test.js b/test/arbitrary_message/home_bridge.test.js
index 1b51139cd..e7c41fb2d 100644
--- a/test/arbitrary_message/home_bridge.test.js
+++ b/test/arbitrary_message/home_bridge.test.js
@@ -2,7 +2,6 @@ const HomeAMB = artifacts.require('HomeAMB.sol')
 const BridgeValidators = artifacts.require('BridgeValidators.sol')
 const Box = artifacts.require('Box.sol')
 const EternalStorageProxy = artifacts.require('EternalStorageProxy.sol')
-const IAMB = artifacts.require('IAMB.sol')
 
 const { expect } = require('chai')
 const { ERROR_MSG, ZERO_ADDRESS, toBN } = require('../setup')
@@ -26,79 +25,6 @@ contract('HomeAMB', async accounts => {
     validatorsRequiredSignatures = 1
     await validatorContract.initialize(validatorsRequiredSignatures, authorities, owner)
   })
-  describe('balance', () => {
-    let boxContract
-    before(async () => {
-      boxContract = await Box.new()
-    })
-    it('should start with zero balance', async () => {
-      const homeBridge = await HomeAMB.new()
-      expect(await homeBridge.balanceOf(boxContract.address)).to.be.bignumber.equal(ZERO)
-    })
-
-    it('should receive balance for a contract', async () => {
-      const homeBridge = await HomeAMB.new()
-      await homeBridge.depositForContractSender(boxContract.address, {
-        from: accounts[1],
-        value: 1
-      })
-
-      expect(await homeBridge.balanceOf(boxContract.address)).to.be.bignumber.equal('1')
-      expect(toBN(await web3.eth.getBalance(homeBridge.address))).to.be.bignumber.equal('1')
-    })
-
-    it('should revert for address 0', async () => {
-      const homeBridge = await HomeAMB.new()
-      await homeBridge
-        .depositForContractSender(ZERO_ADDRESS, {
-          from: accounts[1],
-          value: 1
-        })
-        .should.be.rejectedWith(ERROR_MSG)
-    })
-
-    it('user should be able to withdraw balance', async () => {
-      const user = accounts[8]
-
-      const homeBridge = await HomeAMB.new()
-      await homeBridge.initialize(validatorContract.address, oneEther, gasPrice, requiredBlockConfirmations, owner)
-
-      await homeBridge.depositForContractSender(user, {
-        from: user,
-        value: oneEther
-      })
-
-      const userBalanceOnBridgeAfterDeposit = await homeBridge.balanceOf(user)
-      const userBalanceAfterDeposit = toBN(await web3.eth.getBalance(user))
-      expect(userBalanceOnBridgeAfterDeposit).to.be.bignumber.equal(oneEther)
-
-      const amb = await IAMB.at(boxContract.address)
-      const withdrawFromDepositData = await amb.contract.methods.withdrawFromDeposit(user).encodeABI()
-
-      // Use these calls to simulate foreign bridge on Foreign network
-      const resultPassMessageTx = await homeBridge.requireToPassMessage(
-        homeBridge.address,
-        withdrawFromDepositData,
-        821254,
-        gasPrice,
-        { from: user }
-      )
-
-      // Validator on token-bridge add txHash to message
-      const { encodedData } = resultPassMessageTx.logs[0].args
-      const message = addTxHashToAMBData(encodedData, resultPassMessageTx.tx)
-
-      const { logs } = await homeBridge.executeAffirmation(message, { from: authorities[0], gasPrice }).should.be
-        .fulfilled
-      logs[0].event.should.be.equal('SignedForAffirmation')
-      logs[1].event.should.be.equal('AffirmationCompleted')
-
-      const userBalanceOnBridgeAfterWithdraw = await homeBridge.balanceOf(user)
-      const userBalanceAfterWithdraw = toBN(await web3.eth.getBalance(user))
-      userBalanceOnBridgeAfterWithdraw.should.be.bignumber.equal(ZERO)
-      userBalanceAfterWithdraw.should.be.bignumber.gt(userBalanceAfterDeposit)
-    })
-  })
   describe('getBridgeMode', () => {
     it('should return arbitrary message bridging mode and interface', async () => {
       const homeContract = await HomeAMB.new()
@@ -112,38 +38,6 @@ contract('HomeAMB', async accounts => {
       patch.should.be.bignumber.gte(ZERO)
     })
   })
-  describe('compensation mode', () => {
-    it('should return homeToForeignMode', async () => {
-      const homeBridge = await HomeAMB.new()
-      await homeBridge.initialize(validatorContract.address, oneEther, gasPrice, requiredBlockConfirmations, owner)
-        .should.be.fulfilled
-
-      expect(await homeBridge.homeToForeignMode()).to.be.bignumber.equal('0')
-
-      const { logs } = await homeBridge.setDefrayalModeForHomeToForeign().should.be.fulfilled
-      expect(await homeBridge.homeToForeignMode()).to.be.bignumber.equal('1')
-      expectEventInLogs(logs, 'HomeToForeignModeChanged', { mode: toBN(1) })
-
-      const { logs: logs2 } = await homeBridge.setSubsidizedModeForHomeToForeign().should.be.fulfilled
-      expect(await homeBridge.homeToForeignMode()).to.be.bignumber.equal('0')
-      expectEventInLogs(logs2, 'HomeToForeignModeChanged', { mode: ZERO })
-    })
-    it('should return foreignToHomeMode', async () => {
-      const homeBridge = await HomeAMB.new()
-      await homeBridge.initialize(validatorContract.address, oneEther, gasPrice, requiredBlockConfirmations, owner)
-        .should.be.fulfilled
-
-      expect(await homeBridge.foreignToHomeMode()).to.be.bignumber.equal('0')
-
-      const { logs } = await homeBridge.setDefrayalModeForForeignToHome().should.be.fulfilled
-      expect(await homeBridge.foreignToHomeMode()).to.be.bignumber.equal('1')
-      expectEventInLogs(logs, 'ForeignToHomeModeChanged', { mode: toBN(1) })
-
-      const { logs: logs2 } = await homeBridge.setSubsidizedModeForForeignToHome().should.be.fulfilled
-      expect(await homeBridge.foreignToHomeMode()).to.be.bignumber.equal('0')
-      expectEventInLogs(logs2, 'ForeignToHomeModeChanged', { mode: ZERO })
-    })
-  })
   describe('initialize', () => {
     it('sets variables', async () => {
       const homeBridge = await HomeAMB.new()
@@ -176,8 +70,6 @@ contract('HomeAMB', async accounts => {
         requiredBlockConfirmations: toBN(requiredBlockConfirmations)
       })
       expectEventInLogs(logs, 'GasPriceChanged', { gasPrice })
-      expectEventInLogs(logs, 'HomeToForeignModeChanged', { mode: ZERO })
-      expectEventInLogs(logs, 'ForeignToHomeModeChanged', { mode: ZERO })
     })
     it('should fail with invalid arguments', async () => {
       const homeBridge = await HomeAMB.new()
@@ -287,12 +179,8 @@ contract('HomeAMB', async accounts => {
 
       homeBridge = await HomeAMB.at(proxy.address)
       await homeBridge.initialize(validatorContract.address, oneEther, gasPrice, requiredBlockConfirmations, owner)
-      await homeBridge.setDefrayalModeForHomeToForeign().should.be.fulfilled
-      await homeBridge.setDefrayalModeForForeignToHome().should.be.fulfilled
     })
     it('call requireToPassMessage(address, bytes, uint256)', async () => {
-      await homeBridge.setSubsidizedModeForHomeToForeign().should.be.fulfilled
-
       const tx = await homeBridge.methods['requireToPassMessage(address,bytes,uint256)'](
         '0xf4BEF13F9f4f2B203FAF0C3cBbaAbe1afE056955',
         '0xb1591967aed668a4b27645ff40c444892d91bf5951b382995d4d4f6ee3a2ce03',
@@ -303,16 +191,6 @@ contract('HomeAMB', async accounts => {
       tx.receipt.logs.length.should.be.equal(1)
     })
     it('call requireToPassMessage(address, bytes, uint256) should fail', async () => {
-      // Should fail because subsidized mode not set by default
-      await homeBridge.methods['requireToPassMessage(address,bytes,uint256)'](
-        '0xf4BEF13F9f4f2B203FAF0C3cBbaAbe1afE056955',
-        '0xb1591967aed668a4b27645ff40c444892d91bf5951b382995d4d4f6ee3a2ce03',
-        1535604485,
-        { from: accounts[3] }
-      ).should.be.rejectedWith(ERROR_MSG)
-
-      await homeBridge.setSubsidizedModeForHomeToForeign().should.be.fulfilled
-
       // Should fail because gas < minimumGasUsage
       await homeBridge.methods['requireToPassMessage(address,bytes,uint256)'](
         '0xf4BEF13F9f4f2B203FAF0C3cBbaAbe1afE056955',
@@ -350,85 +228,6 @@ contract('HomeAMB', async accounts => {
         { from: accounts[3] }
       ).should.be.fulfilled
     })
-    it('call requireToPassMessage(address, bytes, uint256, uint256)', async () => {
-      const tx = await homeBridge.methods['requireToPassMessage(address,bytes,uint256,uint256)'](
-        '0xf4BEF13F9f4f2B203FAF0C3cBbaAbe1afE056955',
-        '0xb1591967aed668a4b27645ff40c444892d91bf5951b382995d4d4f6ee3a2ce03',
-        1535604485,
-        1000000000,
-        { from: accounts[3] }
-      )
-
-      tx.receipt.logs.length.should.be.equal(1)
-    })
-    it('call requireToPassMessage(address, bytes, uint256, uint256) on subsidized mode', async () => {
-      await homeBridge.setSubsidizedModeForHomeToForeign().should.be.fulfilled
-      const tx = await homeBridge.methods['requireToPassMessage(address,bytes,uint256,uint256)'](
-        '0xf4BEF13F9f4f2B203FAF0C3cBbaAbe1afE056955',
-        '0xb1591967aed668a4b27645ff40c444892d91bf5951b382995d4d4f6ee3a2ce03',
-        1535604485,
-        1000000000,
-        { from: accounts[3] }
-      )
-      tx.receipt.logs.length.should.be.equal(1)
-    })
-    it('call requireToPassMessage(address, bytes, uint256, uint256) should fail', async () => {
-      // Should fail because gas < minimumGasUsage
-      await homeBridge.methods['requireToPassMessage(address,bytes,uint256,uint256)'](
-        '0xf4BEF13F9f4f2B203FAF0C3cBbaAbe1afE056955',
-        '0xb1591967aed668a4b27645ff40c444892d91bf5951b382995d4d4f6ee3a2ce03',
-        10,
-        1000000000,
-        { from: accounts[3] }
-      ).should.be.rejectedWith(ERROR_MSG)
-
-      // Should fail because gas > maxGasPerTx
-      await homeBridge.methods['requireToPassMessage(address,bytes,uint256,uint256)'](
-        '0xf4BEF13F9f4f2B203FAF0C3cBbaAbe1afE056955',
-        '0xb1591967aed668a4b27645ff40c444892d91bf5951b382995d4d4f6ee3a2ce03',
-        twoEther,
-        1000000000,
-        { from: accounts[3] }
-      ).should.be.rejectedWith(ERROR_MSG)
-    })
-    it('call requireToPassMessage(address, bytes, uint256, bytes1)', async () => {
-      const { logs } = await homeBridge.methods['requireToPassMessage(address,bytes,uint256,bytes1)'](
-        '0xf4BEF13F9f4f2B203FAF0C3cBbaAbe1afE056955',
-        '0xb1591967aed668a4b27645ff40c444892d91bf5951b382995d4d4f6ee3a2ce03',
-        1535604485,
-        '0x01'
-      )
-      logs.length.should.be.equal(1)
-      logs[0].event.should.be.equal('UserRequestForSignature')
-    })
-    it('call requireToPassMessage(address, bytes, uint256, bytes1) on subsidized mode', async () => {
-      await homeBridge.setSubsidizedModeForHomeToForeign().should.be.fulfilled
-      const { logs } = await homeBridge.methods['requireToPassMessage(address,bytes,uint256,bytes1)'](
-        '0xf4BEF13F9f4f2B203FAF0C3cBbaAbe1afE056955',
-        '0xb1591967aed668a4b27645ff40c444892d91bf5951b382995d4d4f6ee3a2ce03',
-        1535604485,
-        '0x01'
-      )
-      logs.length.should.be.equal(1)
-      logs[0].event.should.be.equal('UserRequestForSignature')
-    })
-    it('call requireToPassMessage(address, bytes, uint256, bytes1) should fail', async () => {
-      // Should fail because gas < minimumGasUsage
-      await homeBridge.methods['requireToPassMessage(address,bytes,uint256,bytes1)'](
-        '0xf4BEF13F9f4f2B203FAF0C3cBbaAbe1afE056955',
-        '0xb1591967aed668a4b27645ff40c444892d91bf5951b382995d4d4f6ee3a2ce03',
-        10,
-        '0x01'
-      ).should.be.rejectedWith(ERROR_MSG)
-
-      // Should fail because gas > maxGasPerTx
-      await homeBridge.methods['requireToPassMessage(address,bytes,uint256,bytes1)'](
-        '0xf4BEF13F9f4f2B203FAF0C3cBbaAbe1afE056955',
-        '0xb1591967aed668a4b27645ff40c444892d91bf5951b382995d4d4f6ee3a2ce03',
-        twoEther,
-        '0x01'
-      ).should.be.rejectedWith(ERROR_MSG)
-    })
   })
   describe('executeAffirmation', () => {
     let homeBridge
@@ -442,25 +241,19 @@ contract('HomeAMB', async accounts => {
 
       homeBridge = await HomeAMB.at(proxy.address)
       await homeBridge.initialize(validatorContract.address, oneEther, gasPrice, requiredBlockConfirmations, owner)
-      await homeBridge.setDefrayalModeForHomeToForeign().should.be.fulfilled
-      await homeBridge.setDefrayalModeForForeignToHome().should.be.fulfilled
 
       box = await Box.new()
       // Generate data for method we want to call on Box contract
       setValueData = await box.contract.methods.setValue(3).encodeABI()
     })
     it('should succeed on Subsidized mode', async () => {
-      // set Home bridge on subsidized mode
-      await homeBridge.setSubsidizedModeForForeignToHome().should.be.fulfilled
-
       const user = accounts[8]
 
       const boxInitialValue = await box.value()
       boxInitialValue.should.be.bignumber.equal(ZERO)
 
       // Use these calls to simulate foreign bridge on Foreign network
-      await homeBridge.setSubsidizedModeForHomeToForeign().should.be.fulfilled
-      const resultPassMessageTx = await homeBridge.requireToPassMessage(box.address, setValueData, 221254, 1, {
+      const resultPassMessageTx = await homeBridge.requireToPassMessage(box.address, setValueData, 221254, {
         from: user
       })
 
@@ -483,96 +276,6 @@ contract('HomeAMB', async accounts => {
       expect(await box.txHash()).to.be.equal(resultPassMessageTx.tx)
       expect(await homeBridge.messageSender()).to.be.equal(ZERO_ADDRESS)
     })
-    it('should succeed on defrayal mode using message with oracle gas price', async () => {
-      const user = accounts[8]
-
-      const boxInitialValue = await box.value()
-      boxInitialValue.should.be.bignumber.equal(ZERO)
-
-      // Deposit for user
-      await homeBridge.depositForContractSender(user, {
-        from: user,
-        value: oneEther
-      })
-
-      // Use these calls to simulate foreign bridge on Foreign network
-      const resultPassMessageTx = await homeBridge.methods['requireToPassMessage(address,bytes,uint256,bytes1)'](
-        box.address,
-        setValueData,
-        821254,
-        '0x01',
-        {
-          from: user
-        }
-      )
-
-      // Validator on token-bridge add txHash to message
-      const { encodedData } = resultPassMessageTx.logs[0].args
-      const message = addTxHashToAMBData(encodedData, resultPassMessageTx.tx)
-
-      const { logs } = await homeBridge.executeAffirmation(message, { from: authorities[0], gasPrice }).should.be
-        .fulfilled
-      logs[0].event.should.be.equal('SignedForAffirmation')
-      expectEventInLogs(logs, 'AffirmationCompleted', {
-        sender: user,
-        executor: box.address,
-        transactionHash: resultPassMessageTx.tx,
-        status: true
-      })
-
-      // check Box value
-      expect(await box.value()).to.be.bignumber.equal('3')
-      expect(await box.lastSender()).to.be.equal(user)
-      expect(await box.txHash()).to.be.equal(resultPassMessageTx.tx)
-      expect(await homeBridge.messageSender()).to.be.equal(ZERO_ADDRESS)
-    })
-    it('should succeed on defrayal mode using message with gas price parameter', async () => {
-      const user = accounts[8]
-
-      const boxInitialValue = await box.value()
-      boxInitialValue.should.be.bignumber.equal(ZERO)
-
-      // Deposit for user
-      await homeBridge.depositForContractSender(user, {
-        from: user,
-        value: oneEther
-      })
-
-      // Use these calls to simulate foreign bridge on Foreign network
-      const tx = await homeBridge.methods['requireToPassMessage(address,bytes,uint256,uint256)'](
-        box.address,
-        setValueData,
-        821254,
-        gasPrice,
-        { from: user }
-      )
-
-      const { encodedData } = tx.receipt.logs[0].args
-
-      // Validator on token-bridge add txHash to message
-      const message = addTxHashToAMBData(encodedData, tx.tx)
-
-      // should fail because a different gas price was used
-      await homeBridge
-        .executeAffirmation(message, { from: authorities[0], gasPrice: '3000000000' })
-        .should.be.rejectedWith(ERROR_MSG)
-
-      const { logs } = await homeBridge.executeAffirmation(message, { from: authorities[0], gasPrice }).should.be
-        .fulfilled
-      logs[0].event.should.be.equal('SignedForAffirmation')
-      expectEventInLogs(logs, 'AffirmationCompleted', {
-        sender: user,
-        executor: box.address,
-        transactionHash: tx.tx,
-        status: true
-      })
-
-      // check Box value
-      expect(await box.value()).to.be.bignumber.equal('3')
-      expect(await box.lastSender()).to.be.equal(user)
-      expect(await box.txHash()).to.be.equal(tx.tx)
-      expect(await homeBridge.messageSender()).to.be.equal(ZERO_ADDRESS)
-    })
     it('test with 3 signatures required', async () => {
       // set validator
       const validatorContractWith3Signatures = await BridgeValidators.new()
@@ -595,18 +298,11 @@ contract('HomeAMB', async accounts => {
       const boxInitialValue = await box.value()
       boxInitialValue.should.be.bignumber.equal(ZERO)
 
-      // Deposit for user
-      await homeBridgeWithThreeSigs.depositForContractSender(user, {
-        from: user,
-        value: oneEther
-      })
-
       // Use these calls to simulate foreign bridge on Foreign network
       const resultPassMessageTx = await homeBridgeWithThreeSigs.requireToPassMessage(
         box.address,
         setValueData,
         821254,
-        gasPrice,
         { from: user }
       )
 
@@ -670,14 +366,8 @@ contract('HomeAMB', async accounts => {
     it('should not allow to double execute', async () => {
       const user = accounts[8]
 
-      // Deposit for user
-      await homeBridge.depositForContractSender(user, {
-        from: user,
-        value: oneEther
-      })
-
       // Use these calls to simulate foreign bridge on Foreign network
-      const resultPassMessageTx = await homeBridge.requireToPassMessage(box.address, setValueData, 821254, gasPrice, {
+      const resultPassMessageTx = await homeBridge.requireToPassMessage(box.address, setValueData, 821254, {
         from: user
       })
 
@@ -701,14 +391,8 @@ contract('HomeAMB', async accounts => {
     it('should not allow non-authorities to execute affirmation', async () => {
       const user = accounts[8]
 
-      // Deposit for user
-      await homeBridge.depositForContractSender(user, {
-        from: user,
-        value: oneEther
-      })
-
       // Use these calls to simulate foreign bridge on Foreign network
-      const resultPassMessageTx = await homeBridge.requireToPassMessage(box.address, setValueData, 821254, gasPrice, {
+      const resultPassMessageTx = await homeBridge.requireToPassMessage(box.address, setValueData, 821254, {
         from: user
       })
 
@@ -727,24 +411,12 @@ contract('HomeAMB', async accounts => {
     it('status of AffirmationCompleted should be false on contract failed call', async () => {
       const user = accounts[8]
 
-      // Deposit for user
-      await homeBridge.depositForContractSender(user, {
-        from: user,
-        value: oneEther
-      })
-
       const methodWillFailData = box.contract.methods.methodWillFail().encodeABI()
 
       // Use these calls to simulate foreign bridge on Foreign network
-      const resultPassMessageTx = await homeBridge.requireToPassMessage(
-        box.address,
-        methodWillFailData,
-        141647,
-        gasPrice,
-        {
-          from: user
-        }
-      )
+      const resultPassMessageTx = await homeBridge.requireToPassMessage(box.address, methodWillFailData, 141647, {
+        from: user
+      })
 
       // Validator on token-bridge add txHash to message
       const { encodedData } = resultPassMessageTx.logs[0].args
@@ -766,24 +438,12 @@ contract('HomeAMB', async accounts => {
     it('status of AffirmationCompleted should be false on contract out of gas call', async () => {
       const user = accounts[8]
 
-      // Deposit for user
-      await homeBridge.depositForContractSender(user, {
-        from: user,
-        value: oneEther
-      })
-
       const methodOutOfGasData = box.contract.methods.methodOutOfGas().encodeABI()
 
       // Use these calls to simulate foreign bridge on Foreign network
-      const resultPassMessageTx = await homeBridge.requireToPassMessage(
-        box.address,
-        methodOutOfGasData,
-        1000,
-        gasPrice,
-        {
-          from: user
-        }
-      )
+      const resultPassMessageTx = await homeBridge.requireToPassMessage(box.address, methodOutOfGasData, 1000, {
+        from: user
+      })
 
       // Validator on token-bridge add txHash to message
       const { encodedData } = resultPassMessageTx.logs[0].args
@@ -802,35 +462,6 @@ contract('HomeAMB', async accounts => {
       await homeBridge.executeAffirmation(message, { from: authorities[0], gasPrice }).should.be.rejectedWith(ERROR_MSG)
       await homeBridge.executeAffirmation(message, { from: authorities[1], gasPrice }).should.be.rejectedWith(ERROR_MSG)
     })
-    it('status of AffirmationCompleted should be false if invalid dataType', async () => {
-      // set Home bridge on subsidized mode
-      await homeBridge.setSubsidizedModeForForeignToHome().should.be.fulfilled
-
-      const user = accounts[8]
-
-      const boxInitialValue = await box.value()
-      boxInitialValue.should.be.bignumber.equal(ZERO)
-
-      // Use these calls to simulate foreign bridge on Foreign network
-      await homeBridge.setSubsidizedModeForHomeToForeign().should.be.fulfilled
-      const resultPassMessageTx = await homeBridge.requireToPassMessage(box.address, setValueData, 221254, 1, {
-        from: user
-      })
-
-      // Validator on token-bridge add txHash to message
-      const { encodedData } = resultPassMessageTx.logs[0].args
-      const message = addTxHashToAMBData(encodedData, resultPassMessageTx.tx)
-      const updatedMessage = `${message.slice(0, 210)}06${message.slice(212, message.length)}`
-
-      const { logs } = await homeBridge.executeAffirmation(updatedMessage, { from: authorities[0] }).should.be.fulfilled
-      logs[0].event.should.be.equal('SignedForAffirmation')
-      expectEventInLogs(logs, 'AffirmationCompleted', {
-        sender: user,
-        executor: box.address,
-        transactionHash: resultPassMessageTx.tx,
-        status: false
-      })
-    })
   })
   describe('submitSignature', () => {
     let homeBridge
@@ -852,7 +483,7 @@ contract('HomeAMB', async accounts => {
     it('allows a validator to submit a signature', async () => {
       const user = accounts[8]
 
-      const resultPassMessageTx = await homeBridge.requireToPassMessage(box.address, setValueData, 821254, 1, {
+      const resultPassMessageTx = await homeBridge.requireToPassMessage(box.address, setValueData, 821254, {
         from: user
       })
 
@@ -906,7 +537,6 @@ contract('HomeAMB', async accounts => {
         box.address,
         setValueData,
         821254,
-        1,
         { from: user }
       )
 
@@ -962,7 +592,7 @@ contract('HomeAMB', async accounts => {
     it('should not allow to double submit', async () => {
       const user = accounts[8]
 
-      const resultPassMessageTx = await homeBridge.requireToPassMessage(box.address, setValueData, 821254, 1, {
+      const resultPassMessageTx = await homeBridge.requireToPassMessage(box.address, setValueData, 821254, {
         from: user
       })
 
@@ -987,7 +617,7 @@ contract('HomeAMB', async accounts => {
     it('should not allow non-authorities to submit signatures', async () => {
       const user = accounts[8]
 
-      const resultPassMessageTx = await homeBridge.requireToPassMessage(box.address, setValueData, 821254, 1, {
+      const resultPassMessageTx = await homeBridge.requireToPassMessage(box.address, setValueData, 821254, {
         from: user
       })