Branch data Line data Source code
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 : 161190 : std::vector<size_t> FindInPackageParents(const Package& package, const CTransactionRef& ptx)
19 : : {
20 : 161190 : std::vector<size_t> in_package_parents;
21 : :
22 : 161190 : std::set<Txid> possible_parents;
23 [ + + ]: 583842 : for (auto &input : ptx->vin) {
24 [ + - ]: 422652 : possible_parents.insert(input.prevout.hash);
25 : : }
26 : :
27 [ - + + - ]: 242392 : for (size_t i{0}; i < package.size(); ++i) {
28 [ + - ]: 242392 : 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 [ + + ]: 242392 : if (&(*tx) == &(*ptx)) break;
32 [ + + ]: 81202 : if (possible_parents.contains(tx->GetHash())) {
33 [ + - ]: 65672 : in_package_parents.push_back(i);
34 : : }
35 : : }
36 : 161190 : return in_package_parents;
37 : 161190 : }
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 : 2924 : ParentInfo(const Txid& txid, const Wtxid& wtxid, decltype(CTransaction::version) version, bool has_mempool_descendant) :
52 : 2924 : m_txid{txid}, m_wtxid{wtxid}, m_version{version},
53 : 2924 : m_has_mempool_descendant{has_mempool_descendant}
54 : 2924 : {}
55 : : };
56 : :
57 : 161190 : 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 : : {
61 : 161190 : AssertLockHeld(pool.cs);
62 : : // This function is specialized for these limits, and must be reimplemented if they ever change.
63 : 161190 : static_assert(TRUC_ANCESTOR_LIMIT == 2);
64 : 161190 : static_assert(TRUC_DESCENDANT_LIMIT == 2);
65 : :
66 : 161190 : const auto in_package_parents{FindInPackageParents(package, ptx)};
67 : :
68 : : // Now we have all parents, so we can start checking TRUC rules.
69 [ + + ]: 161190 : if (ptx->version == TRUC_VERSION) {
70 : : // SingleTRUCChecks should have checked this already.
71 [ + - ]: 10889 : if (!Assume(vsize <= TRUC_MAX_VSIZE)) {
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 : : }
75 : :
76 [ - + - + : 10889 : if (mempool_parents.size() + in_package_parents.size() + 1 > TRUC_ANCESTOR_LIMIT) {
+ + ]
77 [ + - ]: 2 : return strprintf("tx %s (wtxid=%s) would have too many ancestors",
78 [ + - + - : 3 : ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString());
+ - ]
79 : : }
80 : :
81 [ + + ]: 10888 : if (mempool_parents.size()) {
82 [ + - - + : 2015 : if (pool.GetAncestorCount(mempool_parents[0]) + in_package_parents.size() + 1 > TRUC_ANCESTOR_LIMIT) {
- + ]
83 [ # # ]: 0 : return strprintf("tx %s (wtxid=%s) would have too many ancestors",
84 [ # # # # : 0 : ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString());
# # ]
85 : : }
86 : : }
87 : :
88 [ - + - + ]: 10888 : const bool has_parent{mempool_parents.size() + in_package_parents.size() > 0};
89 [ + + ]: 10888 : if (has_parent) {
90 : : // A TRUC child cannot be too large.
91 [ + + ]: 3001 : if (vsize > TRUC_CHILD_MAX_VSIZE) {
92 [ + - ]: 154 : return strprintf("version=3 child tx %s (wtxid=%s) is too big: %u > %u virtual bytes",
93 [ + - + - : 154 : ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(),
+ - ]
94 : 77 : vsize, TRUC_CHILD_MAX_VSIZE);
95 : : }
96 : :
97 : : // Exactly 1 parent exists, either in mempool or package. Find it.
98 : 5848 : const auto parent_info = [&] {
99 [ - + + + ]: 2924 : if (mempool_parents.size() > 0) {
100 : 2015 : const auto& mempool_parent = &mempool_parents[0].get();
101 : 2015 : return ParentInfo{mempool_parent->GetTx().GetHash(),
102 : 2015 : mempool_parent->GetTx().GetWitnessHash(),
103 : 2015 : mempool_parent->GetTx().version,
104 : 2015 : /*has_mempool_descendant=*/pool.GetDescendantCount(*mempool_parent) > 1};
105 : : } else {
106 : 909 : auto& parent_index = in_package_parents.front();
107 : 909 : auto& package_parent = package.at(parent_index);
108 : 909 : return ParentInfo{package_parent->GetHash(),
109 : : package_parent->GetWitnessHash(),
110 : 909 : package_parent->version,
111 : 909 : /*has_mempool_descendant=*/false};
112 : : }
113 [ + - ]: 2924 : }();
114 : :
115 : : // If there is a parent, it must have the right version.
116 [ + + ]: 2924 : if (parent_info.m_version != TRUC_VERSION) {
117 : 91 : return strprintf("version=3 tx %s (wtxid=%s) cannot spend from non-version=3 tx %s (wtxid=%s)",
118 [ + - + - : 182 : ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(),
+ - ]
119 [ + - + - : 273 : parent_info.m_txid.ToString(), parent_info.m_wtxid.ToString());
+ - ]
120 : : }
121 : :
122 [ + + ]: 6484 : for (const auto& package_tx : package) {
123 : : // Skip same tx.
124 [ + + ]: 3846 : if (&(*package_tx) == &(*ptx)) continue;
125 : :
126 [ + + ]: 1914 : for (auto& input : package_tx->vin) {
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 [ - + ]: 1096 : if (input.prevout.hash == parent_info.m_txid) {
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 : : }
135 : :
136 : : // This tx can't have both a parent and an in-package child.
137 [ + + ]: 1096 : if (input.prevout.hash == ptx->GetHash()) {
138 [ + - ]: 390 : return strprintf("tx %s (wtxid=%s) would have too many ancestors",
139 [ + - + - : 585 : package_tx->GetHash().ToString(), package_tx->GetWitnessHash().ToString());
+ - ]
140 : : }
141 : : }
142 : : }
143 : :
144 [ - + ]: 2638 : if (parent_info.m_has_mempool_descendant) {
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 : : }
148 : : }
149 : : } else {
150 : : // Non-TRUC transactions cannot have TRUC parents.
151 [ + + ]: 242592 : for (auto it : mempool_parents) {
152 [ - + ]: 92291 : if (it.get().GetTx().version == TRUC_VERSION) {
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 : : }
157 : : }
158 [ + + ]: 214657 : for (const auto& index: in_package_parents) {
159 [ + - + + ]: 64677 : if (package.at(index)->version == TRUC_VERSION) {
160 : 321 : return strprintf("non-version=3 tx %s (wtxid=%s) cannot spend from version=3 tx %s (wtxid=%s)",
161 [ + - + - ]: 642 : ptx->GetHash().ToString(),
162 [ + - + - ]: 642 : ptx->GetWitnessHash().ToString(),
163 [ + - + - ]: 642 : package.at(index)->GetHash().ToString(),
164 [ + - + - : 963 : package.at(index)->GetWitnessHash().ToString());
+ - ]
165 : : }
166 : : }
167 : : }
168 : 160505 : return std::nullopt;
169 : 161190 : }
170 : :
171 : 694823 : 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 : : {
176 : 694823 : AssertLockHeld(pool.cs);
177 : : // Check TRUC and non-TRUC inheritance.
178 [ + + ]: 1228760 : for (const auto& entry_ref : mempool_parents) {
179 [ + + ]: 540951 : const auto& entry = &entry_ref.get();
180 [ + + + + ]: 540951 : if (ptx->version != TRUC_VERSION && entry->GetTx().version == TRUC_VERSION) {
181 : 9166 : return std::make_pair(strprintf("non-version=3 tx %s (wtxid=%s) cannot spend from version=3 tx %s (wtxid=%s)",
182 [ + - + - : 9166 : ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(),
+ - ]
183 [ + - + - : 27498 : entry->GetSharedTx()->GetHash().ToString(), entry->GetSharedTx()->GetWitnessHash().ToString()),
+ - + - +
- + - +
- ]
184 : 4583 : nullptr);
185 [ + + + + ]: 536368 : } else if (ptx->version == TRUC_VERSION && entry->GetTx().version != TRUC_VERSION) {
186 : 4862 : return std::make_pair(strprintf("version=3 tx %s (wtxid=%s) cannot spend from non-version=3 tx %s (wtxid=%s)",
187 [ + - + - : 4862 : ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(),
+ - ]
188 [ + - + - : 14586 : entry->GetSharedTx()->GetHash().ToString(), entry->GetSharedTx()->GetWitnessHash().ToString()),
+ - + - +
- + - +
- ]
189 : 2431 : nullptr);
190 : : }
191 : : }
192 : :
193 : : // This function is specialized for these limits, and must be reimplemented if they ever change.
194 : 687809 : static_assert(TRUC_ANCESTOR_LIMIT == 2);
195 : 687809 : static_assert(TRUC_DESCENDANT_LIMIT == 2);
196 : :
197 : : // The rest of the rules only apply to transactions with version=3.
198 [ + + ]: 687809 : if (ptx->version != TRUC_VERSION) return std::nullopt;
199 : :
200 [ + + ]: 55118 : if (vsize > TRUC_MAX_VSIZE) {
201 : 3572 : return std::make_pair(strprintf("version=3 tx %s (wtxid=%s) is too big: %u > %u virtual bytes",
202 [ + - + - ]: 3572 : ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(), vsize, TRUC_MAX_VSIZE),
203 : 3572 : nullptr);
204 : : }
205 : :
206 : : // Check that TRUC_ANCESTOR_LIMIT would not be violated.
207 [ - + + + ]: 53332 : if (mempool_parents.size() + 1 > TRUC_ANCESTOR_LIMIT) {
208 : 1236 : return std::make_pair(strprintf("tx %s (wtxid=%s) would have too many ancestors",
209 [ + - + - ]: 1236 : ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString()),
210 : 1236 : nullptr);
211 : : }
212 : :
213 : : // Remaining checks only pertain to transactions with unconfirmed ancestors.
214 [ + + ]: 52714 : if (mempool_parents.size() > 0) {
215 : : // Ensure that the in-mempool parent doesn't have any additional
216 : : // ancestors, as that would also be a violation.
217 [ + + ]: 16808 : if (pool.GetAncestorCount(mempool_parents[0]) + 1 > TRUC_ANCESTOR_LIMIT) {
218 : 1410 : return std::make_pair(strprintf("tx %s (wtxid=%s) would have too many ancestors",
219 [ + - + - ]: 1410 : ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString()),
220 : 1410 : nullptr);
221 : : }
222 : : // If this transaction spends TRUC parents, it cannot be too large.
223 [ + + ]: 16103 : if (vsize > TRUC_CHILD_MAX_VSIZE) {
224 : 6424 : return std::make_pair(strprintf("version=3 child tx %s (wtxid=%s) is too big: %u > %u virtual bytes",
225 [ + - + - ]: 6424 : ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(), vsize, TRUC_CHILD_MAX_VSIZE),
226 : 6424 : nullptr);
227 : : }
228 : :
229 : : // Check the descendant counts of in-mempool parents.
230 [ + - ]: 12891 : 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 [ + - ]: 12891 : CTxMemPool::setEntries descendants;
235 [ + - ]: 12891 : auto parent_it = pool.CalculateDescendants(parent_entry, descendants);
236 : 12891 : 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 [ + + + + ]: 19081 : const bool child_will_be_replaced = !descendants.empty() &&
241 : 6190 : std::any_of(descendants.cbegin(), descendants.cend(),
242 : 7100 : [&direct_conflicts](const CTxMemPool::txiter& child){return direct_conflicts.contains(child->GetTx().GetHash());});
243 [ + - + + : 12891 : if (pool.GetDescendantCount(parent_entry) + 1 > TRUC_DESCENDANT_LIMIT && !child_will_be_replaced) {
+ + ]
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 [ + - + + : 5961 : const bool consider_sibling_eviction{pool.GetDescendantCount(parent_entry) == 2 &&
+ + ]
250 [ + - ]: 2950 : pool.GetAncestorCount(**descendants.begin()) == 2};
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 [ + - ]: 8967 : return std::make_pair(strprintf("tx %u (wtxid=%s) would exceed descendant count limit",
255 [ + - + - : 9033 : parent_entry.GetSharedTx()->GetHash().ToString(),
+ - ]
256 [ + - + - : 9033 : parent_entry.GetSharedTx()->GetWitnessHash().ToString()),
+ - ]
257 [ + - + - ]: 11978 : consider_sibling_eviction ? (*descendants.begin())->GetSharedTx() : nullptr);
258 : : }
259 : 12891 : }
260 : 45786 : return std::nullopt;
261 : : }
|
