Inside Bitcoin

1// Copyright (c) 2024-present The Bitcoin Core developers
2// Distributed under the MIT software license, see the accompanying
3// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5#include <node/txdownloadman_impl.h>
6#include <node/txdownloadman.h>
7
8#include <chain.h>
9#include <consensus/validation.h>
10#include <txmempool.h>
11#include <util/log.h>
12#include <validation.h>
13#include <validationinterface.h>
14
15namespace node {
16// TxDownloadManager wrappers
17TxDownloadManager::TxDownloadManager(const TxDownloadOptions& options) :
18    m_impl{std::make_unique<TxDownloadManagerImpl>(options)}
19{}
20TxDownloadManager::~TxDownloadManager() = default;
21
22void TxDownloadManager::ActiveTipChange()
23{
24    m_impl->ActiveTipChange();
25}
26void TxDownloadManager::BlockConnected(const std::shared_ptr<const CBlock>& pblock)
27{
28    m_impl->BlockConnected(pblock);
29}
30void TxDownloadManager::BlockDisconnected()
31{
32    m_impl->BlockDisconnected();
33}
34void TxDownloadManager::ConnectedPeer(NodeId nodeid, const TxDownloadConnectionInfo& info)
35{
36    m_impl->ConnectedPeer(nodeid, info);
37}
38void TxDownloadManager::DisconnectedPeer(NodeId nodeid)
39{
40    m_impl->DisconnectedPeer(nodeid);
41}
42bool TxDownloadManager::AddTxAnnouncement(NodeId peer, const GenTxid& gtxid, std::chrono::microseconds now)
43{
44    return m_impl->AddTxAnnouncement(peer, gtxid, now);
45}
46std::vector<GenTxid> TxDownloadManager::GetRequestsToSend(NodeId nodeid, std::chrono::microseconds current_time)
47{
48    return m_impl->GetRequestsToSend(nodeid, current_time);
49}
50void TxDownloadManager::ReceivedNotFound(NodeId nodeid, const std::vector<GenTxid>& gtxids)
51{
52    m_impl->ReceivedNotFound(nodeid, gtxids);
53}
54void TxDownloadManager::MempoolAcceptedTx(const CTransactionRef& tx)
55{
56    m_impl->MempoolAcceptedTx(tx);
57}
58RejectedTxTodo TxDownloadManager::MempoolRejectedTx(const CTransactionRef& ptx, const TxValidationState& state, NodeId nodeid, bool first_time_failure)
59{
60    return m_impl->MempoolRejectedTx(ptx, state, nodeid, first_time_failure);
61}
62void TxDownloadManager::MempoolRejectedPackage(const Package& package)
63{
64    m_impl->MempoolRejectedPackage(package);
65}
66std::pair<bool, std::optional<PackageToValidate>> TxDownloadManager::ReceivedTx(NodeId nodeid, const CTransactionRef& ptx)
67{
68    return m_impl->ReceivedTx(nodeid, ptx);
69}
70bool TxDownloadManager::HaveMoreWork(NodeId nodeid) const
71{
72    return m_impl->HaveMoreWork(nodeid);
73}
74CTransactionRef TxDownloadManager::GetTxToReconsider(NodeId nodeid)
75{
76    return m_impl->GetTxToReconsider(nodeid);
77}
78void TxDownloadManager::CheckIsEmpty() const
79{
80    m_impl->CheckIsEmpty();
81}
82void TxDownloadManager::CheckIsEmpty(NodeId nodeid) const
83{
84    m_impl->CheckIsEmpty(nodeid);
85}
86std::vector<TxOrphanage::OrphanInfo> TxDownloadManager::GetOrphanTransactions() const
87{
88    return m_impl->GetOrphanTransactions();
89}
90
91// TxDownloadManagerImpl
92void TxDownloadManagerImpl::ActiveTipChange()
93{
94    RecentRejectsFilter().reset();
95    RecentRejectsReconsiderableFilter().reset();
96}
97
98void TxDownloadManagerImpl::BlockConnected(const std::shared_ptr<const CBlock>& pblock)
99{
100    m_orphanage->EraseForBlock(*pblock);
101
102    for (const auto& ptx : pblock->vtx) {
103        // Reconsider potential child transactions.
104        m_orphanage->AddChildrenToWorkSet(*ptx, m_rng);
105
106        RecentConfirmedTransactionsFilter().insert(ptx->GetHash().ToUint256());
107        if (ptx->HasWitness()) {
108            RecentConfirmedTransactionsFilter().insert(ptx->GetWitnessHash().ToUint256());
109        }
110        m_txrequest.ForgetTxHash(ptx->GetHash().ToUint256());
111        m_txrequest.ForgetTxHash(ptx->GetWitnessHash().ToUint256());
112    }
113}
114
115void TxDownloadManagerImpl::BlockDisconnected()
116{
117    // To avoid relay problems with transactions that were previously
118    // confirmed, clear our filter of recently confirmed transactions whenever
119    // there's a reorg.
120    // This means that in a 1-block reorg (where 1 block is disconnected and
121    // then another block reconnected), our filter will drop to having only one
122    // block's worth of transactions in it, but that should be fine, since
123    // presumably the most common case of relaying a confirmed transaction
124    // should be just after a new block containing it is found.
125    RecentConfirmedTransactionsFilter().reset();
126}
127
128bool TxDownloadManagerImpl::AlreadyHaveTx(const GenTxid& gtxid, bool include_reconsiderable)
129{
130    const uint256& hash = gtxid.ToUint256();
131
132    // Never query by txid: it is possible that the transaction in the orphanage has the same
133    // txid but a different witness, which would give us a false positive result. If we decided
134    // not to request the transaction based on this result, an attacker could prevent us from
135    // downloading a transaction by intentionally creating a malleated version of it.  While
136    // only one (or none!) of these transactions can ultimately be confirmed, we have no way of
137    // discerning which one that is, so the orphanage can store multiple transactions with the
138    // same txid.
139    //
140    // While we won't query by txid, we can try to "guess" what the wtxid is based on the txid.
141    // A non-segwit transaction's txid == wtxid. Query this txhash "casted" to a wtxid. This will
142    // help us find non-segwit transactions, saving bandwidth, and should have no false positives.
143    if (m_orphanage->HaveTx(Wtxid::FromUint256(hash))) return true;
144
145    if (include_reconsiderable && RecentRejectsReconsiderableFilter().contains(hash)) return true;
146
147    if (RecentConfirmedTransactionsFilter().contains(hash)) return true;
148
149    return RecentRejectsFilter().contains(hash) || std::visit([&](const auto& id) { return m_mempool.exists(id); }, gtxid);
150}
151
152void TxDownloadManagerImpl::ConnectedPeer(NodeId nodeid, const TxDownloadConnectionInfo& info)
153{
154    // If already connected (shouldn't happen in practice), exit early.
155    if (m_peer_info.contains(nodeid)) return;
156
157    m_peer_info.try_emplace(nodeid, info);
158    if (info.m_wtxid_relay) m_num_wtxid_peers += 1;
159}
160
161void TxDownloadManagerImpl::DisconnectedPeer(NodeId nodeid)
162{
163    m_orphanage->EraseForPeer(nodeid);
164    m_txrequest.DisconnectedPeer(nodeid);
165
166    if (auto it = m_peer_info.find(nodeid); it != m_peer_info.end()) {
167        if (it->second.m_connection_info.m_wtxid_relay) m_num_wtxid_peers -= 1;
168        m_peer_info.erase(it);
169    }
170
171}
172
173bool TxDownloadManagerImpl::AddTxAnnouncement(NodeId peer, const GenTxid& gtxid, std::chrono::microseconds now)
174{
175    // If this is an orphan we are trying to resolve, consider this peer as a orphan resolution candidate instead.
176    // - is wtxid matching something in orphanage
177    // - exists in orphanage
178    // - peer can be an orphan resolution candidate
179    if (const auto* wtxid = std::get_if<Wtxid>(&gtxid)) {
180        if (auto orphan_tx{m_orphanage->GetTx(*wtxid)}) {
181            auto unique_parents{GetUniqueParents(*orphan_tx)};
182            std::erase_if(unique_parents, [&](const auto& txid) {
183                return AlreadyHaveTx(txid, /*include_reconsiderable=*/false);
184            });
185
186            // The missing parents may have all been rejected or accepted since the orphan was added to the orphanage.
187            // Do not delete from the orphanage, as it may be queued for processing.
188            if (unique_parents.empty()) {
189                return true;
190            }
191
192            if (MaybeAddOrphanResolutionCandidate(unique_parents, *wtxid, peer, now)) {
193                m_orphanage->AddAnnouncer(orphan_tx->GetWitnessHash(), peer);
194            }
195
196            // Return even if the peer isn't an orphan resolution candidate. This would be caught by AlreadyHaveTx.
197            return true;
198        }
199    }
200
201    // If this is an inv received from a peer and we already have it, we can drop it.
202    if (AlreadyHaveTx(gtxid, /*include_reconsiderable=*/true)) return true;
203
204    auto it = m_peer_info.find(peer);
205    if (it == m_peer_info.end()) return false;
206    const auto& info = it->second.m_connection_info;
207    if (!info.m_relay_permissions && m_txrequest.Count(peer) >= MAX_PEER_TX_ANNOUNCEMENTS) {
208        // Too many queued announcements for this peer
209        return false;
210    }
211    // Decide the TxRequestTracker parameters for this announcement:
212    // - "preferred": if fPreferredDownload is set (= outbound, or NetPermissionFlags::NoBan permission)
213    // - "reqtime": current time plus delays for:
214    //   - NONPREF_PEER_TX_DELAY for announcements from non-preferred connections
215    //   - TXID_RELAY_DELAY for txid announcements while wtxid peers are available
216    //   - OVERLOADED_PEER_TX_DELAY for announcements from peers which have at least
217    //     MAX_PEER_TX_REQUEST_IN_FLIGHT requests in flight (and don't have NetPermissionFlags::Relay).
218    auto delay{0us};
219    if (!info.m_preferred) delay += NONPREF_PEER_TX_DELAY;
220    if (!gtxid.IsWtxid() && m_num_wtxid_peers > 0) delay += TXID_RELAY_DELAY;
221    const bool overloaded = !info.m_relay_permissions && m_txrequest.CountInFlight(peer) >= MAX_PEER_TX_REQUEST_IN_FLIGHT;
222    if (overloaded) delay += OVERLOADED_PEER_TX_DELAY;
223
224    m_txrequest.ReceivedInv(peer, gtxid, info.m_preferred, now + delay);
225
226    return false;
227}
228
229bool TxDownloadManagerImpl::MaybeAddOrphanResolutionCandidate(const std::vector<Txid>& unique_parents, const Wtxid& wtxid, NodeId nodeid, std::chrono::microseconds now)
230{
231    auto it_peer = m_peer_info.find(nodeid);
232    if (it_peer == m_peer_info.end()) return false;
233    if (m_orphanage->HaveTxFromPeer(wtxid, nodeid)) return false;
234
235    const auto& peer_entry = m_peer_info.at(nodeid);
236    const auto& info = peer_entry.m_connection_info;
237
238    // TODO: add delays and limits based on the amount of orphan resolution we are already doing
239    // with this peer, how much they are using the orphanage, etc.
240    if (!info.m_relay_permissions) {
241        // This mirrors the delaying and dropping behavior in AddTxAnnouncement in order to preserve
242        // existing behavior: drop if we are tracking too many invs for this peer already. Each
243        // orphan resolution involves at least 1 transaction request which may or may not be
244        // currently tracked in m_txrequest, so we include that in the count.
245        if (m_txrequest.Count(nodeid) + unique_parents.size() > MAX_PEER_TX_ANNOUNCEMENTS) return false;
246    }
247
248    std::chrono::seconds delay{0s};
249    if (!info.m_preferred) delay += NONPREF_PEER_TX_DELAY;
250    // The orphan wtxid is used, but resolution entails requesting the parents by txid. Sometimes