spork.h

Go to the documentation of this file.

// Copyright (c) 2014-2019 The Dash Core developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#ifndef SPORK_H
#define SPORK_H

#include <hash.h>
#include <net.h>
#include <utilstrencodings.h>
#include <key.h>

#include <unordered_map>
#include <unordered_set>

class CSporkMessage;
class CSporkManager;

/*
    Don't ever reuse these IDs for other sporks
    - This would result in old clients getting confused about which spork is for what
*/
enum SporkId : int32_t {
    SPORK_2_INSTANTSEND_ENABLED                            = 10001,
    SPORK_3_INSTANTSEND_BLOCK_FILTERING                    = 10002,
    SPORK_9_SUPERBLOCKS_ENABLED                            = 10008,
    SPORK_17_QUORUM_DKG_ENABLED                            = 10016,
    SPORK_19_CHAINLOCKS_ENABLED                            = 10018,
    SPORK_21_QUORUM_ALL_CONNECTED                          = 10020,
    SPORK_22_PS_MORE_PARTICIPANTS                          = 10021,

    SPORK_INVALID                                          = -1,
};
template<> struct is_serializable_enum<SporkId> : std::true_type {};

namespace std
{
    template<> struct hash<SporkId>
    {
        std::size_t operator()(SporkId const& id) const noexcept
        {
            return std::hash<int>{}(id);
        }
    };
}

struct CSporkDef
{
    SporkId sporkId{SPORK_INVALID};
    int64_t defaultValue{0};
    std::string name;
};

extern std::vector<CSporkDef> sporkDefs;
extern CSporkManager sporkManager;

class CSporkMessage
{
private:
    std::vector<unsigned char> vchSig;

public:
    SporkId nSporkID;
    int64_t nValue;
    int64_t nTimeSigned;

    CSporkMessage(SporkId nSporkID, int64_t nValue, int64_t nTimeSigned) :
        nSporkID(nSporkID),
        nValue(nValue),
        nTimeSigned(nTimeSigned)
        {}

    CSporkMessage() :
        nSporkID((SporkId)0),
        nValue(0),
        nTimeSigned(0)
        {}


    ADD_SERIALIZE_METHODS;

    template <typename Stream, typename Operation>
    inline void SerializationOp(Stream& s, Operation ser_action) {
        READWRITE(nSporkID);
        READWRITE(nValue);
        READWRITE(nTimeSigned);
        READWRITE(vchSig);
    }

    uint256 GetHash() const;

    uint256 GetSignatureHash() const;

    bool Sign(const CKey& key);

    bool CheckSignature(const CKeyID& pubKeyId) const;

    bool GetSignerKeyID(CKeyID& retKeyidSporkSigner);

    void Relay(CConnman& connman);
};

class CSporkManager
{
private:
    static const std::string SERIALIZATION_VERSION_STRING;

    std::unordered_map<SporkId, CSporkDef*> sporkDefsById;
    std::unordered_map<std::string, CSporkDef*> sporkDefsByName;

    mutable CCriticalSection cs;
    std::unordered_map<uint256, CSporkMessage> mapSporksByHash;
    std::unordered_map<SporkId, std::map<CKeyID, CSporkMessage> > mapSporksActive;

    std::set<CKeyID> setSporkPubKeyIDs;
    int nMinSporkKeys;
    CKey sporkPrivKey;

    bool SporkValueIsActive(SporkId nSporkID, int64_t& nActiveValueRet) const;

public:

    CSporkManager();

    ADD_SERIALIZE_METHODS;

    template <typename Stream, typename Operation>
    inline void SerializationOp(Stream& s, Operation ser_action) {
        std::string strVersion;
        if(ser_action.ForRead()) {
            READWRITE(strVersion);
            if (strVersion != SERIALIZATION_VERSION_STRING) {
                return;
            }
        } else {
            strVersion = SERIALIZATION_VERSION_STRING;
            READWRITE(strVersion);
        }
        // we don't serialize pubkey ids because pubkeys should be
        // hardcoded or be setted with cmdline or options, should
        // not reuse pubkeys from previous dashd run
        READWRITE(mapSporksByHash);
        READWRITE(mapSporksActive);
        // we don't serialize private key to prevent its leakage
    }

    void Clear();

    void CheckAndRemove();

    void ProcessSpork(CNode* pfrom, const std::string& strCommand, CDataStream& vRecv, CConnman& connman);

    bool UpdateSpork(SporkId nSporkID, int64_t nValue, CConnman& connman);

    bool IsSporkActive(SporkId nSporkID);

    int64_t GetSporkValue(SporkId nSporkID);

    SporkId GetSporkIDByName(const std::string& strName);

    std::string GetSporkNameByID(SporkId nSporkID);

    bool GetSporkByHash(const uint256& hash, CSporkMessage &sporkRet);

    bool SetSporkAddress(const std::string& strAddress);

    bool SetMinSporkKeys(int minSporkKeys);

    bool SetPrivKey(const std::string& strPrivKey);

    std::string ToString() const;
};

#endif