diff --git a/src/instantx.cpp b/src/instantx.cpp
index be4148b39..ad5f1691f 100644
--- a/src/instantx.cpp
+++ b/src/instantx.cpp
@@ -54,13 +54,12 @@ const std::string CInstantSend::SERIALIZATION_VERSION_STRING = "CInstantSend-Ver
 
 void CInstantSend::ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStream& vRecv, CConnman& connman)
 {
-    if(fLiteMode) return; // disable all Dash specific functionality
-    if(!sporkManager.IsSporkActive(SPORK_2_INSTANTSEND_ENABLED)) return;
+    if (fLiteMode) return; // disable all Dash specific functionality
+    if (!sporkManager.IsSporkActive(SPORK_2_INSTANTSEND_ENABLED)) return;
 
     // NOTE: NetMsgType::TXLOCKREQUEST is handled via ProcessMessage() in net_processing.cpp
 
-    if (strCommand == NetMsgType::TXLOCKVOTE) // InstantSend Transaction Lock Consensus Votes
-    {
+    if (strCommand == NetMsgType::TXLOCKVOTE) { // InstantSend Transaction Lock Consensus Votes
         if(pfrom->nVersion < MIN_INSTANTSEND_PROTO_VERSION) {
             LogPrint("instantsend", "TXLOCKVOTE -- peer=%d using obsolete version %i\n", pfrom->id, pfrom->nVersion);
             connman.PushMessage(pfrom, CNetMsgMaker(pfrom->GetSendVersion()).Make(NetMsgType::REJECT, strCommand, REJECT_OBSOLETE,
@@ -77,7 +76,7 @@ void CInstantSend::ProcessMessage(CNode* pfrom, const std::string& strCommand, C
         pfrom->setAskFor.erase(nVoteHash);
 
         // Ignore any InstantSend messages until masternode list is synced
-        if(!masternodeSync.IsMasternodeListSynced()) return;
+        if (!masternodeSync.IsMasternodeListSynced()) return;
 
         {
             LOCK(cs_instantsend);
@@ -104,7 +103,7 @@ bool CInstantSend::ProcessTxLockRequest(const CTxLockRequest& txLockRequest, CCo
     // Check to see if we conflict with existing completed lock
     for (const auto& txin : txLockRequest.tx->vin) {
         std::map<COutPoint, uint256>::iterator it = mapLockedOutpoints.find(txin.prevout);
-        if(it != mapLockedOutpoints.end() && it->second != txLockRequest.GetHash()) {
+        if (it != mapLockedOutpoints.end() && it->second != txLockRequest.GetHash()) {
             // Conflicting with complete lock, proceed to see if we should cancel them both
             LogPrintf("CInstantSend::ProcessTxLockRequest -- WARNING: Found conflicting completed Transaction Lock, txid=%s, completed lock txid=%s\n",
                     txLockRequest.GetHash().ToString(), it->second.ToString());
@@ -115,9 +114,9 @@ bool CInstantSend::ProcessTxLockRequest(const CTxLockRequest& txLockRequest, CCo
     // if so - do not fail, just warn user
     for (const auto& txin : txLockRequest.tx->vin) {
         std::map<COutPoint, std::set<uint256> >::iterator it = mapVotedOutpoints.find(txin.prevout);
-        if(it != mapVotedOutpoints.end()) {
+        if (it != mapVotedOutpoints.end()) {
             for (const auto& hash : it->second) {
-                if(hash != txLockRequest.GetHash()) {
+                if (hash != txLockRequest.GetHash()) {
                     LogPrint("instantsend", "CInstantSend::ProcessTxLockRequest -- Double spend attempt! %s\n", txin.prevout.ToStringShort());
                     // do not fail here, let it go and see which one will get the votes to be locked
                     // NOTIFY ZMQ
@@ -132,7 +131,7 @@ bool CInstantSend::ProcessTxLockRequest(const CTxLockRequest& txLockRequest, CCo
         }
     }
 
-    if(!CreateTxLockCandidate(txLockRequest)) {
+    if (!CreateTxLockCandidate(txLockRequest)) {
         // smth is not right
         LogPrintf("CInstantSend::ProcessTxLockRequest -- CreateTxLockCandidate failed, txid=%s\n", txHash.ToString());
         return false;
@@ -151,19 +150,19 @@ bool CInstantSend::ProcessTxLockRequest(const CTxLockRequest& txLockRequest, CCo
 
 bool CInstantSend::CreateTxLockCandidate(const CTxLockRequest& txLockRequest)
 {
-    if(!txLockRequest.IsValid()) return false;
+    if (!txLockRequest.IsValid()) return false;
 
     LOCK(cs_instantsend);
 
     uint256 txHash = txLockRequest.GetHash();
 
     std::map<uint256, CTxLockCandidate>::iterator itLockCandidate = mapTxLockCandidates.find(txHash);
-    if(itLockCandidate == mapTxLockCandidates.end()) {
+    if (itLockCandidate == mapTxLockCandidates.end()) {
         LogPrintf("CInstantSend::CreateTxLockCandidate -- new, txid=%s\n", txHash.ToString());
 
         CTxLockCandidate txLockCandidate(txLockRequest);
         // all inputs should already be checked by txLockRequest.IsValid() above, just use them now
-        for(const auto& txin : txLockRequest.tx->vin) {
+        for (const auto& txin : txLockRequest.tx->vin) {
             txLockCandidate.AddOutPointLock(txin.prevout);
         }
         mapTxLockCandidates.insert(std::make_pair(txHash, txLockCandidate));
@@ -177,7 +176,7 @@ bool CInstantSend::CreateTxLockCandidate(const CTxLockRequest& txLockRequest)
         LogPrintf("CInstantSend::CreateTxLockCandidate -- update empty, txid=%s\n", txHash.ToString());
 
         // all inputs should already be checked by txLockRequest.IsValid() above, just use them now
-        for(const auto& txin : txLockRequest.tx->vin) {
+        for (const auto& txin : txLockRequest.tx->vin) {
             itLockCandidate->second.AddOutPointLock(txin.prevout);
         }
     } else {
@@ -220,20 +219,20 @@ void CInstantSend::Vote(const uint256& txHash, CConnman& connman)
 
 void CInstantSend::Vote(CTxLockCandidate& txLockCandidate, CConnman& connman)
 {
-    if(!fMasternodeMode) return;
-    if(!sporkManager.IsSporkActive(SPORK_2_INSTANTSEND_ENABLED)) return;
+    if (!fMasternodeMode) return;
+    if (!sporkManager.IsSporkActive(SPORK_2_INSTANTSEND_ENABLED)) return;
 
     AssertLockHeld(cs_main);
     AssertLockHeld(cs_instantsend);
 
     uint256 txHash = txLockCandidate.GetHash();
     // We should never vote on a Transaction Lock Request that was not (yet) accepted by the mempool
-    if(mapLockRequestAccepted.find(txHash) == mapLockRequestAccepted.end()) return;
+    if (mapLockRequestAccepted.find(txHash) == mapLockRequestAccepted.end()) return;
     // check if we need to vote on this candidate's outpoints,
     // it's possible that we need to vote for several of them
     for (auto& outpointLockPair : txLockCandidate.mapOutPointLocks) {
         int nPrevoutHeight = GetUTXOHeight(outpointLockPair.first);
-        if(nPrevoutHeight == -1) {
+        if (nPrevoutHeight == -1) {
             LogPrint("instantsend", "CInstantSend::Vote -- Failed to find UTXO %s\n", outpointLockPair.first.ToStringShort());
             return;
         }
@@ -242,13 +241,13 @@ void CInstantSend::Vote(CTxLockCandidate& txLockCandidate, CConnman& connman)
 
         int nRank;
         int nMinRequiredProtocol = std::max(MIN_INSTANTSEND_PROTO_VERSION, mnpayments.GetMinMasternodePaymentsProto());
-        if(!mnodeman.GetMasternodeRank(activeMasternodeInfo.outpoint, nRank, nLockInputHeight, nMinRequiredProtocol)) {
+        if (!mnodeman.GetMasternodeRank(activeMasternodeInfo.outpoint, nRank, nLockInputHeight, nMinRequiredProtocol)) {
             LogPrint("instantsend", "CInstantSend::Vote -- Can't calculate rank for masternode %s\n", activeMasternodeInfo.outpoint.ToStringShort());
             continue;
         }
 
         int nSignaturesTotal = COutPointLock::SIGNATURES_TOTAL;
-        if(nRank > nSignaturesTotal) {
+        if (nRank > nSignaturesTotal) {
             LogPrint("instantsend", "CInstantSend::Vote -- Masternode not in the top %d (%d)\n", nSignaturesTotal, nRank);
             continue;
         }
@@ -260,10 +259,10 @@ void CInstantSend::Vote(CTxLockCandidate& txLockCandidate, CConnman& connman)
         // Check to see if we already voted for this outpoint,
         // refuse to vote twice or to include the same outpoint in another tx
         bool fAlreadyVoted = false;
-        if(itVoted != mapVotedOutpoints.end()) {
+        if (itVoted != mapVotedOutpoints.end()) {
             for (const auto& hash : itVoted->second) {
                 std::map<uint256, CTxLockCandidate>::iterator it2 = mapTxLockCandidates.find(hash);
-                if(it2->second.HasMasternodeVoted(outpointLockPair.first, activeMasternodeInfo.outpoint)) {
+                if (it2->second.HasMasternodeVoted(outpointLockPair.first, activeMasternodeInfo.outpoint)) {
                     // we already voted for this outpoint to be included either in the same tx or in a competing one,
                     // skip it anyway
                     fAlreadyVoted = true;
@@ -273,18 +272,18 @@ void CInstantSend::Vote(CTxLockCandidate& txLockCandidate, CConnman& connman)
                 }
             }
         }
-        if(fAlreadyVoted) {
+        if (fAlreadyVoted) {
             continue; // skip to the next outpoint
         }
 
         // we haven't voted for this outpoint yet, let's try to do this now
         CTxLockVote vote(txHash, outpointLockPair.first, activeMasternodeInfo.outpoint);
 
-        if(!vote.Sign()) {
+        if (!vote.Sign()) {
             LogPrintf("CInstantSend::Vote -- Failed to sign consensus vote\n");
             return;
         }
-        if(!vote.CheckSignature()) {
+        if (!vote.CheckSignature()) {
             LogPrintf("CInstantSend::Vote -- Signature invalid\n");
             return;
         }
@@ -292,17 +291,17 @@ void CInstantSend::Vote(CTxLockCandidate& txLockCandidate, CConnman& connman)
         // vote constructed sucessfully, let's store and relay it
         uint256 nVoteHash = vote.GetHash();
         mapTxLockVotes.insert(std::make_pair(nVoteHash, vote));
-        if(outpointLockPair.second.AddVote(vote)) {
+        if (outpointLockPair.second.AddVote(vote)) {
             LogPrintf("CInstantSend::Vote -- Vote created successfully, relaying: txHash=%s, outpoint=%s, vote=%s\n",
                     txHash.ToString(), outpointLockPair.first.ToStringShort(), nVoteHash.ToString());
 
-            if(itVoted == mapVotedOutpoints.end()) {
+            if (itVoted == mapVotedOutpoints.end()) {
                 std::set<uint256> setHashes;
                 setHashes.insert(txHash);
                 mapVotedOutpoints.insert(std::make_pair(outpointLockPair.first, setHashes));
             } else {
                 mapVotedOutpoints[outpointLockPair.first].insert(txHash);
-                if(mapVotedOutpoints[outpointLockPair.first].size() > 1) {
+                if (mapVotedOutpoints[outpointLockPair.first].size() > 1) {
                     // it's ok to continue, just warn user
                     LogPrintf("CInstantSend::Vote -- WARNING: Vote conflicts with some existing votes: txHash=%s, outpoint=%s, vote=%s\n",
                             txHash.ToString(), outpointLockPair.first.ToStringShort(), nVoteHash.ToString());
@@ -319,7 +318,7 @@ bool CInstantSend::ProcessNewTxLockVote(CNode* pfrom, const CTxLockVote& vote, C
     uint256 txHash = vote.GetTxHash();
     uint256 nVoteHash = vote.GetHash();
 
-    if(!vote.IsValid(pfrom, connman)) {
+    if (!vote.IsValid(pfrom, connman)) {
         // could be because of missing MN
         LogPrint("instantsend", "CInstantSend::%s -- Vote is invalid, txid=%s\n", __func__, txHash.ToString());
         return false;
@@ -338,9 +337,9 @@ bool CInstantSend::ProcessNewTxLockVote(CNode* pfrom, const CTxLockVote& vote, C
     // will actually process only after the lock request itself has arrived
 
     std::map<uint256, CTxLockCandidate>::iterator it = mapTxLockCandidates.find(txHash);
-    if(it == mapTxLockCandidates.end() || !it->second.txLockRequest) {
+    if (it == mapTxLockCandidates.end() || !it->second.txLockRequest) {
         // no or empty tx lock candidate
-        if(it == mapTxLockCandidates.end()) {
+        if (it == mapTxLockCandidates.end()) {
             // start timeout countdown after the very first vote
             CreateEmptyTxLockCandidate(txHash);
         }
@@ -353,10 +352,10 @@ bool CInstantSend::ProcessNewTxLockVote(CNode* pfrom, const CTxLockVote& vote, C
 
         int nMasternodeOrphanExpireTime = GetTime() + 60*10; // keep time data for 10 minutes
         auto itMnOV = mapMasternodeOrphanVotes.find(vote.GetMasternodeOutpoint());
-        if(itMnOV == mapMasternodeOrphanVotes.end()) {
+        if (itMnOV == mapMasternodeOrphanVotes.end()) {
             mapMasternodeOrphanVotes.emplace(vote.GetMasternodeOutpoint(), nMasternodeOrphanExpireTime);
         } else {
-            if(itMnOV->second > GetTime() && itMnOV->second > GetAverageMasternodeOrphanVoteTime()) {
+            if (itMnOV->second > GetTime() && itMnOV->second > GetAverageMasternodeOrphanVoteTime()) {
                 LogPrint("instantsend", "CInstantSend::%s -- masternode is spamming orphan Transaction Lock Votes: txid=%s  masternode=%s\n",
                         __func__, txHash.ToString(), vote.GetMasternodeOutpoint().ToStringShort());
                 // Misbehaving(pfrom->id, 1);
@@ -381,7 +380,7 @@ bool CInstantSend::ProcessNewTxLockVote(CNode* pfrom, const CTxLockVote& vote, C
 
     UpdateVotedOutpoints(vote, txLockCandidate);
 
-    if(!txLockCandidate.AddVote(vote)) {
+    if (!txLockCandidate.AddVote(vote)) {
         // this should never happen
         return false;
     }
@@ -410,7 +409,7 @@ bool CInstantSend::ProcessOrphanTxLockVote(const CTxLockVote& vote)
 
     // We shouldn't process orphan votes without a valid tx lock candidate
     std::map<uint256, CTxLockCandidate>::iterator it = mapTxLockCandidates.find(txHash);
-    if(it == mapTxLockCandidates.end() || !it->second.txLockRequest)
+    if (it == mapTxLockCandidates.end() || !it->second.txLockRequest)
         return false; // this shouldn never happen
 
     CTxLockCandidate& txLockCandidate = it->second;
@@ -424,7 +423,7 @@ bool CInstantSend::ProcessOrphanTxLockVote(const CTxLockVote& vote)
 
     UpdateVotedOutpoints(vote, txLockCandidate);
 
-    if(!txLockCandidate.AddVote(vote)) {
+    if (!txLockCandidate.AddVote(vote)) {
         // this should never happen
         return false;
     }
@@ -444,14 +443,14 @@ void CInstantSend::UpdateVotedOutpoints(const CTxLockVote& vote, CTxLockCandidat
     uint256 txHash = vote.GetTxHash();
 
     std::map<COutPoint, std::set<uint256> >::iterator it1 = mapVotedOutpoints.find(vote.GetOutpoint());
-    if(it1 != mapVotedOutpoints.end()) {
+    if (it1 != mapVotedOutpoints.end()) {
         for (const auto& hash : it1->second) {
-            if(hash != txHash) {
+            if (hash != txHash) {
                 // same outpoint was already voted to be locked by another tx lock request,
                 // let's see if it was the same masternode who voted on this outpoint
                 // for another tx lock request
                 std::map<uint256, CTxLockCandidate>::iterator it2 = mapTxLockCandidates.find(hash);
-                if(it2 !=mapTxLockCandidates.end() && it2->second.HasMasternodeVoted(vote.GetOutpoint(), vote.GetMasternodeOutpoint())) {
+                if (it2 !=mapTxLockCandidates.end() && it2->second.HasMasternodeVoted(vote.GetOutpoint(), vote.GetMasternodeOutpoint())) {
                     // yes, it was the same masternode
                     LogPrintf("CInstantSend::%s -- masternode sent conflicting votes! %s\n", __func__, vote.GetMasternodeOutpoint().ToStringShort());
                     // mark both Lock Candidates as attacked, none of them should complete,
@@ -480,8 +479,8 @@ void CInstantSend::ProcessOrphanTxLockVotes()
     AssertLockHeld(cs_instantsend);
 
     std::map<uint256, CTxLockVote>::iterator it = mapTxLockVotesOrphan.begin();
-    while(it != mapTxLockVotesOrphan.end()) {
-        if(ProcessOrphanTxLockVote(it->second)) {
+    while (it != mapTxLockVotesOrphan.end()) {
+        if (ProcessOrphanTxLockVote(it->second)) {
             mapTxLockVotesOrphan.erase(it++);
         } else {
             ++it;
@@ -491,16 +490,16 @@ void CInstantSend::ProcessOrphanTxLockVotes()
 
 void CInstantSend::TryToFinalizeLockCandidate(const CTxLockCandidate& txLockCandidate)
 {
-    if(!sporkManager.IsSporkActive(SPORK_2_INSTANTSEND_ENABLED)) return;
+    if (!sporkManager.IsSporkActive(SPORK_2_INSTANTSEND_ENABLED)) return;
 
     AssertLockHeld(cs_main);
     AssertLockHeld(cs_instantsend);
 
     uint256 txHash = txLockCandidate.txLockRequest.tx->GetHash();
-    if(txLockCandidate.IsAllOutPointsReady() && !IsLockedInstantSendTransaction(txHash)) {
+    if (txLockCandidate.IsAllOutPointsReady() && !IsLockedInstantSendTransaction(txHash)) {
         // we have enough votes now
         LogPrint("instantsend", "CInstantSend::TryToFinalizeLockCandidate -- Transaction Lock is ready to complete, txid=%s\n", txHash.ToString());
-        if(ResolveConflicts(txLockCandidate)) {
+        if (ResolveConflicts(txLockCandidate)) {
             LockTransactionInputs(txLockCandidate);
             UpdateLockedTransaction(txLockCandidate);
         }
@@ -512,22 +511,23 @@ void CInstantSend::UpdateLockedTransaction(const CTxLockCandidate& txLockCandida
     // cs_main, cs_wallet and cs_instantsend should be already locked
     AssertLockHeld(cs_main);
 #ifdef ENABLE_WALLET
-    if (pwalletMain)
+    if (pwalletMain) {
         AssertLockHeld(pwalletMain->cs_wallet);
+    }
 #endif
     AssertLockHeld(cs_instantsend);
 
     uint256 txHash = txLockCandidate.GetHash();
 
-    if(!IsLockedInstantSendTransaction(txHash)) return; // not a locked tx, do not update/notify
+    if (!IsLockedInstantSendTransaction(txHash)) return; // not a locked tx, do not update/notify
 
 #ifdef ENABLE_WALLET
-    if(pwalletMain && pwalletMain->UpdatedTransaction(txHash)) {
+    if (pwalletMain && pwalletMain->UpdatedTransaction(txHash)) {
         // bumping this to update UI
         nCompleteTXLocks++;
         // notify an external script once threshold is reached
         std::string strCmd = GetArg("-instantsendnotify", "");
-        if(!strCmd.empty()) {
+        if (!strCmd.empty()) {
             boost::replace_all(strCmd, "%s", txHash.GetHex());
             boost::thread t(runCommand, strCmd); // thread runs free
         }
@@ -541,13 +541,13 @@ void CInstantSend::UpdateLockedTransaction(const CTxLockCandidate& txLockCandida
 
 void CInstantSend::LockTransactionInputs(const CTxLockCandidate& txLockCandidate)
 {
-    if(!sporkManager.IsSporkActive(SPORK_2_INSTANTSEND_ENABLED)) return;
+    if (!sporkManager.IsSporkActive(SPORK_2_INSTANTSEND_ENABLED)) return;
 
     LOCK(cs_instantsend);
 
     uint256 txHash = txLockCandidate.GetHash();
 
-    if(!txLockCandidate.IsAllOutPointsReady()) return;
+    if (!txLockCandidate.IsAllOutPointsReady()) return;
 
     for (const auto& pair : txLockCandidate.mapOutPointLocks) {
         mapLockedOutpoints.insert(std::make_pair(pair.first, txHash));
@@ -559,7 +559,7 @@ bool CInstantSend::GetLockedOutPointTxHash(const COutPoint& outpoint, uint256& h
 {
     LOCK(cs_instantsend);
     std::map<COutPoint, uint256>::iterator it = mapLockedOutpoints.find(outpoint);
-    if(it == mapLockedOutpoints.end()) return false;
+    if (it == mapLockedOutpoints.end()) return false;
     hashRet = it->second;
     return true;
 }
@@ -572,18 +572,18 @@ bool CInstantSend::ResolveConflicts(const CTxLockCandidate& txLockCandidate)
     uint256 txHash = txLockCandidate.GetHash();
 
     // make sure the lock is ready
-    if(!txLockCandidate.IsAllOutPointsReady()) return false;
+    if (!txLockCandidate.IsAllOutPointsReady()) return false;
 
     AssertLockHeld(mempool.cs); // protect mempool.mapNextTx
 
     for (const auto& txin : txLockCandidate.txLockRequest.tx->vin) {
         uint256 hashConflicting;
-        if(GetLockedOutPointTxHash(txin.prevout, hashConflicting) && txHash != hashConflicting) {
+        if (GetLockedOutPointTxHash(txin.prevout, hashConflicting) && txHash != hashConflicting) {
             // completed lock which conflicts with another completed one?
             // this means that majority of MNs in the quorum for this specific tx input are malicious!
             std::map<uint256, CTxLockCandidate>::iterator itLockCandidate = mapTxLockCandidates.find(txHash);
             std::map<uint256, CTxLockCandidate>::iterator itLockCandidateConflicting = mapTxLockCandidates.find(hashConflicting);
-            if(itLockCandidate == mapTxLockCandidates.end() || itLockCandidateConflicting == mapTxLockCandidates.end()) {
+            if (itLockCandidate == mapTxLockCandidates.end() || itLockCandidateConflicting == mapTxLockCandidates.end()) {
                 // safety check, should never really happen
                 LogPrintf("CInstantSend::ResolveConflicts -- ERROR: Found conflicting completed Transaction Lock, but one of txLockCandidate-s is missing, txid=%s, conflicting txid=%s\n",
                         txHash.ToString(), hashConflicting.ToString());
@@ -613,7 +613,7 @@ bool CInstantSend::ResolveConflicts(const CTxLockCandidate& txLockCandidate)
         } else if (mempool.mapNextTx.count(txin.prevout)) {
             // check if it's in mempool
             hashConflicting = mempool.mapNextTx.find(txin.prevout)->second->GetHash();
-            if(txHash == hashConflicting) continue; // matches current, not a conflict, skip to next txin
+            if (txHash == hashConflicting) continue; // matches current, not a conflict, skip to next txin
             // conflicts with tx in mempool
             LogPrintf("CInstantSend::ResolveConflicts -- ERROR: Failed to complete Transaction Lock, conflicts with mempool, txid=%s\n", txHash.ToString());
             return false;
@@ -622,14 +622,14 @@ bool CInstantSend::ResolveConflicts(const CTxLockCandidate& txLockCandidate)
     // No conflicts were found so far, check to see if it was already included in block
     CTransactionRef txTmp;
     uint256 hashBlock;
-    if(GetTransaction(txHash, txTmp, Params().GetConsensus(), hashBlock, true) && hashBlock != uint256()) {
+    if (GetTransaction(txHash, txTmp, Params().GetConsensus(), hashBlock, true) && hashBlock != uint256()) {
         LogPrint("instantsend", "CInstantSend::ResolveConflicts -- Done, %s is included in block %s\n", txHash.ToString(), hashBlock.ToString());
         return true;
     }
     // Not in block yet, make sure all its inputs are still unspent
     for (const auto& txin : txLockCandidate.txLockRequest.tx->vin) {
         Coin coin;
-        if(!GetUTXOCoin(txin.prevout, coin)) {
+        if (!GetUTXOCoin(txin.prevout, coin)) {
             // Not in UTXO anymore? A conflicting tx was mined while we were waiting for votes.
             LogPrintf("CInstantSend::ResolveConflicts -- ERROR: Failed to find UTXO %s, can't complete Transaction Lock\n", txin.prevout.ToStringShort());
             return false;
@@ -644,7 +644,7 @@ int64_t CInstantSend::GetAverageMasternodeOrphanVoteTime()
 {
     LOCK(cs_instantsend);
     // NOTE: should never actually call this function when mapMasternodeOrphanVotes is empty
-    if(mapMasternodeOrphanVotes.empty()) return 0;
+    if (mapMasternodeOrphanVotes.empty()) return 0;
 
     int64_t total = 0;
     for (const auto& pair : mapMasternodeOrphanVotes) {
@@ -656,17 +656,17 @@ int64_t CInstantSend::GetAverageMasternodeOrphanVoteTime()
 
 void CInstantSend::CheckAndRemove()
 {
-    if(!masternodeSync.IsMasternodeListSynced()) return;
+    if (!masternodeSync.IsMasternodeListSynced()) return;
 
     LOCK(cs_instantsend);
 
     std::map<uint256, CTxLockCandidate>::iterator itLockCandidate = mapTxLockCandidates.begin();
 
     // remove expired candidates
-    while(itLockCandidate != mapTxLockCandidates.end()) {
+    while (itLockCandidate != mapTxLockCandidates.end()) {
         CTxLockCandidate &txLockCandidate = itLockCandidate->second;
         uint256 txHash = txLockCandidate.GetHash();
-        if(txLockCandidate.IsExpired(nCachedBlockHeight)) {
+        if (txLockCandidate.IsExpired(nCachedBlockHeight)) {
             LogPrintf("CInstantSend::CheckAndRemove -- Removing expired Transaction Lock Candidate: txid=%s\n", txHash.ToString());
 
             for (const auto& pair : txLockCandidate.mapOutPointLocks) {
@@ -683,8 +683,8 @@ void CInstantSend::CheckAndRemove()
 
     // remove expired votes
     std::map<uint256, CTxLockVote>::iterator itVote = mapTxLockVotes.begin();
-    while(itVote != mapTxLockVotes.end()) {
-        if(itVote->second.IsExpired(nCachedBlockHeight)) {
+    while (itVote != mapTxLockVotes.end()) {
+        if (itVote->second.IsExpired(nCachedBlockHeight)) {
             LogPrint("instantsend", "CInstantSend::CheckAndRemove -- Removing expired vote: txid=%s  masternode=%s\n",
                     itVote->second.GetTxHash().ToString(), itVote->second.GetMasternodeOutpoint().ToStringShort());
             mapTxLockVotes.erase(itVote++);
@@ -695,8 +695,8 @@ void CInstantSend::CheckAndRemove()
 
     // remove timed out orphan votes
     std::map<uint256, CTxLockVote>::iterator itOrphanVote = mapTxLockVotesOrphan.begin();
-    while(itOrphanVote != mapTxLockVotesOrphan.end()) {
-        if(itOrphanVote->second.IsTimedOut()) {
+    while (itOrphanVote != mapTxLockVotesOrphan.end()) {
+        if (itOrphanVote->second.IsTimedOut()) {
             LogPrint("instantsend", "CInstantSend::CheckAndRemove -- Removing timed out orphan vote: txid=%s  masternode=%s\n",
                     itOrphanVote->second.GetTxHash().ToString(), itOrphanVote->second.GetMasternodeOutpoint().ToStringShort());
             mapTxLockVotes.erase(itOrphanVote->first);
@@ -708,8 +708,8 @@ void CInstantSend::CheckAndRemove()
 
     // remove invalid votes and votes for failed lock attempts
     itVote = mapTxLockVotes.begin();
-    while(itVote != mapTxLockVotes.end()) {
-        if(itVote->second.IsFailed()) {
+    while (itVote != mapTxLockVotes.end()) {
+        if (itVote->second.IsFailed()) {
             LogPrint("instantsend", "CInstantSend::CheckAndRemove -- Removing vote for failed lock attempt: txid=%s  masternode=%s\n",
                     itVote->second.GetTxHash().ToString(), itVote->second.GetMasternodeOutpoint().ToStringShort());
             mapTxLockVotes.erase(itVote++);
@@ -720,8 +720,8 @@ void CInstantSend::CheckAndRemove()
 
     // remove timed out masternode orphan votes (DOS protection)
     std::map<COutPoint, int64_t>::iterator itMasternodeOrphan = mapMasternodeOrphanVotes.begin();
-    while(itMasternodeOrphan != mapMasternodeOrphanVotes.end()) {
-        if(itMasternodeOrphan->second < GetTime()) {
+    while (itMasternodeOrphan != mapMasternodeOrphanVotes.end()) {
+        if (itMasternodeOrphan->second < GetTime()) {
             LogPrint("instantsend", "CInstantSend::CheckAndRemove -- Removing timed out orphan masternode vote: masternode=%s\n",
                     itMasternodeOrphan->first.ToStringShort());
             mapMasternodeOrphanVotes.erase(itMasternodeOrphan++);
@@ -763,7 +763,7 @@ bool CInstantSend::GetTxLockRequest(const uint256& txHash, CTxLockRequest& txLoc
     LOCK(cs_instantsend);
 
     std::map<uint256, CTxLockCandidate>::iterator it = mapTxLockCandidates.find(txHash);
-    if(it == mapTxLockCandidates.end() || !it->second.txLockRequest) return false;
+    if (it == mapTxLockCandidates.end() || !it->second.txLockRequest) return false;
     txLockRequestRet = it->second.txLockRequest;
 
     return true;
@@ -774,7 +774,7 @@ bool CInstantSend::GetTxLockVote(const uint256& hash, CTxLockVote& txLockVoteRet
     LOCK(cs_instantsend);
 
     std::map<uint256, CTxLockVote>::iterator it = mapTxLockVotes.find(hash);
-    if(it == mapTxLockVotes.end()) return false;
+    if (it == mapTxLockVotes.end()) return false;
     txLockVoteRet = it->second;
 
     return true;
@@ -797,22 +797,22 @@ void CInstantSend::Clear()
 
 bool CInstantSend::IsLockedInstantSendTransaction(const uint256& txHash)
 {
-    if(!fEnableInstantSend || GetfLargeWorkForkFound() || GetfLargeWorkInvalidChainFound() ||
+    if (!fEnableInstantSend || GetfLargeWorkForkFound() || GetfLargeWorkInvalidChainFound() ||
         !sporkManager.IsSporkActive(SPORK_3_INSTANTSEND_BLOCK_FILTERING)) return false;
 
     LOCK(cs_instantsend);
 
     // there must be a lock candidate
     std::map<uint256, CTxLockCandidate>::iterator itLockCandidate = mapTxLockCandidates.find(txHash);
-    if(itLockCandidate == mapTxLockCandidates.end()) return false;
+    if (itLockCandidate == mapTxLockCandidates.end()) return false;
 
     // which should have outpoints
-    if(itLockCandidate->second.mapOutPointLocks.empty()) return false;
+    if (itLockCandidate->second.mapOutPointLocks.empty()) return false;
 
     // and all of these outputs must be included in mapLockedOutpoints with correct hash
     for (const auto& pair : itLockCandidate->second.mapOutPointLocks) {
         uint256 hashLocked;
-        if(!GetLockedOutPointTxHash(pair.first, hashLocked) || hashLocked != txHash) return false;
+        if (!GetLockedOutPointTxHash(pair.first, hashLocked) || hashLocked != txHash) return false;
     }
 
     return true;
@@ -820,14 +820,14 @@ bool CInstantSend::IsLockedInstantSendTransaction(const uint256& txHash)
 
 int CInstantSend::GetTransactionLockSignatures(const uint256& txHash)
 {
-    if(!fEnableInstantSend) return -1;
-    if(GetfLargeWorkForkFound() || GetfLargeWorkInvalidChainFound()) return -2;
-    if(!sporkManager.IsSporkActive(SPORK_2_INSTANTSEND_ENABLED)) return -3;
+    if (!fEnableInstantSend) return -1;
+    if (GetfLargeWorkForkFound() || GetfLargeWorkInvalidChainFound()) return -2;
+    if (!sporkManager.IsSporkActive(SPORK_2_INSTANTSEND_ENABLED)) return -3;
 
     LOCK(cs_instantsend);
 
     std::map<uint256, CTxLockCandidate>::iterator itLockCandidate = mapTxLockCandidates.find(txHash);
-    if(itLockCandidate != mapTxLockCandidates.end()) {
+    if (itLockCandidate != mapTxLockCandidates.end()) {
         return itLockCandidate->second.CountVotes();
     }
 
@@ -836,7 +836,7 @@ int CInstantSend::GetTransactionLockSignatures(const uint256& txHash)
 
 bool CInstantSend::IsTxLockCandidateTimedOut(const uint256& txHash)
 {
-    if(!fEnableInstantSend) return false;
+    if (!fEnableInstantSend) return false;
 
     LOCK(cs_instantsend);
 
@@ -882,20 +882,19 @@ void CInstantSend::SyncTransaction(const CTransaction& tx, const CBlockIndex *pi
 
     // Check lock candidates
     std::map<uint256, CTxLockCandidate>::iterator itLockCandidate = mapTxLockCandidates.find(txHash);
-    if(itLockCandidate != mapTxLockCandidates.end()) {
+    if (itLockCandidate != mapTxLockCandidates.end()) {
         LogPrint("instantsend", "CInstantSend::SyncTransaction -- txid=%s nHeightNew=%d lock candidate updated\n",
                 txHash.ToString(), nHeightNew);
         itLockCandidate->second.SetConfirmedHeight(nHeightNew);
         // Loop through outpoint locks
         for (const auto& pair : itLockCandidate->second.mapOutPointLocks) {
-
             // Check corresponding lock votes
             for (const auto& vote : pair.second.GetVotes()) {
                 uint256 nVoteHash = vote.GetHash();
                 LogPrint("instantsend", "CInstantSend::SyncTransaction -- txid=%s nHeightNew=%d vote %s updated\n",
                         txHash.ToString(), nHeightNew, nVoteHash.ToString());
                 const auto& it = mapTxLockVotes.find(nVoteHash);
-                if(it != mapTxLockVotes.end()) {
+                if (it != mapTxLockVotes.end()) {
                     it->second.SetConfirmedHeight(nHeightNew);
                 }
             }
@@ -904,7 +903,7 @@ void CInstantSend::SyncTransaction(const CTransaction& tx, const CBlockIndex *pi
 
     // check orphan votes
     for (const auto& pair : mapTxLockVotesOrphan) {
-        if(pair.second.GetTxHash() == txHash) {
+        if (pair.second.GetTxHash() == txHash) {
             LogPrint("instantsend", "CInstantSend::SyncTransaction -- txid=%s nHeightNew=%d vote %s updated\n",
                     txHash.ToString(), nHeightNew, pair.first.ToString());
             mapTxLockVotes[pair.first].SetConfirmedHeight(nHeightNew);
@@ -920,10 +919,12 @@ std::string CInstantSend::ToString() const
 
 bool CInstantSend::CanAutoLock()
 {
-    if(!isAutoLockBip9Active)
+    if (!isAutoLockBip9Active) {
         return false;
-    if(!sporkManager.IsSporkActive(SPORK_16_INSTANTSEND_AUTOLOCKS))
+    }
+    if (!sporkManager.IsSporkActive(SPORK_16_INSTANTSEND_AUTOLOCKS)) {
         return false;
+    }
     return (mempool.UsedMemoryShare() < AUTO_IX_MEMPOOL_THRESHOLD);
 }
 
@@ -933,14 +934,14 @@ bool CInstantSend::CanAutoLock()
 
 bool CTxLockRequest::IsValid() const
 {
-    if(tx->vout.size() < 1) return false;
+    if (tx->vout.size() < 1) return false;
 
-    if(tx->vin.size() > WARN_MANY_INPUTS) {
+    if (tx->vin.size() > WARN_MANY_INPUTS) {
         LogPrint("instantsend", "CTxLockRequest::IsValid -- WARNING: Too many inputs: tx=%s", ToString());
     }
 
     AssertLockHeld(cs_main);
-    if(!CheckFinalTx(*tx)) {
+    if (!CheckFinalTx(*tx)) {
         LogPrint("instantsend", "CTxLockRequest::IsValid -- Transaction is not final: tx=%s", ToString());
         return false;
     }
@@ -953,7 +954,7 @@ bool CTxLockRequest::IsValid() const
 
         Coin coin;
 
-        if(!GetUTXOCoin(txin.prevout, coin)) {
+        if (!GetUTXOCoin(txin.prevout, coin)) {
             LogPrint("instantsend", "CTxLockRequest::IsValid -- Failed to find UTXO %s\n", txin.prevout.ToStringShort());
             return false;
         }
@@ -962,7 +963,7 @@ bool CTxLockRequest::IsValid() const
         // 1 less than the "send IX" gui requires, in case of a block propagating the network at the time
         int nConfirmationsRequired = nInstantSendConfirmationsRequired - 1;
 
-        if(nTxAge < nConfirmationsRequired) {
+        if (nTxAge < nConfirmationsRequired) {
             LogPrint("instantsend", "CTxLockRequest::IsValid -- outpoint %s too new: nTxAge=%d, nConfirmationsRequired=%d, txid=%s\n",
                     txin.prevout.ToStringShort(), nTxAge, nConfirmationsRequired, GetHash().ToString());
             return false;
@@ -971,14 +972,14 @@ bool CTxLockRequest::IsValid() const
         nValueIn += coin.out.nValue;
     }
 
-    if(nValueIn > sporkManager.GetSporkValue(SPORK_5_INSTANTSEND_MAX_VALUE)*COIN) {
+    if (nValueIn > sporkManager.GetSporkValue(SPORK_5_INSTANTSEND_MAX_VALUE)*COIN) {
         LogPrint("instantsend", "CTxLockRequest::IsValid -- Transaction value too high: nValueIn=%d, tx=%s", nValueIn, ToString());
         return false;
     }
 
     CAmount nValueOut = tx->GetValueOut();
 
-    if(nValueIn - nValueOut < GetMinFee()) {
+    if (nValueIn - nValueOut < GetMinFee()) {
         LogPrint("instantsend", "CTxLockRequest::IsValid -- did not include enough fees in transaction: fees=%d, tx=%s", nValueOut - nValueIn, ToString());
         return false;
     }
@@ -988,8 +989,9 @@ bool CTxLockRequest::IsValid() const
 
 CAmount CTxLockRequest::GetMinFee() const
 {
-    if(IsSimple())
+    if (IsSimple()) {
         return CAmount();
+    }
     CAmount nMinFee = MIN_FEE;
     return std::max(nMinFee, CAmount(tx->vin.size() * nMinFee));
 }
@@ -1010,14 +1012,14 @@ bool CTxLockRequest::IsSimple() const
 
 bool CTxLockVote::IsValid(CNode* pnode, CConnman& connman) const
 {
-    if(!mnodeman.Has(outpointMasternode)) {
+    if (!mnodeman.Has(outpointMasternode)) {
         LogPrint("instantsend", "CTxLockVote::IsValid -- Unknown masternode %s\n", outpointMasternode.ToStringShort());
         mnodeman.AskForMN(pnode, outpointMasternode, connman);
         return false;
     }
 
     Coin coin;
-    if(!GetUTXOCoin(outpoint, coin)) {
+    if (!GetUTXOCoin(outpoint, coin)) {
         LogPrint("instantsend", "CTxLockVote::IsValid -- Failed to find UTXO %s\n", outpoint.ToStringShort());
         return false;
     }
@@ -1026,7 +1028,7 @@ bool CTxLockVote::IsValid(CNode* pnode, CConnman& connman) const
 
     int nRank;
     int nMinRequiredProtocol = std::max(MIN_INSTANTSEND_PROTO_VERSION, mnpayments.GetMinMasternodePaymentsProto());
-    if(!mnodeman.GetMasternodeRank(outpointMasternode, nRank, nLockInputHeight, nMinRequiredProtocol)) {
+    if (!mnodeman.GetMasternodeRank(outpointMasternode, nRank, nLockInputHeight, nMinRequiredProtocol)) {
         //can be caused by past versions trying to vote with an invalid protocol
         LogPrint("instantsend", "CTxLockVote::IsValid -- Can't calculate rank for masternode %s\n", outpointMasternode.ToStringShort());
         return false;
@@ -1034,13 +1036,13 @@ bool CTxLockVote::IsValid(CNode* pnode, CConnman& connman) const
     LogPrint("instantsend", "CTxLockVote::IsValid -- Masternode %s, rank=%d\n", outpointMasternode.ToStringShort(), nRank);
 
     int nSignaturesTotal = COutPointLock::SIGNATURES_TOTAL;
-    if(nRank > nSignaturesTotal) {
+    if (nRank > nSignaturesTotal) {
         LogPrint("instantsend", "CTxLockVote::IsValid -- Masternode %s is not in the top %d (%d), vote hash=%s\n",
                 outpointMasternode.ToStringShort(), nSignaturesTotal, nRank, GetHash().ToString());
         return false;
     }
 
-    if(!CheckSignature()) {
+    if (!CheckSignature()) {
         LogPrintf("CTxLockVote::IsValid -- Signature invalid\n");
         return false;
     }
@@ -1064,7 +1066,7 @@ bool CTxLockVote::CheckSignature() const
 
     masternode_info_t infoMn;
 
-    if(!mnodeman.GetMasternodeInfo(outpointMasternode, infoMn)) {
+    if (!mnodeman.GetMasternodeInfo(outpointMasternode, infoMn)) {
         LogPrintf("CTxLockVote::CheckSignature -- Unknown Masternode: masternode=%s\n", outpointMasternode.ToString());
         return false;
     }
@@ -1075,7 +1077,7 @@ bool CTxLockVote::CheckSignature() const
         if (!CHashSigner::VerifyHash(hash, infoMn.keyIDOperator, vchMasternodeSignature, strError)) {
             // could be a signature in old format
             std::string strMessage = txHash.ToString() + outpoint.ToStringShort();
-        if(!CMessageSigner::VerifyMessage(infoMn.keyIDOperator, vchMasternodeSignature, strMessage, strError)) {
+        if (!CMessageSigner::VerifyMessage(infoMn.keyIDOperator, vchMasternodeSignature, strMessage, strError)) {
                 // nope, not in old format either
                 LogPrintf("CTxLockVote::CheckSignature -- VerifyMessage() failed, error: %s\n", strError);
                 return false;
@@ -1083,7 +1085,7 @@ bool CTxLockVote::CheckSignature() const
         }
     } else {
         std::string strMessage = txHash.ToString() + outpoint.ToStringShort();
-        if(!CMessageSigner::VerifyMessage(infoMn.keyIDOperator, vchMasternodeSignature, strMessage, strError)) {
+        if (!CMessageSigner::VerifyMessage(infoMn.keyIDOperator, vchMasternodeSignature, strMessage, strError)) {
             LogPrintf("CTxLockVote::CheckSignature -- VerifyMessage() failed, error: %s\n", strError);
             return false;
         }
@@ -1099,7 +1101,7 @@ bool CTxLockVote::Sign()
     if (sporkManager.IsSporkActive(SPORK_6_NEW_SIGS)) {
         uint256 hash = GetSignatureHash();
 
-        if(!CHashSigner::SignHash(hash, activeMasternodeInfo.keyOperator, vchMasternodeSignature)) {
+        if (!CHashSigner::SignHash(hash, activeMasternodeInfo.keyOperator, vchMasternodeSignature)) {
             LogPrintf("CTxLockVote::Sign -- SignHash() failed\n");
             return false;
         }
@@ -1111,12 +1113,12 @@ bool CTxLockVote::Sign()
     } else {
         std::string strMessage = txHash.ToString() + outpoint.ToStringShort();
 
-        if(!CMessageSigner::SignMessage(strMessage, vchMasternodeSignature, activeMasternodeInfo.keyOperator)) {
+        if (!CMessageSigner::SignMessage(strMessage, vchMasternodeSignature, activeMasternodeInfo.keyOperator)) {
             LogPrintf("CTxLockVote::Sign -- SignMessage() failed\n");
             return false;
         }
 
-        if(!CMessageSigner::VerifyMessage(activeMasternodeInfo.keyIDOperator, vchMasternodeSignature, strMessage, strError)) {
+        if (!CMessageSigner::VerifyMessage(activeMasternodeInfo.keyIDOperator, vchMasternodeSignature, strMessage, strError)) {
             LogPrintf("CTxLockVote::Sign -- VerifyMessage() failed, error: %s\n", strError);
             return false;
         }
@@ -1129,10 +1131,11 @@ void CTxLockVote::Relay(CConnman& connman) const
 {
     CInv inv(MSG_TXLOCK_VOTE, GetHash());
     CTxLockRequest request;
-    if(instantsend.GetTxLockRequest(txHash, request))
+    if (instantsend.GetTxLockRequest(txHash, request)) {
         connman.RelayInvFiltered(inv, *request.tx);
-    else
+    } else {
         connman.RelayInv(inv);
+    }
 }
 
 bool CTxLockVote::IsExpired(int nHeight) const
@@ -1193,23 +1196,23 @@ void CTxLockCandidate::AddOutPointLock(const COutPoint& outpoint)
 void CTxLockCandidate::MarkOutpointAsAttacked(const COutPoint& outpoint)
 {
     std::map<COutPoint, COutPointLock>::iterator it = mapOutPointLocks.find(outpoint);
-    if(it != mapOutPointLocks.end())
+    if (it != mapOutPointLocks.end())
         it->second.MarkAsAttacked();
 }
 
 bool CTxLockCandidate::AddVote(const CTxLockVote& vote)
 {
     std::map<COutPoint, COutPointLock>::iterator it = mapOutPointLocks.find(vote.GetOutpoint());
-    if(it == mapOutPointLocks.end()) return false;
+    if (it == mapOutPointLocks.end()) return false;
     return it->second.AddVote(vote);
 }
 
 bool CTxLockCandidate::IsAllOutPointsReady() const
 {
-    if(mapOutPointLocks.empty()) return false;
+    if (mapOutPointLocks.empty()) return false;
 
     for (const auto& pair : mapOutPointLocks) {
-        if(!pair.second.IsReady()) return false;
+        if (!pair.second.IsReady()) return false;
     }
     return true;
 }