private_broadcast.h

Go to the documentation of this file.

// Copyright (c) 2023-present The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or https://opensource.org/license/mit/.
 
#ifndef BITCOIN_PRIVATE_BROADCAST_H
#define BITCOIN_PRIVATE_BROADCAST_H
 
#include <net.h>
#include <primitives/transaction.h>
#include <primitives/transaction_identifier.h>
#include <sync.h>
#include <util/time.h>
 
#include <optional>
#include <tuple>
#include <unordered_map>
#include <vector>
 
class PrivateBroadcast
{
public:
 
    static constexpr size_t INITIAL_CONNECTION_COUNT{3};
 
    static constexpr auto INITIAL_STALE_DURATION{5min};
 
    static constexpr auto STALE_DURATION{1min};
 
    static constexpr size_t MAX_TRANSACTIONS{10'000};
 
    static constexpr size_t MAX_SEND_ATTEMPTS{1'000};
 
    explicit PrivateBroadcast(size_t max_transactions = MAX_TRANSACTIONS,
                              size_t max_send_attempts = MAX_SEND_ATTEMPTS)
        : m_max_transactions{max_transactions}, m_max_send_attempts{max_send_attempts} {}
 
    struct PeerSendInfo {
        CService address;
        NodeClock::time_point sent;
        std::optional<NodeClock::time_point> received;
    };
 
    struct TxBroadcastInfo {
        CTransactionRef tx;
        NodeClock::time_point time_added;
        size_t attempts_remaining;
        std::vector<PeerSendInfo> peers;
    };
 
    enum class AddResult {
        Added,
        AlreadyPresent,
        QueueFull,
    };
 
    [[nodiscard]] AddResult Add(const CTransactionRef& tx)
        EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
 
    std::optional<size_t> Remove(const CTransactionRef& tx)
        EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
 
    bool MarkResolved(const CTransactionRef& tx)
        EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
 
    void NodeDisconnected(NodeId nodeid)
        EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
 
    bool TryGrantRetry(const CTransactionRef& tx)
        EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
 
    std::optional<CTransactionRef> PickTxForSend(const NodeId& will_send_to_nodeid, const CService& will_send_to_address)
        EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
 
    std::optional<CTransactionRef> GetTxForNode(const NodeId& nodeid)
        EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
 
    void NodeConfirmedReception(const NodeId& nodeid)
        EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
 
    bool HavePendingTransactions()
        EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
 
    std::vector<CTransactionRef> GetStale() const
        EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
 
    std::vector<TxBroadcastInfo> GetBroadcastInfo() const
        EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
 
private:
    struct SendStatus {
        const NodeId nodeid;
        const CService address;
        const NodeClock::time_point picked;
        std::optional<NodeClock::time_point> confirmed;
        bool disconnected{false};
 
        SendStatus(const NodeId& nodeid, const CService& address, const NodeClock::time_point& picked) : nodeid{nodeid}, address{address}, picked{picked} {}
    };
 
    struct Priority {
        size_t num_picked{0}; 
        NodeClock::time_point last_picked{}; 
        size_t num_confirmed{0}; 
        NodeClock::time_point last_confirmed{}; 
 
        auto operator<=>(const Priority& other) const
        {
            // Invert `other` and `this` in the comparison because smaller num_picked, num_confirmed or
            // earlier times mean greater priority. In other words, if this.num_picked < other.num_picked
            // then this > other.
            return std::tie(other.num_picked, other.num_confirmed, other.last_picked, other.last_confirmed) <=>
                   std::tie(num_picked, num_confirmed, last_picked, last_confirmed);
        }
    };
 
    struct TxAndSendStatusForNode {
        const CTransactionRef& tx;
        SendStatus& send_status;
    };
 
    // No need for salted hasher because we are going to store just a bunch of locally originating transactions.
 
    struct CTransactionRefHash {
        size_t operator()(const CTransactionRef& tx) const
        {
            return static_cast<size_t>(tx->GetWitnessHash().ToUint256().GetUint64(0));
        }
    };
 
    struct CTransactionRefComp {
        bool operator()(const CTransactionRef& a, const CTransactionRef& b) const
        {
            return a->GetWitnessHash() == b->GetWitnessHash(); // If wtxid equals, then txid also equals.
        }
    };
 
    static Priority DerivePriority(const std::vector<SendStatus>& sent_to);
 
    std::optional<TxAndSendStatusForNode> GetSendStatusByNode(const NodeId& nodeid)
        EXCLUSIVE_LOCKS_REQUIRED(m_mutex);
    struct TxSendStatus {
        NodeClock::time_point time_added{NodeClock::now()};
        std::vector<SendStatus> send_statuses;
        size_t planned_sends{INITIAL_CONNECTION_COUNT};
        bool resolved{false};
    };
    bool IsPending(const TxSendStatus& status) const;
    const size_t m_max_transactions;
    const size_t m_max_send_attempts;
    mutable Mutex m_mutex;
    std::unordered_map<CTransactionRef, TxSendStatus, CTransactionRefHash, CTransactionRefComp>
        m_transactions GUARDED_BY(m_mutex);
};
 
#endif // BITCOIN_PRIVATE_BROADCAST_H