Inside Bitcoin

251    // parent and child are announced and thus requested around the same time, and we happen to
252    // receive child sooner. Waiting a few seconds may allow us to cancel the orphan resolution
253    // request if the parent arrives in that time.
254    if (m_num_wtxid_peers > 0) delay += TXID_RELAY_DELAY;
255    const bool overloaded = !info.m_relay_permissions && m_txrequest.CountInFlight(nodeid) >= MAX_PEER_TX_REQUEST_IN_FLIGHT;
256    if (overloaded) delay += OVERLOADED_PEER_TX_DELAY;
257
258    // Treat finding orphan resolution candidate as equivalent to the peer announcing all missing parents.
259    // In the future, orphan resolution may include more explicit steps
260    for (const auto& parent_txid : unique_parents) {
261        m_txrequest.ReceivedInv(nodeid, parent_txid, info.m_preferred, now + delay);
262    }
263    LogDebug(BCLog::TXPACKAGES, "added peer=%d as a candidate for resolving orphan %s\n", nodeid, wtxid.ToString());
264    return true;
265}
266
267std::vector<GenTxid> TxDownloadManagerImpl::GetRequestsToSend(NodeId nodeid, std::chrono::microseconds current_time)
268{
269    std::vector<GenTxid> requests;
270    std::vector<std::pair<NodeId, GenTxid>> expired;
271    auto requestable = m_txrequest.GetRequestable(nodeid, current_time, &expired);
272    for (const auto& [expired_nodeid, gtxid] : expired) {
273        LogDebug(BCLog::NET, "timeout of inflight %s %s from peer=%d\n", gtxid.IsWtxid() ? "wtx" : "tx",
274                 gtxid.ToUint256().ToString(), expired_nodeid);
275    }
276    for (const GenTxid& gtxid : requestable) {
277        if (!AlreadyHaveTx(gtxid, /*include_reconsiderable=*/false)) {
278            LogDebug(BCLog::NET, "Requesting %s %s peer=%d\n", gtxid.IsWtxid() ? "wtx" : "tx",
279                     gtxid.ToUint256().ToString(), nodeid);
280            requests.emplace_back(gtxid);
281            m_txrequest.RequestedTx(nodeid, gtxid.ToUint256(), current_time + GETDATA_TX_INTERVAL);
282        } else {
283            // We have already seen this transaction, no need to download. This is just a belt-and-suspenders, as
284            // this should already be called whenever a transaction becomes AlreadyHaveTx().
285            m_txrequest.ForgetTxHash(gtxid.ToUint256());
286        }
287    }
288    return requests;
289}
290
291void TxDownloadManagerImpl::ReceivedNotFound(NodeId nodeid, const std::vector<GenTxid>& gtxids)
292{
293    for (const auto& gtxid : gtxids) {
294        // If we receive a NOTFOUND message for a tx we requested, mark the announcement for it as
295        // completed in TxRequestTracker.
296        m_txrequest.ReceivedResponse(nodeid, gtxid.ToUint256());
297    }
298}
299
300std::optional<PackageToValidate> TxDownloadManagerImpl::Find1P1CPackage(const CTransactionRef& ptx, NodeId nodeid)
301{
302    const auto& parent_wtxid{ptx->GetWitnessHash()};
303
304    Assume(RecentRejectsReconsiderableFilter().contains(parent_wtxid.ToUint256()));
305
306    // Only consider children from this peer. This helps prevent censorship attempts in which an attacker
307    // sends lots of fake children for the parent, and we (unluckily) keep selecting the fake
308    // children instead of the real one provided by the honest peer. Since we track all announcers
309    // of an orphan, this does not exclude parent + orphan pairs that we happened to request from
310    // different peers.
311    const auto cpfp_candidates_same_peer{m_orphanage->GetChildrenFromSamePeer(ptx, nodeid)};
312
313    // These children should be sorted from newest to oldest. In the (probably uncommon) case
314    // of children that replace each other, this helps us accept the highest feerate (probably the
315    // most recent) one efficiently.
316    for (const auto& child : cpfp_candidates_same_peer) {
317        Package maybe_cpfp_package{ptx, child};
318        if (!RecentRejectsReconsiderableFilter().contains(GetPackageHash(maybe_cpfp_package)) &&
319            !RecentRejectsFilter().contains(child->GetHash().ToUint256())) {
320            return PackageToValidate{ptx, child, nodeid, nodeid};
321        }
322    }
323    return std::nullopt;
324}
325
326void TxDownloadManagerImpl::MempoolAcceptedTx(const CTransactionRef& tx)
327{
328    // As this version of the transaction was acceptable, we can forget about any requests for it.
329    // No-op if the tx is not in txrequest.
330    m_txrequest.ForgetTxHash(tx->GetHash().ToUint256());
331    m_txrequest.ForgetTxHash(tx->GetWitnessHash().ToUint256());
332
333    m_orphanage->AddChildrenToWorkSet(*tx, m_rng);
334    // If it came from the orphanage, remove it. No-op if the tx is not in txorphanage.
335    m_orphanage->EraseTx(tx->GetWitnessHash());
336}
337
338std::vector<Txid> TxDownloadManagerImpl::GetUniqueParents(const CTransaction& tx)
339{
340    std::vector<Txid> unique_parents;
341    unique_parents.reserve(tx.vin.size());
342    for (const CTxIn& txin : tx.vin) {
343        // We start with all parents, and then remove duplicates below.
344        unique_parents.push_back(txin.prevout.hash);
345    }
346
347    std::sort(unique_parents.begin(), unique_parents.end());
348    unique_parents.erase(std::unique(unique_parents.begin(), unique_parents.end()), unique_parents.end());
349
350    return unique_parents;
351}
352
353node::RejectedTxTodo TxDownloadManagerImpl::MempoolRejectedTx(const CTransactionRef& ptx, const TxValidationState& state, NodeId nodeid, bool first_time_failure)
354{
355    const CTransaction& tx{*ptx};
356    // Results returned to caller
357    // Whether we should call AddToCompactExtraTransactions at the end
358    bool add_extra_compact_tx{first_time_failure};
359    // Hashes to pass to AddKnownTx later
360    std::vector<Txid> unique_parents;
361    // Populated if failure is reconsiderable and eligible package is found.
362    std::optional<node::PackageToValidate> package_to_validate;
363
364    if (state.GetResult() == TxValidationResult::TX_MISSING_INPUTS) {
365        // Only process a new orphan if this is a first time failure, as otherwise it must be either
366        // already in orphanage or from 1p1c processing.
367        if (first_time_failure && !RecentRejectsFilter().contains(ptx->GetWitnessHash().ToUint256())) {
368            bool fRejectedParents = false; // It may be the case that the orphans parents have all been rejected
369
370            // Deduplicate parent txids, so that we don't have to loop over
371            // the same parent txid more than once down below.
372            unique_parents = GetUniqueParents(tx);
373
374            // Distinguish between parents in m_lazy_recent_rejects and m_lazy_recent_rejects_reconsiderable.
375            // We can tolerate having up to 1 parent in m_lazy_recent_rejects_reconsiderable since we
376            // submit 1p1c packages. However, fail immediately if any are in m_lazy_recent_rejects.
377            std::optional<Txid> rejected_parent_reconsiderable;
378            for (const Txid& parent_txid : unique_parents) {
379                if (RecentRejectsFilter().contains(parent_txid.ToUint256())) {
380                    fRejectedParents = true;
381                    break;
382                } else if (RecentRejectsReconsiderableFilter().contains(parent_txid.ToUint256()) &&
383                           !m_mempool.exists(parent_txid)) {
384                    // More than 1 parent in m_lazy_recent_rejects_reconsiderable: 1p1c will not be
385                    // sufficient to accept this package, so just give up here.
386                    if (rejected_parent_reconsiderable.has_value()) {
387                        fRejectedParents = true;
388                        break;
389                    }
390                    rejected_parent_reconsiderable = parent_txid;
391                }
392            }
393            if (!fRejectedParents) {
394                // Filter parents that we already have.
395                // Exclude m_lazy_recent_rejects_reconsiderable: the missing parent may have been
396                // previously rejected for being too low feerate. This orphan might CPFP it.
397                std::erase_if(unique_parents, [&](const auto& txid) {
398                    return AlreadyHaveTx(txid, /*include_reconsiderable=*/false);
399                });
400                const auto now{GetTime<std::chrono::microseconds>()};
401                const auto& wtxid = ptx->GetWitnessHash();
402                // Potentially flip add_extra_compact_tx to false if tx is already in orphanage, which
403                // means it was already added to vExtraTxnForCompact.
404                add_extra_compact_tx &= !m_orphanage->HaveTx(wtxid);
405
406                // If there is no candidate for orphan resolution, AddTx will not be called. This means
407                // that if a peer is overloading us with invs and orphans, they will eventually not be
408                // able to add any more transactions to the orphanage.
409                //
410                // Search by txid and, if the tx has a witness, wtxid
411                std::vector<NodeId> orphan_resolution_candidates{nodeid};
412                m_txrequest.GetCandidatePeers(ptx->GetHash().ToUint256(), orphan_resolution_candidates);
413                if (ptx->HasWitness()) m_txrequest.GetCandidatePeers(ptx->GetWitnessHash().ToUint256(), orphan_resolution_candidates);
414
415                for (const auto& nodeid : orphan_resolution_candidates) {
416                    if (MaybeAddOrphanResolutionCandidate(unique_parents, ptx->GetWitnessHash(), nodeid, now)) {
417                        m_orphanage->AddTx(ptx, nodeid);
418                    }
419                }
420
421                // Once added to the orphan pool, a tx is considered AlreadyHave, and we shouldn't request it anymore.
422                m_txrequest.ForgetTxHash(tx.GetHash().ToUint256());
423                m_txrequest.ForgetTxHash(tx.GetWitnessHash().ToUint256());
424            } else {
425                unique_parents.clear();
426                LogDebug(BCLog::MEMPOOL, "not keeping orphan with rejected parents %s (wtxid=%s)\n",
427                         tx.GetHash().ToString(),
428                         tx.GetWitnessHash().ToString());
429                // We will continue to reject this tx since it has rejected
430                // parents so avoid re-requesting it from other peers.
431                // Here we add both the txid and the wtxid, as we know that
432                // regardless of what witness is provided, we will not accept
433                // this, so we don't need to allow for redownload of this txid
434                // from any of our non-wtxidrelay peers.
435                RecentRejectsFilter().insert(tx.GetHash().ToUint256());
436                RecentRejectsFilter().insert(tx.GetWitnessHash().ToUint256());
437                m_txrequest.ForgetTxHash(tx.GetHash().ToUint256());
438                m_txrequest.ForgetTxHash(tx.GetWitnessHash().ToUint256());
439            }
440        }
441    } else if (state.GetResult() == TxValidationResult::TX_WITNESS_STRIPPED) {
442        add_extra_compact_tx = false;
443    } else {
444        // We can add the wtxid of this transaction to our reject filter.
445        // Do not add txids of witness transactions or witness-stripped
446        // transactions to the filter, as they can have been malleated;
447        // adding such txids to the reject filter would potentially
448        // interfere with relay of valid transactions from peers that
449        // do not support wtxid-based relay. See
450        // https://github.com/bitcoin/bitcoin/issues/8279 for details.
451        // We can remove this restriction (and always add wtxids to
452        // the filter even for witness stripped transactions) once
453        // wtxid-based relay is broadly deployed.
454        // See also comments in https://github.com/bitcoin/bitcoin/pull/18044#discussion_r443419034
455        // for concerns around weakening security of unupgraded nodes
456        // if we start doing this too early.
457        if (state.GetResult() == TxValidationResult::TX_RECONSIDERABLE) {
458            // If the result is TX_RECONSIDERABLE, add it to m_lazy_recent_rejects_reconsiderable
459            // because we should not download or submit this transaction by itself again, but may
460            // submit it as part of a package later.
461            RecentRejectsReconsiderableFilter().insert(ptx->GetWitnessHash().ToUint256());
462
463            if (first_time_failure) {
464                // When a transaction fails for TX_RECONSIDERABLE, look for a matching child in the
465                // orphanage, as it is possible that they succeed as a package.
466                LogDebug(BCLog::TXPACKAGES, "tx %s (wtxid=%s) failed but reconsiderable, looking for child in orphanage\n",
467                         ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString());
468                package_to_validate = Find1P1CPackage(ptx, nodeid);
469            }
470        } else {
471            RecentRejectsFilter().insert(ptx->GetWitnessHash().ToUint256());
472        }
473        m_txrequest.ForgetTxHash(ptx->GetWitnessHash().ToUint256());
474        // If the transaction failed for TX_INPUTS_NOT_STANDARD,
475        // then we know that the witness was irrelevant to the policy
476        // failure, since this check depends only on the txid
477        // (the scriptPubKey being spent is covered by the txid).
478        // Add the txid to the reject filter to prevent repeated
479        // processing of this transaction in the event that child
480        // transactions are later received (resulting in
481        // parent-fetching by txid via the orphan-handling logic).
482        // We only add the txid if it differs from the wtxid, to avoid wasting entries in the
483        // rolling bloom filter.
484        if (state.GetResult() == TxValidationResult::TX_INPUTS_NOT_STANDARD && ptx->HasWitness()) {
485            RecentRejectsFilter().insert(ptx->GetHash().ToUint256());
486            m_txrequest.ForgetTxHash(ptx->GetHash().ToUint256());
487        }
488    }
489
490    // If the tx failed in ProcessOrphanTx, it should be removed from the orphanage unless the
491    // tx was still missing inputs. If the tx was not in the orphanage, EraseTx does nothing and returns 0.
492    if (state.GetResult() != TxValidationResult::TX_MISSING_INPUTS && m_orphanage->EraseTx(ptx->GetWitnessHash())) {
493        LogDebug(BCLog::TXPACKAGES, "   removed orphan tx %s (wtxid=%s)\n", ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString());
494    }
495
496    return RejectedTxTodo{
497        .m_should_add_extra_compact_tx = add_extra_compact_tx,
498        .m_unique_parents = std::move(unique_parents),
499        .m_package_to_validate = std::move(package_to_validate)
500    };