22 std::deque<COutPoint> g_available_coins;
23 void initialize_miner()
25 static const auto testing_setup = MakeNoLogFileContext<const TestingSetup>();
26 g_setup = testing_setup.get();
27 for (uint32_t i = 0; i < uint32_t{100}; ++i) {
37 std::vector<COutPoint> outpoints;
38 std::deque<COutPoint> available_coins = g_available_coins;
44 const size_t num_inputs = fuzzed_data_provider.ConsumeIntegralInRange<
size_t>(1, available_coins.size());
45 const size_t num_outputs = fuzzed_data_provider.ConsumeIntegralInRange<
size_t>(1, 50);
46 for (
size_t n{0}; n < num_inputs; ++n) {
47 auto prevout = available_coins.front();
49 available_coins.pop_front();
51 for (uint32_t n{0}; n < num_outputs; ++n) {
58 pool.addUnchecked(entry.
Fee(fee).
FromTx(tx));
61 for (uint32_t n{0}; n < num_outputs; ++n) {
62 if (fuzzed_data_provider.ConsumeBool()) {
63 available_coins.push_back(
COutPoint{tx->GetHash(), n});
67 if (fuzzed_data_provider.ConsumeBool() && !tx->vout.empty()) {
69 outpoints.push_back(
COutPoint{tx->GetHash(),
70 (uint32_t)fuzzed_data_provider.ConsumeIntegralInRange<
size_t>(0, tx->vout.size())});
74 auto outpoint = ConsumeDeserializable<COutPoint>(fuzzed_data_provider);
75 if (outpoint.has_value() && std::find(outpoints.begin(), outpoints.end(), *outpoint) == outpoints.end()) {
76 outpoints.push_back(*outpoint);
83 std::optional<CAmount> total_bumpfee;
87 assert(mini_miner.IsReadyToCalculate());
88 const auto bump_fees = mini_miner.CalculateBumpFees(target_feerate);
89 for (
const auto& outpoint : outpoints) {
90 auto it = bump_fees.find(outpoint);
91 assert(it != bump_fees.end());
93 sum_fees += it->second;
95 assert(!mini_miner.IsReadyToCalculate());
99 assert(mini_miner.IsReadyToCalculate());
100 total_bumpfee = mini_miner.CalculateTotalBumpFees(target_feerate);
101 assert(total_bumpfee.has_value());
102 assert(!mini_miner.IsReadyToCalculate());
105 assert (sum_fees >= *total_bumpfee);
114 std::deque<COutPoint> available_coins = g_available_coins;
115 std::vector<CTransactionRef> transactions;
121 assert(!available_coins.empty());
122 const size_t num_inputs = std::min(
size_t{2}, available_coins.size());
123 const size_t num_outputs = fuzzed_data_provider.ConsumeIntegralInRange<
size_t>(2, 5);
124 for (
size_t n{0}; n < num_inputs; ++n) {
125 auto prevout = available_coins.at(0);
127 available_coins.pop_front();
129 for (uint32_t n{0}; n < num_outputs; ++n) {
137 for (uint32_t n{0}; n < num_outputs - 1; ++n) {
138 if (fuzzed_data_provider.ConsumeBool()) {
139 available_coins.push_front(
COutPoint{tx->GetHash(), n});
141 available_coins.push_back(
COutPoint{tx->GetHash(), n});
151 pool.addUnchecked(entry.
Fee(fee).
FromTx(tx));
152 transactions.push_back(tx);
154 std::vector<COutPoint> outpoints;
155 for (
const auto& coin : g_available_coins) {
156 if (!pool.GetConflictTx(coin)) outpoints.push_back(coin);
158 for (
const auto& tx : transactions) {
160 for (uint32_t n{0}; n < tx->vout.size(); ++n) {
162 if (!pool.GetConflictTx(coin)) outpoints.push_back(coin);
174 assert(mini_miner.IsReadyToCalculate());
179 const auto blocktemplate{miner.CreateNewBlock(spk_placeholder)};
180 mini_miner.BuildMockTemplate(target_feerate);
181 assert(!mini_miner.IsReadyToCalculate());
182 auto mock_template_txids = mini_miner.GetMockTemplateTxids();
184 assert(mock_template_txids.count(blocktemplate->block.vtx[0]->GetHash()) == 0);
185 mock_template_txids.emplace(blocktemplate->block.vtx[0]->GetHash());
186 assert(mock_template_txids.size() <= blocktemplate->block.vtx.size());
187 assert(mock_template_txids.size() >= blocktemplate->block.vtx.size());
188 assert(mock_template_txids.size() == blocktemplate->block.vtx.size());
189 for (
const auto& tx : blocktemplate->block.vtx) {
190 assert(mock_template_txids.count(tx->GetHash()));
static constexpr CAmount MAX_MONEY
No amount larger than this (in satoshi) is valid.
bool MoneyRange(const CAmount &nValue)
int64_t CAmount
Amount in satoshis (Can be negative)
Fee rate in satoshis per kilovirtualbyte: CAmount / kvB.
An outpoint - a combination of a transaction hash and an index n into its vout.
Serialized script, used inside transaction inputs and outputs.
An input of a transaction.
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
An output of a transaction.
static GenTxid Txid(const uint256 &hash)
Generate a new block, without valid proof-of-work.
A minimal version of BlockAssembler.
static const uint256 ZERO
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
#define LIMITED_WHILE(condition, limit)
Can be used to limit a theoretically unbounded loop.
int64_t GetVirtualTransactionSize(int64_t nWeight, int64_t nSigOpCost, unsigned int bytes_per_sigop)
Compute the virtual transaction size (weight reinterpreted as bytes).
static constexpr unsigned int DEFAULT_BLOCK_MAX_WEIGHT
Default for -blockmaxweight, which controls the range of block weights the mining code will create.
static CTransactionRef MakeTransactionRef(Tx &&txIn)
std::shared_ptr< const CTransaction > CTransactionRef
A mutable version of CTransaction.
std::vector< CTxOut > vout
CTxMemPoolEntry FromTx(const CMutableTransaction &tx) const
TestMemPoolEntryHelper & Fee(CAmount _fee)
Testing setup that configures a complete environment.
Options struct containing options for constructing a CTxMemPool.
std::unique_ptr< ChainstateManager > chainman
CAmount ConsumeMoney(FuzzedDataProvider &fuzzed_data_provider, const std::optional< CAmount > &max) noexcept
static const CScript P2WSH_OP_TRUE