Bitcoin Core  22.99.0
P2P Digital Currency
txvalidation_tests.cpp
Go to the documentation of this file.
1 // Copyright (c) 2017-2020 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/validation.h>
6 #include <key_io.h>
7 #include <policy/packages.h>
8 #include <policy/policy.h>
10 #include <script/script.h>
11 #include <script/standard.h>
12 #include <test/util/setup_common.h>
13 #include <validation.h>
14 
15 #include <boost/test/unit_test.hpp>
16 
17 
18 BOOST_AUTO_TEST_SUITE(txvalidation_tests)
19 
20 
23 BOOST_FIXTURE_TEST_CASE(tx_mempool_reject_coinbase, TestChain100Setup)
24 {
25  CScript scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
26  CMutableTransaction coinbaseTx;
27 
28  coinbaseTx.nVersion = 1;
29  coinbaseTx.vin.resize(1);
30  coinbaseTx.vout.resize(1);
31  coinbaseTx.vin[0].scriptSig = CScript() << OP_11 << OP_EQUAL;
32  coinbaseTx.vout[0].nValue = 1 * CENT;
33  coinbaseTx.vout[0].scriptPubKey = scriptPubKey;
34 
35  BOOST_CHECK(CTransaction(coinbaseTx).IsCoinBase());
36 
37  LOCK(cs_main);
38 
39  unsigned int initialPoolSize = m_node.mempool->size();
40  const MempoolAcceptResult result = AcceptToMemoryPool(m_node.chainman->ActiveChainstate(), *m_node.mempool, MakeTransactionRef(coinbaseTx),
41  true /* bypass_limits */);
42 
44 
45  // Check that the transaction hasn't been added to mempool.
46  BOOST_CHECK_EQUAL(m_node.mempool->size(), initialPoolSize);
47 
48  // Check that the validation state reflects the unsuccessful attempt.
49  BOOST_CHECK(result.m_state.IsInvalid());
50  BOOST_CHECK_EQUAL(result.m_state.GetRejectReason(), "coinbase");
52 }
53 
54 // Create placeholder transactions that have no meaning.
55 inline CTransactionRef create_placeholder_tx(size_t num_inputs, size_t num_outputs)
56 {
58  mtx.vin.resize(num_inputs);
59  mtx.vout.resize(num_outputs);
60  auto random_script = CScript() << ToByteVector(InsecureRand256()) << ToByteVector(InsecureRand256());
61  for (size_t i{0}; i < num_inputs; ++i) {
62  mtx.vin[i].prevout.hash = InsecureRand256();
63  mtx.vin[i].prevout.n = 0;
64  mtx.vin[i].scriptSig = random_script;
65  }
66  for (size_t o{0}; o < num_outputs; ++o) {
67  mtx.vout[o].nValue = 1 * CENT;
68  mtx.vout[o].scriptPubKey = random_script;
69  }
70  return MakeTransactionRef(mtx);
71 }
72 
74 {
75  LOCK(cs_main);
76  unsigned int initialPoolSize = m_node.mempool->size();
77 
78  // Parent and Child Package
79  CKey parent_key;
80  parent_key.MakeNewKey(true);
81  CScript parent_locking_script = GetScriptForDestination(PKHash(parent_key.GetPubKey()));
82  auto mtx_parent = CreateValidMempoolTransaction(/* input_transaction */ m_coinbase_txns[0], /* vout */ 0,
83  /* input_height */ 0, /* input_signing_key */ coinbaseKey,
84  /* output_destination */ parent_locking_script,
85  /* output_amount */ CAmount(49 * COIN), /* submit */ false);
86  CTransactionRef tx_parent = MakeTransactionRef(mtx_parent);
87 
88  CKey child_key;
89  child_key.MakeNewKey(true);
90  CScript child_locking_script = GetScriptForDestination(PKHash(child_key.GetPubKey()));
91  auto mtx_child = CreateValidMempoolTransaction(/* input_transaction */ tx_parent, /* vout */ 0,
92  /* input_height */ 101, /* input_signing_key */ parent_key,
93  /* output_destination */ child_locking_script,
94  /* output_amount */ CAmount(48 * COIN), /* submit */ false);
95  CTransactionRef tx_child = MakeTransactionRef(mtx_child);
96  const auto result_parent_child = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool, {tx_parent, tx_child}, /* test_accept */ true);
97  BOOST_CHECK_MESSAGE(result_parent_child.m_state.IsValid(),
98  "Package validation unexpectedly failed: " << result_parent_child.m_state.GetRejectReason());
99  auto it_parent = result_parent_child.m_tx_results.find(tx_parent->GetWitnessHash());
100  auto it_child = result_parent_child.m_tx_results.find(tx_child->GetWitnessHash());
101  BOOST_CHECK(it_parent != result_parent_child.m_tx_results.end());
102  BOOST_CHECK_MESSAGE(it_parent->second.m_state.IsValid(),
103  "Package validation unexpectedly failed: " << it_parent->second.m_state.GetRejectReason());
104  BOOST_CHECK(it_child != result_parent_child.m_tx_results.end());
105  BOOST_CHECK_MESSAGE(it_child->second.m_state.IsValid(),
106  "Package validation unexpectedly failed: " << it_child->second.m_state.GetRejectReason());
107 
108  // Packages can't have more than 25 transactions.
109  Package package_too_many;
110  package_too_many.reserve(MAX_PACKAGE_COUNT + 1);
111  for (size_t i{0}; i < MAX_PACKAGE_COUNT + 1; ++i) {
112  package_too_many.emplace_back(create_placeholder_tx(1, 1));
113  }
114  auto result_too_many = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool, package_too_many, /* test_accept */ true);
115  BOOST_CHECK(result_too_many.m_state.IsInvalid());
116  BOOST_CHECK_EQUAL(result_too_many.m_state.GetResult(), PackageValidationResult::PCKG_POLICY);
117  BOOST_CHECK_EQUAL(result_too_many.m_state.GetRejectReason(), "package-too-many-transactions");
118 
119  // Packages can't have a total size of more than 101KvB.
120  CTransactionRef large_ptx = create_placeholder_tx(150, 150);
121  Package package_too_large;
122  auto size_large = GetVirtualTransactionSize(*large_ptx);
123  size_t total_size{0};
124  while (total_size <= MAX_PACKAGE_SIZE * 1000) {
125  package_too_large.push_back(large_ptx);
126  total_size += size_large;
127  }
128  BOOST_CHECK(package_too_large.size() <= MAX_PACKAGE_COUNT);
129  auto result_too_large = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool, package_too_large, /* test_accept */ true);
130  BOOST_CHECK(result_too_large.m_state.IsInvalid());
131  BOOST_CHECK_EQUAL(result_too_large.m_state.GetResult(), PackageValidationResult::PCKG_POLICY);
132  BOOST_CHECK_EQUAL(result_too_large.m_state.GetRejectReason(), "package-too-large");
133 
134  // A single, giant transaction submitted through ProcessNewPackage fails on single tx policy.
135  CTransactionRef giant_ptx = create_placeholder_tx(999, 999);
137  auto result_single_large = ProcessNewPackage(m_node.chainman->ActiveChainstate(), *m_node.mempool, {giant_ptx}, /* test_accept */ true);
138  BOOST_CHECK(result_single_large.m_state.IsInvalid());
139  BOOST_CHECK_EQUAL(result_single_large.m_state.GetResult(), PackageValidationResult::PCKG_TX);
140  BOOST_CHECK_EQUAL(result_single_large.m_state.GetRejectReason(), "transaction failed");
141  auto it_giant_tx = result_single_large.m_tx_results.find(giant_ptx->GetWitnessHash());
142  BOOST_CHECK(it_giant_tx != result_single_large.m_tx_results.end());
143  BOOST_CHECK_EQUAL(it_giant_tx->second.m_state.GetRejectReason(), "tx-size");
144 
145  // Check that mempool size hasn't changed.
146  BOOST_CHECK_EQUAL(m_node.mempool->size(), initialPoolSize);
147 }
policy.h
CMutableTransaction::vin
std::vector< CTxIn > vin
Definition: transaction.h:346
BOOST_AUTO_TEST_SUITE
BOOST_AUTO_TEST_SUITE(cuckoocache_tests)
Test Suite for CuckooCache.
PackageValidationResult::PCKG_TX
@ PCKG_TX
At least one tx is invalid.
CKey::MakeNewKey
void MakeNewKey(bool fCompressed)
Generate a new private key using a cryptographic PRNG.
Definition: key.cpp:160
MempoolAcceptResult::m_state
const TxValidationState m_state
Definition: validation.h:166
key_io.h
setup_common.h
NodeContext::mempool
std::unique_ptr< CTxMemPool > mempool
Definition: context.h:44
transaction.h
MempoolAcceptResult::m_result_type
const ResultType m_result_type
Definition: validation.h:165
AcceptToMemoryPool
MempoolAcceptResult AcceptToMemoryPool(CChainState &active_chainstate, CTxMemPool &pool, const CTransactionRef &tx, bool bypass_limits, bool test_accept)
(Try to) add a transaction to the memory pool.
Definition: validation.cpp:1040
GetScriptForDestination
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
Definition: standard.cpp:351
CMutableTransaction::nVersion
int32_t nVersion
Definition: transaction.h:348
InsecureRand256
static uint256 InsecureRand256()
Definition: setup_common.h:66
m_node
NodeContext & m_node
Definition: bitcoin-node.cpp:38
validation.h
MakeTransactionRef
static CTransactionRef MakeTransactionRef(Tx &&txIn)
Definition: transaction.h:387
CTransactionRef
std::shared_ptr< const CTransaction > CTransactionRef
Definition: transaction.h:386
BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END()
CTransaction
The basic transaction that is broadcasted on the network and contained in blocks.
Definition: transaction.h:259
packages.h
PackageValidationResult::PCKG_POLICY
@ PCKG_POLICY
The package itself is invalid (e.g. too many transactions).
ToByteVector
std::vector< unsigned char > ToByteVector(const T &in)
Definition: script.h:60
OP_EQUAL
@ OP_EQUAL
Definition: script.h:139
MempoolAcceptResult::ResultType::INVALID
@ INVALID
Fully validated, valid.
CENT
static constexpr CAmount CENT
Definition: setup_common.h:71
CAmount
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
standard.h
create_placeholder_tx
CTransactionRef create_placeholder_tx(size_t num_inputs, size_t num_outputs)
Definition: txvalidation_tests.cpp:55
TestChain100Setup
Testing fixture that pre-creates a 100-block REGTEST-mode block chain.
Definition: setup_common.h:116
CKey::GetPubKey
CPubKey GetPubKey() const
Compute the public key from a private key.
Definition: key.cpp:187
CScript
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:405
script.h
MAX_PACKAGE_COUNT
static constexpr uint32_t MAX_PACKAGE_COUNT
Default maximum number of transactions in a package.
Definition: packages.h:15
ValidationState::GetResult
Result GetResult() const
Definition: validation.h:122
CMutableTransaction::vout
std::vector< CTxOut > vout
Definition: transaction.h:347
PKHash
Definition: standard.h:79
BOOST_FIXTURE_TEST_CASE
BOOST_FIXTURE_TEST_CASE(tx_mempool_reject_coinbase, TestChain100Setup)
Ensure that the mempool won't accept coinbase transactions.
Definition: txvalidation_tests.cpp:23
TxValidationResult::TX_CONSENSUS
@ TX_CONSENSUS
invalid by consensus rules
CKey
An encapsulated private key.
Definition: key.h:26
cs_main
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition: validation.cpp:116
NodeContext::chainman
std::unique_ptr< ChainstateManager > chainman
Definition: context.h:47
LOCK
#define LOCK(cs)
Definition: sync.h:226
MempoolAcceptResult
Validation result for a single transaction mempool acceptance.
Definition: validation.h:159
Package
std::vector< CTransactionRef > Package
A package is an ordered list of transactions.
Definition: packages.h:32
COIN
static const CAmount COIN
Definition: amount.h:14
ValidationState::GetRejectReason
std::string GetRejectReason() const
Definition: validation.h:123
MAX_PACKAGE_SIZE
static constexpr uint32_t MAX_PACKAGE_SIZE
Default maximum total virtual size of transactions in a package in KvB.
Definition: packages.h:17
CMutableTransaction
A mutable version of CTransaction.
Definition: transaction.h:344
OP_CHECKSIG
@ OP_CHECKSIG
Definition: script.h:183
OP_11
@ OP_11
Definition: script.h:87
GetVirtualTransactionSize
int64_t GetVirtualTransactionSize(int64_t nWeight, int64_t nSigOpCost, unsigned int bytes_per_sigop)
Compute the virtual transaction size (weight reinterpreted as bytes).
Definition: policy.cpp:280
ValidationState::IsInvalid
bool IsInvalid() const
Definition: validation.h:120
BOOST_CHECK
#define BOOST_CHECK(expr)
Definition: object.cpp:17
BOOST_CHECK_EQUAL
#define BOOST_CHECK_EQUAL(v1, v2)
Definition: object.cpp:18
ProcessNewPackage
PackageMempoolAcceptResult ProcessNewPackage(CChainState &active_chainstate, CTxMemPool &pool, const Package &package, bool test_accept)
Atomically test acceptance of a package.
Definition: validation.cpp:1046