28 std::vector<COutPoint> g_outpoints_coinbase_init_mature;
29 std::vector<COutPoint> g_outpoints_coinbase_init_immature;
35 lastRollingFeeUpdate =
GetTime();
36 blockSinceLastRollingFeeBump =
true;
40 void initialize_tx_pool()
42 static const auto testing_setup = MakeNoLogFileContext<const TestingSetup>();
43 g_setup = testing_setup.get();
49 g_outpoints_coinbase_init_mature :
50 g_outpoints_coinbase_init_immature;
51 outpoints.push_back(prevout);
57 std::set<CTransactionRef>& m_removed;
58 std::set<CTransactionRef>& m_added;
60 explicit TransactionsDelta(std::set<CTransactionRef>& r, std::set<CTransactionRef>& a)
61 : m_removed{r}, m_added{a} {}
70 Assert(m_removed.insert(tx).second);
94 BlockAssembler::Options options;
98 auto block_template = assembler.CreateNewBlock(
CScript{} <<
OP_TRUE);
99 Assert(block_template->block.vtx.size() >= 1);
101 const auto info_all = tx_pool.infoAll();
102 if (!info_all.empty()) {
103 const auto& tx_to_remove = *
PickValue(fuzzed_data_provider, info_all).tx;
105 assert(tx_pool.size() < info_all.size());
113 const auto time =
ConsumeTime(fuzzed_data_provider,
115 std::numeric_limits<decltype(chainstate.
m_chain.
Tip()->
nTime)>::max());
126 mempool_opts.require_standard = fuzzed_data_provider.
ConsumeBool();
132 void CheckATMPInvariants(
const MempoolAcceptResult& res,
bool txid_in_mempool,
bool wtxid_in_mempool)
188 MockTime(fuzzed_data_provider, chainstate);
191 std::set<COutPoint> outpoints_rbf;
193 std::set<COutPoint> outpoints_supply;
194 for (
const auto& outpoint : g_outpoints_coinbase_init_mature) {
195 Assert(outpoints_supply.insert(outpoint).second);
197 outpoints_rbf = outpoints_supply;
202 SetMempoolConstraints(*
node.args, fuzzed_data_provider);
204 MockedTxPool& tx_pool = *
static_cast<MockedTxPool*
>(&tx_pool_);
206 chainstate.SetMempool(&tx_pool);
210 const auto GetAmount = [&](
const COutPoint& outpoint) {
212 Assert(amount_view.GetCoin(outpoint, c));
221 for (
const auto& op : outpoints_supply) {
222 supply_now += GetAmount(op);
224 Assert(supply_now == SUPPLY_TOTAL);
226 Assert(!outpoints_supply.empty());
237 for (
int i = 0; i < num_in; ++i) {
239 auto pop = outpoints_rbf.begin();
241 const auto outpoint = *pop;
242 outpoints_rbf.erase(pop);
243 amount_in += GetAmount(outpoint);
247 const auto script_sig =
CScript{};
255 tx_mut.
vin.push_back(in);
258 const auto amount_out = (amount_in - amount_fee) / num_out;
259 for (
int i = 0; i < num_out; ++i) {
264 for (
const auto& in : tx->vin) {
271 MockTime(fuzzed_data_provider, chainstate);
274 tx_pool.RollingFeeUpdate();
277 const auto& txid = fuzzed_data_provider.
ConsumeBool() ?
279 PickValue(fuzzed_data_provider, outpoints_rbf).hash;
281 tx_pool.PrioritiseTransaction(txid.ToUint256(), delta);
285 std::set<CTransactionRef> removed;
286 std::set<CTransactionRef> added;
287 auto txr = std::make_shared<TransactionsDelta>(removed, added);
288 node.validation_signals->RegisterSharedValidationInterface(txr);
289 const bool bypass_limits = fuzzed_data_provider.
ConsumeBool();
298 auto it = result_package.m_tx_results.find(tx->GetWitnessHash());
299 Assert(it != result_package.m_tx_results.end());
306 node.validation_signals->SyncWithValidationInterfaceQueue();
307 node.validation_signals->UnregisterSharedValidationInterface(txr);
309 bool txid_in_mempool = tx_pool.exists(
GenTxid::Txid(tx->GetHash()));
310 bool wtxid_in_mempool = tx_pool.exists(
GenTxid::Wtxid(tx->GetWitnessHash()));
311 CheckATMPInvariants(res, txid_in_mempool, wtxid_in_mempool);
313 Assert(accepted != added.empty());
315 Assert(added.size() == 1);
316 Assert(tx == *added.begin());
324 using Sets = std::vector<std::reference_wrapper<std::set<COutPoint>>>;
325 const auto insert_tx = [](Sets created_by_tx, Sets consumed_by_tx,
const auto& tx) {
326 for (
size_t i{0}; i < tx.vout.size(); ++i) {
327 for (
auto& set : created_by_tx) {
328 Assert(set.get().emplace(tx.GetHash(), i).second);
331 for (
const auto& in : tx.vin) {
332 for (
auto& set : consumed_by_tx) {
340 std::set<COutPoint> consumed_erased;
342 std::set<COutPoint> consumed_supply;
343 for (
const auto& removed_tx : removed) {
344 insert_tx({consumed_erased}, {outpoints_supply}, *removed_tx);
346 for (
const auto& added_tx : added) {
347 insert_tx({outpoints_supply, outpoints_rbf}, {consumed_supply}, *added_tx);
349 for (
const auto& p : consumed_erased) {
350 Assert(outpoints_supply.erase(p) == 1);
351 Assert(outpoints_rbf.erase(p) == 1);
353 for (
const auto& p : consumed_supply) {
354 Assert(outpoints_supply.erase(p) == 1);
358 Finish(fuzzed_data_provider, tx_pool, chainstate);
367 MockTime(fuzzed_data_provider, chainstate);
369 std::vector<Txid> txids;
370 txids.reserve(g_outpoints_coinbase_init_mature.size());
371 for (
const auto& outpoint : g_outpoints_coinbase_init_mature) {
372 txids.push_back(outpoint.hash);
374 for (
int i{0}; i <= 3; ++i) {
376 txids.push_back(g_outpoints_coinbase_init_immature.at(i).hash);
380 SetMempoolConstraints(*
node.args, fuzzed_data_provider);
382 MockedTxPool& tx_pool = *
static_cast<MockedTxPool*
>(&tx_pool_);
384 chainstate.SetMempool(&tx_pool);
391 MockTime(fuzzed_data_provider, chainstate);
394 tx_pool.RollingFeeUpdate();
397 const auto txid = fuzzed_data_provider.
ConsumeBool() ?
401 tx_pool.PrioritiseTransaction(txid.ToUint256(), delta);
405 const bool bypass_limits = fuzzed_data_provider.
ConsumeBool();
409 txids.push_back(tx->GetHash());
413 Finish(fuzzed_data_provider, tx_pool, chainstate);
int64_t CAmount
Amount in satoshis (Can be negative)
static constexpr CAmount COIN
The amount of satoshis in one BTC.
#define Assert(val)
Identity function.
void ForceSetArg(const std::string &strArg, const std::string &strValue)
int64_t GetMedianTimePast() const
CBlockIndex * Tip() const
Returns the index entry for the tip of this chain, or nullptr if none.
int Height() const
Return the maximal height in the chain.
CCoinsView that brings transactions from a mempool into view.
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.
static const int32_t CURRENT_VERSION
An input of a transaction.
CScriptWitness scriptWitness
Only serialized through CTransaction.
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
Implement this to subscribe to events generated in validation and mempool.
virtual void TransactionRemovedFromMempool(const CTransactionRef &tx, MemPoolRemovalReason reason, uint64_t mempool_sequence)
Notifies listeners of a transaction leaving mempool.
virtual void TransactionAddedToMempool(const NewMempoolTransactionInfo &tx, uint64_t mempool_sequence)
Notifies listeners of a transaction having been added to mempool.
Chainstate stores and provides an API to update our local knowledge of the current best chain.
CChain m_chain
The current chain of blockheaders we consult and build on.
CCoinsViewCache & CoinsTip() EXCLUSIVE_LOCKS_REQUIRED(
CTxOut out
unspent transaction output
T ConsumeIntegralInRange(T min, T max)
static GenTxid Wtxid(const uint256 &hash)
static GenTxid Txid(const uint256 &hash)
Generate a new block, without valid proof-of-work.
static transaction_identifier FromUint256(const uint256 &id)
@ TX_RECONSIDERABLE
fails some policy, but might be acceptable if submitted in a (different) package
static const unsigned int MAX_BLOCK_WEIGHT
The maximum allowed weight for a block, see BIP 141 (network rule)
static const int COINBASE_MATURITY
Coinbase transaction outputs can only be spent after this number of new blocks (network rule)
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.
MemPoolRemovalReason
Reason why a transaction was removed from the mempool, this is passed to the notification signal.
@ BLOCK
Removed for block.
@ PCKG_POLICY
The package itself is invalid (e.g. too many transactions).
static CTransactionRef MakeTransactionRef(Tx &&txIn)
std::shared_ptr< const CTransaction > CTransactionRef
std::string ToString(const T &t)
Locale-independent version of std::to_string.
A mutable version of CTransaction.
std::vector< CTxOut > vout
std::vector< std::vector< unsigned char > > stack
Validation result for a transaction evaluated by MemPoolAccept (single or package).
const std::optional< int64_t > m_vsize
Virtual size as used by the mempool, calculated using serialized size and sigops.
const ResultType m_result_type
Result type.
const std::optional< CAmount > m_base_fees
Raw base fees in satoshis.
const std::optional< std::list< CTransactionRef > > m_replaced_transactions
Mempool transactions replaced by the tx.
const TxValidationState m_state
Contains information about why the transaction failed.
@ DIFFERENT_WITNESS
Valid, transaction was already in the mempool.
@ INVALID
Fully validated, valid.
const std::optional< CFeeRate > m_effective_feerate
The feerate at which this transaction was considered.
const std::optional< uint256 > m_other_wtxid
The wtxid of the transaction in the mempool which has the same txid but different witness.
const std::optional< std::vector< Wtxid > > m_wtxids_fee_calculations
Contains the wtxids of the transactions used for fee-related checks.
Testing setup that configures a complete environment.
const CTransactionRef m_tx
Options struct containing options for constructing a CTxMemPool.
NodeContext struct containing references to chain state and connection state.
std::unique_ptr< ValidationSignals > validation_signals
Issues calls about blocks and transactions.
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
uint32_t ConsumeSequence(FuzzedDataProvider &fuzzed_data_provider) noexcept
int64_t ConsumeTime(FuzzedDataProvider &fuzzed_data_provider, const std::optional< int64_t > &min, const std::optional< int64_t > &max) noexcept
CMutableTransaction ConsumeTransaction(FuzzedDataProvider &fuzzed_data_provider, const std::optional< std::vector< Txid >> &prevout_txids, const int max_num_in, const int max_num_out) noexcept
CAmount ConsumeMoney(FuzzedDataProvider &fuzzed_data_provider, const std::optional< CAmount > &max) noexcept
auto & PickValue(FuzzedDataProvider &fuzzed_data_provider, Collection &col)
uint256 ConsumeUInt256(FuzzedDataProvider &fuzzed_data_provider) noexcept
COutPoint MineBlock(const NodeContext &node, const CScript &coinbase_scriptPubKey)
Returns the generated coin.
static const std::vector< uint8_t > WITNESS_STACK_ELEM_OP_TRUE
static const CScript P2WSH_OP_TRUE
CTxMemPool::Options MemPoolOptionsForTest(const NodeContext &node)
void CheckMempoolV3Invariants(const CTxMemPool &tx_pool)
For every transaction in tx_pool, check v3 invariants:
#define EXCLUSIVE_LOCKS_REQUIRED(...)
void SetMockTime(int64_t nMockTimeIn)
DEPRECATED Use SetMockTime with chrono type.
PackageMempoolAcceptResult ProcessNewPackage(Chainstate &active_chainstate, CTxMemPool &pool, const Package &package, bool test_accept, const std::optional< CFeeRate > &client_maxfeerate)
Validate (and maybe submit) a package to the mempool.
MempoolAcceptResult AcceptToMemoryPool(Chainstate &active_chainstate, const CTransactionRef &tx, int64_t accept_time, bool bypass_limits, bool test_accept) EXCLUSIVE_LOCKS_REQUIRED(
Try to add a transaction to the mempool.