txrequest.h

Go to the documentation of this file.

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

#ifndef BITCOIN_TXREQUEST_H
#define BITCOIN_TXREQUEST_H

#include <primitives/transaction.h>
#include <net.h>
#include <uint256.h>

#include <chrono>
#include <cstdint>
#include <memory>
#include <vector>

class TxRequestTracker {
    // Avoid littering this header file with implementation details.
    class Impl;
    const std::unique_ptr<Impl> m_impl;

public:
    explicit TxRequestTracker(bool deterministic = false);
    ~TxRequestTracker();

    // Conceptually, the data structure consists of a collection of "announcements", one for each peer/txhash
    // combination:
    //
    // - CANDIDATE announcements represent transactions that were announced by a peer, and that become available for
    //   download after their reqtime has passed.
    //
    // - REQUESTED announcements represent transactions that have been requested, and which we're awaiting a
    //   response for from that peer. Their expiry value determines when the request times out.
    //
    // - COMPLETED announcements represent transactions that have been requested from a peer, and a NOTFOUND or a
    //   transaction was received in response (valid or not), or they timed out. They're only kept around to
    //   prevent requesting them again. If only COMPLETED announcements for a given txhash remain (so no CANDIDATE
    //   or REQUESTED ones), all of them are deleted (this is an invariant, and maintained by all operations below).
    //
    // The operations below manipulate the data structure.

    void ReceivedInv(NodeId peer, const GenTxid& gtxid, bool preferred,
                     std::chrono::microseconds reqtime);

    void DisconnectedPeer(NodeId peer);

    void ForgetTxHash(const uint256& txhash);

    std::vector<GenTxid> GetRequestable(NodeId peer, std::chrono::microseconds now,
                                        std::vector<std::pair<NodeId, GenTxid>>* expired = nullptr);

    void RequestedTx(NodeId peer, const uint256& txhash, std::chrono::microseconds expiry);

    void ReceivedResponse(NodeId peer, const uint256& txhash);

    // The operations below inspect the data structure.

    size_t CountInFlight(NodeId peer) const;

    size_t CountCandidates(NodeId peer) const;

    size_t Count(NodeId peer) const;

    size_t Size() const;

    void GetCandidatePeers(const uint256& txhash, std::vector<NodeId>& result_peers) const;

    uint64_t ComputePriority(const uint256& txhash, NodeId peer, bool preferred) const;

    void SanityCheck() const;

    void PostGetRequestableSanityCheck(std::chrono::microseconds now) const;
};

#endif // BITCOIN_TXREQUEST_H