From ec239ffa36d0ff09f55fc2abaa73e9d0944e17c0 Mon Sep 17 00:00:00 2001 From: UdjinM6 Date: Wed, 21 Sep 2016 18:45:29 +0400 Subject: [PATCH] Mostly winner -> payment vote (#1033) Followup for the recent winner_block PR (#1028) and name confusion discovered during code review. "Mostly" because also: - CMasternodeBlockPayees::GetPayee -> CMasternodeBlockPayees::GetBestPayee which describes what this function is actually doing a bit better imo; - fixing constructor CMasternodePaymentVote empty constructor --- src/main.cpp | 22 ++--- src/masternode-payments.cpp | 158 ++++++++++++++++++------------------ src/masternode-payments.h | 32 ++++---- src/masternode-sync.cpp | 22 ++--- src/masternode-sync.h | 4 +- src/protocol.cpp | 16 ++-- src/protocol.h | 8 +- 7 files changed, 132 insertions(+), 130 deletions(-) diff --git a/src/main.cpp b/src/main.cpp index e368c61fc..8ebef4cc3 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -4936,10 +4936,10 @@ bool static AlreadyHave(const CInv& inv) EXCLUSIVE_LOCKS_REQUIRED(cs_main) case MSG_SPORK: return mapSporks.count(inv.hash); - case MSG_MASTERNODE_WINNER: - return mnpayments.mapMasternodePayeeVotes.count(inv.hash); + case MSG_MASTERNODE_PAYMENT_VOTE: + return mnpayments.mapMasternodePaymentVotes.count(inv.hash); - case MSG_MASTERNODE_WINNER_BLOCK: + case MSG_MASTERNODE_PAYMENT_BLOCK: { BlockMap::iterator mi = mapBlockIndex.find(inv.hash); return mi != mapBlockIndex.end() && mnpayments.mapMasternodeBlocks.find(mi->second->nHeight) != mnpayments.mapMasternodeBlocks.end(); @@ -5112,28 +5112,28 @@ void static ProcessGetData(CNode* pfrom, const Consensus::Params& consensusParam } } - if (!pushed && inv.type == MSG_MASTERNODE_WINNER) { - if(mnpayments.mapMasternodePayeeVotes.count(inv.hash)) { + if (!pushed && inv.type == MSG_MASTERNODE_PAYMENT_VOTE) { + if(mnpayments.mapMasternodePaymentVotes.count(inv.hash)) { CDataStream ss(SER_NETWORK, PROTOCOL_VERSION); ss.reserve(1000); - ss << mnpayments.mapMasternodePayeeVotes[inv.hash]; - pfrom->PushMessage(NetMsgType::MNWINNER, ss); + ss << mnpayments.mapMasternodePaymentVotes[inv.hash]; + pfrom->PushMessage(NetMsgType::MASTERNODEPAYMENTVOTE, ss); pushed = true; } } - if (!pushed && inv.type == MSG_MASTERNODE_WINNER_BLOCK) { + if (!pushed && inv.type == MSG_MASTERNODE_PAYMENT_BLOCK) { BlockMap::iterator mi = mapBlockIndex.find(inv.hash); LOCK(cs_mapMasternodeBlocks); if (mi != mapBlockIndex.end() && mnpayments.mapMasternodeBlocks.count(mi->second->nHeight)) { BOOST_FOREACH(CMasternodePayee& payee, mnpayments.mapMasternodeBlocks[mi->second->nHeight].vecPayees) { std::vector vecVoteHashes = payee.GetVoteHashes(); BOOST_FOREACH(uint256& hash, vecVoteHashes) { - if(mnpayments.mapMasternodePayeeVotes.count(hash)) { + if(mnpayments.mapMasternodePaymentVotes.count(hash)) { CDataStream ss(SER_NETWORK, PROTOCOL_VERSION); ss.reserve(1000); - ss << mnpayments.mapMasternodePayeeVotes[hash]; - pfrom->PushMessage(NetMsgType::MNWINNER, ss); + ss << mnpayments.mapMasternodePaymentVotes[hash]; + pfrom->PushMessage(NetMsgType::MASTERNODEPAYMENTVOTE, ss); } } } diff --git a/src/masternode-payments.cpp b/src/masternode-payments.cpp index 36802209f..3b35f9b7f 100644 --- a/src/masternode-payments.cpp +++ b/src/masternode-payments.cpp @@ -19,7 +19,7 @@ CMasternodePayments mnpayments; CCriticalSection cs_vecPayees; CCriticalSection cs_mapMasternodeBlocks; -CCriticalSection cs_mapMasternodePayeeVotes; +CCriticalSection cs_mapMasternodePaymentVotes; /** * IsBlockValueValid @@ -211,14 +211,14 @@ std::string GetRequiredPaymentsString(int nBlockHeight) void CMasternodePayments::Clear() { - LOCK2(cs_mapMasternodeBlocks, cs_mapMasternodePayeeVotes); + LOCK2(cs_mapMasternodeBlocks, cs_mapMasternodePaymentVotes); mapMasternodeBlocks.clear(); - mapMasternodePayeeVotes.clear(); + mapMasternodePaymentVotes.clear(); } bool CMasternodePayments::CanVote(COutPoint outMasternode, int nBlockHeight) { - LOCK(cs_mapMasternodePayeeVotes); + LOCK(cs_mapMasternodePaymentVotes); if (mapMasternodesLastVote.count(outMasternode) && mapMasternodesLastVote[outMasternode] == nBlockHeight) { return false; @@ -284,7 +284,7 @@ void CMasternodePayments::ProcessMessage(CNode* pfrom, std::string& strCommand, if(fLiteMode) return; // disable all Dash specific functionality - if (strCommand == NetMsgType::MNWINNERSSYNC) { //Masternode Payments Request Sync + if (strCommand == NetMsgType::MASTERNODEPAYMENTSYNC) { //Masternode Payments Request Sync // Ignore such requests until we are fully synced. // We could start processing this after masternode list is synced @@ -295,74 +295,74 @@ void CMasternodePayments::ProcessMessage(CNode* pfrom, std::string& strCommand, vRecv >> nCountNeeded; if(Params().NetworkIDString() == CBaseChainParams::MAIN){ - if(pfrom->HasFulfilledRequest(NetMsgType::MNWINNERSSYNC)) { - LogPrintf("MNWINNERSSYNC -- peer already asked me for the list, peer=%d\n", pfrom->id); + if(pfrom->HasFulfilledRequest(NetMsgType::MASTERNODEPAYMENTSYNC)) { + LogPrintf("MASTERNODEPAYMENTSYNC -- peer already asked me for the list, peer=%d\n", pfrom->id); Misbehaving(pfrom->GetId(), 20); return; } } - pfrom->FulfilledRequest(NetMsgType::MNWINNERSSYNC); + pfrom->FulfilledRequest(NetMsgType::MASTERNODEPAYMENTSYNC); Sync(pfrom, nCountNeeded); - LogPrintf("MNWINNERSSYNC -- Sent Masternode winners to peer %d\n", pfrom->id); + LogPrintf("MASTERNODEPAYMENTSYNC -- Sent Masternode payment votes to peer %d\n", pfrom->id); - } else if (strCommand == NetMsgType::MNWINNER) { //Masternode Payments Declare Winner + } else if (strCommand == NetMsgType::MASTERNODEPAYMENTVOTE) { // Masternode Payments Vote for the Winner - CMasternodePaymentWinner winner; - vRecv >> winner; + CMasternodePaymentVote vote; + vRecv >> vote; if(pfrom->nVersion < GetMinMasternodePaymentsProto()) return; if(!pCurrentBlockIndex) return; - if(mapMasternodePayeeVotes.count(winner.GetHash())) { - LogPrint("mnpayments", "MNWINNER -- hash=%s, nHeight=%d seen\n", winner.GetHash().ToString(), pCurrentBlockIndex->nHeight); - masternodeSync.AddedMasternodeWinner(); + if(mapMasternodePaymentVotes.count(vote.GetHash())) { + LogPrint("mnpayments", "MASTERNODEPAYMENTVOTE -- hash=%s, nHeight=%d seen\n", vote.GetHash().ToString(), pCurrentBlockIndex->nHeight); + masternodeSync.AddedPaymentVote(); return; } int nFirstBlock = pCurrentBlockIndex->nHeight - GetStorageLimit(); - if(winner.nBlockHeight < nFirstBlock || winner.nBlockHeight > pCurrentBlockIndex->nHeight+20) { - LogPrint("mnpayments", "MNWINNER -- winner out of range: nFirstBlock=%d, nBlockHeight=%d, nHeight=%d\n", nFirstBlock, winner.nBlockHeight, pCurrentBlockIndex->nHeight); + if(vote.nBlockHeight < nFirstBlock || vote.nBlockHeight > pCurrentBlockIndex->nHeight+20) { + LogPrint("mnpayments", "MASTERNODEPAYMENTVOTE -- vote out of range: nFirstBlock=%d, nBlockHeight=%d, nHeight=%d\n", nFirstBlock, vote.nBlockHeight, pCurrentBlockIndex->nHeight); return; } std::string strError = ""; - if(!winner.IsValid(pfrom, pCurrentBlockIndex->nHeight, strError)) { - LogPrint("mnpayments", "MNWINNER -- invalid message, error: %s\n", strError); + if(!vote.IsValid(pfrom, pCurrentBlockIndex->nHeight, strError)) { + LogPrint("mnpayments", "MASTERNODEPAYMENTVOTE -- invalid message, error: %s\n", strError); return; } - if(!CanVote(winner.vinMasternode.prevout, winner.nBlockHeight)) { - LogPrintf("MNWINNER -- masternode already voted, masternode=%s\n", winner.vinMasternode.prevout.ToStringShort()); + if(!CanVote(vote.vinMasternode.prevout, vote.nBlockHeight)) { + LogPrintf("MASTERNODEPAYMENTVOTE -- masternode already voted, masternode=%s\n", vote.vinMasternode.prevout.ToStringShort()); return; } - if(!winner.CheckSignature()) { + if(!vote.CheckSignature()) { // do not ban for old mnw, MN simply might be not active anymore - if(masternodeSync.IsSynced() && winner.nBlockHeight > pCurrentBlockIndex->nHeight) { - LogPrintf("MNWINNER -- invalid signature\n"); + if(masternodeSync.IsSynced() && vote.nBlockHeight > pCurrentBlockIndex->nHeight) { + LogPrintf("MASTERNODEPAYMENTVOTE -- invalid signature\n"); Misbehaving(pfrom->GetId(), 20); } // it could just be a non-synced masternode - mnodeman.AskForMN(pfrom, winner.vinMasternode); + mnodeman.AskForMN(pfrom, vote.vinMasternode); return; } CTxDestination address1; - ExtractDestination(winner.payee, address1); + ExtractDestination(vote.payee, address1); CBitcoinAddress address2(address1); - LogPrint("mnpayments", "MNWINNER -- winning vote: address=%s, nBlockHeight=%d, nHeight=%d, prevout=%s\n", address2.ToString(), winner.nBlockHeight, pCurrentBlockIndex->nHeight, winner.vinMasternode.prevout.ToStringShort()); + LogPrint("mnpayments", "MASTERNODEPAYMENTVOTE -- vote: address=%s, nBlockHeight=%d, nHeight=%d, prevout=%s\n", address2.ToString(), vote.nBlockHeight, pCurrentBlockIndex->nHeight, vote.vinMasternode.prevout.ToStringShort()); - if(AddWinningMasternode(winner)){ - winner.Relay(); - masternodeSync.AddedMasternodeWinner(); + if(AddPaymentVote(vote)){ + vote.Relay(); + masternodeSync.AddedPaymentVote(); } } } -bool CMasternodePaymentWinner::Sign() +bool CMasternodePaymentVote::Sign() { std::string strError; std::string strMessage = vinMasternode.prevout.ToStringShort() + @@ -370,12 +370,12 @@ bool CMasternodePaymentWinner::Sign() ScriptToAsmStr(payee); if(!darkSendSigner.SignMessage(strMessage, vchSig, activeMasternode.keyMasternode)) { - LogPrintf("CMasternodePaymentWinner::Sign -- SignMessage() failed\n"); + LogPrintf("CMasternodePaymentVote::Sign -- SignMessage() failed\n"); return false; } if(!darkSendSigner.VerifyMessage(activeMasternode.pubKeyMasternode, vchSig, strMessage, strError)) { - LogPrintf("CMasternodePaymentWinner::Sign -- VerifyMessage() failed, error: %s\n", strError); + LogPrintf("CMasternodePaymentVote::Sign -- VerifyMessage() failed, error: %s\n", strError); return false; } @@ -385,14 +385,14 @@ bool CMasternodePaymentWinner::Sign() bool CMasternodePayments::GetBlockPayee(int nBlockHeight, CScript& payee) { if(mapMasternodeBlocks.count(nBlockHeight)){ - return mapMasternodeBlocks[nBlockHeight].GetPayee(payee); + return mapMasternodeBlocks[nBlockHeight].GetBestPayee(payee); } return false; } // Is this masternode scheduled to get paid soon? -// -- Only look ahead up to 8 blocks to allow for propagation of the latest 2 winners +// -- Only look ahead up to 8 blocks to allow for propagation of the latest 2 blocks of votes bool CMasternodePayments::IsScheduled(CMasternode& mn, int nNotBlockHeight) { LOCK(cs_mapMasternodeBlocks); @@ -405,7 +405,7 @@ bool CMasternodePayments::IsScheduled(CMasternode& mn, int nNotBlockHeight) CScript payee; for(int64_t h = pCurrentBlockIndex->nHeight; h <= pCurrentBlockIndex->nHeight + 8; h++){ if(h == nNotBlockHeight) continue; - if(mapMasternodeBlocks.count(h) && mapMasternodeBlocks[h].GetPayee(payee) && mnpayee == payee) { + if(mapMasternodeBlocks.count(h) && mapMasternodeBlocks[h].GetBestPayee(payee) && mnpayee == payee) { return true; } } @@ -413,47 +413,47 @@ bool CMasternodePayments::IsScheduled(CMasternode& mn, int nNotBlockHeight) return false; } -bool CMasternodePayments::AddWinningMasternode(CMasternodePaymentWinner& winnerIn) +bool CMasternodePayments::AddPaymentVote(const CMasternodePaymentVote& vote) { uint256 blockHash = uint256(); - if(!GetBlockHash(blockHash, winnerIn.nBlockHeight - 101)) return false; + if(!GetBlockHash(blockHash, vote.nBlockHeight - 101)) return false; - LOCK2(cs_mapMasternodePayeeVotes, cs_mapMasternodeBlocks); + LOCK2(cs_mapMasternodePaymentVotes, cs_mapMasternodeBlocks); - if(mapMasternodePayeeVotes.count(winnerIn.GetHash())) return false; + if(mapMasternodePaymentVotes.count(vote.GetHash())) return false; - mapMasternodePayeeVotes[winnerIn.GetHash()] = winnerIn; + mapMasternodePaymentVotes[vote.GetHash()] = vote; - if(!mapMasternodeBlocks.count(winnerIn.nBlockHeight)) { - CMasternodeBlockPayees blockPayees(winnerIn.nBlockHeight); - mapMasternodeBlocks[winnerIn.nBlockHeight] = blockPayees; + if(!mapMasternodeBlocks.count(vote.nBlockHeight)) { + CMasternodeBlockPayees blockPayees(vote.nBlockHeight); + mapMasternodeBlocks[vote.nBlockHeight] = blockPayees; } - mapMasternodeBlocks[winnerIn.nBlockHeight].AddPayee(winnerIn); + mapMasternodeBlocks[vote.nBlockHeight].AddPayee(vote); return true; } -void CMasternodeBlockPayees::AddPayee(CMasternodePaymentWinner winner) +void CMasternodeBlockPayees::AddPayee(const CMasternodePaymentVote& vote) { LOCK(cs_vecPayees); BOOST_FOREACH(CMasternodePayee& payee, vecPayees) { - if (payee.GetPayee() == winner.payee) { - payee.AddVoteHash(winner.GetHash()); + if (payee.GetPayee() == vote.payee) { + payee.AddVoteHash(vote.GetHash()); return; } } - CMasternodePayee payeeNew(winner.payee, winner.GetHash()); + CMasternodePayee payeeNew(vote.payee, vote.GetHash()); vecPayees.push_back(payeeNew); } -bool CMasternodeBlockPayees::GetPayee(CScript& payeeRet) +bool CMasternodeBlockPayees::GetBestPayee(CScript& payeeRet) { LOCK(cs_vecPayees); if(!vecPayees.size()) { - LogPrint("mnpayments", "CMasternodeBlockPayees::GetPayee -- ERROR: couldn't find any payee\n"); + LogPrint("mnpayments", "CMasternodeBlockPayees::GetBestPayee -- ERROR: couldn't find any payee\n"); return false; } @@ -575,18 +575,18 @@ void CMasternodePayments::CheckAndRemove() { if(!pCurrentBlockIndex) return; - LOCK2(cs_mapMasternodePayeeVotes, cs_mapMasternodeBlocks); + LOCK2(cs_mapMasternodePaymentVotes, cs_mapMasternodeBlocks); int nLimit = GetStorageLimit(); - std::map::iterator it = mapMasternodePayeeVotes.begin(); - while(it != mapMasternodePayeeVotes.end()) { - CMasternodePaymentWinner winner = (*it).second; + std::map::iterator it = mapMasternodePaymentVotes.begin(); + while(it != mapMasternodePaymentVotes.end()) { + CMasternodePaymentVote vote = (*it).second; - if(pCurrentBlockIndex->nHeight - winner.nBlockHeight > nLimit) { - LogPrint("mnpayments", "CMasternodePayments::CheckAndRemove -- Removing old Masternode payment: nBlockHeight=%d\n", winner.nBlockHeight); - mapMasternodePayeeVotes.erase(it++); - mapMasternodeBlocks.erase(winner.nBlockHeight); + if(pCurrentBlockIndex->nHeight - vote.nBlockHeight > nLimit) { + LogPrint("mnpayments", "CMasternodePayments::CheckAndRemove -- Removing old Masternode payment: nBlockHeight=%d\n", vote.nBlockHeight); + mapMasternodePaymentVotes.erase(it++); + mapMasternodeBlocks.erase(vote.nBlockHeight); } else { ++it; } @@ -594,7 +594,7 @@ void CMasternodePayments::CheckAndRemove() LogPrintf("CMasternodePayments::CheckAndRemove -- %s\n", ToString()); } -bool CMasternodePaymentWinner::IsValid(CNode* pnode, int nValidationHeight, std::string& strError) +bool CMasternodePaymentVote::IsValid(CNode* pnode, int nValidationHeight, std::string& strError) { CMasternode* pmn = mnodeman.Find(vinMasternode); @@ -610,7 +610,7 @@ bool CMasternodePaymentWinner::IsValid(CNode* pnode, int nValidationHeight, std: int nMinRequiredProtocol; if(nBlockHeight > nValidationHeight) { - // new winners must comply SPORK_10_MASTERNODE_PAY_UPDATED_NODES rules + // new votes must comply SPORK_10_MASTERNODE_PAY_UPDATED_NODES rules nMinRequiredProtocol = mnpayments.GetMinMasternodePaymentsProto(); } else { // allow non-updated masternodes for old blocks @@ -631,7 +631,7 @@ bool CMasternodePaymentWinner::IsValid(CNode* pnode, int nValidationHeight, std: // Only ban for new mnw which is out of bounds, for old mnw MN list itself might be way too much off if(nRank > MNPAYMENTS_SIGNATURES_TOTAL*2 && nBlockHeight > nValidationHeight) { strError = strprintf("Masternode is not in the top %d (%d)", MNPAYMENTS_SIGNATURES_TOTAL*2, nRank); - LogPrintf("CMasternodePaymentWinner::IsValid -- Error: %s\n", strError); + LogPrintf("CMasternodePaymentVote::IsValid -- Error: %s\n", strError); Misbehaving(pnode->GetId(), 20); } // Still invalid however @@ -683,22 +683,22 @@ bool CMasternodePayments::ProcessBlock(int nBlockHeight) CScript payee = GetScriptForDestination(pmn->pubKeyCollateralAddress.GetID()); - CMasternodePaymentWinner newWinner(activeMasternode.vin, nBlockHeight, payee); + CMasternodePaymentVote voteNew(activeMasternode.vin, nBlockHeight, payee); CTxDestination address1; ExtractDestination(payee, address1); CBitcoinAddress address2(address1); - LogPrintf("CMasternodePayments::ProcessBlock -- Winner: payee=%s, nBlockHeight=%d\n", address2.ToString(), nBlockHeight); + LogPrintf("CMasternodePayments::ProcessBlock -- vote: payee=%s, nBlockHeight=%d\n", address2.ToString(), nBlockHeight); // SIGN MESSAGE TO NETWORK WITH OUR MASTERNODE KEYS - LogPrintf("CMasternodePayments::ProcessBlock -- Signing Winner\n"); - if (newWinner.Sign()) { - LogPrintf("CMasternodePayments::ProcessBlock -- AddWinningMasternode()\n"); + LogPrintf("CMasternodePayments::ProcessBlock -- Signing vote\n"); + if (voteNew.Sign()) { + LogPrintf("CMasternodePayments::ProcessBlock -- AddPaymentVote()\n"); - if (AddWinningMasternode(newWinner)) { - newWinner.Relay(); + if (AddPaymentVote(voteNew)) { + voteNew.Relay(); return true; } } @@ -706,13 +706,13 @@ bool CMasternodePayments::ProcessBlock(int nBlockHeight) return false; } -void CMasternodePaymentWinner::Relay() +void CMasternodePaymentVote::Relay() { - CInv inv(MSG_MASTERNODE_WINNER, GetHash()); + CInv inv(MSG_MASTERNODE_PAYMENT_VOTE, GetHash()); RelayInv(inv); } -bool CMasternodePaymentWinner::CheckSignature() +bool CMasternodePaymentVote::CheckSignature() { CMasternode* pmn = mnodeman.Find(vinMasternode); @@ -725,13 +725,13 @@ bool CMasternodePaymentWinner::CheckSignature() std::string strError = ""; if (!darkSendSigner.VerifyMessage(pmn->pubKeyMasternode, vchSig, strMessage, strError)) { - return error("CMasternodePaymentWinner::CheckSignature -- Got bad Masternode payment signature, masternode=%s, error: %s", vinMasternode.prevout.ToStringShort().c_str(), strError); + return error("CMasternodePaymentVote::CheckSignature -- Got bad Masternode payment signature, masternode=%s, error: %s", vinMasternode.prevout.ToStringShort().c_str(), strError); } return true; } -std::string CMasternodePaymentWinner::ToString() const +std::string CMasternodePaymentVote::ToString() const { std::ostringstream info; @@ -755,7 +755,7 @@ void CMasternodePayments::Sync(CNode* pnode, int nCountNeeded) int nLimit = GetStorageLimit(); if(nCountNeeded > nLimit) nCountNeeded = nLimit; } else { - // New nodes request missing payment blocks themselves, push only future winners to them + // New nodes request missing payment blocks themselves, push only votes for future blocks to them nCountNeeded = 0; } @@ -766,14 +766,14 @@ void CMasternodePayments::Sync(CNode* pnode, int nCountNeeded) BOOST_FOREACH(CMasternodePayee& payee, mapMasternodeBlocks[h].vecPayees) { std::vector vecVoteHashes = payee.GetVoteHashes(); BOOST_FOREACH(uint256& hash, vecVoteHashes) { - pnode->PushInventory(CInv(MSG_MASTERNODE_WINNER, hash)); + pnode->PushInventory(CInv(MSG_MASTERNODE_PAYMENT_VOTE, hash)); nInvCount++; } } } } - LogPrintf("CMasternodePayments::Sync -- Sent %d winners to peer %d\n", nInvCount, pnode->id); + LogPrintf("CMasternodePayments::Sync -- Sent %d votes to peer %d\n", nInvCount, pnode->id); pnode->PushMessage(NetMsgType::SYNCSTATUSCOUNT, MASTERNODE_SYNC_MNW, nInvCount); } @@ -820,7 +820,7 @@ void CMasternodePayments::RequestLowDataPaymentBlocks(CNode* pnode) // Low data block found, let's try to sync it uint256 hash; if(GetBlockHash(hash, it->first)) { - vToFetch.push_back(CInv(MSG_MASTERNODE_WINNER_BLOCK, hash)); + vToFetch.push_back(CInv(MSG_MASTERNODE_PAYMENT_BLOCK, hash)); } // We should not violate GETDATA rules if(vToFetch.size() == MAX_INV_SZ) { @@ -842,7 +842,7 @@ std::string CMasternodePayments::ToString() const { std::ostringstream info; - info << "Votes: " << (int)mapMasternodePayeeVotes.size() << + info << "Votes: " << (int)mapMasternodePaymentVotes.size() << ", Blocks: " << (int)mapMasternodeBlocks.size(); return info.str(); diff --git a/src/masternode-payments.h b/src/masternode-payments.h index 7f91f4ed2..3fa368336 100644 --- a/src/masternode-payments.h +++ b/src/masternode-payments.h @@ -13,14 +13,14 @@ #include "utilstrencodings.h" class CMasternodePayments; -class CMasternodePaymentWinner; +class CMasternodePaymentVote; class CMasternodeBlockPayees; static const int MNPAYMENTS_SIGNATURES_REQUIRED = 6; static const int MNPAYMENTS_SIGNATURES_TOTAL = 10; //! minimum peer version that can receive and send masternode payment messages, -// vote for masternode winner and be elected as a winner +// vote for masternode and be elected as a payment winner // V1 - Last protocol version before update // V2 - Newest protocol version static const int MIN_MASTERNODE_PAYMENT_PROTO_VERSION_1 = 70103; @@ -90,8 +90,8 @@ public: READWRITE(vecPayees); } - void AddPayee(CMasternodePaymentWinner winner); - bool GetPayee(CScript& payeeRet); + void AddPayee(const CMasternodePaymentVote& vote); + bool GetBestPayee(CScript& payeeRet); bool HasPayeeWithVotes(CScript payeeIn, int nVotesReq); bool IsTransactionValid(const CTransaction& txNew); @@ -99,8 +99,8 @@ public: std::string GetRequiredPaymentsString(); }; -// for storing the winning payments -class CMasternodePaymentWinner +// vote for the winning payment +class CMasternodePaymentVote { public: CTxIn vinMasternode; @@ -109,16 +109,18 @@ public: CScript payee; std::vector vchSig; - CMasternodePaymentWinner() : - vinMasternode(CTxIn()), + CMasternodePaymentVote() : + vinMasternode(), nBlockHeight(0), - payee(CScript()) + payee(), + vchSig() {} - CMasternodePaymentWinner(CTxIn vinMasternode, int nBlockHeight, CScript payee) : + CMasternodePaymentVote(CTxIn vinMasternode, int nBlockHeight, CScript payee) : vinMasternode(vinMasternode), nBlockHeight(nBlockHeight), - payee(payee) + payee(payee), + vchSig() {} ADD_SERIALIZE_METHODS; @@ -165,7 +167,7 @@ private: const CBlockIndex *pCurrentBlockIndex; public: - std::map mapMasternodePayeeVotes; + std::map mapMasternodePaymentVotes; std::map mapMasternodeBlocks; std::map mapMasternodesLastVote; @@ -175,13 +177,13 @@ public: template inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { - READWRITE(mapMasternodePayeeVotes); + READWRITE(mapMasternodePaymentVotes); READWRITE(mapMasternodeBlocks); } void Clear(); - bool AddWinningMasternode(CMasternodePaymentWinner& winner); + bool AddPaymentVote(const CMasternodePaymentVote& vote); bool ProcessBlock(int nBlockHeight); void Sync(CNode* node, int nCountNeeded); @@ -201,7 +203,7 @@ public: std::string ToString() const; int GetBlockCount() { return mapMasternodeBlocks.size(); } - int GetVoteCount() { return mapMasternodePayeeVotes.size(); } + int GetVoteCount() { return mapMasternodePaymentVotes.size(); } bool IsEnoughData(int nMnCount); int GetStorageLimit(); diff --git a/src/masternode-sync.cpp b/src/masternode-sync.cpp index 2364ebf12..0099efdb7 100644 --- a/src/masternode-sync.cpp +++ b/src/masternode-sync.cpp @@ -51,7 +51,7 @@ void CMasternodeSync::Reset() nRequestedMasternodeAttempt = 0; nTimeAssetSyncStarted = GetTime(); nTimeLastMasternodeList = GetTime(); - nTimeLastMasternodeWinner = GetTime(); + nTimeLastPaymentVote = GetTime(); nTimeLastBudgetItem = GetTime(); nTimeLastFailure = 0; nCountFailures = 0; @@ -88,7 +88,7 @@ void CMasternodeSync::SwitchToNextAsset() nRequestedMasternodeAssets = MASTERNODE_SYNC_LIST; break; case(MASTERNODE_SYNC_LIST): - nTimeLastMasternodeWinner = GetTime(); + nTimeLastPaymentVote = GetTime(); nRequestedMasternodeAssets = MASTERNODE_SYNC_MNW; break; case(MASTERNODE_SYNC_MNW): @@ -113,7 +113,7 @@ std::string CMasternodeSync::GetSyncStatus() case MASTERNODE_SYNC_INITIAL: return _("Synchronization pending..."); case MASTERNODE_SYNC_SPORKS: return _("Synchronizing sporks..."); case MASTERNODE_SYNC_LIST: return _("Synchronizing masternodes..."); - case MASTERNODE_SYNC_MNW: return _("Synchronizing masternode winners..."); + case MASTERNODE_SYNC_MNW: return _("Synchronizing masternode payments..."); case MASTERNODE_SYNC_GOVERNANCE: return _("Synchronizing governance objects..."); case MASTERNODE_SYNC_FAILED: return _("Synchronization failed"); case MASTERNODE_SYNC_FINISHED: return _("Synchronization finished"); @@ -144,7 +144,7 @@ void CMasternodeSync::ClearFulfilledRequest() BOOST_FOREACH(CNode* pnode, vNodes) { pnode->ClearFulfilledRequest("spork-sync"); - pnode->ClearFulfilledRequest("masternode-winner-sync"); + pnode->ClearFulfilledRequest("masternode-payment-sync"); pnode->ClearFulfilledRequest("governance-sync"); pnode->ClearFulfilledRequest("masternode-sync"); } @@ -209,7 +209,7 @@ void CMasternodeSync::ProcessTick() mnodeman.DsegUpdate(pnode); } else if(nRequestedMasternodeAttempt < 6) { int nMnCount = mnodeman.CountEnabled(); - pnode->PushMessage(NetMsgType::MNWINNERSSYNC, nMnCount); //sync payees + pnode->PushMessage(NetMsgType::MASTERNODEPAYMENTSYNC, nMnCount); //sync payment votes uint256 n = uint256(); pnode->PushMessage(NetMsgType::MNGOVERNANCESYNC, n); //sync masternode votes } else { @@ -275,13 +275,13 @@ void CMasternodeSync::ProcessTick() return; //this will cause each peer to get one request each six seconds for the various assets we need } - // MNW : SYNC MASTERNODE WINNERS FROM OTHER CONNECTED CLIENTS + // MNW : SYNC MASTERNODE PAYMENT VOTES FROM OTHER CONNECTED CLIENTS if(nRequestedMasternodeAssets == MASTERNODE_SYNC_MNW) { // check for timeout first // This might take a lot longer than MASTERNODE_SYNC_TIMEOUT_SECONDS minutes due to new blocks, // but that should be OK and it should timeout eventually. - if(nTimeLastMasternodeWinner < GetTime() - MASTERNODE_SYNC_TIMEOUT_SECONDS) { + if(nTimeLastPaymentVote < GetTime() - MASTERNODE_SYNC_TIMEOUT_SECONDS) { LogPrintf("CMasternodeSync::Process -- nTick %d nRequestedMasternodeAssets %d -- timeout\n", nTick, nRequestedMasternodeAssets); if (nRequestedMasternodeAttempt == 0) { LogPrintf("CMasternodeSync::Process -- WARNING: failed to sync %s\n", GetAssetName()); @@ -303,14 +303,14 @@ void CMasternodeSync::ProcessTick() } // only request once from each peer - if(pnode->HasFulfilledRequest("masternode-winner-sync")) continue; - pnode->FulfilledRequest("masternode-winner-sync"); + if(pnode->HasFulfilledRequest("masternode-payment-sync")) continue; + pnode->FulfilledRequest("masternode-payment-sync"); if(pnode->nVersion < mnpayments.GetMinMasternodePaymentsProto()) continue; nRequestedMasternodeAttempt++; - // ask node for all winners it has (new nodes will only return future winners) - pnode->PushMessage(NetMsgType::MNWINNERSSYNC, mnpayments.GetStorageLimit()); + // ask node for all payment votes it has (new nodes will only return votes for future payments) + pnode->PushMessage(NetMsgType::MASTERNODEPAYMENTSYNC, mnpayments.GetStorageLimit()); // ask node for missing pieces only (old nodes will not be asked) mnpayments.RequestLowDataPaymentBlocks(pnode); diff --git a/src/masternode-sync.h b/src/masternode-sync.h index c3ca85fda..710258f44 100644 --- a/src/masternode-sync.h +++ b/src/masternode-sync.h @@ -42,7 +42,7 @@ private: // Last time when we received some masternode asset ... int64_t nTimeLastMasternodeList; - int64_t nTimeLastMasternodeWinner; + int64_t nTimeLastPaymentVote; int64_t nTimeLastBudgetItem; // ... or failed int64_t nTimeLastFailure; @@ -60,7 +60,7 @@ public: CMasternodeSync() { Reset(); } void AddedMasternodeList() { nTimeLastMasternodeList = GetTime(); } - void AddedMasternodeWinner() { nTimeLastMasternodeWinner = GetTime(); } + void AddedPaymentVote() { nTimeLastPaymentVote = GetTime(); } void AddedBudgetItem(uint256 hash); bool IsFailed() { return nRequestedMasternodeAssets == MASTERNODE_SYNC_FAILED; } diff --git a/src/protocol.cpp b/src/protocol.cpp index 5981dc2f5..4cc640a52 100644 --- a/src/protocol.cpp +++ b/src/protocol.cpp @@ -40,9 +40,9 @@ const char *TXLOCKREQUEST="ix"; const char *TXLOCKVOTE="txlvote"; const char *SPORK="spork"; const char *GETSPORKS="getsporks"; -const char *MNWINNER="mnw"; -const char *MNWINNERBLOCK="mnwb"; -const char *MNWINNERSSYNC="mnget"; +const char *MASTERNODEPAYMENTVOTE="mnw"; +const char *MASTERNODEPAYMENTBLOCK="mnwb"; +const char *MASTERNODEPAYMENTSYNC="mnget"; const char *MNSCANERROR="mn scan error"; // not implemented const char *MNBUDGETSYNC="mnvs"; // depreciated since 12.1 const char *MNBUDGETVOTE="mvote"; // depreciated since 12.1 @@ -78,8 +78,8 @@ static const char* ppszTypeName[] = NetMsgType::TXLOCKREQUEST, NetMsgType::TXLOCKVOTE, NetMsgType::SPORK, - NetMsgType::MNWINNER, - NetMsgType::MNWINNERBLOCK, // reusing, was MNSCANERROR previousely, was NOT used in 12.0, we need this for inv + NetMsgType::MASTERNODEPAYMENTVOTE, + NetMsgType::MASTERNODEPAYMENTBLOCK, // reusing, was MNSCANERROR previousely, was NOT used in 12.0, we need this for inv NetMsgType::MNBUDGETVOTE, // depreciated since 12.1 NetMsgType::MNBUDGETPROPOSAL, // depreciated since 12.1 NetMsgType::MNBUDGETFINAL, // depreciated since 12.1 @@ -124,9 +124,9 @@ const static std::string allNetMessageTypes[] = { NetMsgType::TXLOCKVOTE, NetMsgType::SPORK, NetMsgType::GETSPORKS, - NetMsgType::MNWINNER, - // NetMsgType::MNWINNERBLOCK, // there is no message for this, only inventory - NetMsgType::MNWINNERSSYNC, + NetMsgType::MASTERNODEPAYMENTVOTE, + // NetMsgType::MASTERNODEPAYMENTBLOCK, // there is no message for this, only inventory + NetMsgType::MASTERNODEPAYMENTSYNC, NetMsgType::MNANNOUNCE, NetMsgType::MNPING, NetMsgType::DSACCEPT, diff --git a/src/protocol.h b/src/protocol.h index e2107aebc..868e3924d 100644 --- a/src/protocol.h +++ b/src/protocol.h @@ -226,8 +226,8 @@ extern const char *TXLOCKREQUEST; extern const char *TXLOCKVOTE; extern const char *SPORK; extern const char *GETSPORKS; -extern const char *MNWINNER; -extern const char *MNWINNERSSYNC; +extern const char *MASTERNODEPAYMENTVOTE; +extern const char *MASTERNODEPAYMENTSYNC; extern const char *MNANNOUNCE; extern const char *MNPING; extern const char *DSACCEPT; @@ -345,8 +345,8 @@ enum { MSG_TXLOCK_REQUEST, MSG_TXLOCK_VOTE, MSG_SPORK, - MSG_MASTERNODE_WINNER, - MSG_MASTERNODE_WINNER_BLOCK, // reusing, was MSG_MASTERNODE_SCANNING_ERROR previousely, was NOT used in 12.0 + MSG_MASTERNODE_PAYMENT_VOTE, + MSG_MASTERNODE_PAYMENT_BLOCK, // reusing, was MSG_MASTERNODE_SCANNING_ERROR previousely, was NOT used in 12.0 MSG_BUDGET_VOTE, // depreciated since 12.1 MSG_BUDGET_PROPOSAL, // depreciated since 12.1 MSG_BUDGET_FINALIZED, // depreciated since 12.1