protocol.h

Go to the documentation of this file.

// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2015 The Bitcoin developers
// Copyright (c) 2014-2021 The Dash Core developers
// Copyright (c) 2016-2022 The PIVX Core developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef __cplusplus
#error This header can only be compiled as C++.
#endif
 
#ifndef PIVX_PROTOCOL_H
#define PIVX_PROTOCOL_H
 
#include "netaddress.h"
#include "serialize.h"
#include "streams.h"
#include "uint256.h"
#include "version.h"
 
#include <stdint.h>
#include <string>
 
class CMessageHeader
{
public:
    static constexpr size_t MESSAGE_START_SIZE = 4;
    static constexpr size_t COMMAND_SIZE = 12;
    static constexpr size_t MESSAGE_SIZE_SIZE = 4;
    static constexpr size_t CHECKSUM_SIZE = 4;
    static constexpr size_t MESSAGE_SIZE_OFFSET = MESSAGE_START_SIZE + COMMAND_SIZE;
    static constexpr size_t CHECKSUM_OFFSET = MESSAGE_SIZE_OFFSET + MESSAGE_SIZE_SIZE;
    static constexpr size_t HEADER_SIZE = MESSAGE_START_SIZE + COMMAND_SIZE + MESSAGE_SIZE_SIZE + CHECKSUM_SIZE;
    typedef unsigned char MessageStartChars[MESSAGE_START_SIZE];
 
    explicit CMessageHeader(const MessageStartChars& pchMessageStartIn);
 
    CMessageHeader(const MessageStartChars& pchMessageStartIn, const char* pszCommand, unsigned int nMessageSizeIn);
 
    std::string GetCommand() const;
    bool IsValid(const MessageStartChars& messageStart) const;
 
    SERIALIZE_METHODS(CMessageHeader, obj) { READWRITE(obj.pchMessageStart, obj.pchCommand, obj.nMessageSize, obj.pchChecksum); }
 
    char pchMessageStart[MESSAGE_START_SIZE];
    char pchCommand[COMMAND_SIZE];
    uint32_t nMessageSize;
    uint8_t pchChecksum[CHECKSUM_SIZE];
};
 
namespace NetMsgType
{
extern const char* VERSION;
extern const char* VERACK;
extern const char* ADDR;
extern const char *ADDRV2;
extern const char *SENDADDRV2;
extern const char* INV;
extern const char* GETDATA;
extern const char* MERKLEBLOCK;
extern const char* GETBLOCKS;
extern const char* GETHEADERS;
extern const char* TX;
extern const char* HEADERS;
extern const char* BLOCK;
extern const char* GETADDR;
extern const char* MEMPOOL;
extern const char* PING;
extern const char* PONG;
extern const char* ALERT;
extern const char* NOTFOUND;
extern const char* FILTERLOAD;
extern const char* FILTERADD;
extern const char* FILTERCLEAR;
extern const char* SENDHEADERS;
extern const char* SPORK;
extern const char* GETSPORKS;
extern const char* MNBROADCAST;
extern const char* MNBROADCAST2;
extern const char* MNPING;
extern const char* MNWINNER;
extern const char* GETMNWINNERS;
extern const char* GETMNLIST;
extern const char* BUDGETPROPOSAL;
extern const char* BUDGETVOTE;
extern const char* BUDGETVOTESYNC;
extern const char* FINALBUDGET;
extern const char* FINALBUDGETVOTE;
extern const char* SYNCSTATUSCOUNT;
extern const char* QFCOMMITMENT;
extern const char* QSENDRECSIGS;
extern const char* MNAUTH;
/*
 * Messages for LLMQ-DKG inter-quorum communication
 */
extern const char* QCONTRIB;
extern const char* QCOMPLAINT;
extern const char* QJUSTIFICATION;
extern const char* QPCOMMITMENT;
extern const char* QSIGSESANN;
extern const char* QSIGSHARESINV;
extern const char* QGETSIGSHARES;
extern const char* QBSIGSHARES;
extern const char* QSIGREC;
extern const char* QSIGSHARE;
extern const char* CLSIG;
}; // namespace NetMsgType
 
/* Get a vector of all valid message types (see above) */
const std::vector<std::string>& getAllNetMessageTypes();
 
/* Get a vector of all tier two valid message types (see above) */
const std::vector<std::string>& getTierTwoNetMessageTypes();
 
enum ServiceFlags : uint64_t {
    // Nothing
    NODE_NONE = 0,
    // NODE_NETWORK means that the node is capable of serving the block chain. It is currently
    // set by all Bitcoin Core nodes, and is unset by SPV clients or other peers that just want
    // network services but don't provide them.
    NODE_NETWORK = (1 << 0),
 
    // NODE_BLOOM means the node is capable and willing to handle bloom-filtered connections.
    NODE_BLOOM = (1 << 2),
 
    // NODE_BLOOM_WITHOUT_MN means the node has the same features as NODE_BLOOM with the only difference
    // that the node doesn't want to receive master nodes messages. (the 1<<3 was not picked as constant because on bitcoin 0.14 is witness and we want that update here )
    NODE_BLOOM_WITHOUT_MN = (1 << 4),
 
    // Bits 24-31 are reserved for temporary experiments. Just pick a bit that
    // isn't getting used, or one not being used much, and notify the
    // bitcoin-development mailing list. Remember that service bits are just
    // unauthenticated advertisements, so your code must be robust against
    // collisions and other cases where nodes may be advertising a service they
    // do not actually support. Other service bits should be allocated via the
    // BIP process.
};
 
class CAddress : public CService
{
    static constexpr uint32_t TIME_INIT{100000000};
 
    static constexpr uint32_t DISK_VERSION_INIT{220000};
    static constexpr uint32_t DISK_VERSION_IGNORE_MASK{0b00000000'00000111'11111111'11111111};
    static constexpr uint32_t DISK_VERSION_ADDRV2{1 << 29};
    static_assert((DISK_VERSION_INIT & ~DISK_VERSION_IGNORE_MASK) == 0, "DISK_VERSION_INIT must be covered by DISK_VERSION_IGNORE_MASK");
    static_assert((DISK_VERSION_ADDRV2 & DISK_VERSION_IGNORE_MASK) == 0, "DISK_VERSION_ADDRV2 must not be covered by DISK_VERSION_IGNORE_MASK");
 
public:
    CAddress() : CService{} {};
    CAddress(CService ipIn, ServiceFlags nServicesIn) : CService{ipIn}, nServices{nServicesIn} {};
    CAddress(CService ipIn, ServiceFlags nServicesIn, uint32_t nTimeIn) : CService{ipIn}, nTime{nTimeIn}, nServices{nServicesIn} {};
 
    SERIALIZE_METHODS(CAddress, obj)
    {
        // CAddress has a distinct network serialization and a disk serialization, but it should never
        // be hashed (except through CHashWriter in addrdb.cpp, which sets SER_DISK), and it's
        // ambiguous what that would mean. Make sure no code relying on that is introduced:
        assert(!(s.GetType() & SER_GETHASH));
        bool use_v2;
        bool store_time;
        if (s.GetType() & SER_DISK) {
            // In the disk serialization format, the encoding (v1 or v2) is determined by a flag version
            // that's part of the serialization itself. ADDRV2_FORMAT in the stream version only determines
            // whether V2 is chosen/permitted at all.
            uint32_t stored_format_version = DISK_VERSION_INIT;
            if (s.GetVersion() & ADDRV2_FORMAT) stored_format_version |= DISK_VERSION_ADDRV2;
            READWRITE(stored_format_version);
            stored_format_version &= ~DISK_VERSION_IGNORE_MASK; // ignore low bits
            if (stored_format_version == 0) {
                use_v2 = false;
            } else if (stored_format_version == DISK_VERSION_ADDRV2 && (s.GetVersion() & ADDRV2_FORMAT)) {
                // Only support v2 deserialization if ADDRV2_FORMAT is set.
                use_v2 = true;
            } else {
                throw std::ios_base::failure("Unsupported CAddress disk format version");
            }
            store_time = true;
        } else {
            // In the network serialization format, the encoding (v1 or v2) is determined directly by
            // the value of ADDRV2_FORMAT in the stream version, as no explicitly encoded version
            // exists in the stream.
            assert(s.GetType() & SER_NETWORK);
            use_v2 = s.GetVersion() & ADDRV2_FORMAT;
            // The only time we serialize a CAddress object without nTime is in
            // the initial VERSION messages which contain two CAddress records.
            // At that point, the serialization version is INIT_PROTO_VERSION.
            // After the version handshake, serialization version is >=
            // MIN_PEER_PROTO_VERSION and all ADDR messages are serialized with
            // nTime.
            store_time = s.GetVersion() != INIT_PROTO_VERSION;
        }
 
        SER_READ(obj, obj.nTime = TIME_INIT);
        if (store_time) READWRITE(obj.nTime);
        // nServices is serialized as CompactSize in V2; as uint64_t in V1.
        if (use_v2) {
            uint64_t services_tmp;
            SER_WRITE(obj, services_tmp = obj.nServices);
            READWRITE(Using<CompactSizeFormatter<false>>(services_tmp));
            SER_READ(obj, obj.nServices = static_cast<ServiceFlags>(services_tmp));
        } else {
            READWRITE(Using<CustomUintFormatter<8>>(obj.nServices));
        }
        // Invoke V1/V2 serializer for CService parent object.
        OverrideStream<Stream> os(&s, s.GetType(), use_v2 ? ADDRV2_FORMAT : 0);
        SerReadWriteMany(os, ser_action, ReadWriteAsHelper<CService>(obj));
    }
 
    uint32_t nTime{TIME_INIT};
    ServiceFlags nServices{NODE_NONE};
};
 
enum GetDataMsg {
    UNDEFINED = 0,
    MSG_TX,
    MSG_BLOCK,
    // Nodes may always request a MSG_FILTERED_BLOCK in a getdata, however,
    // MSG_FILTERED_BLOCK should not appear in any invs except as a part of getdata.
    MSG_FILTERED_BLOCK,
    MSG_TXLOCK_REQUEST, // Deprecated
    MSG_TXLOCK_VOTE,    // Deprecated
    MSG_SPORK,
    MSG_MASTERNODE_WINNER,
    MSG_MASTERNODE_SCANNING_ERROR,
    MSG_BUDGET_VOTE,
    MSG_BUDGET_PROPOSAL,
    MSG_BUDGET_FINALIZED,
    MSG_BUDGET_FINALIZED_VOTE,
    MSG_MASTERNODE_QUORUM,
    MSG_MASTERNODE_ANNOUNCE,
    MSG_MASTERNODE_PING,
    MSG_DSTX, // Deprecated
    MSG_QUORUM_FINAL_COMMITMENT,
    MSG_QUORUM_CONTRIB,
    MSG_QUORUM_COMPLAINT,
    MSG_QUORUM_JUSTIFICATION,
    MSG_QUORUM_PREMATURE_COMMITMENT,
    MSG_QUORUM_RECOVERED_SIG,
    MSG_CLSIG,
    MSG_TYPE_MAX = MSG_CLSIG,
};
 
class CInv
{
public:
    CInv();
    CInv(int typeIn, const uint256& hashIn);
 
    SERIALIZE_METHODS(CInv, obj) { READWRITE(obj.type, obj.hash); }
 
    friend bool operator<(const CInv& a, const CInv& b);
 
    bool IsMasterNodeType() const;
    std::string ToString() const;
 
    // TODO: make private (improve encapsulation)
    int type;
    uint256 hash;
 
private:
    std::string GetCommand() const;
};
 
#endif // PIVX_PROTOCOL_H