/root/bitcoin/src/policy/truc_policy.cpp

Source
// Copyright (c) 2022-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.

#include <policy/truc_policy.h>

#include <coins.h>
#include <consensus/amount.h>
#include <tinyformat.h>
#include <util/check.h>

#include <algorithm>
#include <numeric>
#include <vector>

/** Helper for PackageTRUCChecks: Returns a vector containing the indices of transactions (within
 * package) that are direct parents of ptx. */
std::vector<size_t> FindInPackageParents(const Package& package, const CTransactionRef& ptx)
{
    std::vector<size_t> in_package_parents;

    std::set<Txid> possible_parents;
    for (auto &input : ptx->vin) {
        possible_parents.insert(input.prevout.hash);
    }

    for (size_t i{0}; i < package.size(); ++i) {
        const auto& tx = package.at(i);
        // We assume the package is sorted, so that we don't need to continue
        // looking past the transaction itself.
        if (&(*tx) == &(*ptx)) break;
        if (possible_parents.contains(tx->GetHash())) {
            in_package_parents.push_back(i);
        }
    }
    return in_package_parents;
}

/** Helper for PackageTRUCChecks, storing info for a mempool or package parent. */
struct ParentInfo {
    /** Txid used to identify this parent by prevout */
    const Txid& m_txid;
    /** Wtxid used for debug string */
    const Wtxid& m_wtxid;
    /** version used to check inheritance of TRUC and non-TRUC */
    decltype(CTransaction::version) m_version;
    /** If parent is in mempool, whether it has any descendants in mempool. */
    bool m_has_mempool_descendant;

    ParentInfo() = delete;
    ParentInfo(const Txid& txid, const Wtxid& wtxid, decltype(CTransaction::version) version, bool has_mempool_descendant) :
        m_txid{txid}, m_wtxid{wtxid}, m_version{version},
        m_has_mempool_descendant{has_mempool_descendant}
    {}
};

std::optional<std::string> PackageTRUCChecks(const CTxMemPool& pool, const CTransactionRef& ptx, int64_t vsize,
                                           const Package& package,
                                           const std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef>& mempool_parents)
{
    AssertLockHeld(pool.cs);
    // This function is specialized for these limits, and must be reimplemented if they ever change.
    static_assert(TRUC_ANCESTOR_LIMIT == 2);
    static_assert(TRUC_DESCENDANT_LIMIT == 2);

    const auto in_package_parents{FindInPackageParents(package, ptx)};

    // Now we have all parents, so we can start checking TRUC rules.
    if (ptx->version == TRUC_VERSION) {
        // SingleTRUCChecks should have checked this already.
        if (!Assume(vsize <= TRUC_MAX_VSIZE)) {
            return strprintf("version=3 tx %s (wtxid=%s) is too big: %u > %u virtual bytes",
                             ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(), vsize, TRUC_MAX_VSIZE);
        }

        if (mempool_parents.size() + in_package_parents.size() + 1 > TRUC_ANCESTOR_LIMIT) {
            return strprintf("tx %s (wtxid=%s) would have too many ancestors",
                             ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString());
        }

        if (mempool_parents.size()) {
            if (pool.GetAncestorCount(mempool_parents[0]) + in_package_parents.size() + 1 > TRUC_ANCESTOR_LIMIT) {
                return strprintf("tx %s (wtxid=%s) would have too many ancestors",
                                 ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString());
            }
        }

        const bool has_parent{mempool_parents.size() + in_package_parents.size() > 0};
        if (has_parent) {
            // A TRUC child cannot be too large.
            if (vsize > TRUC_CHILD_MAX_VSIZE) {
                return strprintf("version=3 child tx %s (wtxid=%s) is too big: %u > %u virtual bytes",
                                 ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(),
                                 vsize, TRUC_CHILD_MAX_VSIZE);
            }

            // Exactly 1 parent exists, either in mempool or package. Find it.
            const auto parent_info = [&] {
                if (mempool_parents.size() > 0) {
                    const auto& mempool_parent = &mempool_parents[0].get();
                    return ParentInfo{mempool_parent->GetTx().GetHash(),
                                      mempool_parent->GetTx().GetWitnessHash(),
                                      mempool_parent->GetTx().version,
                                      /*has_mempool_descendant=*/pool.GetDescendantCount(*mempool_parent) > 1};
                } else {
                    auto& parent_index = in_package_parents.front();
                    auto& package_parent = package.at(parent_index);
                    return ParentInfo{package_parent->GetHash(),
                                      package_parent->GetWitnessHash(),
                                      package_parent->version,
                                      /*has_mempool_descendant=*/false};
                }
            }();

            // If there is a parent, it must have the right version.
            if (parent_info.m_version != TRUC_VERSION) {
                return strprintf("version=3 tx %s (wtxid=%s) cannot spend from non-version=3 tx %s (wtxid=%s)",
                                 ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(),
                                 parent_info.m_txid.ToString(), parent_info.m_wtxid.ToString());
            }

            for (const auto& package_tx : package) {
                // Skip same tx.
                if (&(*package_tx) == &(*ptx)) continue;

                for (auto& input : package_tx->vin) {
                    // Fail if we find another tx with the same parent. We don't check whether the
                    // sibling is to-be-replaced (done in SingleTRUCChecks) because these transactions
                    // are within the same package.
                    if (input.prevout.hash == parent_info.m_txid) {
                        return strprintf("tx %s (wtxid=%s) would exceed descendant count limit",
                                         parent_info.m_txid.ToString(),
                                         parent_info.m_wtxid.ToString());
                    }

                    // This tx can't have both a parent and an in-package child.
                    if (input.prevout.hash == ptx->GetHash()) {
                        return strprintf("tx %s (wtxid=%s) would have too many ancestors",
                                         package_tx->GetHash().ToString(), package_tx->GetWitnessHash().ToString());
                    }
                }
            }

            if (parent_info.m_has_mempool_descendant) {
                return strprintf("tx %s (wtxid=%s) would exceed descendant count limit",
                                parent_info.m_txid.ToString(), parent_info.m_wtxid.ToString());
            }
        }
    } else {
        // Non-TRUC transactions cannot have TRUC parents.
        for (auto it : mempool_parents) {
            if (it.get().GetTx().version == TRUC_VERSION) {
                return strprintf("non-version=3 tx %s (wtxid=%s) cannot spend from version=3 tx %s (wtxid=%s)",
                                 ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(),
                                 it.get().GetSharedTx()->GetHash().ToString(), it.get().GetSharedTx()->GetWitnessHash().ToString());
            }
        }
        for (const auto& index: in_package_parents) {
            if (package.at(index)->version == TRUC_VERSION) {
                return strprintf("non-version=3 tx %s (wtxid=%s) cannot spend from version=3 tx %s (wtxid=%s)",
                                 ptx->GetHash().ToString(),
                                 ptx->GetWitnessHash().ToString(),
                                 package.at(index)->GetHash().ToString(),
                                 package.at(index)->GetWitnessHash().ToString());
            }
        }
    }
    return std::nullopt;
}

std::optional<std::pair<std::string, CTransactionRef>> SingleTRUCChecks(const CTxMemPool& pool, const CTransactionRef& ptx,
                                          const std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef>& mempool_parents,
                                          const std::set<Txid>& direct_conflicts,
                                          int64_t vsize)
{
    AssertLockHeld(pool.cs);
    // Check TRUC and non-TRUC inheritance.
    for (const auto& entry_ref : mempool_parents) {
        const auto& entry = &entry_ref.get();
        if (ptx->version != TRUC_VERSION && entry->GetTx().version == TRUC_VERSION) {
            return std::make_pair(strprintf("non-version=3 tx %s (wtxid=%s) cannot spend from version=3 tx %s (wtxid=%s)",
                             ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(),
                             entry->GetSharedTx()->GetHash().ToString(), entry->GetSharedTx()->GetWitnessHash().ToString()),
                nullptr);
        } else if (ptx->version == TRUC_VERSION && entry->GetTx().version != TRUC_VERSION) {
            return std::make_pair(strprintf("version=3 tx %s (wtxid=%s) cannot spend from non-version=3 tx %s (wtxid=%s)",
                             ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(),
                             entry->GetSharedTx()->GetHash().ToString(), entry->GetSharedTx()->GetWitnessHash().ToString()),
                nullptr);
        }
    }

    // This function is specialized for these limits, and must be reimplemented if they ever change.
    static_assert(TRUC_ANCESTOR_LIMIT == 2);
    static_assert(TRUC_DESCENDANT_LIMIT == 2);

    // The rest of the rules only apply to transactions with version=3.
    if (ptx->version != TRUC_VERSION) return std::nullopt;

    if (vsize > TRUC_MAX_VSIZE) {
        return std::make_pair(strprintf("version=3 tx %s (wtxid=%s) is too big: %u > %u virtual bytes",
                         ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(), vsize, TRUC_MAX_VSIZE),
            nullptr);
    }

    // Check that TRUC_ANCESTOR_LIMIT would not be violated.
    if (mempool_parents.size() + 1 > TRUC_ANCESTOR_LIMIT) {
        return std::make_pair(strprintf("tx %s (wtxid=%s) would have too many ancestors",
                         ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString()),
            nullptr);
    }

    // Remaining checks only pertain to transactions with unconfirmed ancestors.
    if (mempool_parents.size() > 0) {
        // Ensure that the in-mempool parent doesn't have any additional
        // ancestors, as that would also be a violation.
        if (pool.GetAncestorCount(mempool_parents[0]) + 1 > TRUC_ANCESTOR_LIMIT) {
            return std::make_pair(strprintf("tx %s (wtxid=%s) would have too many ancestors",
                             ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString()),
                nullptr);
        }
        // If this transaction spends TRUC parents, it cannot be too large.
        if (vsize > TRUC_CHILD_MAX_VSIZE) {
            return std::make_pair(strprintf("version=3 child tx %s (wtxid=%s) is too big: %u > %u virtual bytes",
                             ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(), vsize, TRUC_CHILD_MAX_VSIZE),
                nullptr);
        }

        // Check the descendant counts of in-mempool parents.
        const auto& parent_entry = mempool_parents[0].get();
        // If there are any parents, this is the only child allowed. The parent cannot have any
        // other descendants. We handle the possibility of multiple children as that case is
        // possible through a reorg.
        CTxMemPool::setEntries descendants;
        auto parent_it = pool.CalculateDescendants(parent_entry, descendants);
        descendants.erase(parent_it);
        // Don't double-count a transaction that is going to be replaced. This logic assumes that
        // any descendant of the TRUC transaction is a direct child, which makes sense because a
        // TRUC transaction can only have 1 descendant.
        const bool child_will_be_replaced = !descendants.empty() &&
            std::any_of(descendants.cbegin(), descendants.cend(),
                [&direct_conflicts](const CTxMemPool::txiter& child){return direct_conflicts.contains(child->GetTx().GetHash());});
        if (pool.GetDescendantCount(parent_entry) + 1 > TRUC_DESCENDANT_LIMIT && !child_will_be_replaced) {
            // Allow sibling eviction for TRUC transaction: if another child already exists, even if
            // we don't conflict inputs with it, consider evicting it under RBF rules. We rely on TRUC rules
            // only permitting 1 descendant, as otherwise we would need to have logic for deciding
            // which descendant to evict. Skip if this isn't true, e.g. if the transaction has
            // multiple children or the sibling also has descendants due to a reorg.
            const bool consider_sibling_eviction{pool.GetDescendantCount(parent_entry) == 2 &&
                pool.GetAncestorCount(**descendants.begin()) == 2};

            // Return the sibling if its eviction can be considered. Provide the "descendant count
            // limit" string either way, as the caller may decide not to do sibling eviction.
            return std::make_pair(strprintf("tx %u (wtxid=%s) would exceed descendant count limit",
                                            parent_entry.GetSharedTx()->GetHash().ToString(),
                                            parent_entry.GetSharedTx()->GetWitnessHash().ToString()),
                                  consider_sibling_eviction ? (*descendants.begin())->GetSharedTx() : nullptr);
        }
    }
    return std::nullopt;
}

Coverage Report

Created: 2026-06-09 19:51

Line	Count	Source
1		// Copyright (c) 2022-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 <policy/truc_policy.h>
6
7		#include <coins.h>
8		#include <consensus/amount.h>
9		#include <tinyformat.h>
10		#include <util/check.h>
11
12		#include <algorithm>
13		#include <numeric>
14		#include <vector>
15
16		/** Helper for PackageTRUCChecks: Returns a vector containing the indices of transactions (within
17		* package) that are direct parents of ptx. */
18		std::vector<size_t> FindInPackageParents(const Package& package, const CTransactionRef& ptx)
19	0	{
20	0	std::vector<size_t> in_package_parents;
21
22	0	std::set<Txid> possible_parents;
23	0	for (auto &input : ptx->vin) { Branch (23:22): [True: 0, False: 0]
24	0	possible_parents.insert(input.prevout.hash);
25	0	}
26
27	0	for (size_t i{0}; i < package.size(); ++i) { Branch (27:23): [True: 0, False: 0]
28	0	const auto& tx = package.at(i);
29		// We assume the package is sorted, so that we don't need to continue
30		// looking past the transaction itself.
31	0	if (&(tx) == &(ptx)) break; Branch (31:13): [True: 0, False: 0]
32	0	if (possible_parents.contains(tx->GetHash())) { Branch (32:13): [True: 0, False: 0]
33	0	in_package_parents.push_back(i);
34	0	}
35	0	}
36	0	return in_package_parents;
37	0	}
38
39		/** Helper for PackageTRUCChecks, storing info for a mempool or package parent. */
40		struct ParentInfo {
41		/** Txid used to identify this parent by prevout */
42		const Txid& m_txid;
43		/** Wtxid used for debug string */
44		const Wtxid& m_wtxid;
45		/** version used to check inheritance of TRUC and non-TRUC */
46		decltype(CTransaction::version) m_version;
47		/** If parent is in mempool, whether it has any descendants in mempool. */
48		bool m_has_mempool_descendant;
49
50		ParentInfo() = delete;
51		ParentInfo(const Txid& txid, const Wtxid& wtxid, decltype(CTransaction::version) version, bool has_mempool_descendant) :
52	0	m_txid{txid}, m_wtxid{wtxid}, m_version{version},
53	0	m_has_mempool_descendant{has_mempool_descendant}
54	0	{}
55		};
56
57		std::optional<std::string> PackageTRUCChecks(const CTxMemPool& pool, const CTransactionRef& ptx, int64_t vsize,
58		const Package& package,
59		const std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef>& mempool_parents)
60	0	{
61	0	AssertLockHeld(pool.cs);
62		// This function is specialized for these limits, and must be reimplemented if they ever change.
63	0	static_assert(TRUC_ANCESTOR_LIMIT == 2);
64	0	static_assert(TRUC_DESCENDANT_LIMIT == 2);
65
66	0	const auto in_package_parents{FindInPackageParents(package, ptx)};
67
68		// Now we have all parents, so we can start checking TRUC rules.
69	0	if (ptx->version == TRUC_VERSION) { Branch (69:9): [True: 0, False: 0]
70		// SingleTRUCChecks should have checked this already.
71	0	if (!Assume(vsize <= TRUC_MAX_VSIZE)) { Branch (71:13): [True: 0, False: 0]
72	0	return strprintf("version=3 tx %s (wtxid=%s) is too big: %u > %u virtual bytes",
73	0	ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(), vsize, TRUC_MAX_VSIZE);
74	0	}
75
76	0	if (mempool_parents.size() + in_package_parents.size() + 1 > TRUC_ANCESTOR_LIMIT) { Branch (76:13): [True: 0, False: 0]
77	0	return strprintf("tx %s (wtxid=%s) would have too many ancestors",
78	0	ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString());
79	0	}
80
81	0	if (mempool_parents.size()) { Branch (81:13): [True: 0, False: 0]
82	0	if (pool.GetAncestorCount(mempool_parents[0]) + in_package_parents.size() + 1 > TRUC_ANCESTOR_LIMIT) { Branch (82:17): [True: 0, False: 0]
83	0	return strprintf("tx %s (wtxid=%s) would have too many ancestors",
84	0	ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString());
85	0	}
86	0	}
87
88	0	const bool has_parent{mempool_parents.size() + in_package_parents.size() > 0};
89	0	if (has_parent) { Branch (89:13): [True: 0, False: 0]
90		// A TRUC child cannot be too large.
91	0	if (vsize > TRUC_CHILD_MAX_VSIZE) { Branch (91:17): [True: 0, False: 0]
92	0	return strprintf("version=3 child tx %s (wtxid=%s) is too big: %u > %u virtual bytes",
93	0	ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(),
94	0	vsize, TRUC_CHILD_MAX_VSIZE);
95	0	}
96
97		// Exactly 1 parent exists, either in mempool or package. Find it.
98	0	const auto parent_info = [&] {
99	0	if (mempool_parents.size() > 0) { Branch (99:21): [True: 0, False: 0]
100	0	const auto& mempool_parent = &mempool_parents[0].get();
101	0	return ParentInfo{mempool_parent->GetTx().GetHash(),
102	0	mempool_parent->GetTx().GetWitnessHash(),
103	0	mempool_parent->GetTx().version,
104	0	/has_mempool_descendant=/pool.GetDescendantCount(*mempool_parent) > 1};
105	0	} else {
106	0	auto& parent_index = in_package_parents.front();
107	0	auto& package_parent = package.at(parent_index);
108	0	return ParentInfo{package_parent->GetHash(),
109	0	package_parent->GetWitnessHash(),
110	0	package_parent->version,
111	0	/has_mempool_descendant=/false};
112	0	}
113	0	}();
114
115		// If there is a parent, it must have the right version.
116	0	if (parent_info.m_version != TRUC_VERSION) { Branch (116:17): [True: 0, False: 0]
117	0	return strprintf("version=3 tx %s (wtxid=%s) cannot spend from non-version=3 tx %s (wtxid=%s)",
118	0	ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(),
119	0	parent_info.m_txid.ToString(), parent_info.m_wtxid.ToString());
120	0	}
121
122	0	for (const auto& package_tx : package) { Branch (122:41): [True: 0, False: 0]
123		// Skip same tx.
124	0	if (&(package_tx) == &(ptx)) continue; Branch (124:21): [True: 0, False: 0]
125
126	0	for (auto& input : package_tx->vin) { Branch (126:34): [True: 0, False: 0]
127		// Fail if we find another tx with the same parent. We don't check whether the
128		// sibling is to-be-replaced (done in SingleTRUCChecks) because these transactions
129		// are within the same package.
130	0	if (input.prevout.hash == parent_info.m_txid) { Branch (130:25): [True: 0, False: 0]
131	0	return strprintf("tx %s (wtxid=%s) would exceed descendant count limit",
132	0	parent_info.m_txid.ToString(),
133	0	parent_info.m_wtxid.ToString());
134	0	}
135
136		// This tx can't have both a parent and an in-package child.
137	0	if (input.prevout.hash == ptx->GetHash()) { Branch (137:25): [True: 0, False: 0]
138	0	return strprintf("tx %s (wtxid=%s) would have too many ancestors",
139	0	package_tx->GetHash().ToString(), package_tx->GetWitnessHash().ToString());
140	0	}
141	0	}
142	0	}
143
144	0	if (parent_info.m_has_mempool_descendant) { Branch (144:17): [True: 0, False: 0]
145	0	return strprintf("tx %s (wtxid=%s) would exceed descendant count limit",
146	0	parent_info.m_txid.ToString(), parent_info.m_wtxid.ToString());
147	0	}
148	0	}
149	0	} else {
150		// Non-TRUC transactions cannot have TRUC parents.
151	0	for (auto it : mempool_parents) { Branch (151:22): [True: 0, False: 0]
152	0	if (it.get().GetTx().version == TRUC_VERSION) { Branch (152:17): [True: 0, False: 0]
153	0	return strprintf("non-version=3 tx %s (wtxid=%s) cannot spend from version=3 tx %s (wtxid=%s)",
154	0	ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(),
155	0	it.get().GetSharedTx()->GetHash().ToString(), it.get().GetSharedTx()->GetWitnessHash().ToString());
156	0	}
157	0	}
158	0	for (const auto& index: in_package_parents) { Branch (158:31): [True: 0, False: 0]
159	0	if (package.at(index)->version == TRUC_VERSION) { Branch (159:17): [True: 0, False: 0]
160	0	return strprintf("non-version=3 tx %s (wtxid=%s) cannot spend from version=3 tx %s (wtxid=%s)",
161	0	ptx->GetHash().ToString(),
162	0	ptx->GetWitnessHash().ToString(),
163	0	package.at(index)->GetHash().ToString(),
164	0	package.at(index)->GetWitnessHash().ToString());
165	0	}
166	0	}
167	0	}
168	0	return std::nullopt;
169	0	}
170
171		std::optional<std::pair<std::string, CTransactionRef>> SingleTRUCChecks(const CTxMemPool& pool, const CTransactionRef& ptx,
172		const std::vector<CTxMemPoolEntry::CTxMemPoolEntryRef>& mempool_parents,
173		const std::set<Txid>& direct_conflicts,
174		int64_t vsize)
175	0	{
176	0	AssertLockHeld(pool.cs);
177		// Check TRUC and non-TRUC inheritance.
178	0	for (const auto& entry_ref : mempool_parents) { Branch (178:32): [True: 0, False: 0]
179	0	const auto& entry = &entry_ref.get();
180	0	if (ptx->version != TRUC_VERSION && entry->GetTx().version == TRUC_VERSION) { Branch (180:13): [True: 0, False: 0] Branch (180:45): [True: 0, False: 0]
181	0	return std::make_pair(strprintf("non-version=3 tx %s (wtxid=%s) cannot spend from version=3 tx %s (wtxid=%s)",
182	0	ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(),
183	0	entry->GetSharedTx()->GetHash().ToString(), entry->GetSharedTx()->GetWitnessHash().ToString()),
184	0	nullptr);
185	0	} else if (ptx->version == TRUC_VERSION && entry->GetTx().version != TRUC_VERSION) { Branch (185:20): [True: 0, False: 0] Branch (185:52): [True: 0, False: 0]
186	0	return std::make_pair(strprintf("version=3 tx %s (wtxid=%s) cannot spend from non-version=3 tx %s (wtxid=%s)",
187	0	ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(),
188	0	entry->GetSharedTx()->GetHash().ToString(), entry->GetSharedTx()->GetWitnessHash().ToString()),
189	0	nullptr);
190	0	}
191	0	}
192
193		// This function is specialized for these limits, and must be reimplemented if they ever change.
194	0	static_assert(TRUC_ANCESTOR_LIMIT == 2);
195	0	static_assert(TRUC_DESCENDANT_LIMIT == 2);
196
197		// The rest of the rules only apply to transactions with version=3.
198	0	if (ptx->version != TRUC_VERSION) return std::nullopt; Branch (198:9): [True: 0, False: 0]
199
200	0	if (vsize > TRUC_MAX_VSIZE) { Branch (200:9): [True: 0, False: 0]
201	0	return std::make_pair(strprintf("version=3 tx %s (wtxid=%s) is too big: %u > %u virtual bytes",
202	0	ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(), vsize, TRUC_MAX_VSIZE),
203	0	nullptr);
204	0	}
205
206		// Check that TRUC_ANCESTOR_LIMIT would not be violated.
207	0	if (mempool_parents.size() + 1 > TRUC_ANCESTOR_LIMIT) { Branch (207:9): [True: 0, False: 0]
208	0	return std::make_pair(strprintf("tx %s (wtxid=%s) would have too many ancestors",
209	0	ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString()),
210	0	nullptr);
211	0	}
212
213		// Remaining checks only pertain to transactions with unconfirmed ancestors.
214	0	if (mempool_parents.size() > 0) { Branch (214:9): [True: 0, False: 0]
215		// Ensure that the in-mempool parent doesn't have any additional
216		// ancestors, as that would also be a violation.
217	0	if (pool.GetAncestorCount(mempool_parents[0]) + 1 > TRUC_ANCESTOR_LIMIT) { Branch (217:13): [True: 0, False: 0]
218	0	return std::make_pair(strprintf("tx %s (wtxid=%s) would have too many ancestors",
219	0	ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString()),
220	0	nullptr);
221	0	}
222		// If this transaction spends TRUC parents, it cannot be too large.
223	0	if (vsize > TRUC_CHILD_MAX_VSIZE) { Branch (223:13): [True: 0, False: 0]
224	0	return std::make_pair(strprintf("version=3 child tx %s (wtxid=%s) is too big: %u > %u virtual bytes",
225	0	ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(), vsize, TRUC_CHILD_MAX_VSIZE),
226	0	nullptr);
227	0	}
228
229		// Check the descendant counts of in-mempool parents.
230	0	const auto& parent_entry = mempool_parents[0].get();
231		// If there are any parents, this is the only child allowed. The parent cannot have any
232		// other descendants. We handle the possibility of multiple children as that case is
233		// possible through a reorg.
234	0	CTxMemPool::setEntries descendants;
235	0	auto parent_it = pool.CalculateDescendants(parent_entry, descendants);
236	0	descendants.erase(parent_it);
237		// Don't double-count a transaction that is going to be replaced. This logic assumes that
238		// any descendant of the TRUC transaction is a direct child, which makes sense because a
239		// TRUC transaction can only have 1 descendant.
240	0	const bool child_will_be_replaced = !descendants.empty() && Branch (240:45): [True: 0, False: 0]
241	0	std::any_of(descendants.cbegin(), descendants.cend(), Branch (241:13): [True: 0, False: 0]
242	0	[&direct_conflicts](const CTxMemPool::txiter& child){return direct_conflicts.contains(child->GetTx().GetHash());});
243	0	if (pool.GetDescendantCount(parent_entry) + 1 > TRUC_DESCENDANT_LIMIT && !child_will_be_replaced) { Branch (243:13): [True: 0, False: 0] Branch (243:82): [True: 0, False: 0]
244		// Allow sibling eviction for TRUC transaction: if another child already exists, even if
245		// we don't conflict inputs with it, consider evicting it under RBF rules. We rely on TRUC rules
246		// only permitting 1 descendant, as otherwise we would need to have logic for deciding
247		// which descendant to evict. Skip if this isn't true, e.g. if the transaction has
248		// multiple children or the sibling also has descendants due to a reorg.
249	0	const bool consider_sibling_eviction{pool.GetDescendantCount(parent_entry) == 2 && Branch (249:50): [True: 0, False: 0]
250	0	pool.GetAncestorCount(**descendants.begin()) == 2}; Branch (250:17): [True: 0, False: 0]
251
252		// Return the sibling if its eviction can be considered. Provide the "descendant count
253		// limit" string either way, as the caller may decide not to do sibling eviction.
254	0	return std::make_pair(strprintf("tx %u (wtxid=%s) would exceed descendant count limit",
255	0	parent_entry.GetSharedTx()->GetHash().ToString(),
256	0	parent_entry.GetSharedTx()->GetWitnessHash().ToString()),
257	0	consider_sibling_eviction ? (*descendants.begin())->GetSharedTx() : nullptr); Branch (257:35): [True: 0, False: 0]
258	0	}
259	0	}
260	0	return std::nullopt;
261	0	}