Bitcoin Core  25.99.0
P2P Digital Currency
txorphan.cpp
Go to the documentation of this file.
1 // Copyright (c) 2022 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 <consensus/amount.h>
6 #include <consensus/validation.h>
7 #include <net_processing.h>
8 #include <node/eviction.h>
9 #include <policy/policy.h>
10 #include <primitives/transaction.h>
11 #include <script/script.h>
12 #include <sync.h>
14 #include <test/fuzz/fuzz.h>
15 #include <test/fuzz/util.h>
16 #include <test/util/setup_common.h>
17 #include <txorphanage.h>
18 #include <uint256.h>
19 #include <util/check.h>
20 #include <util/time.h>
21 
22 #include <cstdint>
23 #include <memory>
24 #include <set>
25 #include <utility>
26 #include <vector>
27 
29 {
30  static const auto testing_setup = MakeNoLogFileContext();
31 }
32 
34 {
35  FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
36  SetMockTime(ConsumeTime(fuzzed_data_provider));
37 
38  TxOrphanage orphanage;
39  std::vector<COutPoint> outpoints;
40  // initial outpoints used to construct transactions later
41  for (uint8_t i = 0; i < 4; i++) {
42  outpoints.emplace_back(uint256{i}, 0);
43  }
44  // if true, allow duplicate input when constructing tx
45  const bool duplicate_input = fuzzed_data_provider.ConsumeBool();
46 
47  LIMITED_WHILE(outpoints.size() < 200'000 && fuzzed_data_provider.ConsumeBool(), 10 * DEFAULT_MAX_ORPHAN_TRANSACTIONS)
48  {
49  // construct transaction
50  const CTransactionRef tx = [&] {
51  CMutableTransaction tx_mut;
52  const auto num_in = fuzzed_data_provider.ConsumeIntegralInRange<uint32_t>(1, outpoints.size());
53  const auto num_out = fuzzed_data_provider.ConsumeIntegralInRange<uint32_t>(1, outpoints.size());
54  // pick unique outpoints from outpoints as input
55  for (uint32_t i = 0; i < num_in; i++) {
56  auto& prevout = PickValue(fuzzed_data_provider, outpoints);
57  tx_mut.vin.emplace_back(prevout);
58  // pop the picked outpoint if duplicate input is not allowed
59  if (!duplicate_input) {
60  std::swap(prevout, outpoints.back());
61  outpoints.pop_back();
62  }
63  }
64  // output amount will not affect txorphanage
65  for (uint32_t i = 0; i < num_out; i++) {
66  tx_mut.vout.emplace_back(CAmount{0}, CScript{});
67  }
68  // restore previously popped outpoints
69  for (auto& in : tx_mut.vin) {
70  outpoints.push_back(in.prevout);
71  }
72  auto new_tx = MakeTransactionRef(tx_mut);
73  // add newly constructed transaction to outpoints
74  for (uint32_t i = 0; i < num_out; i++) {
75  outpoints.emplace_back(new_tx->GetHash(), i);
76  }
77  return new_tx;
78  }();
79 
80  // trigger orphanage functions
81  LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 10 * DEFAULT_MAX_ORPHAN_TRANSACTIONS)
82  {
83  NodeId peer_id = fuzzed_data_provider.ConsumeIntegral<NodeId>();
84 
85  CallOneOf(
86  fuzzed_data_provider,
87  [&] {
88  orphanage.AddChildrenToWorkSet(*tx);
89  },
90  [&] {
91  {
92  CTransactionRef ref = orphanage.GetTxToReconsider(peer_id);
93  if (ref) {
94  bool have_tx = orphanage.HaveTx(GenTxid::Txid(ref->GetHash())) || orphanage.HaveTx(GenTxid::Wtxid(ref->GetHash()));
95  Assert(have_tx);
96  }
97  }
98  },
99  [&] {
100  bool have_tx = orphanage.HaveTx(GenTxid::Txid(tx->GetHash())) || orphanage.HaveTx(GenTxid::Wtxid(tx->GetHash()));
101  // AddTx should return false if tx is too big or already have it
102  // tx weight is unknown, we only check when tx is already in orphanage
103  {
104  bool add_tx = orphanage.AddTx(tx, peer_id);
105  // have_tx == true -> add_tx == false
106  Assert(!have_tx || !add_tx);
107  }
108  have_tx = orphanage.HaveTx(GenTxid::Txid(tx->GetHash())) || orphanage.HaveTx(GenTxid::Wtxid(tx->GetHash()));
109  {
110  bool add_tx = orphanage.AddTx(tx, peer_id);
111  // if have_tx is still false, it must be too big
112  Assert(!have_tx == (GetTransactionWeight(*tx) > MAX_STANDARD_TX_WEIGHT));
113  Assert(!have_tx || !add_tx);
114  }
115  },
116  [&] {
117  bool have_tx = orphanage.HaveTx(GenTxid::Txid(tx->GetHash())) || orphanage.HaveTx(GenTxid::Wtxid(tx->GetHash()));
118  // EraseTx should return 0 if m_orphans doesn't have the tx
119  {
120  Assert(have_tx == orphanage.EraseTx(tx->GetHash()));
121  }
122  have_tx = orphanage.HaveTx(GenTxid::Txid(tx->GetHash())) || orphanage.HaveTx(GenTxid::Wtxid(tx->GetHash()));
123  // have_tx should be false and EraseTx should fail
124  {
125  Assert(!have_tx && !orphanage.EraseTx(tx->GetHash()));
126  }
127  },
128  [&] {
129  orphanage.EraseForPeer(peer_id);
130  },
131  [&] {
132  // test mocktime and expiry
133  SetMockTime(ConsumeTime(fuzzed_data_provider));
134  auto limit = fuzzed_data_provider.ConsumeIntegral<unsigned int>();
135  orphanage.LimitOrphans(limit);
136  Assert(orphanage.Size() <= limit);
137  });
138  }
139  }
140 }
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
#define Assert(val)
Identity function.
Definition: check.h:73
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:413
T ConsumeIntegralInRange(T min, T max)
static GenTxid Wtxid(const uint256 &hash)
Definition: transaction.h:433
static GenTxid Txid(const uint256 &hash)
Definition: transaction.h:432
A class to track orphan transactions (failed on TX_MISSING_INPUTS) Since we cannot distinguish orphan...
Definition: txorphanage.h:21
void AddChildrenToWorkSet(const CTransaction &tx) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Add any orphans that list a particular tx as a parent into the from peer's work set.
bool HaveTx(const GenTxid &gtxid) const EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Check if we already have an orphan transaction (by txid or wtxid)
size_t Size() EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Return how many entries exist in the orphange.
Definition: txorphanage.h:55
CTransactionRef GetTxToReconsider(NodeId peer) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Extract a transaction from a peer's work set Returns nullptr if there are no transactions to work on.
void EraseForPeer(NodeId peer) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Erase all orphans announced by a peer (eg, after that peer disconnects)
Definition: txorphanage.cpp:96
void LimitOrphans(unsigned int max_orphans) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Limit the orphanage to the given maximum.
256-bit opaque blob.
Definition: uint256.h:106
#define LIMITED_WHILE(condition, limit)
Can be used to limit a theoretically unbounded loop.
Definition: fuzz.h:18
int64_t NodeId
Definition: net.h:97
static const uint32_t DEFAULT_MAX_ORPHAN_TRANSACTIONS
Default for -maxorphantx, maximum number of orphan transactions kept in memory.
static CTransactionRef MakeTransactionRef(Tx &&txIn)
Definition: transaction.h:422
std::shared_ptr< const CTransaction > CTransactionRef
Definition: transaction.h:421
std::unique_ptr< T > MakeNoLogFileContext(const ChainType chain_type=ChainType::REGTEST, const std::vector< const char * > &extra_args={})
Make a test setup that has disk access to the debug.log file disabled.
Definition: setup_common.h:178
A mutable version of CTransaction.
Definition: transaction.h:380
std::vector< CTxOut > vout
Definition: transaction.h:382
std::vector< CTxIn > vin
Definition: transaction.h:381
int64_t ConsumeTime(FuzzedDataProvider &fuzzed_data_provider, const std::optional< int64_t > &min, const std::optional< int64_t > &max) noexcept
Definition: util.cpp:35
auto & PickValue(FuzzedDataProvider &fuzzed_data_provider, Collection &col)
Definition: util.h:48
size_t CallOneOf(FuzzedDataProvider &fuzzed_data_provider, Callables... callables)
Definition: util.h:36
void SetMockTime(int64_t nMockTimeIn)
DEPRECATED Use SetMockTime with chrono type.
Definition: time.cpp:81
void initialize_orphanage()
Definition: txorphan.cpp:28
FUZZ_TARGET(txorphan,.init=initialize_orphanage)
Definition: txorphan.cpp:33