251 * cfcheckpt is a response to a getcfcheckpt request containing a vector of
252 * evenly spaced filter headers for blocks on the requested chain.
253 */
254inline constexpr const char* CFCHECKPT{"cfcheckpt"};
255/**
256 * Indicates that a node prefers to relay transactions via wtxid, rather than
257 * txid.
258 * @since protocol version 70016 as described by BIP 339.
259 */
260inline constexpr const char* WTXIDRELAY{"wtxidrelay"};
261/**
262 * Contains a 4-byte version number and an 8-byte salt.
263 * The salt is used to compute short txids needed for efficient
264 * txreconciliation, as described by BIP 330.
265 */
266inline constexpr const char* SENDTXRCNCL{"sendtxrcncl"};
267/**
268 * BIP 434 Peer feature negotiation
269 */
270inline constexpr const char* FEATURE{"feature"};
271}; // namespace NetMsgType
272
273/** All known message types (see above). Keep this in the same order as the list of messages above. */
274inline const std::array ALL_NET_MESSAGE_TYPES{std::to_array<std::string>({
275    NetMsgType::VERSION,
276    NetMsgType::VERACK,
277    NetMsgType::ADDR,
278    NetMsgType::ADDRV2,
279    NetMsgType::SENDADDRV2,
280    NetMsgType::INV,
281    NetMsgType::GETDATA,
282    NetMsgType::MERKLEBLOCK,
283    NetMsgType::GETBLOCKS,
284    NetMsgType::GETHEADERS,
285    NetMsgType::TX,
286    NetMsgType::HEADERS,
287    NetMsgType::BLOCK,
288    NetMsgType::GETADDR,
289    NetMsgType::MEMPOOL,
290    NetMsgType::PING,
291    NetMsgType::PONG,
292    NetMsgType::NOTFOUND,
293    NetMsgType::FILTERLOAD,
294    NetMsgType::FILTERADD,
295    NetMsgType::FILTERCLEAR,
296    NetMsgType::SENDHEADERS,
297    NetMsgType::FEEFILTER,
298    NetMsgType::SENDCMPCT,
299    NetMsgType::CMPCTBLOCK,
300    NetMsgType::GETBLOCKTXN,
301    NetMsgType::BLOCKTXN,
302    NetMsgType::GETCFILTERS,
303    NetMsgType::CFILTER,
304    NetMsgType::GETCFHEADERS,
305    NetMsgType::CFHEADERS,
306    NetMsgType::GETCFCHECKPT,
307    NetMsgType::CFCHECKPT,
308    NetMsgType::WTXIDRELAY,
309    NetMsgType::SENDTXRCNCL,
310    NetMsgType::FEATURE,
311})};
312
313inline constexpr size_t MAX_FEATUREID_LENGTH{80};
314inline constexpr size_t MAX_FEATUREDATA_LENGTH{512};
315
316namespace NetMsgFeature {
317//inline constexpr std::string_view FOO{"BIP-FOO"};
318}
319
320/** nServices flags */
321enum ServiceFlags : uint64_t {
322    // NOTE: When adding here, be sure to update serviceFlagToStr too
323    // Nothing
324    NODE_NONE = 0,
325    // NODE_NETWORK means that the node is capable of serving the complete block chain. It is currently
326    // set by all Bitcoin Core non pruned nodes, and is unset by SPV clients or other light clients.
327    NODE_NETWORK = (1 << 0),
328    // NODE_BLOOM means the node is capable and willing to handle bloom-filtered connections.
329    NODE_BLOOM = (1 << 2),
330    // NODE_WITNESS indicates that a node can be asked for blocks and transactions including
331    // witness data.
332    NODE_WITNESS = (1 << 3),
333    // NODE_COMPACT_FILTERS means the node will service basic block filter requests.
334    // See BIP157 and BIP158 for details on how this is implemented.
335    NODE_COMPACT_FILTERS = (1 << 6),
336    // NODE_NETWORK_LIMITED means the same as NODE_NETWORK with the limitation of only
337    // serving the last 288 (2 day) blocks
338    // See BIP159 for details on how this is implemented.
339    NODE_NETWORK_LIMITED = (1 << 10),
340
341    // NODE_P2P_V2 means the node supports BIP324 transport
342    NODE_P2P_V2 = (1 << 11),
343
344    // Bits 24-31 are reserved for temporary experiments. Just pick a bit that
345    // isn't getting used, or one not being used much, and notify the
346    // bitcoin-development mailing list. Remember that service bits are just
347    // unauthenticated advertisements, so your code must be robust against
348    // collisions and other cases where nodes may be advertising a service they
349    // do not actually support. Other service bits should be allocated via the
350    // BIP process.
351};
352
353/**
354 * Convert service flags (a bitmask of NODE_*) to human readable strings.
355 * It supports unknown service flags which will be returned as "UNKNOWN[...]".
356 * @param[in] flags multiple NODE_* bitwise-OR-ed together
357 */
358std::vector<std::string> serviceFlagsToStr(uint64_t flags);
359
360/**
361 * State independent service flags.
362 * If the return value is changed, contrib/seeds/makeseeds.py
363 * should be updated appropriately to filter for nodes with
364 * desired service flags (compatible with our new flags).
365 */
366constexpr ServiceFlags SeedsServiceFlags() { return ServiceFlags(NODE_NETWORK | NODE_WITNESS); }
367
368/**
369 * Service flags we assume for addresses obtained from the DNS seeds and the
370 * fixed seeds, which don't come with service flags attached.
371 * BIP324 support can be safely assumed because the vast majority of listening nodes signals NODE_P2P_V2, and if the
372 * assumption is wrong for a given peer we simply reconnect using v1 transport.
373 */
374constexpr ServiceFlags SeedsAssumedServiceFlags() { return ServiceFlags(SeedsServiceFlags() | NODE_P2P_V2); }
375
376/**
377 * Checks if a peer with the given service flags may be capable of having a
378 * robust address-storage DB.
379 */
380static inline bool MayHaveUsefulAddressDB(ServiceFlags services)
381{
382    return (services & NODE_NETWORK) || (services & NODE_NETWORK_LIMITED);
383}
384
385/** A CService with information about it as peer */
386class CAddress : public CService
387{
388    static constexpr std::chrono::seconds TIME_INIT{100000000};
389
390    /** Historically, CAddress disk serialization stored the CLIENT_VERSION, optionally OR'ed with
391     *  the ADDRV2_FORMAT flag to indicate V2 serialization. The first field has since been
392     *  disentangled from client versioning, and now instead:
393     *  - The low bits (masked by DISK_VERSION_IGNORE_MASK) store the fixed value DISK_VERSION_INIT,
394     *    (in case any code exists that treats it as a client version) but are ignored on
395     *    deserialization.
396     *  - The high bits (masked by ~DISK_VERSION_IGNORE_MASK) store actual serialization information.
397     *    Only 0 or DISK_VERSION_ADDRV2 (equal to the historical ADDRV2_FORMAT) are valid now, and
398     *    any other value triggers a deserialization failure. Other values can be added later if
399     *    needed.
400     *
401     *  For disk deserialization, ADDRV2_FORMAT in the stream version signals that ADDRV2
402     *  deserialization is permitted, but the actual format is determined by the high bits in the
403     *  stored version field. For network serialization, the stream version having ADDRV2_FORMAT or
404     *  not determines the actual format used (as it has no embedded version number).
405     */
406    static constexpr uint32_t DISK_VERSION_INIT{220000};
407    static constexpr uint32_t DISK_VERSION_IGNORE_MASK{0b00000000'00000111'11111111'11111111};
408    /** The version number written in disk serialized addresses to indicate V2 serializations.
409     * It must be exactly 1<<29, as that is the value that historical versions used for this
410     * (they used their internal ADDRV2_FORMAT flag here). */
411    static constexpr uint32_t DISK_VERSION_ADDRV2{1 << 29};
412    static_assert((DISK_VERSION_INIT & ~DISK_VERSION_IGNORE_MASK) == 0, "DISK_VERSION_INIT must be covered by DISK_VERSION_IGNORE_MASK");
413    static_assert((DISK_VERSION_ADDRV2 & DISK_VERSION_IGNORE_MASK) == 0, "DISK_VERSION_ADDRV2 must not be covered by DISK_VERSION_IGNORE_MASK");
414
415public:
416    CAddress() : CService{} {};
417    CAddress(CService ipIn, ServiceFlags nServicesIn) : CService{ipIn}, nServices{nServicesIn} {};
418    CAddress(CService ipIn, ServiceFlags nServicesIn, NodeSeconds time) : CService{ipIn}, nTime{time}, nServices{nServicesIn} {};
419
420    enum class Format {
421        Disk,
422        Network,
423    };
424    struct SerParams : CNetAddr::SerParams {
425        const Format fmt;
426        SER_PARAMS_OPFUNC
427    };
428    static constexpr SerParams V1_NETWORK{{CNetAddr::Encoding::V1}, Format::Network};
429    static constexpr SerParams V2_NETWORK{{CNetAddr::Encoding::V2}, Format::Network};
430    static constexpr SerParams V1_DISK{{CNetAddr::Encoding::V1}, Format::Disk};
431    static constexpr SerParams V2_DISK{{CNetAddr::Encoding::V2}, Format::Disk};
432
433    SERIALIZE_METHODS(CAddress, obj)
434    {
435        bool use_v2;
436        auto& params = SER_PARAMS(SerParams);
437        if (params.fmt == Format::Disk) {
438            // In the disk serialization format, the encoding (v1 or v2) is determined by a flag version
439            // that's part of the serialization itself. ADDRV2_FORMAT in the stream version only determines
440            // whether V2 is chosen/permitted at all.
441            uint32_t stored_format_version = DISK_VERSION_INIT;
442            if (params.enc == Encoding::V2) stored_format_version |= DISK_VERSION_ADDRV2;
443            READWRITE(stored_format_version);
444            stored_format_version &= ~DISK_VERSION_IGNORE_MASK; // ignore low bits
445            if (stored_format_version == 0) {
446                use_v2 = false;
447            } else if (stored_format_version == DISK_VERSION_ADDRV2 && params.enc == Encoding::V2) {
448                // Only support v2 deserialization if V2 is set.
449                use_v2 = true;
450            } else {
451                throw std::ios_base::failure("Unsupported CAddress disk format version");
452            }
453        } else {
454            assert(params.fmt == Format::Network);
455            // In the network serialization format, the encoding (v1 or v2) is determined directly by
456            // the value of enc in the stream params, as no explicitly encoded version
457            // exists in the stream.
458            use_v2 = params.enc == Encoding::V2;
459        }
460
461        READWRITE(Using<LossyChronoFormatter<uint32_t>>(obj.nTime));
462        // nServices is serialized as CompactSize in V2; as uint64_t in V1.
463        if (use_v2) {
464            uint64_t services_tmp;
465            SER_WRITE(obj, services_tmp = obj.nServices);
466            READWRITE(Using<CompactSizeFormatter<false>>(services_tmp));
467            SER_READ(obj, obj.nServices = static_cast<ServiceFlags>(services_tmp));
468        } else {
469            READWRITE(Using<CustomUintFormatter<8>>(obj.nServices));
470        }
471        // Invoke V1/V2 serializer for CService parent object.
472        const auto ser_params{use_v2 ? CNetAddr::V2 : CNetAddr::V1};
473        READWRITE(ser_params(AsBase<CService>(obj)));
474    }
475
476    //! Always included in serialization. The behavior is unspecified if the value is not representable as uint32_t.
477    NodeSeconds nTime{TIME_INIT};
478    //! Serialized as uint64_t in V1, and as CompactSize in V2.
479    ServiceFlags nServices{NODE_NONE};
480
481    friend bool operator==(const CAddress& a, const CAddress& b)
482    {
483        return a.nTime == b.nTime &&
484               a.nServices == b.nServices &&
485               static_cast<const CService&>(a) == static_cast<const CService&>(b);
486    }
487};
488
489/** getdata message type flags */
490inline constexpr uint32_t MSG_WITNESS_FLAG = 1 << 30;
491inline constexpr uint32_t MSG_TYPE_MASK = 0xffffffff >> 2;
492
493/** getdata / inv message types.
494 * These numbers are defined by the protocol. When adding a new value, be sure
495 * to mention it in the respective BIP.
496 */
497enum GetDataMsg : uint32_t {
498    UNDEFINED = 0,
499    MSG_TX = 1,
500    MSG_BLOCK = 2,