diff --git a/contracts/MainChain.sol b/contracts/MainChain.sol
index 96d716a..46a5d51 100644
--- a/contracts/MainChain.sol
+++ b/contracts/MainChain.sol
@@ -101,25 +101,23 @@ contract MainChain is Freezable {
         emit Deposit(msg.sender, to, msg.value);
     }
 
-    /// @dev submit a transaction to be processed
-    /// @param msgHash sha3 hash of txHash destination value data and VERSION
-    /// @param txHash transaction hash of the deposit tx in side chain
-    /// @param destination destination provided in deposit tx in side chain
-    /// @param value msg.value of deposit tx in side chain
-    /// @param data data of deposit tx in side chain
-    /// @param v list of v part of sig
-    /// @param r list of r part of sig
-    /// @param s list of s part of sig
-    function submitTransaction(bytes32 msgHash, bytes32 txHash, address destination, uint256 value, bytes data, uint8[] v, bytes32[] r, bytes32[] s)
-      notNull(destination)
-      transactionDoesNotExists(txHash)
-      txNotBlackListed(txHash)
-      onlyWhenNotFrozen
-      public {
+	/// @dev submit a transaction to be processed
+	/// @param txHash transaction hash of the deposit tx in side chain
+	/// @param destination destination provided in deposit tx in side chain
+	/// @param value msg.value of deposit tx in side chain
+	/// @param data data of deposit tx in side chain
+	/// @param v list of v part of sig
+	/// @param r list of r part of sig
+	/// @param s list of s part of sig
+    function submitTransaction(bytes32 txHash, address destination, uint256 value, bytes data, uint8[] v, bytes32[] r, bytes32[] s)
+	  notNull(destination)
+	  transactionDoesNotExists(txHash)
+	  txNotBlackListed(txHash)
+	  onlyWhenNotFrozen
+	  public {
         require(v.length >= required);
 
-        bytes32 hashedTxParams = keccak256(txHash, destination, value, data, VERSION);
-        require(hashedTxParams == msgHash);
+        bytes32 msgHash = keccak256(byte(0x19), VERSION, address(this),txHash, destination, value, data);
 
         // execute the transaction after all checking the signatures
         require (hasEnoughRequiredSignatures(msgHash, v, r, s));
@@ -160,7 +158,6 @@ contract MainChain is Freezable {
     /// @param destination target destination
     /// @param value ether value
     /// @param data data payload
-    // @TODO still need to write tests for emergency withdrawal
     function emergencyWithdrawal(address destination, uint256 value, bytes data)
       onlyWhenFrozen
       ownerExists(msg.sender)
diff --git a/contracts/SideChain.sol b/contracts/SideChain.sol
index 24d60f7..3f19fe9 100644
--- a/contracts/SideChain.sol
+++ b/contracts/SideChain.sol
@@ -31,11 +31,11 @@ contract SideChain is Freezable {
     ////////////////////////
     //	 Storage Variables
     ////////////////////////
-    mapping (bytes32 => Transaction) public sideChainTx;
+    mapping (bytes32 => SideChainTransaction) public sideChainTx;
     mapping (bytes32 => mapping(address => bool)) public isSignedSC;
     uint256 sideChainTxCount;
 
-    mapping (bytes32 => Transaction) mainChainTxs;
+    mapping (bytes32 => MainChainTransaction) mainChainTxs;
     mapping (bytes32 => Signatures) mainChainSigs;
     mapping (bytes32 => mapping(address => bool)) public isSignedMC;
     uint256 mainChainTxCount;
@@ -43,13 +43,21 @@ contract SideChain is Freezable {
     ////////////////////////
     //	 Structs
     ////////////////////////
-    struct Transaction {
+    struct SideChainTransaction {
+        bytes32 msgHash;
         address destination;
         uint256 value;
         bytes data;
         bool executed;
     }
 
+
+    struct MainChainTransaction {
+        address destination;
+        uint256 value;
+        bytes data;
+    }
+
     struct Signatures {
         uint8[] v;
         bytes32[] r;
@@ -76,30 +84,26 @@ contract SideChain is Freezable {
         emit Deposit(msg.sender, to, msg.value);
     }
 
-    /// @dev submit transaction to be processed pending the approvals
-    /// @param msgHash sha3 hash of txHash destination value data and VERSION
-    /// @param txHash transaction hash of the deposit tx in main chain
-    /// @param destination destination provided in deposit tx in main chain
-    /// @param value msg.value of deposit tx in main chain
-    /// @param data data of deposit tx in main chain
-    /// @param v part of sig
-    /// @param r part of sig
-    /// @param s part of sig
-    function submitTransactionSC(bytes32 msgHash, bytes32 txHash, address destination, uint256 value, bytes data, uint8 v, bytes32 r, bytes32 s)
+	/// @dev submit transaction to be processed pending the approvals
+	/// @param txHash transaction hash of the deposit tx in main chain
+	/// @param destination destination provided in deposit tx in main chain
+	/// @param value msg.value of deposit tx in main chain
+	/// @param data data of deposit tx in main chain
+    function submitTransactionSC(bytes32 txHash, address destination, uint256 value, bytes data)
         ownerExists(msg.sender)
         notNull(destination)
         public {
         require(!isSignedSC[txHash][msg.sender]);
-        address signer = ecrecover(msgHash, v, r, s);
-        require(msg.sender == signer);
-        bytes32 hashedTxParams = keccak256(txHash, destination, value, data, VERSION);
-        require(hashedTxParams == msgHash);
+
+        bytes32 msgHash = keccak256(txHash, destination, value, data, VERSION);
+
         if (sideChainTx[txHash].destination == address(0)) {
-            addTransactionSC(txHash, destination, value, data);
-        } else {
-            require(sideChainTx[txHash].destination == destination);
-            require(sideChainTx[txHash].value == value);
+            addTransactionSC(msgHash, txHash, destination, value, data);
         }
+
+        // this validates that all the parameters are the same as the previous submitter
+        require(sideChainTx[txHash].msgHash == msgHash);
+
         isSignedSC[txHash][msg.sender] = true;
         emit Confirmation(msg.sender, txHash);
         executeTransaction(txHash);
@@ -124,7 +128,7 @@ contract SideChain is Freezable {
         require(isSignedSC[txHash][msg.sender]);
         require(!sideChainTx[txHash].executed);
         if (isConfirmed(txHash)) {
-            Transaction storage txn = sideChainTx[txHash];
+            SideChainTransaction storage txn = sideChainTx[txHash];
             txn.executed = true;
             if (external_call(txn.destination, txn.value, txn.data.length, txn.data))
                 emit Execution(txHash);
@@ -142,7 +146,7 @@ contract SideChain is Freezable {
       public
       returns(bool) {
         uint count = 0;
-        for (uint i=0; i<owners.length; i++) {
+        for (uint i = 0; i<owners.length; i++) {
             if (isSignedSC[txHash][owners[i]])
                 count += 1;
             if (count == required)
@@ -156,7 +160,7 @@ contract SideChain is Freezable {
       view
       public
       returns(uint count) {
-        for (uint i=0; i<owners.length; i++) {
+        for (uint i = 0; i<owners.length; i++) {
             if (isSignedSC[txHash][owners[i]]) {
                 count += 1;
             }
@@ -172,13 +176,13 @@ contract SideChain is Freezable {
         address[] memory isSignedSCTemp = new address[](owners.length);
         uint count = 0;
         uint i;
-        for (i=0; i<owners.length; i++)
+        for (i = 0; i<owners.length; i++)
             if (isSignedSC[txHash][owners[i]]) {
                 isSignedSCTemp[count] = owners[i];
                 count += 1;
             }
         _isSignedSC = new address[](count);
-        for (i=0; i<count; i++)
+        for (i = 0; i<count; i++)
             _isSignedSC[i] = isSignedSCTemp[i];
     }
 
@@ -188,14 +192,16 @@ contract SideChain is Freezable {
 
 
     /// @dev Adds a new transaction to the transaction mapping, if transaction does not exist yet.
+    /// @param msgHash keccek256 hash of the parameters
     /// @param txHash Transaction transactionHash
     /// @param destination Transaction target address.
     /// @param value Transaction ether value.
     /// @param data Transaction data payload.
-    function addTransactionSC(bytes32 txHash, address destination, uint value, bytes data)
+    function addTransactionSC(bytes32 msgHash, bytes32 txHash, address destination, uint value, bytes data)
       notNull(destination)
       private {
-        sideChainTx[txHash] = Transaction({
+        sideChainTx[txHash] = SideChainTransaction({
+            msgHash: msgHash,
             destination: destination,
             value: value,
             executed: false,
@@ -230,27 +236,25 @@ contract SideChain is Freezable {
     // SUBMIT SIGNATURES TO WITHDRAW ON MAINCHAIN
     //////////////////////////////////////////////
 
-    /// @dev store signature to be submitted in mainchain
-    /// @param msgHash sha3 hash of txHash destination value data and VERSION
-    /// @param txHash transaction hash of the deposit tx in side chain
-    /// @param destination destination provided in deposit tx in side chain
-    /// @param value msg.value of deposit tx in side chain
-    /// @param data data of deposit tx in side chain
-    /// @param v part of sig
-    /// @param r part of sig
-    /// @param s part of sig
-    function submitSignatureMC(bytes32 msgHash, bytes32 txHash, address destination, uint256 value, bytes data, uint8 v, bytes32 r, bytes32 s)
+	/// @dev store signature to be submitted in mainchain
+	/// @param txHash transaction hash of the deposit tx in side chain
+	/// @param destination destination provided in deposit tx in side chain
+	/// @param value msg.value of deposit tx in side chain
+	/// @param data data of deposit tx in side chain
+	/// @param v part of sig
+	/// @param r part of sig
+	/// @param s part of sig
+    function submitSignatureMC(bytes32 txHash, address destination, uint256 value, bytes data, uint8 v, bytes32 r, bytes32 s)
       ownerExists(msg.sender)
       notNull(destination)
       public {
         require(!isSignedMC[txHash][msg.sender]);
 
+        bytes32 msgHash = keccak256(byte(0x19), VERSION, address(this),txHash, destination, value, data);
+
         address signer = ecrecover(msgHash, v, r, s);
         require(msg.sender == signer);
 
-        bytes32 hashedTxParams = keccak256(txHash, destination, value, data, VERSION);
-        require(hashedTxParams == msgHash);
-
         if(mainChainTxs[txHash].destination == address(0)){
             addTransactionMC(txHash, destination, value, data);
         }
@@ -276,10 +280,9 @@ contract SideChain is Freezable {
     function addTransactionMC(bytes32 txHash, address destination, uint256 value, bytes data)
       notNull(destination)
       private {
-        mainChainTxs[txHash] = Transaction({
+        mainChainTxs[txHash] = MainChainTransaction({
             destination: destination,
             value: value,
-            executed: false,
             data: data
             });
         mainChainTxCount += 1;
@@ -291,7 +294,7 @@ contract SideChain is Freezable {
       view
       public
       returns(address destination, uint256 value, bytes data, uint8[] v, bytes32[] r, bytes32[] s) {
-        Transaction storage tempTx = mainChainTxs[txHash];
+        MainChainTransaction storage tempTx = mainChainTxs[txHash];
         Signatures storage tempSigs = mainChainSigs[txHash];
         return (tempTx.destination, tempTx.value, tempTx.data, tempSigs.v, tempSigs.r, tempSigs.s);
     }
diff --git a/contracts/libs/Freezable.sol b/contracts/libs/Freezable.sol
index ca4a9f8..8c1fc0b 100644
--- a/contracts/libs/Freezable.sol
+++ b/contracts/libs/Freezable.sol
@@ -53,7 +53,7 @@ contract Freezable is MultiSigOwnable {
         if (frozenAt == 0 || approvalCount == 0) return false;
         else {
             uint256 frozenDuration = minTimeFrozen * (frozenDurationRatio ** (approvalCount - 1));
-            if (now < (frozenAt + frozenDuration)) return true;
+            if (block.timestamp < (frozenAt + frozenDuration)) return true;
         }
         return false;
     }
@@ -85,8 +85,8 @@ contract Freezable is MultiSigOwnable {
         approvalCount++;
 
         if (frozenAt == 0) {
-            frozenAt = now;
-            emit contractFrozen(now);
+            frozenAt = block.timestamp;
+            emit contractFrozen(block.timestamp);
         }
     }
 
@@ -100,7 +100,7 @@ contract Freezable is MultiSigOwnable {
 
         if (approvalCount == 0) {
             frozenAt = 0;
-            emit contractUnFrozen(now);
+            emit contractUnFrozen(block.timestamp);
         }
     }
 }
diff --git a/contracts/libs/MultiSigOwnable.sol b/contracts/libs/MultiSigOwnable.sol
index 73b7826..693c195 100644
--- a/contracts/libs/MultiSigOwnable.sol
+++ b/contracts/libs/MultiSigOwnable.sol
@@ -34,11 +34,10 @@ contract MultiSigOwnable {
     }
 
     modifier validRequirement(uint ownerCount, uint8 _required) {
-        require(
-            ownerCount <= MAX_OWNER_COUNT
-            && _required <= ownerCount
-            && _required != 0
-            && ownerCount != 0);
+        require(ownerCount <= MAX_OWNER_COUNT);
+        require(_required <= ownerCount);
+        require(_required != 0);
+        require(ownerCount != 0);
         _;
     }
 
@@ -84,9 +83,9 @@ contract MultiSigOwnable {
         ownerExists(owner)
         public {
         isOwner[owner] = false;
-        for (uint i=0; i< owners.length - 1; i++) {
+        for (uint i = 0; i < owners.length - 1; i++) {
             if (owners[i] == owner) {
-                owners[i] = owners[ owners.length - 1];
+                owners[i] = owners[owners.length - 1];
                 break;
             }
         }
diff --git a/test/MainChainUnitTest/addBlackListUnitTest.js b/test/MainChainUnitTest/addBlackListUnitTest.js
index ea982c0..65f2312 100644
--- a/test/MainChainUnitTest/addBlackListUnitTest.js
+++ b/test/MainChainUnitTest/addBlackListUnitTest.js
@@ -18,6 +18,7 @@ let txHash;
 let toAddress;
 let value;
 let version;
+let contractAddress;
 
 contract('MainChain: addBlackList Unit Test', function(accounts) {
   beforeEach(async function() {
@@ -27,6 +28,7 @@ contract('MainChain: addBlackList Unit Test', function(accounts) {
     toAddress = mainchainInstance.address;
     value = 0;
     version = await mainchainInstance.VERSION.call();
+    contractAddress = mainchainInstance.address;
   });
 
   it('checks that addBlackList work as intended if all the condition are valid', async function() {
@@ -44,6 +46,7 @@ contract('MainChain: addBlackList Unit Test', function(accounts) {
     );
     const sigs = utils.multipleSignedTransaction(
       [0, 1],
+      contractAddress,
       txHash,
       toAddress,
       value,
@@ -51,7 +54,6 @@ contract('MainChain: addBlackList Unit Test', function(accounts) {
       version,
     );
     await mainchainInstance.submitTransaction(
-      sigs.msgHash,
       txHash,
       toAddress,
       value,
@@ -90,6 +92,7 @@ contract('MainChain: addBlackList Unit Test', function(accounts) {
     );
     let sigs = utils.multipleSignedTransaction(
       [0, 1],
+      contractAddress,
       txHash,
       toAddress,
       value,
@@ -97,7 +100,6 @@ contract('MainChain: addBlackList Unit Test', function(accounts) {
       version,
     );
     await mainchainInstance.submitTransaction(
-      sigs.msgHash,
       txHash,
       toAddress,
       value,
@@ -114,6 +116,7 @@ contract('MainChain: addBlackList Unit Test', function(accounts) {
     // const data = mainchainInstance.contract.addBlackList.getData(txHash);
     sigs = utils.multipleSignedTransaction(
       [0, 1],
+      contractAddress,
       txHashes[1],
       toAddress,
       value,
@@ -121,7 +124,6 @@ contract('MainChain: addBlackList Unit Test', function(accounts) {
       version,
     );
     const res = await mainchainInstance.submitTransaction(
-      sigs.msgHash,
       txHashes[1],
       toAddress,
       value,
@@ -141,6 +143,7 @@ contract('MainChain: addBlackList Unit Test', function(accounts) {
     );
     const sigs = utils.multipleSignedTransaction(
       [0, 1],
+      contractAddress,
       txHash,
       toAddress,
       value,
@@ -148,7 +151,6 @@ contract('MainChain: addBlackList Unit Test', function(accounts) {
       version,
     );
     const res = await mainchainInstance.submitTransaction(
-      sigs.msgHash,
       txHash,
       toAddress,
       value,
diff --git a/test/MainChainUnitTest/removeBlackListUnitTest.js b/test/MainChainUnitTest/removeBlackListUnitTest.js
index 01593d7..10c382c 100644
--- a/test/MainChainUnitTest/removeBlackListUnitTest.js
+++ b/test/MainChainUnitTest/removeBlackListUnitTest.js
@@ -18,6 +18,7 @@ let txHash;
 let toAddress;
 let value;
 let version;
+let contractAddress;
 
 contract('MainChain: removeBlackList Unit Test', function(accounts) {
   beforeEach(async function() {
@@ -27,11 +28,13 @@ contract('MainChain: removeBlackList Unit Test', function(accounts) {
     toAddress = mainchainInstance.address;
     value = 0;
     version = await mainchainInstance.VERSION.call();
+    contractAddress = mainchainInstance.address;
     const addBlackListData = mainchainInstance.contract.addBlackList.getData(
       txHash,
     );
     const sigs = utils.multipleSignedTransaction(
       [0, 1],
+      contractAddress,
       txHash,
       toAddress,
       value,
@@ -39,7 +42,6 @@ contract('MainChain: removeBlackList Unit Test', function(accounts) {
       version,
     );
     await mainchainInstance.submitTransaction(
-      sigs.msgHash,
       txHash,
       toAddress,
       value,
@@ -65,6 +67,7 @@ contract('MainChain: removeBlackList Unit Test', function(accounts) {
     );
     const removeBlackListSigs = utils.multipleSignedTransaction(
       [0, 1],
+      contractAddress,
       txHashes[1],
       toAddress,
       value,
@@ -72,7 +75,6 @@ contract('MainChain: removeBlackList Unit Test', function(accounts) {
       version,
     );
     await mainchainInstance.submitTransaction(
-      removeBlackListSigs.msgHash,
       txHashes[1],
       toAddress,
       value,
@@ -117,6 +119,7 @@ contract('MainChain: removeBlackList Unit Test', function(accounts) {
     );
     const removeBlackListSigs = utils.multipleSignedTransaction(
       [0, 1],
+      contractAddress,
       txHashes[1],
       toAddress,
       value,
@@ -124,7 +127,6 @@ contract('MainChain: removeBlackList Unit Test', function(accounts) {
       version,
     );
     const res = await mainchainInstance.submitTransaction(
-      removeBlackListSigs.msgHash,
       txHashes[1],
       toAddress,
       value,
@@ -144,6 +146,7 @@ contract('MainChain: removeBlackList Unit Test', function(accounts) {
     );
     const sigs1 = utils.multipleSignedTransaction(
       [0, 1],
+      contractAddress,
       txHashes[1],
       toAddress,
       value,
@@ -151,7 +154,6 @@ contract('MainChain: removeBlackList Unit Test', function(accounts) {
       version,
     );
     const res = await mainchainInstance.submitTransaction(
-      sigs1.msgHash,
       txHashes[1],
       toAddress,
       value,
diff --git a/test/MainChainUnitTest/submitTransactionUnitTest.js b/test/MainChainUnitTest/submitTransactionUnitTest.js
index a39b5c6..f7b72ce 100644
--- a/test/MainChainUnitTest/submitTransactionUnitTest.js
+++ b/test/MainChainUnitTest/submitTransactionUnitTest.js
@@ -23,6 +23,7 @@ let value;
 let data;
 let sigs;
 let version;
+let contractAddress;
 
 contract('MainChain: submitTransaction Unit Test', function(accounts) {
   beforeEach(async function() {
@@ -39,6 +40,7 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
     value = 1e6;
     data = '';
     version = await mainchainInstance.VERSION.call();
+    contractAddress = mainchainInstance.address;
   });
 
   it('checks that ETH withdrawal works as intended if all the condition are valid', async function() {
@@ -51,6 +53,7 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
     toAddress = user;
     sigs = utils.multipleSignedTransaction(
       [0, 1],
+      contractAddress,
       txHash,
       toAddress,
       value,
@@ -58,7 +61,6 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
       version,
     );
     await mainchainInstance.submitTransaction(
-      sigs.msgHash,
       txHash,
       toAddress,
       value,
@@ -101,6 +103,7 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
 
     sigs = utils.multipleSignedTransaction(
       [0, 1],
+      contractAddress,
       txHash,
       toAddress,
       value,
@@ -108,7 +111,6 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
       version,
     );
     await mainchainInstance.submitTransaction(
-      sigs.msgHash,
       txHash,
       toAddress,
       value,
@@ -138,6 +140,7 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
     value = 0;
     sigs = utils.multipleSignedTransaction(
       [0, 1],
+      contractAddress,
       txHash,
       toAddress,
       value,
@@ -145,7 +148,6 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
       version,
     );
     let res = await mainchainInstance.submitTransaction(
-      sigs.msgHash,
       txHash,
       toAddress,
       value,
@@ -167,6 +169,7 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
     txHash = txHashes[1]; // we need to use a different txHash for this to succeed
     sigs = utils.multipleSignedTransaction(
       [0, 1],
+      contractAddress,
       txHash,
       toAddress,
       value,
@@ -174,7 +177,6 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
       version,
     );
     res = await mainchainInstance.submitTransaction(
-      sigs.msgHash,
       txHash,
       toAddress,
       value,
@@ -202,6 +204,7 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
 
     sigs = utils.multipleSignedTransaction(
       [0, 1],
+      contractAddress,
       txHash,
       toAddress,
       value,
@@ -209,7 +212,6 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
       version,
     );
     await mainchainInstance.submitTransaction(
-      sigs.msgHash,
       txHash,
       toAddress,
       value,
@@ -228,7 +230,6 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
 
   it('revert if transaction Hash already exits', async function() {
     await mainchainInstance.submitTransaction(
-      sigs.msgHash,
       txHash,
       toAddress,
       value,
@@ -240,7 +241,6 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
 
     await utils.assertRevert(
       mainchainInstance.submitTransaction(
-        sigs.msgHash,
         txHash,
         toAddress,
         value,
@@ -260,6 +260,7 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
     );
     const addBlackListSigs = utils.multipleSignedTransaction(
       [0, 1],
+      contractAddress,
       txHashToBlackList,
       mainchainInstance.contract.address,
       0,
@@ -267,7 +268,6 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
       version,
     );
     await mainchainInstance.submitTransaction(
-      addBlackListSigs.msgHash,
       txHashToBlackList,
       mainchainInstance.contract.address,
       0,
@@ -288,6 +288,7 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
     toAddress = user;
     sigs = utils.multipleSignedTransaction(
       [0, 1],
+      contractAddress,
       txHash,
       toAddress,
       value,
@@ -298,7 +299,6 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
     // check transaction is reverted.
     utils.assertRevert(
       mainchainInstance.submitTransaction(
-        sigs.msgHash,
         txHash,
         toAddress,
         value,
@@ -327,6 +327,7 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
 
     sigs = utils.multipleSignedTransaction(
       [0, 1],
+      contractAddress,
       txHash,
       toAddress,
       value,
@@ -335,7 +336,6 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
     );
     await utils.assertRevert(
       mainchainInstance.submitTransaction(
-        sigs.msgHash,
         txHash,
         toAddress,
         value,
@@ -351,6 +351,7 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
     // one less signature than required
     sigs = utils.multipleSignedTransaction(
       [0],
+      contractAddress,
       txHash,
       toAddress,
       value,
@@ -359,7 +360,6 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
     );
     await utils.assertRevert(
       mainchainInstance.submitTransaction(
-        sigs.msgHash,
         txHash,
         toAddress,
         value,
@@ -372,6 +372,7 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
 
     sigs = utils.multipleSignedTransaction(
       [0, 1],
+      contractAddress,
       txHash,
       toAddress,
       value,
@@ -379,7 +380,6 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
       version,
     );
     await mainchainInstance.submitTransaction(
-      sigs.msgHash,
       txHash,
       toAddress,
       value,
@@ -390,42 +390,11 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
     );
   });
 
-  it("revert if the hash of the parameter doesn't equal to msgHash signed", async function() {
-    // use a different txHash than the one signed with
-    const msgHash = utils.createMsgHash(
-      txHashes[1],
-      toAddress,
-      value,
-      data,
-      version,
-    );
-
-    sigs = utils.multipleSignedTransaction(
-      [0, 1],
-      txHash,
-      toAddress,
-      value,
-      data,
-      version,
-    );
-    await utils.assertRevert(
-      mainchainInstance.submitTransaction(
-        msgHash,
-        txHash,
-        toAddress,
-        value,
-        data,
-        sigs.v,
-        sigs.r,
-        sigs.s,
-      ),
-    );
-  });
-
   it("revert if there aren't enough valid signatures", async function() {
     // two of the same signature
     sigs = utils.multipleSignedTransaction(
       [0, 0],
+      contractAddress,
       txHash,
       toAddress,
       value,
@@ -434,7 +403,6 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
     );
     await utils.assertRevert(
       mainchainInstance.submitTransaction(
-        sigs.msgHash,
         txHash,
         toAddress,
         value,
@@ -447,6 +415,7 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
 
     sigs = utils.multipleSignedTransaction(
       [0, 1],
+      contractAddress,
       txHash,
       toAddress,
       value,
@@ -454,7 +423,6 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
       version,
     );
     await mainchainInstance.submitTransaction(
-      sigs.msgHash,
       txHash,
       toAddress,
       value,
@@ -468,6 +436,7 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
   it('checks that Execution event is emitted properly', async function() {
     sigs = utils.multipleSignedTransaction(
       [0, 1],
+      contractAddress,
       txHash,
       toAddress,
       value,
@@ -475,7 +444,6 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
       version,
     );
     const res = await mainchainInstance.submitTransaction(
-      sigs.msgHash,
       txHash,
       toAddress,
       value,
@@ -494,6 +462,7 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
 
     sigs = utils.multipleSignedTransaction(
       [0, 1],
+      contractAddress,
       txHash,
       toAddress,
       value,
@@ -501,7 +470,6 @@ contract('MainChain: submitTransaction Unit Test', function(accounts) {
       version,
     );
     const res = await mainchainInstance.submitTransaction(
-      sigs.msgHash,
       txHash,
       toAddress,
       value,
diff --git a/test/SideChainUnitTest/submitSignatureMCUnit.js b/test/SideChainUnitTest/submitSignatureMCUnit.js
index 456c36c..3995091 100644
--- a/test/SideChainUnitTest/submitSignatureMCUnit.js
+++ b/test/SideChainUnitTest/submitSignatureMCUnit.js
@@ -4,7 +4,6 @@ let utils = require('./../utils/utils');
 let consts = require('./../utils/consts');
 let web3Utils = require('web3-utils');
 let sidechain = artifacts.require('SideChain.sol');
-let exampleToken = artifacts.require('./test/ExampleToken.sol');
 
 let sidechainInstance;
 let txHashes = [];
@@ -22,19 +21,21 @@ let value;
 let data;
 let sigs;
 let version;
+let contractAddress;
 
 contract('SideChain: submitSignature Unit Test', function(accounts) {
   beforeEach(async function() {
     sidechainInstance = await sidechain.new(accounts.slice(0, 3), 2);
-    await exampleToken.new(accounts.slice(0, 4));
 
     txHash = txHashes[0];
     toAddress = accounts[1];
     value = 1e6;
     data = '';
     version = await sidechainInstance.VERSION.call();
+    contractAddress = sidechainInstance.address;
     sigs = utils.multipleSignedTransaction(
       [0, 1, 2, 3, 4, 5, 6],
+      contractAddress,
       txHash,
       toAddress,
       value,
@@ -52,7 +53,6 @@ contract('SideChain: submitSignature Unit Test', function(accounts) {
 
     // we only need to submit one signature
     await sidechainInstance.submitSignatureMC(
-      sigs.msgHash,
       txHash,
       toAddress,
       value,
@@ -80,7 +80,6 @@ contract('SideChain: submitSignature Unit Test', function(accounts) {
 
   it('checks that signature is added properly to existing transaction object for non-first signature submission', async function() {
     await sidechainInstance.submitSignatureMC(
-      sigs.msgHash,
       txHash,
       toAddress,
       value,
@@ -96,7 +95,6 @@ contract('SideChain: submitSignature Unit Test', function(accounts) {
     assert.equal(v.length, 1);
 
     await sidechainInstance.submitSignatureMC(
-      sigs.msgHash,
       txHash,
       toAddress,
       value,
@@ -122,7 +120,6 @@ contract('SideChain: submitSignature Unit Test', function(accounts) {
     const signer = accounts[0];
     await utils.assertRevert(
       sidechainInstance.submitSignatureMC(
-        sigs.msgHash,
         txHash,
         toAddress,
         value,
@@ -135,7 +132,6 @@ contract('SideChain: submitSignature Unit Test', function(accounts) {
     );
 
     await sidechainInstance.submitSignatureMC(
-      sigs.msgHash,
       txHash,
       toAddress,
       value,
@@ -152,7 +148,6 @@ contract('SideChain: submitSignature Unit Test', function(accounts) {
     const nonOwner = accounts[9];
     await utils.assertRevert(
       sidechainInstance.submitSignatureMC(
-        sigs.msgHash,
         txHash,
         toAddress,
         value,
@@ -166,7 +161,6 @@ contract('SideChain: submitSignature Unit Test', function(accounts) {
 
     const owner = accounts[0];
     await sidechainInstance.submitSignatureMC(
-      sigs.msgHash,
       txHash,
       toAddress,
       value,
@@ -182,6 +176,7 @@ contract('SideChain: submitSignature Unit Test', function(accounts) {
     toAddress = consts.ZERO_ADDRESS;
     sigs = utils.multipleSignedTransaction(
       [0],
+      contractAddress,
       txHash,
       toAddress,
       value,
@@ -191,7 +186,6 @@ contract('SideChain: submitSignature Unit Test', function(accounts) {
 
     await utils.assertRevert(
       sidechainInstance.submitSignatureMC(
-        sigs.msgHash,
         txHash,
         toAddress,
         value,
@@ -206,6 +200,7 @@ contract('SideChain: submitSignature Unit Test', function(accounts) {
     toAddress = accounts[1];
     sigs = utils.multipleSignedTransaction(
       [0],
+      contractAddress,
       txHash,
       toAddress,
       value,
@@ -213,7 +208,6 @@ contract('SideChain: submitSignature Unit Test', function(accounts) {
       version,
     );
     await sidechainInstance.submitSignatureMC(
-      sigs.msgHash,
       txHash,
       toAddress,
       value,
@@ -226,7 +220,6 @@ contract('SideChain: submitSignature Unit Test', function(accounts) {
 
   it('revert if owner already submitted a signature', async function() {
     await sidechainInstance.submitSignatureMC(
-      sigs.msgHash,
       txHash,
       toAddress,
       value,
@@ -249,7 +242,6 @@ contract('SideChain: submitSignature Unit Test', function(accounts) {
     // try to submit the same signature again
     await utils.assertRevert(
       sidechainInstance.submitSignatureMC(
-        sigs.msgHash,
         txHash,
         toAddress,
         value,
@@ -265,7 +257,6 @@ contract('SideChain: submitSignature Unit Test', function(accounts) {
     toAddress = accounts[2]; // a different account than one used to create msgHash
     await utils.assertRevert(
       sidechainInstance.submitSignatureMC(
-        sigs.msgHash,
         txHash,
         toAddress,
         value,
@@ -278,7 +269,6 @@ contract('SideChain: submitSignature Unit Test', function(accounts) {
 
     toAddress = accounts[1]; // try to make sure it works with proper value
     await sidechainInstance.submitSignatureMC(
-      sigs.msgHash,
       txHash,
       toAddress,
       value,
@@ -291,7 +281,6 @@ contract('SideChain: submitSignature Unit Test', function(accounts) {
 
   it('checks that signatureAdded event is emitted properly', async function() {
     const res = await sidechainInstance.submitSignatureMC(
-      sigs.msgHash,
       txHash,
       toAddress,
       value,
diff --git a/test/utils/utils.js b/test/utils/utils.js
index bae44d4..cef6b95 100644
--- a/test/utils/utils.js
+++ b/test/utils/utils.js
@@ -87,16 +87,25 @@ module.exports = {
     });
   },
 
-  createMsgHash: function(txHash, toAddress, value, data, version) {
+  createMsgHash: function(
+    contractAddress,
+    txHash,
+    toAddress,
+    value,
+    data,
+    version,
+  ) {
     const hexEncodedData = this.checkAndEncodeHexPrefix(data);
 
     return web3Uitl
       .soliditySha3(
+        { t: 'bytes', v: '0x19' },
+        { t: 'uint8', v: version },
+        { t: 'address', v: contractAddress },
         { t: 'bytes32', v: txHash },
         { t: 'address', v: toAddress },
         value,
         { t: 'bytes', v: hexEncodedData },
-        { t: 'uint8', v: version },
       )
       .substring(2);
   },
@@ -138,6 +147,7 @@ module.exports = {
 
   multipleSignedTransaction: function(
     arryOfUserIndexes,
+    contractAddress,
     txHash,
     toAddress,
     value,
@@ -148,7 +158,14 @@ module.exports = {
     const r = [];
     const s = [];
 
-    const msgHash = this.createMsgHash(txHash, toAddress, value, data, version);
+    const msgHash = this.createMsgHash(
+      contractAddress,
+      txHash,
+      toAddress,
+      value,
+      data,
+      version,
+    );
 
     for (let i = 0; i < arryOfUserIndexes.length; i++) {
       const sig = ethUtils.ecsign(