masternode-payments.h

Go to the documentation of this file.

// Copyright (c) 2014-2015 The Dash developers
// Copyright (c) 2015-2018 The PIVX developers
// Copyright (c) 2018-2020 The DAPS Project developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef MASTERNODE_PAYMENTS_H
#define MASTERNODE_PAYMENTS_H
 
#include "key.h"
#include "main.h"
#include "masternode.h"
 
 
extern RecursiveMutex cs_vecPayments;
extern RecursiveMutex cs_mapMasternodeBlocks;
extern RecursiveMutex cs_mapMasternodePayeeVotes;
 
class CMasternodePayments;
class CMasternodePaymentWinner;
class CMasternodeBlockPayees;
 
extern CMasternodePayments masternodePayments;
 
#define MNPAYMENTS_SIGNATURES_REQUIRED 6
#define MNPAYMENTS_SIGNATURES_TOTAL 10
 
void ProcessMessageMasternodePayments(CNode* pfrom, std::string& strCommand, CDataStream& vRecv);
bool IsBlockPayeeValid(const CBlock& block, int nBlockHeight);
std::string GetRequiredPaymentsString(int nBlockHeight);
bool IsBlockValueValid(int nHeight, CAmount nExpectedValue, CAmount nMinted);
bool FillBlockPayee(CMutableTransaction& txNew, CAmount nFees, bool fProofOfStake);
 
void DumpMasternodePayments();
 
class CMasternodePaymentDB
{
private:
    fs::path pathDB;
    std::string strMagicMessage;
 
public:
    enum ReadResult {
        Ok,
        FileError,
        HashReadError,
        IncorrectHash,
        IncorrectMagicMessage,
        IncorrectMagicNumber,
        IncorrectFormat
    };
 
    CMasternodePaymentDB();
    bool Write(const CMasternodePayments& objToSave);
    ReadResult Read(CMasternodePayments& objToLoad, bool fDryRun = false);
};
 
class CMasternodePayee
{
public:
    int nVotes;
    std::vector<unsigned char> masternodeStealthAddress;
 
    CMasternodePayee()
    {
        nVotes = 0;
    }
 
    CMasternodePayee(int nVotesIn, std::vector<unsigned char> masternodeStealthAddress)
    {
        nVotes = nVotesIn;
        this->masternodeStealthAddress = masternodeStealthAddress;
    }
 
    ADD_SERIALIZE_METHODS;
 
    template <typename Stream, typename Operation>
    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion)
    {
        READWRITE(nVotes);
        READWRITE(masternodeStealthAddress);
    }
};
 
// Keep track of votes for payees from masternodes
class CMasternodeBlockPayees
{
public:
    int nBlockHeight;
    std::vector<CMasternodePayee> vecPayments;
 
    CMasternodeBlockPayees()
    {
        nBlockHeight = 0;
        vecPayments.clear();
    }
    CMasternodeBlockPayees(int nBlockHeightIn)
    {
        nBlockHeight = nBlockHeightIn;
        vecPayments.clear();
    }
 
    void AddPayee(int nIncrement, std::vector<unsigned char> masternodeStealthAddress)
    {
        LOCK(cs_vecPayments);
 
        for (CMasternodePayee& payee : vecPayments) {
            if (payee.masternodeStealthAddress == masternodeStealthAddress) {
                payee.nVotes += nIncrement;
                return;
            }
        }
 
        CMasternodePayee c(nIncrement, masternodeStealthAddress);
        vecPayments.push_back(c);
    }
 
    bool GetPayee(std::vector<unsigned char>& payee)
    {
        LOCK(cs_vecPayments);
 
        int nVotes = -1;
        for (CMasternodePayee& p : vecPayments) {
            if (p.nVotes > nVotes) {
                payee = p.masternodeStealthAddress;
                nVotes = p.nVotes;
            }
        }
 
        return (nVotes > -1);
    }
 
    bool HasPayeeWithVotes(std::vector<unsigned char> payee, int nVotesReq)
    {
        LOCK(cs_vecPayments);
 
        for (CMasternodePayee& p : vecPayments) {
            if (p.nVotes >= nVotesReq && p.masternodeStealthAddress == payee) return true;
        }
 
        return false;
    }
 
    bool IsTransactionValid(const CTransaction& txNew);
    std::string GetRequiredPaymentsString();
 
    ADD_SERIALIZE_METHODS;
 
    template <typename Stream, typename Operation>
    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion)
    {
        READWRITE(nBlockHeight);
        READWRITE(vecPayments);
    }
};
 
// for storing the winning payments
class CMasternodePaymentWinner
{
public:
    CTxIn vinMasternode;
 
    int nBlockHeight;
    std::vector<unsigned char> payee;//masternode stealth public address
    std::vector<unsigned char> vchSig;
 
    CMasternodePaymentWinner()
    {
        nBlockHeight = 0;
        vinMasternode = CTxIn();
    }
 
    CMasternodePaymentWinner(CTxIn vinIn)
    {
        nBlockHeight = 0;
        vinMasternode = vinIn;
        payee = vinIn.masternodeStealthAddress;
    }
 
    uint256 GetHash()
    {
        CHashWriter ss(SER_GETHASH, PROTOCOL_VERSION);
        ss << payee;
        ss << nBlockHeight;
        ss << vinMasternode.prevout;
 
        return ss.GetHash();
    }
 
    bool Sign(CKey& keyMasternode, CPubKey& pubKeyMasternode);
    bool IsValid(CNode* pnode, std::string& strError);
    bool SignatureValid();
    void Relay();
 
    void AddPayee(std::vector<unsigned char> payeeIn)
    {
        payee = payeeIn;
    }
 
 
    ADD_SERIALIZE_METHODS;
 
    template <typename Stream, typename Operation>
    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion)
    {
        READWRITE(vinMasternode);
        READWRITE(nBlockHeight);
        READWRITE(payee);
        READWRITE(vchSig);
    }
 
    std::string ToString()
    {
        std::string s(payee.begin(), payee.end());
        std::string ret = "";
        ret += vinMasternode.ToString();
        ret += ", " + std::to_string(nBlockHeight);
        ret += ", " + s;
        ret += ", " + std::to_string((int)vchSig.size());
        return ret;
    }
};
 
//
// Masternode Payments Class
// Keeps track of who should get paid for which blocks
//
 
class CMasternodePayments
{
private:
    int nSyncedFromPeer;
    int nLastBlockHeight;
 
public:
    std::map<uint256, CMasternodePaymentWinner> mapMasternodePayeeVotes;
    std::map<int, CMasternodeBlockPayees> mapMasternodeBlocks;
    std::map<uint256, int> mapMasternodesLastVote; //prevout.hash + prevout.n, nBlockHeight
 
    CMasternodePayments()
    {
        nSyncedFromPeer = 0;
        nLastBlockHeight = 0;
    }
 
    void Clear()
    {
        LOCK2(cs_mapMasternodeBlocks, cs_mapMasternodePayeeVotes);
        mapMasternodeBlocks.clear();
        mapMasternodePayeeVotes.clear();
    }
 
    bool AddWinningMasternode(CMasternodePaymentWinner& winner);
    bool ProcessBlock(int nBlockHeight);
 
    void Sync(CNode* node, int nCountNeeded);
    void CleanPaymentList();
    int LastPayment(CMasternode& mn);
 
    bool GetBlockPayee(int nBlockHeight, std::vector<unsigned char>& payee);
    bool IsTransactionValid(const CTransaction& txNew, int nBlockHeight);
    bool IsScheduled(CMasternode& mn, int nNotBlockHeight);
 
    bool CanVote(COutPoint outMasternode, int nBlockHeight)
    {
        LOCK(cs_mapMasternodePayeeVotes);
 
        if (mapMasternodesLastVote.count(outMasternode.hash + outMasternode.n)) {
            if (mapMasternodesLastVote[outMasternode.hash + outMasternode.n] == nBlockHeight) {
                return false;
            }
        }
 
        //record this masternode voted
        mapMasternodesLastVote[outMasternode.hash + outMasternode.n] = nBlockHeight;
        return true;
    }
 
    int GetMinMasternodePaymentsProto();
    void ProcessMessageMasternodePayments(CNode* pfrom, std::string& strCommand, CDataStream& vRecv);
    std::string GetRequiredPaymentsString(int nBlockHeight);
    bool FillBlockPayee(CMutableTransaction& txNew, int64_t nFees, bool fProofOfStake);
    std::string ToString() const;
    int GetOldestBlock();
    int GetNewestBlock();
 
    ADD_SERIALIZE_METHODS;
 
    template <typename Stream, typename Operation>
    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion)
    {
        READWRITE(mapMasternodePayeeVotes);
        READWRITE(mapMasternodeBlocks);
    }
};
 
 
#endif