622 lines
17 KiB
C++
622 lines
17 KiB
C++
// Copyright (c) 2014-2015 The Dash developers
|
|
// Distributed under the MIT/X11 software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#include "masternode-budget.h"
|
|
#include "masternode.h"
|
|
#include "darksend.h"
|
|
#include "masternodeman.h"
|
|
#include "util.h"
|
|
#include "addrman.h"
|
|
#include <boost/filesystem.hpp>
|
|
#include <boost/lexical_cast.hpp>
|
|
|
|
CBudgetManager budget;
|
|
CCriticalSection cs_budget;
|
|
|
|
//
|
|
// CBudgetDB
|
|
//
|
|
|
|
CBudgetDB::CBudgetDB()
|
|
{
|
|
pathDB = GetDataDir() / "budget.dat";
|
|
strMagicMessage = "MasternodeBudget";
|
|
}
|
|
|
|
bool CBudgetDB::Write(const CBudgetManager& budgetToSave)
|
|
{
|
|
int64_t nStart = GetTimeMillis();
|
|
|
|
// serialize, checksum data up to that point, then append checksum
|
|
CDataStream ssBudget(SER_DISK, CLIENT_VERSION);
|
|
ssBudget << strMagicMessage; // masternode cache file specific magic message
|
|
ssBudget << FLATDATA(Params().MessageStart()); // network specific magic number
|
|
ssBudget << budgetToSave;
|
|
uint256 hash = Hash(ssBudget.begin(), ssBudget.end());
|
|
ssBudget << hash;
|
|
|
|
// open output file, and associate with CAutoFile
|
|
FILE *file = fopen(pathDB.string().c_str(), "wb");
|
|
CAutoFile fileout(file, SER_DISK, CLIENT_VERSION);
|
|
if (fileout.IsNull())
|
|
return error("%s : Failed to open file %s", __func__, pathDB.string());
|
|
|
|
// Write and commit header, data
|
|
try {
|
|
fileout << ssBudget;
|
|
}
|
|
catch (std::exception &e) {
|
|
return error("%s : Serialize or I/O error - %s", __func__, e.what());
|
|
}
|
|
// FileCommit(fileout);
|
|
fileout.fclose();
|
|
|
|
LogPrintf("Written info to mncache.dat %dms\n", GetTimeMillis() - nStart);
|
|
//LogPrintf(" %s\n", budgetToSave.ToString().c_str());
|
|
|
|
return true;
|
|
}
|
|
|
|
CBudgetDB::ReadResult CBudgetDB::Read(CBudgetManager& budgetToLoad)
|
|
{
|
|
int64_t nStart = GetTimeMillis();
|
|
// open input file, and associate with CAutoFile
|
|
FILE *file = fopen(pathDB.string().c_str(), "rb");
|
|
CAutoFile filein(file, SER_DISK, CLIENT_VERSION);
|
|
if (filein.IsNull())
|
|
{
|
|
error("%s : Failed to open file %s", __func__, pathDB.string());
|
|
return FileError;
|
|
}
|
|
|
|
// use file size to size memory buffer
|
|
int fileSize = boost::filesystem::file_size(pathDB);
|
|
int dataSize = fileSize - sizeof(uint256);
|
|
// Don't try to resize to a negative number if file is small
|
|
if (dataSize < 0)
|
|
dataSize = 0;
|
|
vector<unsigned char> vchData;
|
|
vchData.resize(dataSize);
|
|
uint256 hashIn;
|
|
|
|
// read data and checksum from file
|
|
try {
|
|
filein.read((char *)&vchData[0], dataSize);
|
|
filein >> hashIn;
|
|
}
|
|
catch (std::exception &e) {
|
|
error("%s : Deserialize or I/O error - %s", __func__, e.what());
|
|
return HashReadError;
|
|
}
|
|
filein.fclose();
|
|
|
|
CDataStream ssBudget(vchData, SER_DISK, CLIENT_VERSION);
|
|
|
|
// verify stored checksum matches input data
|
|
uint256 hashTmp = Hash(ssBudget.begin(), ssBudget.end());
|
|
if (hashIn != hashTmp)
|
|
{
|
|
error("%s : Checksum mismatch, data corrupted", __func__);
|
|
return IncorrectHash;
|
|
}
|
|
|
|
|
|
unsigned char pchMsgTmp[4];
|
|
std::string strMagicMessageTmp;
|
|
try {
|
|
// de-serialize file header (masternode cache file specific magic message) and ..
|
|
ssBudget >> strMagicMessageTmp;
|
|
|
|
// ... verify the message matches predefined one
|
|
if (strMagicMessage != strMagicMessageTmp)
|
|
{
|
|
error("%s : Invalid masternode cache magic message", __func__);
|
|
return IncorrectMagicMessage;
|
|
}
|
|
|
|
|
|
// de-serialize file header (network specific magic number) and ..
|
|
ssBudget >> FLATDATA(pchMsgTmp);
|
|
|
|
// ... verify the network matches ours
|
|
if (memcmp(pchMsgTmp, Params().MessageStart(), sizeof(pchMsgTmp)))
|
|
{
|
|
error("%s : Invalid network magic number", __func__);
|
|
return IncorrectMagicNumber;
|
|
}
|
|
|
|
// de-serialize data into CBudgetManager object
|
|
ssBudget >> budgetToLoad;
|
|
}
|
|
catch (std::exception &e) {
|
|
budgetToLoad.Clear();
|
|
error("%s : Deserialize or I/O error - %s", __func__, e.what());
|
|
return IncorrectFormat;
|
|
}
|
|
|
|
|
|
budgetToLoad.CheckAndRemove(); // clean out expired
|
|
LogPrintf("Loaded info from mncache.dat %dms\n", GetTimeMillis() - nStart);
|
|
LogPrintf(" %s\n", budgetToLoad.ToString());
|
|
|
|
return Ok;
|
|
}
|
|
|
|
void DumpBudgets()
|
|
{
|
|
int64_t nStart = GetTimeMillis();
|
|
|
|
CBudgetDB mndb;
|
|
CBudgetManager tempbudget;
|
|
|
|
LogPrintf("Verifying mncache.dat format...\n");
|
|
CBudgetDB::ReadResult readResult = mndb.Read(tempbudget);
|
|
// there was an error and it was not an error on file openning => do not proceed
|
|
if (readResult == CBudgetDB::FileError)
|
|
LogPrintf("Missing masternode cache file - mncache.dat, will try to recreate\n");
|
|
else if (readResult != CBudgetDB::Ok)
|
|
{
|
|
LogPrintf("Error reading mncache.dat: ");
|
|
if(readResult == CBudgetDB::IncorrectFormat)
|
|
LogPrintf("magic is ok but data has invalid format, will try to recreate\n");
|
|
else
|
|
{
|
|
LogPrintf("file format is unknown or invalid, please fix it manually\n");
|
|
return;
|
|
}
|
|
}
|
|
LogPrintf("Writting info to mncache.dat...\n");
|
|
mndb.Write(budget);
|
|
|
|
LogPrintf("Masternode dump finished %dms\n", GetTimeMillis() - nStart);
|
|
}
|
|
|
|
|
|
|
|
CBudgetVote::CBudgetVote()
|
|
{
|
|
vin = CTxIn();
|
|
nVote = VOTE_ABSTAIN;
|
|
strProposalName = "unknown";
|
|
nBlockStart = 0;
|
|
nBlockEnd = 0;
|
|
nAmount = 0;
|
|
nTime = 0;
|
|
}
|
|
|
|
CBudgetVote::CBudgetVote(CTxIn vinIn, std::string strProposalNameIn, int nBlockStartIn, int nBlockEndIn, CScript addressIn, CAmount nAmountIn, int nVoteIn)
|
|
{
|
|
vin = vinIn;
|
|
strProposalName = strProposalNameIn;
|
|
nBlockStart = nBlockStartIn;
|
|
nBlockEnd = nBlockEndIn;
|
|
address = addressIn;
|
|
nAmount = nAmountIn;
|
|
nVote = nVoteIn;
|
|
nTime = GetAdjustedTime();
|
|
}
|
|
|
|
|
|
CBudgetVote::CBudgetVote(CTxIn vinIn, std::string strProposalNameIn, int nPaymentCount, CScript addressIn, CAmount nAmountIn, int nVoteIn)
|
|
{
|
|
vin = vinIn;
|
|
strProposalName = strProposalNameIn;
|
|
|
|
CBlockIndex* pindexPrev = chainActive.Tip();
|
|
if(pindexPrev != NULL)
|
|
{
|
|
//calculate beginning of payment cycle
|
|
nBlockStart = (pindexPrev->nHeight-(pindexPrev->nHeight % PAYMENT_CYCLE_BLOCKS));
|
|
//calculate the end of the cycle for this vote
|
|
nBlockEnd = nBlockStart + (PAYMENT_CYCLE_BLOCKS*nPaymentCount);
|
|
// These numbers don't require being all the same across the network due to the way
|
|
// they are sampled from the votes.
|
|
} else {
|
|
nBlockStart = 0;
|
|
nBlockEnd = 0;
|
|
}
|
|
|
|
address = addressIn;
|
|
nAmount = nAmountIn;
|
|
nVote = nVoteIn;
|
|
nTime = GetAdjustedTime();
|
|
}
|
|
|
|
|
|
bool CBudgetVote::Sign(CKey& keyMasternode, CPubKey& pubKeyMasternode)
|
|
{
|
|
// Choose coins to use
|
|
CPubKey pubKeyCollateralAddress;
|
|
CKey keyCollateralAddress;
|
|
|
|
std::string errorMessage;
|
|
std::string strMessage = vin.ToString() + boost::lexical_cast<std::string>(nVote) + boost::lexical_cast<std::string>(nTime);
|
|
|
|
if(!darkSendSigner.SignMessage(strMessage, errorMessage, vchSig, keyMasternode))
|
|
return(" Error upon calling SignMessage");
|
|
|
|
if(!darkSendSigner.VerifyMessage(pubKeyMasternode, vchSig, strMessage, errorMessage))
|
|
return(" Error upon calling VerifyMessage");
|
|
|
|
return true;
|
|
}
|
|
|
|
void CBudgetVote::Relay()
|
|
{
|
|
CInv inv(MSG_MASTERNODE_VOTE, GetHash());
|
|
|
|
vector<CInv> vInv;
|
|
vInv.push_back(inv);
|
|
LOCK(cs_vNodes);
|
|
BOOST_FOREACH(CNode* pnode, vNodes){
|
|
pnode->PushMessage("inv", vInv);
|
|
}
|
|
}
|
|
|
|
uint256 GetBudgetProposalHash(std::string strProposalName)
|
|
{
|
|
return Hash(strProposalName.begin(), strProposalName.end());
|
|
}
|
|
|
|
|
|
void CBudgetManager::ProcessMessage(CNode* pfrom, std::string& strCommand, CDataStream& vRecv)
|
|
{
|
|
// lite mode is not supported
|
|
if(IsInitialBlockDownload()) return;
|
|
|
|
LOCK(cs_budget);
|
|
|
|
if (strCommand == "mnvs") { //Masternode vote sync
|
|
if(pfrom->HasFulfilledRequest("mnvs")) {
|
|
LogPrintf("mnvs - peer already asked me for the list\n");
|
|
Misbehaving(pfrom->GetId(), 20);
|
|
return;
|
|
}
|
|
|
|
pfrom->FulfilledRequest("mnvs");
|
|
budget.Sync(pfrom);
|
|
LogPrintf("mnvs - Sent Masternode votes to %s\n", pfrom->addr.ToString().c_str());
|
|
}
|
|
|
|
if (strCommand == "mvote") { //Masternode Vote
|
|
CBudgetVote vote;
|
|
vRecv >> vote;
|
|
if(!vote.SignatureValid()){
|
|
LogPrintf("mvote - signature invalid\n");
|
|
Misbehaving(pfrom->GetId(), 20);
|
|
return;
|
|
}
|
|
|
|
CMasternode* pmn = mnodeman.Find(vote.vin);
|
|
if(pmn == NULL) {
|
|
LogPrintf("mvote - unknown masternode - vin:%s \n", pmn->vin.ToString().c_str());
|
|
return;
|
|
}
|
|
|
|
if(pmn->nVotedTimes < 100){
|
|
budget.AddOrUpdateProposal(vote);
|
|
vote.Relay();
|
|
pmn->nVotedTimes++;
|
|
} else {
|
|
LogPrintf("mvote - masternode can't vote again - vin:%s \n", pmn->vin.ToString().c_str());
|
|
return;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
bool CBudgetVote::SignatureValid()
|
|
{
|
|
std::string errorMessage;
|
|
std::string strMessage = vin.prevout.ToStringShort() + boost::lexical_cast<std::string>(nVote) + boost::lexical_cast<std::string>(nTime);
|
|
|
|
CMasternode* pmn = mnodeman.Find(vin);
|
|
|
|
if(pmn == NULL)
|
|
{
|
|
LogPrintf("CBudgetVote::SignatureValid() - Unknown Masternode\n");
|
|
return false;
|
|
}
|
|
|
|
CScript pubkey;
|
|
pubkey = GetScriptForDestination(pmn->pubkey2.GetID());
|
|
CTxDestination address1;
|
|
ExtractDestination(pubkey, address1);
|
|
CBitcoinAddress address2(address1);
|
|
|
|
if(!darkSendSigner.VerifyMessage(pmn->pubkey2, vchSig, strMessage, errorMessage)) {
|
|
LogPrintf("CBudgetVote::SignatureValid() - Verify message failed\n");
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void CBudgetManager::AddOrUpdateProposal(CBudgetVote& vote)
|
|
{
|
|
LOCK(cs);
|
|
|
|
uint256 hash = GetBudgetProposalHash(vote.strProposalName);
|
|
|
|
if(!mapProposals.count(hash)){
|
|
CBudgetProposal prop(vote.strProposalName);
|
|
//mapProposals.insert(make_pair(hash, prop));
|
|
return;
|
|
}
|
|
|
|
mapProposals[hash].AddOrUpdateVote(vote);
|
|
}
|
|
|
|
void CBudgetProposal::AddOrUpdateVote(CBudgetVote& vote)
|
|
{
|
|
LOCK(cs);
|
|
|
|
uint256 hash = vote.vin.prevout.GetHash();
|
|
|
|
if(!mapVotes.count(hash)){
|
|
mapVotes.insert(make_pair(hash, vote));
|
|
return;
|
|
}
|
|
|
|
mapVotes[hash] = vote;
|
|
}
|
|
|
|
inline void CBudgetManager::NewBlock()
|
|
{
|
|
//this function should be called 1/6 blocks, allowing up to 100 votes per day on all proposals
|
|
if(chainActive.Height() % 6 != 0) return;
|
|
|
|
mnodeman.DecrementVotedTimes();
|
|
}
|
|
|
|
CBudgetProposal *CBudgetManager::Find(const std::string &strProposalName)
|
|
{
|
|
uint256 hash = GetBudgetProposalHash(strProposalName);
|
|
|
|
if(mapProposals.count(hash)){
|
|
return &mapProposals[hash];
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
CBudgetProposal::CBudgetProposal()
|
|
{
|
|
strProposalName = "";
|
|
}
|
|
|
|
CBudgetProposal::CBudgetProposal(const CBudgetProposal& other)
|
|
{
|
|
strProposalName = other.strProposalName;
|
|
}
|
|
|
|
CBudgetProposal::CBudgetProposal(std::string strProposalNameIn)
|
|
{
|
|
strProposalName = strProposalNameIn;
|
|
}
|
|
|
|
std::string CBudgetProposal::GetName()
|
|
{
|
|
return strProposalName;
|
|
}
|
|
|
|
int CBudgetProposal::GetBlockStart()
|
|
{
|
|
std::map<int, int> mapList;
|
|
|
|
std::map<uint256, CBudgetVote>::iterator it = mapVotes.begin();
|
|
|
|
while(it != mapVotes.end()) {
|
|
if ((*it).second.nVote != VOTE_YES) continue;
|
|
|
|
if(mapList.count((*it).second.nBlockStart)){
|
|
mapList[(*it).second.nBlockStart]++;
|
|
} else {
|
|
mapList[(*it).second.nBlockStart] = 1;
|
|
}
|
|
}
|
|
|
|
//sort the map and grab the highest count item
|
|
std::vector<std::pair<int,int> > vecList(mapList.begin(), mapList.end());
|
|
std::sort(vecList.begin(),vecList.end());
|
|
return vecList.begin()->second;
|
|
}
|
|
|
|
int CBudgetProposal::GetBlockEnd()
|
|
{
|
|
std::map<int, int> mapList;
|
|
|
|
std::map<uint256, CBudgetVote>::iterator it = mapVotes.begin();
|
|
|
|
while(it != mapVotes.end()) {
|
|
if ((*it).second.nVote != VOTE_YES) continue;
|
|
|
|
if(mapList.count((*it).second.nBlockEnd)){
|
|
mapList[(*it).second.nBlockEnd]++;
|
|
} else {
|
|
mapList[(*it).second.nBlockEnd] = 1;
|
|
}
|
|
}
|
|
|
|
//sort the map and grab the highest count item
|
|
std::vector<std::pair<int,int> > vecList(mapList.begin(), mapList.end());
|
|
std::sort(vecList.begin(),vecList.end());
|
|
return vecList.begin()->second;
|
|
}
|
|
|
|
int64_t CBudgetProposal::GetAmount()
|
|
{
|
|
std::map<int64_t, int> mapList;
|
|
|
|
std::map<uint256, CBudgetVote>::iterator it = mapVotes.begin();
|
|
|
|
while(it != mapVotes.end()) {
|
|
if ((*it).second.nVote != VOTE_YES) continue;
|
|
|
|
if(mapList.count((*it).second.nAmount)){
|
|
mapList[(*it).second.nAmount]++;
|
|
} else {
|
|
mapList[(*it).second.nAmount] = 1;
|
|
}
|
|
}
|
|
|
|
//sort the map and grab the highest count item
|
|
std::vector<std::pair<int64_t,int> > vecList(mapList.begin(), mapList.end());
|
|
std::sort(vecList.begin(),vecList.end());
|
|
return vecList.begin()->second;
|
|
}
|
|
|
|
CScript CBudgetProposal::GetPayee()
|
|
{
|
|
std::map<CScript, int> mapList;
|
|
|
|
std::map<uint256, CBudgetVote>::iterator it = mapVotes.begin();
|
|
|
|
while(it != mapVotes.end()) {
|
|
if ((*it).second.nVote != VOTE_YES) continue;
|
|
|
|
CTxDestination address1;
|
|
ExtractDestination((*it).second.address, address1);
|
|
CBitcoinAddress address2(address1);
|
|
|
|
if(mapList.count((*it).second.address)){
|
|
mapList[(*it).second.address]++;
|
|
} else {
|
|
mapList[(*it).second.address] = 1;
|
|
}
|
|
|
|
}
|
|
|
|
//sort the map and grab the highest count item
|
|
std::vector<std::pair<CScript,int> > vecList(mapList.begin(), mapList.end());
|
|
std::sort(vecList.begin(),vecList.end());
|
|
return vecList.begin()->second;
|
|
}
|
|
|
|
double CBudgetProposal::GetRatio()
|
|
{
|
|
int yeas = 0;
|
|
int nays = 0;
|
|
|
|
std::map<uint256, CBudgetVote>::iterator it = mapVotes.begin();
|
|
|
|
while(it != mapVotes.end()) {
|
|
if ((*it).second.nVote == VOTE_YES) yeas++;
|
|
if ((*it).second.nVote == VOTE_NO) nays++;
|
|
}
|
|
|
|
return ((double)yeas / (double)yeas+nays);
|
|
}
|
|
|
|
int CBudgetProposal::GetYeas()
|
|
{
|
|
int ret = 0;
|
|
|
|
std::map<uint256, CBudgetVote>::iterator it = mapVotes.begin();
|
|
while(it != mapVotes.end())
|
|
if ((*it).second.nVote == VOTE_YES) ret++;
|
|
|
|
return ret;
|
|
}
|
|
|
|
int CBudgetProposal::GetNays()
|
|
{
|
|
int ret = 0;
|
|
|
|
std::map<uint256, CBudgetVote>::iterator it = mapVotes.begin();
|
|
while(it != mapVotes.end())
|
|
if ((*it).second.nVote == VOTE_NO) ret++;
|
|
|
|
return ret;
|
|
}
|
|
|
|
int CBudgetProposal::GetAbstains()
|
|
{
|
|
int ret = 0;
|
|
|
|
std::map<uint256, CBudgetVote>::iterator it = mapVotes.begin();
|
|
while(it != mapVotes.end())
|
|
if ((*it).second.nVote == VOTE_ABSTAIN) ret++;
|
|
|
|
return ret;
|
|
}
|
|
|
|
bool CBudgetManager::IsBudgetPaymentBlock(int nHeight)
|
|
{
|
|
if(nHeight > 158000+((576*30)*15)) return (nHeight % 7) == 0 ; // 417200 - 57.5% - 2016-02-08 -- 12.5% of blocks
|
|
if(nHeight > 158000+((576*30)*13)) return (nHeight % 10) == 0 ; // 382640 - 55.0% - 2015-12-07 -- 10.0% of blocks
|
|
if(nHeight > 158000+((576*30)*11)) return (nHeight % 13) == 0 ; // 348080 - 52.5% - 2015-10-05 -- 7.5 of blocks
|
|
if(nHeight > 158000+((576*30)* 9)) return (nHeight % 20) == 0 ; // 313520 - 50.0% - 2015-08-03 -- 5.0% of blocks
|
|
if(nHeight > 158000+((576*30)* 7)) return (nHeight % 40) == 0 ; // 278960 - 47.5% - 2015-06-01 -- 2.5% of blocks
|
|
|
|
return false;
|
|
}
|
|
|
|
int64_t CBudgetManager::GetTotalBudget()
|
|
{
|
|
if(chainActive.Tip() == NULL) return 0;
|
|
|
|
const CBlockIndex* pindex = chainActive.Tip();
|
|
return (GetBlockValue(pindex->pprev->nBits, pindex->pprev->nHeight, 0)/100)*15;
|
|
}
|
|
|
|
//Need to review this function
|
|
std::vector<CBudgetProposal*> CBudgetManager::GetBudget()
|
|
{
|
|
// ------- Sort budgets by Yes Count
|
|
|
|
std::map<uint256, int> mapList;
|
|
|
|
std::map<uint256, CBudgetProposal>::iterator it = mapProposals.begin();
|
|
while(it != mapProposals.end())
|
|
mapList[GetBudgetProposalHash((*it).second.strProposalName)] = (*it).second.GetYeas();
|
|
|
|
//sort the map and grab the highest count item
|
|
std::vector<std::pair<uint256,int> > vecList(mapList.begin(), mapList.end());
|
|
std::sort(vecList.begin(),vecList.end());
|
|
|
|
// ------- Grab The Budgets In Order
|
|
|
|
std::vector<CBudgetProposal*> ret;
|
|
|
|
int64_t nBudgetAllocated = 0;
|
|
int64_t nTotalBudget = GetTotalBudget();
|
|
|
|
std::map<uint256, CBudgetProposal>::iterator it2 = mapProposals.begin();
|
|
while(it2 != mapProposals.end())
|
|
{
|
|
CBudgetProposal prop = (*it2).second;
|
|
|
|
if(nTotalBudget == nBudgetAllocated){
|
|
prop.SetAllotted(0);
|
|
} else if(prop.GetAmount() + nBudgetAllocated <= nTotalBudget) {
|
|
prop.SetAllotted(prop.GetAmount());
|
|
nBudgetAllocated += prop.GetAmount();
|
|
} else {
|
|
//couldn't pay for the entire budget, so it'll be partially paid.
|
|
prop.SetAllotted(nTotalBudget - nBudgetAllocated);
|
|
nBudgetAllocated = nTotalBudget;
|
|
}
|
|
|
|
ret.push_back(&prop);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
void CBudgetManager::Sync(CNode* node)
|
|
{
|
|
std::map<uint256, CBudgetProposal>::iterator it = mapProposals.begin();
|
|
while(it != mapProposals.end())
|
|
(*it).second.Sync(node);
|
|
|
|
}
|
|
|
|
void CBudgetProposal::Sync(CNode* node)
|
|
{
|
|
std::map<uint256, CBudgetVote>::iterator it = mapVotes.begin();
|
|
while(it != mapVotes.end())
|
|
node->PushMessage("mvote", (*it).second);
|
|
} |