From ce88ab3144ed77d5fb14e0b15919c47c1cde45de Mon Sep 17 00:00:00 2001 From: UdjinM6 Date: Thu, 17 Nov 2016 04:31:35 +0400 Subject: [PATCH] Refactor IS - rename only (+related log messages) (#1146) --- src/darksend.cpp | 2 +- src/instantx.cpp | 216 +++++++++++++++++++++--------------------- src/instantx.h | 30 +++--- src/main.cpp | 12 +-- src/net.cpp | 6 +- src/wallet/wallet.cpp | 4 +- 6 files changed, 135 insertions(+), 135 deletions(-) diff --git a/src/darksend.cpp b/src/darksend.cpp index dd2f36907..9b6af3aa7 100644 --- a/src/darksend.cpp +++ b/src/darksend.cpp @@ -2454,7 +2454,7 @@ void ThreadCheckDarkSendPool() mnodeman.CheckAndRemove(); mnodeman.ProcessMasternodeConnections(); mnpayments.CheckAndRemove(); - CleanTransactionLocksList(); + CleanTxLockCandidates(); } darkSendPool.CheckTimeout(); diff --git a/src/instantx.cpp b/src/instantx.cpp index d3913eac3..8f6673a19 100644 --- a/src/instantx.cpp +++ b/src/instantx.cpp @@ -26,12 +26,12 @@ bool fEnableInstantSend = true; int nInstantSendDepth = DEFAULT_INSTANTSEND_DEPTH; int nCompleteTXLocks; -std::map mapTxLockReq; -std::map mapTxLockReqRejected; -std::map mapTxLockVote; +std::map mapLockRequestAccepted; +std::map mapLockRequestRejected; +std::map mapTxLockVotes; std::map mapLockedInputs; -std::map mapTxLocks; +std::map mapTxLockCandidates; std::map mapUnknownVotes; //track votes with no tx for DOS CCriticalSection cs_instantsend; @@ -65,7 +65,7 @@ void ProcessMessageInstantSend(CNode* pfrom, std::string& strCommand, CDataStrea GetMainSignals().Inventory(inv.hash); // have we seen it already? - if(mapTxLockReq.count(inv.hash) || mapTxLockReqRejected.count(inv.hash)) return; + if(mapLockRequestAccepted.count(inv.hash) || mapLockRequestRejected.count(inv.hash)) return; // is it a valid one? if(!IsInstantSendTxValid(tx)) return; @@ -78,7 +78,7 @@ void ProcessMessageInstantSend(CNode* pfrom, std::string& strCommand, CDataStrea } } - int nBlockHeight = CreateNewLock(tx); + int nBlockHeight = CreateTxLockCandidate(tx); bool fMissingInputs = false; CValidationState state; @@ -91,9 +91,9 @@ void ProcessMessageInstantSend(CNode* pfrom, std::string& strCommand, CDataStrea if(fAccepted) { RelayInv(inv); - DoConsensusVote(tx, nBlockHeight); + CreateTxLockVote(tx, nBlockHeight); - mapTxLockReq.insert(std::make_pair(tx.GetHash(), tx)); + mapLockRequestAccepted.insert(std::make_pair(tx.GetHash(), tx)); LogPrintf("ProcessMessageInstantSend -- Transaction Lock Request: %s %s : accepted %s\n", pfrom->addr.ToString(), pfrom->cleanSubVer, @@ -112,7 +112,7 @@ void ProcessMessageInstantSend(CNode* pfrom, std::string& strCommand, CDataStrea return; } else { - mapTxLockReqRejected.insert(std::make_pair(tx.GetHash(), tx)); + mapLockRequestRejected.insert(std::make_pair(tx.GetHash(), tx)); // can we get the conflicting transaction as proof? @@ -129,28 +129,28 @@ void ProcessMessageInstantSend(CNode* pfrom, std::string& strCommand, CDataStrea } else if (strCommand == NetMsgType::TXLOCKVOTE) // InstantSend Transaction Lock Consensus Votes { - CConsensusVote vote; + CTxLockVote vote; vRecv >> vote; CInv inv(MSG_TXLOCK_VOTE, vote.GetHash()); pfrom->AddInventoryKnown(inv); - if(mapTxLockVote.count(vote.GetHash())) return; - mapTxLockVote.insert(std::make_pair(vote.GetHash(), vote)); + if(mapTxLockVotes.count(vote.GetHash())) return; + mapTxLockVotes.insert(std::make_pair(vote.GetHash(), vote)); - if(ProcessConsensusVote(pfrom, vote)) { + if(ProcessTxLockVote(pfrom, vote)) { //Spam/Dos protection /* Masternodes will sometimes propagate votes before the transaction is known to the client. This tracks those messages and allows it at the same rate of the rest of the network, if a peer violates it, it will simply be ignored */ - if(!mapTxLockReq.count(vote.txHash) && !mapTxLockReqRejected.count(vote.txHash)) { + if(!mapLockRequestAccepted.count(vote.txHash) && !mapLockRequestRejected.count(vote.txHash)) { if(!mapUnknownVotes.count(vote.vinMasternode.prevout.hash)) mapUnknownVotes[vote.vinMasternode.prevout.hash] = GetTime()+(60*10); if(mapUnknownVotes[vote.vinMasternode.prevout.hash] > GetTime() && - mapUnknownVotes[vote.vinMasternode.prevout.hash] - GetAverageVoteTime() > 60*10) { + mapUnknownVotes[vote.vinMasternode.prevout.hash] - GetAverageUnknownVoteTime() > 60*10) { LogPrintf("ProcessMessageInstantSend -- masternode is spamming transaction votes: %s %s\n", vote.vinMasternode.ToString(), vote.txHash.ToString() @@ -218,14 +218,14 @@ bool IsInstantSendTxValid(const CTransaction& txCandidate) return true; } -int64_t CreateNewLock(CTransaction tx) +int64_t CreateTxLockCandidate(CTransaction tx) { int64_t nTxAge = 0; BOOST_REVERSE_FOREACH(CTxIn txin, tx.vin) { nTxAge = GetInputAge(txin); if(nTxAge < 5) { //1 less than the "send IX" gui requires, incase of a block propagating the network at the time - LogPrintf("CreateNewLock -- Transaction not found / too new: nTxAge=%d, txid=%s\n", nTxAge, tx.GetHash().ToString()); + LogPrintf("CreateTxLockCandidate -- Transaction not found / too new: nTxAge=%d, txid=%s\n", nTxAge, tx.GetHash().ToString()); return 0; } } @@ -245,19 +245,19 @@ int64_t CreateNewLock(CTransaction tx) return 0; } - if(!mapTxLocks.count(tx.GetHash())) { - LogPrintf("CreateNewLock -- New Transaction Lock! txid=%s\n", tx.GetHash().ToString()); + if(!mapTxLockCandidates.count(tx.GetHash())) { + LogPrintf("CreateTxLockCandidate -- New Transaction Lock Candidate! txid=%s\n", tx.GetHash().ToString()); - CTransactionLock newLock; - newLock.nBlockHeight = nBlockHeight; + CTxLockCandidate txLockCandidate; + txLockCandidate.nBlockHeight = nBlockHeight; //locks expire after nInstantSendKeepLock confirmations - newLock.nLockExpirationBlock = chainActive.Height() + Params().GetConsensus().nInstantSendKeepLock; - newLock.nTimeout = GetTime()+(60*5); - newLock.txHash = tx.GetHash(); - mapTxLocks.insert(std::make_pair(tx.GetHash(), newLock)); + txLockCandidate.nExpirationBlock = chainActive.Height() + Params().GetConsensus().nInstantSendKeepLock; + txLockCandidate.nTimeout = GetTime()+(60*5); + txLockCandidate.txHash = tx.GetHash(); + mapTxLockCandidates.insert(std::make_pair(tx.GetHash(), txLockCandidate)); } else { - mapTxLocks[tx.GetHash()].nBlockHeight = nBlockHeight; - LogPrint("instantsend", "CreateNewLock -- Transaction Lock Exists! txid=%s\n", tx.GetHash().ToString()); + mapTxLockCandidates[tx.GetHash()].nBlockHeight = nBlockHeight; + LogPrint("instantsend", "CreateTxLockCandidate -- Transaction Lock Candidate exists! txid=%s\n", tx.GetHash().ToString()); } @@ -266,43 +266,43 @@ int64_t CreateNewLock(CTransaction tx) } // check if we need to vote on this transaction -void DoConsensusVote(CTransaction& tx, int64_t nBlockHeight) +void CreateTxLockVote(CTransaction& tx, int64_t nBlockHeight) { if(!fMasterNode) return; int n = mnodeman.GetMasternodeRank(activeMasternode.vin, nBlockHeight, MIN_INSTANTSEND_PROTO_VERSION); if(n == -1) { - LogPrint("instantsend", "DoConsensusVote -- Unknown Masternode %s\n", activeMasternode.vin.prevout.ToStringShort()); + LogPrint("instantsend", "CreateTxLockVote -- Unknown Masternode %s\n", activeMasternode.vin.prevout.ToStringShort()); return; } if(n > INSTANTSEND_SIGNATURES_TOTAL) { - LogPrint("instantsend", "DoConsensusVote -- Masternode not in the top %d (%d)\n", INSTANTSEND_SIGNATURES_TOTAL, n); + LogPrint("instantsend", "CreateTxLockVote -- Masternode not in the top %d (%d)\n", INSTANTSEND_SIGNATURES_TOTAL, n); return; } /* nBlockHeight calculated from the transaction is the authoritive source */ - LogPrint("instantsend", "DoConsensusVote -- In the top %d (%d)\n", INSTANTSEND_SIGNATURES_TOTAL, n); + LogPrint("instantsend", "CreateTxLockVote -- In the top %d (%d)\n", INSTANTSEND_SIGNATURES_TOTAL, n); - CConsensusVote vote; + CTxLockVote vote; vote.vinMasternode = activeMasternode.vin; vote.txHash = tx.GetHash(); vote.nBlockHeight = nBlockHeight; if(!vote.Sign()) { - LogPrintf("DoConsensusVote -- Failed to sign consensus vote\n"); + LogPrintf("CreateTxLockVote -- Failed to sign consensus vote\n"); return; } if(!vote.CheckSignature()) { - LogPrintf("DoConsensusVote -- Signature invalid\n"); + LogPrintf("CreateTxLockVote -- Signature invalid\n"); return; } { LOCK(cs_instantsend); - mapTxLockVote[vote.GetHash()] = vote; + mapTxLockVotes[vote.GetHash()] = vote; } CInv inv(MSG_TXLOCK_VOTE, vote.GetHash()); @@ -310,73 +310,73 @@ void DoConsensusVote(CTransaction& tx, int64_t nBlockHeight) } //received a consensus vote -bool ProcessConsensusVote(CNode* pnode, CConsensusVote& vote) +bool ProcessTxLockVote(CNode* pnode, CTxLockVote& vote) { int n = mnodeman.GetMasternodeRank(vote.vinMasternode, vote.nBlockHeight, MIN_INSTANTSEND_PROTO_VERSION); CMasternode* pmn = mnodeman.Find(vote.vinMasternode); if(pmn != NULL) - LogPrint("instantsend", "ProcessConsensusVote -- Masternode addr=%s, rank: %d\n", pmn->addr.ToString(), n); + LogPrint("instantsend", "ProcessTxLockVote -- Masternode addr=%s, rank: %d\n", pmn->addr.ToString(), n); if(n == -1) { //can be caused by past versions trying to vote with an invalid protocol - LogPrint("instantsend", "ProcessConsensusVote -- Unknown Masternode: txin=%s\n", vote.vinMasternode.ToString()); + LogPrint("instantsend", "ProcessTxLockVote -- Unknown Masternode: txin=%s\n", vote.vinMasternode.ToString()); mnodeman.AskForMN(pnode, vote.vinMasternode); return false; } - LogPrint("instantsend", "ProcessConsensusVote -- Masternode %s, rank=%d\n", vote.vinMasternode.prevout.ToStringShort(), n); + LogPrint("instantsend", "ProcessTxLockVote -- Masternode %s, rank=%d\n", vote.vinMasternode.prevout.ToStringShort(), n); if(n > INSTANTSEND_SIGNATURES_TOTAL) { - LogPrint("instantsend", "ProcessConsensusVote -- Masternode %s is not in the top %d (%d), vote hash %s\n", + LogPrint("instantsend", "ProcessTxLockVote -- Masternode %s is not in the top %d (%d), vote hash %s\n", vote.vinMasternode.prevout.ToStringShort(), INSTANTSEND_SIGNATURES_TOTAL, n, vote.GetHash().ToString()); return false; } if(!vote.CheckSignature()) { - LogPrintf("ProcessConsensusVote -- Signature invalid\n"); + LogPrintf("ProcessTxLockVote -- Signature invalid\n"); // don't ban, it could just be a non-synced masternode mnodeman.AskForMN(pnode, vote.vinMasternode); return false; } - if (!mapTxLocks.count(vote.txHash)) { - LogPrintf("ProcessConsensusVote -- New Transaction Lock! txid=%s\n", vote.txHash.ToString()); + if (!mapTxLockCandidates.count(vote.txHash)) { + LogPrintf("ProcessTxLockVote -- New Transaction Lock Candidate! txid=%s\n", vote.txHash.ToString()); - CTransactionLock newLock; - newLock.nBlockHeight = 0; + CTxLockCandidate txLockCandidate; + txLockCandidate.nBlockHeight = 0; //locks expire after nInstantSendKeepLock confirmations - newLock.nLockExpirationBlock = chainActive.Height() + Params().GetConsensus().nInstantSendKeepLock; - newLock.nTimeout = GetTime()+(60*5); - newLock.txHash = vote.txHash; - mapTxLocks.insert(std::make_pair(vote.txHash, newLock)); + txLockCandidate.nExpirationBlock = chainActive.Height() + Params().GetConsensus().nInstantSendKeepLock; + txLockCandidate.nTimeout = GetTime()+(60*5); + txLockCandidate.txHash = vote.txHash; + mapTxLockCandidates.insert(std::make_pair(vote.txHash, txLockCandidate)); } else { - LogPrint("instantsend", "ProcessConsensusVote -- Transaction Lock Exists! txid=%s\n", vote.txHash.ToString()); + LogPrint("instantsend", "ProcessTxLockVote -- Transaction Lock Exists! txid=%s\n", vote.txHash.ToString()); } //compile consessus vote - std::map::iterator i = mapTxLocks.find(vote.txHash); - if (i != mapTxLocks.end()) { + std::map::iterator i = mapTxLockCandidates.find(vote.txHash); + if (i != mapTxLockCandidates.end()) { (*i).second.AddVote(vote); int nSignatures = (*i).second.CountVotes(); - LogPrint("instantsend", "ProcessConsensusVote -- Transaction Lock signatures count: %d, vote hash=%s\n", nSignatures, vote.GetHash().ToString()); + LogPrint("instantsend", "ProcessTxLockVote -- Transaction Lock signatures count: %d, vote hash=%s\n", nSignatures, vote.GetHash().ToString()); if(nSignatures >= INSTANTSEND_SIGNATURES_REQUIRED) { - LogPrint("instantsend", "ProcessConsensusVote -- Transaction Lock Is Complete! txid=%s\n", vote.txHash.ToString()); + LogPrint("instantsend", "ProcessTxLockVote -- Transaction Lock Is Complete! txid=%s\n", vote.txHash.ToString()); // Masternodes will sometimes propagate votes before the transaction is known to the client, // will check for conflicting locks and update transaction status on a new vote message // only after the lock itself has arrived - if(!mapTxLockReq.count(vote.txHash) && !mapTxLockReqRejected.count(vote.txHash)) return true; + if(!mapLockRequestAccepted.count(vote.txHash) && !mapLockRequestRejected.count(vote.txHash)) return true; - if(!FindConflictingLocks(mapTxLockReq[vote.txHash])) { //????? - if(mapTxLockReq.count(vote.txHash)) { - UpdateLockedTransaction(mapTxLockReq[vote.txHash]); - LockTransactionInputs(mapTxLockReq[vote.txHash]); - } else if(mapTxLockReqRejected.count(vote.txHash)) { - ResolveConflicts(mapTxLockReqRejected[vote.txHash]); ///????? + if(!FindConflictingLocks(mapLockRequestAccepted[vote.txHash])) { //????? + if(mapLockRequestAccepted.count(vote.txHash)) { + UpdateLockedTransaction(mapLockRequestAccepted[vote.txHash]); + LockTransactionInputs(mapLockRequestAccepted[vote.txHash]); + } else if(mapLockRequestRejected.count(vote.txHash)) { + ResolveConflicts(mapLockRequestRejected[vote.txHash]); ///????? } else { - LogPrint("instantsend", "ProcessConsensusVote -- Transaction Lock Request is missing! nSignatures=%d, vote hash %s\n", nSignatures, vote.GetHash().ToString()); + LogPrint("instantsend", "ProcessTxLockVote -- Transaction Lock Request is missing! nSignatures=%d, vote hash %s\n", nSignatures, vote.GetHash().ToString()); } } } @@ -393,7 +393,7 @@ void UpdateLockedTransaction(CTransaction& tx, bool fForceNotification) if(FindConflictingLocks(tx)) return; uint256 txHash = tx.GetHash(); // there must be a successfully verified lock request - if(!mapTxLockReq.count(txHash)) return; + if(!mapLockRequestAccepted.count(txHash)) return; int nSignatures = GetTransactionLockSignatures(txHash); @@ -418,7 +418,7 @@ void UpdateLockedTransaction(CTransaction& tx, bool fForceNotification) } void LockTransactionInputs(CTransaction& tx) { - if(!mapTxLockReq.count(tx.GetHash())) return; + if(!mapLockRequestAccepted.count(tx.GetHash())) return; BOOST_FOREACH(const CTxIn& txin, tx.vin) if(!mapLockedInputs.count(txin.prevout)) @@ -439,11 +439,11 @@ bool FindConflictingLocks(CTransaction& tx) if(mapLockedInputs[txin.prevout] != tx.GetHash()) { LogPrintf("FindConflictingLocks -- found two complete conflicting Transaction Locks, removing both: txid=%s, txin=%s", tx.GetHash().ToString(), mapLockedInputs[txin.prevout].ToString()); - if(mapTxLocks.count(tx.GetHash())) - mapTxLocks[tx.GetHash()].nLockExpirationBlock = -1; + if(mapTxLockCandidates.count(tx.GetHash())) + mapTxLockCandidates[tx.GetHash()].nExpirationBlock = -1; - if(mapTxLocks.count(mapLockedInputs[txin.prevout])) - mapTxLocks[mapLockedInputs[txin.prevout]].nLockExpirationBlock = -1; + if(mapTxLockCandidates.count(mapLockedInputs[txin.prevout])) + mapTxLockCandidates[mapLockedInputs[txin.prevout]].nExpirationBlock = -1; return true; } @@ -461,12 +461,12 @@ void ResolveConflicts(CTransaction& tx) //reprocess the last nInstantSendReprocessBlocks blocks ReprocessBlocks(Params().GetConsensus().nInstantSendReprocessBlocks); - if(!mapTxLockReq.count(tx.GetHash())) - mapTxLockReq.insert(std::make_pair(tx.GetHash(), tx)); //????? + if(!mapLockRequestAccepted.count(tx.GetHash())) + mapLockRequestAccepted.insert(std::make_pair(tx.GetHash(), tx)); //????? } } -int64_t GetAverageVoteTime() +int64_t GetAverageUnknownVoteTime() { std::map::iterator it = mapUnknownVotes.begin(); int64_t total = 0; @@ -481,33 +481,33 @@ int64_t GetAverageVoteTime() return total / count; } -void CleanTransactionLocksList() +void CleanTxLockCandidates() { LOCK(cs_instantsend); - std::map::iterator it = mapTxLocks.begin(); + std::map::iterator it = mapTxLockCandidates.begin(); int nHeight = chainActive.Height(); - while(it != mapTxLocks.end()) { - CTransactionLock &txLock = it->second; - if(nHeight > txLock.nLockExpirationBlock) { - LogPrintf("Removing old transaction lock: txid=%s\n", txLock.txHash.ToString()); + while(it != mapTxLockCandidates.end()) { + CTxLockCandidate &txLockCandidate = it->second; + if(nHeight > txLockCandidate.nExpirationBlock) { + LogPrintf("CleanTxLockCandidates -- Removing expired Transaction Lock Candidate for txid %s\n", txLockCandidate.txHash.ToString()); - if(mapTxLockReq.count(txLock.txHash)){ - CTransaction& tx = mapTxLockReq[txLock.txHash]; + if(mapLockRequestAccepted.count(txLockCandidate.txHash)){ + CTransaction& tx = mapLockRequestAccepted[txLockCandidate.txHash]; BOOST_FOREACH(const CTxIn& txin, tx.vin) mapLockedInputs.erase(txin.prevout); - mapTxLockReq.erase(txLock.txHash); - mapTxLockReqRejected.erase(txLock.txHash); + mapLockRequestAccepted.erase(txLockCandidate.txHash); + mapLockRequestRejected.erase(txLockCandidate.txHash); - BOOST_FOREACH(const CConsensusVote& vote, txLock.vecConsensusVotes) - if(mapTxLockVote.count(vote.GetHash())) - mapTxLockVote.erase(vote.GetHash()); + BOOST_FOREACH(const CTxLockVote& vote, txLockCandidate.vecTxLockVotes) + if(mapTxLockVotes.count(vote.GetHash())) + mapTxLockVotes.erase(vote.GetHash()); } - mapTxLocks.erase(it++); + mapTxLockCandidates.erase(it++); } else { it++; } @@ -517,10 +517,10 @@ void CleanTransactionLocksList() bool IsLockedInstandSendTransaction(uint256 txHash) { // there must be a successfully verified lock request... - if (!mapTxLockReq.count(txHash)) return false; + if (!mapLockRequestAccepted.count(txHash)) return false; // ...and corresponding lock must have enough signatures - std::map::iterator i = mapTxLocks.find(txHash); - return i != mapTxLocks.end() && (*i).second.CountVotes() >= INSTANTSEND_SIGNATURES_REQUIRED; + std::map::iterator i = mapTxLockCandidates.find(txHash); + return i != mapTxLockCandidates.end() && (*i).second.CountVotes() >= INSTANTSEND_SIGNATURES_REQUIRED; } int GetTransactionLockSignatures(uint256 txHash) @@ -529,8 +529,8 @@ int GetTransactionLockSignatures(uint256 txHash) if(fLargeWorkForkFound || fLargeWorkInvalidChainFound) return -2; if(!sporkManager.IsSporkActive(SPORK_2_INSTANTSEND_ENABLED)) return -3; - std::map::iterator it = mapTxLocks.find(txHash); - if(it != mapTxLocks.end()) return it->second.CountVotes(); + std::map::iterator it = mapTxLockCandidates.find(txHash); + if(it != mapTxLockCandidates.end()) return it->second.CountVotes(); return -1; } @@ -539,19 +539,19 @@ bool IsTransactionLockTimedOut(uint256 txHash) { if(!fEnableInstantSend) return 0; - std::map::iterator i = mapTxLocks.find(txHash); - if (i != mapTxLocks.end()) return GetTime() > (*i).second.nTimeout; + std::map::iterator i = mapTxLockCandidates.find(txHash); + if (i != mapTxLockCandidates.end()) return GetTime() > (*i).second.nTimeout; return false; } -uint256 CConsensusVote::GetHash() const +uint256 CTxLockVote::GetHash() const { return ArithToUint256(UintToArith256(vinMasternode.prevout.hash) + vinMasternode.prevout.n + UintToArith256(txHash)); } -bool CConsensusVote::CheckSignature() +bool CTxLockVote::CheckSignature() { std::string strError; std::string strMessage = txHash.ToString().c_str() + boost::lexical_cast(nBlockHeight); @@ -559,31 +559,31 @@ bool CConsensusVote::CheckSignature() CMasternode* pmn = mnodeman.Find(vinMasternode); if(pmn == NULL) { - LogPrintf("CConsensusVote::CheckSignature -- Unknown Masternode: txin=%s\n", vinMasternode.ToString()); + LogPrintf("CTxLockVote::CheckSignature -- Unknown Masternode: txin=%s\n", vinMasternode.ToString()); return false; } if(!darkSendSigner.VerifyMessage(pmn->pubKeyMasternode, vchMasterNodeSignature, strMessage, strError)) { - LogPrintf("CConsensusVote::CheckSignature -- VerifyMessage() failed, error: %s\n", strError); + LogPrintf("CTxLockVote::CheckSignature -- VerifyMessage() failed, error: %s\n", strError); return false; } return true; } -bool CConsensusVote::Sign() +bool CTxLockVote::Sign() { std::string strError; std::string strMessage = txHash.ToString().c_str() + boost::lexical_cast(nBlockHeight); if(!darkSendSigner.SignMessage(strMessage, vchMasterNodeSignature, activeMasternode.keyMasternode)) { - LogPrintf("CConsensusVote::Sign -- SignMessage() failed\n"); + LogPrintf("CTxLockVote::Sign -- SignMessage() failed\n"); return false; } if(!darkSendSigner.VerifyMessage(activeMasternode.pubKeyMasternode, vchMasterNodeSignature, strMessage, strError)) { - LogPrintf("CConsensusVote::Sign -- VerifyMessage() failed, error: %s\n", strError); + LogPrintf("CTxLockVote::Sign -- VerifyMessage() failed, error: %s\n", strError); return false; } @@ -591,25 +591,25 @@ bool CConsensusVote::Sign() } -bool CTransactionLock::IsAllVotesValid() +bool CTxLockCandidate::IsAllVotesValid() { - BOOST_FOREACH(CConsensusVote vote, vecConsensusVotes) + BOOST_FOREACH(CTxLockVote vote, vecTxLockVotes) { int n = mnodeman.GetMasternodeRank(vote.vinMasternode, vote.nBlockHeight, MIN_INSTANTSEND_PROTO_VERSION); if(n == -1) { - LogPrintf("CTransactionLock::IsAllVotesValid -- Unknown Masternode, txin=%s\n", vote.vinMasternode.ToString()); + LogPrintf("CTxLockCandidate::IsAllVotesValid -- Unknown Masternode, txin=%s\n", vote.vinMasternode.ToString()); return false; } if(n > INSTANTSEND_SIGNATURES_TOTAL) { - LogPrintf("CTransactionLock::IsAllVotesValid -- Masternode not in the top %s\n", INSTANTSEND_SIGNATURES_TOTAL); + LogPrintf("CTxLockCandidate::IsAllVotesValid -- Masternode not in the top %s\n", INSTANTSEND_SIGNATURES_TOTAL); return false; } if(!vote.CheckSignature()) { - LogPrintf("CTransactionLock::IsAllVotesValid -- Signature not valid\n"); + LogPrintf("CTxLockCandidate::IsAllVotesValid -- Signature not valid\n"); return false; } } @@ -617,12 +617,12 @@ bool CTransactionLock::IsAllVotesValid() return true; } -void CTransactionLock::AddVote(CConsensusVote& vote) +void CTxLockCandidate::AddVote(CTxLockVote& vote) { - vecConsensusVotes.push_back(vote); + vecTxLockVotes.push_back(vote); } -int CTransactionLock::CountVotes() +int CTxLockCandidate::CountVotes() { /* Only count signatures where the BlockHeight matches the transaction's blockheight. @@ -632,7 +632,7 @@ int CTransactionLock::CountVotes() if(nBlockHeight == 0) return -1; int nCount = 0; - BOOST_FOREACH(CConsensusVote vote, vecConsensusVotes) + BOOST_FOREACH(CTxLockVote vote, vecTxLockVotes) if(vote.nBlockHeight == nBlockHeight) nCount++; diff --git a/src/instantx.h b/src/instantx.h index 297c258f8..a49c3d69e 100644 --- a/src/instantx.h +++ b/src/instantx.h @@ -11,9 +11,9 @@ #include "base58.h" #include "main.h" -class CConsensusVote; class CTransaction; -class CTransactionLock; +class CTxLockVote; +class CTxLockCandidate; /* At 15 signatures, 1/2 of the masternode network can be owned by @@ -35,23 +35,23 @@ extern bool fEnableInstantSend; extern int nInstantSendDepth; extern int nCompleteTXLocks; -extern std::map mapTxLockReq; -extern std::map mapTxLockReqRejected; -extern std::map mapTxLockVote; +extern std::map mapLockRequestAccepted; +extern std::map mapLockRequestRejected; +extern std::map mapTxLockVotes; extern std::map mapLockedInputs; -int64_t CreateNewLock(CTransaction tx); +int64_t CreateTxLockCandidate(CTransaction tx); bool IsInstantSendTxValid(const CTransaction& txCandidate); void ProcessMessageInstantSend(CNode* pfrom, std::string& strCommand, CDataStream& vRecv); //check if we need to vote on this transaction -void DoConsensusVote(CTransaction& tx, int64_t nBlockHeight); +void CreateTxLockVote(CTransaction& tx, int64_t nBlockHeight); //process consensus vote message -bool ProcessConsensusVote(CNode *pnode, CConsensusVote& vote); +bool ProcessTxLockVote(CNode *pnode, CTxLockVote& vote); //update UI and notify external script if any void UpdateLockedTransaction(CTransaction& tx, bool fForceNotification = false); @@ -65,7 +65,7 @@ bool FindConflictingLocks(CTransaction& tx); void ResolveConflicts(CTransaction& tx); // keep transaction locks in memory for an hour -void CleanTransactionLocksList(); +void CleanTxLockCandidates(); // verify if transaction is currently locked bool IsLockedInstandSendTransaction(uint256 txHash); @@ -76,9 +76,9 @@ int GetTransactionLockSignatures(uint256 txHash); // verify if transaction lock timed out bool IsTransactionLockTimedOut(uint256 txHash); -int64_t GetAverageVoteTime(); +int64_t GetAverageUnknownVoteTime(); -class CConsensusVote +class CTxLockVote { public: CTxIn vinMasternode; @@ -102,19 +102,19 @@ public: bool CheckSignature(); }; -class CTransactionLock +class CTxLockCandidate { public: int nBlockHeight; uint256 txHash; - std::vector vecConsensusVotes; - int nLockExpirationBlock; + std::vector vecTxLockVotes; + int nExpirationBlock; int nTimeout; uint256 GetHash() const { return txHash; } bool IsAllVotesValid(); - void AddVote(CConsensusVote& vote); + void AddVote(CTxLockVote& vote); int CountVotes(); }; diff --git a/src/main.cpp b/src/main.cpp index 2f820ee69..bd3e909d9 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -4921,10 +4921,10 @@ bool static AlreadyHave(const CInv& inv) EXCLUSIVE_LOCKS_REQUIRED(cs_main) We want to only update the time on new hits, so that we can time out appropriately if needed. */ case MSG_TXLOCK_REQUEST: - return mapTxLockReq.count(inv.hash) || mapTxLockReqRejected.count(inv.hash); + return mapLockRequestAccepted.count(inv.hash) || mapLockRequestRejected.count(inv.hash); case MSG_TXLOCK_VOTE: - return mapTxLockVote.count(inv.hash); + return mapTxLockVotes.count(inv.hash); case MSG_SPORK: return mapSporks.count(inv.hash); @@ -5078,20 +5078,20 @@ void static ProcessGetData(CNode* pfrom, const Consensus::Params& consensusParam } if (!pushed && inv.type == MSG_TXLOCK_REQUEST) { - if(mapTxLockReq.count(inv.hash)) { + if(mapLockRequestAccepted.count(inv.hash)) { CDataStream ss(SER_NETWORK, PROTOCOL_VERSION); ss.reserve(1000); - ss << mapTxLockReq[inv.hash]; + ss << mapLockRequestAccepted[inv.hash]; pfrom->PushMessage(NetMsgType::TXLOCKREQUEST, ss); pushed = true; } } if (!pushed && inv.type == MSG_TXLOCK_VOTE) { - if(mapTxLockVote.count(inv.hash)) { + if(mapTxLockVotes.count(inv.hash)) { CDataStream ss(SER_NETWORK, PROTOCOL_VERSION); ss.reserve(1000); - ss << mapTxLockVote[inv.hash]; + ss << mapTxLockVotes[inv.hash]; pfrom->PushMessage(NetMsgType::TXLOCKVOTE, ss); pushed = true; } diff --git a/src/net.cpp b/src/net.cpp index bef30cf08..466a02458 100644 --- a/src/net.cpp +++ b/src/net.cpp @@ -2068,8 +2068,8 @@ void RelayTransaction(const CTransaction& tx) uint256 hash = tx.GetHash(); if(mapDarksendBroadcastTxes.count(hash)) { // MSG_DSTX ss << mapDarksendBroadcastTxes[hash]; - } else if(mapTxLockReq.count(hash)) { // MSG_TXLOCK_REQUEST - ss << mapTxLockReq[hash]; + } else if(mapLockRequestAccepted.count(hash)) { // MSG_TXLOCK_REQUEST + ss << mapLockRequestAccepted[hash]; } else { // MSG_TX ss << tx; } @@ -2080,7 +2080,7 @@ void RelayTransaction(const CTransaction& tx, const CDataStream& ss) { uint256 hash = tx.GetHash(); int nInv = mapDarksendBroadcastTxes.count(hash) ? MSG_DSTX : - (mapTxLockReq.count(hash) ? MSG_TXLOCK_REQUEST : MSG_TX); + (mapLockRequestAccepted.count(hash) ? MSG_TXLOCK_REQUEST : MSG_TX); CInv inv(nInv, hash); { LOCK(cs_mapRelay); diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp index 35d61d15b..20546daf0 100644 --- a/src/wallet/wallet.cpp +++ b/src/wallet/wallet.cpp @@ -1472,8 +1472,8 @@ bool CWalletTx::RelayWalletTransaction(std::string strCommand) LogPrintf("Relaying wtx %s\n", hash.ToString()); if(strCommand == NetMsgType::TXLOCKREQUEST){ - mapTxLockReq.insert(make_pair(hash, (CTransaction)*this)); - CreateNewLock(((CTransaction)*this)); + mapLockRequestAccepted.insert(make_pair(hash, (CTransaction)*this)); + CreateTxLockCandidate(((CTransaction)*this)); } RelayTransaction((CTransaction)*this); return true;