Bitcoin Core  22.99.0
P2P Digital Currency
txvalidationcache_tests.cpp
Go to the documentation of this file.
1 // Copyright (c) 2011-2021 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.h>
7 #include <script/sign.h>
9 #include <script/standard.h>
10 #include <test/util/setup_common.h>
11 #include <txmempool.h>
12 #include <validation.h>
13 
14 #include <boost/test/unit_test.hpp>
15 
18  : TestChain100Setup{{"-testactivationheight=dersig@102"}} {}
19 };
20 
21 bool CheckInputScripts(const CTransaction& tx, TxValidationState& state,
22  const CCoinsViewCache& inputs, unsigned int flags, bool cacheSigStore,
23  bool cacheFullScriptStore, PrecomputedTransactionData& txdata,
24  std::vector<CScriptCheck>* pvChecks) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
25 
26 BOOST_AUTO_TEST_SUITE(txvalidationcache_tests)
27 
28 BOOST_FIXTURE_TEST_CASE(tx_mempool_block_doublespend, Dersig100Setup)
29 {
30  // Make sure skipping validation of transactions that were
31  // validated going into the memory pool does not allow
32  // double-spends in blocks to pass validation when they should not.
33 
34  CScript scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
35 
36  const auto ToMemPool = [this](const CMutableTransaction& tx) {
37  LOCK(cs_main);
38 
39  const MempoolAcceptResult result = m_node.chainman->ProcessTransaction(MakeTransactionRef(tx));
41  };
42 
43  // Create a double-spend of mature coinbase txn:
44  std::vector<CMutableTransaction> spends;
45  spends.resize(2);
46  for (int i = 0; i < 2; i++)
47  {
48  spends[i].nVersion = 1;
49  spends[i].vin.resize(1);
50  spends[i].vin[0].prevout.hash = m_coinbase_txns[0]->GetHash();
51  spends[i].vin[0].prevout.n = 0;
52  spends[i].vout.resize(1);
53  spends[i].vout[0].nValue = 11*CENT;
54  spends[i].vout[0].scriptPubKey = scriptPubKey;
55 
56  // Sign:
57  std::vector<unsigned char> vchSig;
58  uint256 hash = SignatureHash(scriptPubKey, spends[i], 0, SIGHASH_ALL, 0, SigVersion::BASE);
59  BOOST_CHECK(coinbaseKey.Sign(hash, vchSig));
60  vchSig.push_back((unsigned char)SIGHASH_ALL);
61  spends[i].vin[0].scriptSig << vchSig;
62  }
63 
64  CBlock block;
65 
66  // Test 1: block with both of those transactions should be rejected.
67  block = CreateAndProcessBlock(spends, scriptPubKey);
68  {
69  LOCK(cs_main);
70  BOOST_CHECK(m_node.chainman->ActiveChain().Tip()->GetBlockHash() != block.GetHash());
71  }
72 
73  // Test 2: ... and should be rejected if spend1 is in the memory pool
74  BOOST_CHECK(ToMemPool(spends[0]));
75  block = CreateAndProcessBlock(spends, scriptPubKey);
76  {
77  LOCK(cs_main);
78  BOOST_CHECK(m_node.chainman->ActiveChain().Tip()->GetBlockHash() != block.GetHash());
79  }
80  m_node.mempool->clear();
81 
82  // Test 3: ... and should be rejected if spend2 is in the memory pool
83  BOOST_CHECK(ToMemPool(spends[1]));
84  block = CreateAndProcessBlock(spends, scriptPubKey);
85  {
86  LOCK(cs_main);
87  BOOST_CHECK(m_node.chainman->ActiveChain().Tip()->GetBlockHash() != block.GetHash());
88  }
89  m_node.mempool->clear();
90 
91  // Final sanity test: first spend in *m_node.mempool, second in block, that's OK:
92  std::vector<CMutableTransaction> oneSpend;
93  oneSpend.push_back(spends[0]);
94  BOOST_CHECK(ToMemPool(spends[1]));
95  block = CreateAndProcessBlock(oneSpend, scriptPubKey);
96  {
97  LOCK(cs_main);
98  BOOST_CHECK(m_node.chainman->ActiveChain().Tip()->GetBlockHash() == block.GetHash());
99  }
100  // spends[1] should have been removed from the mempool when the
101  // block with spends[0] is accepted:
102  BOOST_CHECK_EQUAL(m_node.mempool->size(), 0U);
103 }
104 
105 // Run CheckInputScripts (using CoinsTip()) on the given transaction, for all script
106 // flags. Test that CheckInputScripts passes for all flags that don't overlap with
107 // the failing_flags argument, but otherwise fails.
108 // CHECKLOCKTIMEVERIFY and CHECKSEQUENCEVERIFY (and future NOP codes that may
109 // get reassigned) have an interaction with DISCOURAGE_UPGRADABLE_NOPS: if
110 // the script flags used contain DISCOURAGE_UPGRADABLE_NOPS but don't contain
111 // CHECKLOCKTIMEVERIFY (or CHECKSEQUENCEVERIFY), but the script does contain
112 // OP_CHECKLOCKTIMEVERIFY (or OP_CHECKSEQUENCEVERIFY), then script execution
113 // should fail.
114 // Capture this interaction with the upgraded_nop argument: set it when evaluating
115 // any script flag that is implemented as an upgraded NOP code.
116 static void ValidateCheckInputsForAllFlags(const CTransaction &tx, uint32_t failing_flags, bool add_to_cache, CCoinsViewCache& active_coins_tip) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
117 {
119 
120  FastRandomContext insecure_rand(true);
121 
122  for (int count = 0; count < 10000; ++count) {
123  TxValidationState state;
124 
125  // Randomly selects flag combinations
126  uint32_t test_flags = (uint32_t) insecure_rand.randrange((SCRIPT_VERIFY_END_MARKER - 1) << 1);
127 
128  // Filter out incompatible flag choices
129  if ((test_flags & SCRIPT_VERIFY_CLEANSTACK)) {
130  // CLEANSTACK requires P2SH and WITNESS, see VerifyScript() in
131  // script/interpreter.cpp
133  }
134  if ((test_flags & SCRIPT_VERIFY_WITNESS)) {
135  // WITNESS requires P2SH
136  test_flags |= SCRIPT_VERIFY_P2SH;
137  }
138  bool ret = CheckInputScripts(tx, state, &active_coins_tip, test_flags, true, add_to_cache, txdata, nullptr);
139  // CheckInputScripts should succeed iff test_flags doesn't intersect with
140  // failing_flags
141  bool expected_return_value = !(test_flags & failing_flags);
142  BOOST_CHECK_EQUAL(ret, expected_return_value);
143 
144  // Test the caching
145  if (ret && add_to_cache) {
146  // Check that we get a cache hit if the tx was valid
147  std::vector<CScriptCheck> scriptchecks;
148  BOOST_CHECK(CheckInputScripts(tx, state, &active_coins_tip, test_flags, true, add_to_cache, txdata, &scriptchecks));
149  BOOST_CHECK(scriptchecks.empty());
150  } else {
151  // Check that we get script executions to check, if the transaction
152  // was invalid, or we didn't add to cache.
153  std::vector<CScriptCheck> scriptchecks;
154  BOOST_CHECK(CheckInputScripts(tx, state, &active_coins_tip, test_flags, true, add_to_cache, txdata, &scriptchecks));
155  BOOST_CHECK_EQUAL(scriptchecks.size(), tx.vin.size());
156  }
157  }
158 }
159 
161 {
162  // Test that passing CheckInputScripts with one set of script flags doesn't imply
163  // that we would pass again with a different set of flags.
164  {
165  LOCK(cs_main);
167  }
168 
169  CScript p2pk_scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
170  CScript p2sh_scriptPubKey = GetScriptForDestination(ScriptHash(p2pk_scriptPubKey));
171  CScript p2pkh_scriptPubKey = GetScriptForDestination(PKHash(coinbaseKey.GetPubKey()));
172  CScript p2wpkh_scriptPubKey = GetScriptForDestination(WitnessV0KeyHash(coinbaseKey.GetPubKey()));
173 
174  FillableSigningProvider keystore;
175  BOOST_CHECK(keystore.AddKey(coinbaseKey));
176  BOOST_CHECK(keystore.AddCScript(p2pk_scriptPubKey));
177 
178  // flags to test: SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY, SCRIPT_VERIFY_CHECKSEQUENCE_VERIFY, SCRIPT_VERIFY_NULLDUMMY, uncompressed pubkey thing
179 
180  // Create 2 outputs that match the three scripts above, spending the first
181  // coinbase tx.
182  CMutableTransaction spend_tx;
183 
184  spend_tx.nVersion = 1;
185  spend_tx.vin.resize(1);
186  spend_tx.vin[0].prevout.hash = m_coinbase_txns[0]->GetHash();
187  spend_tx.vin[0].prevout.n = 0;
188  spend_tx.vout.resize(4);
189  spend_tx.vout[0].nValue = 11*CENT;
190  spend_tx.vout[0].scriptPubKey = p2sh_scriptPubKey;
191  spend_tx.vout[1].nValue = 11*CENT;
192  spend_tx.vout[1].scriptPubKey = p2wpkh_scriptPubKey;
193  spend_tx.vout[2].nValue = 11*CENT;
194  spend_tx.vout[2].scriptPubKey = CScript() << OP_CHECKLOCKTIMEVERIFY << OP_DROP << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
195  spend_tx.vout[3].nValue = 11*CENT;
196  spend_tx.vout[3].scriptPubKey = CScript() << OP_CHECKSEQUENCEVERIFY << OP_DROP << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
197 
198  // Sign, with a non-DER signature
199  {
200  std::vector<unsigned char> vchSig;
201  uint256 hash = SignatureHash(p2pk_scriptPubKey, spend_tx, 0, SIGHASH_ALL, 0, SigVersion::BASE);
202  BOOST_CHECK(coinbaseKey.Sign(hash, vchSig));
203  vchSig.push_back((unsigned char) 0); // padding byte makes this non-DER
204  vchSig.push_back((unsigned char)SIGHASH_ALL);
205  spend_tx.vin[0].scriptSig << vchSig;
206  }
207 
208  // Test that invalidity under a set of flags doesn't preclude validity
209  // under other (eg consensus) flags.
210  // spend_tx is invalid according to DERSIG
211  {
212  LOCK(cs_main);
213 
214  TxValidationState state;
215  PrecomputedTransactionData ptd_spend_tx;
216 
217  BOOST_CHECK(!CheckInputScripts(CTransaction(spend_tx), state, &m_node.chainman->ActiveChainstate().CoinsTip(), SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_DERSIG, true, true, ptd_spend_tx, nullptr));
218 
219  // If we call again asking for scriptchecks (as happens in
220  // ConnectBlock), we should add a script check object for this -- we're
221  // not caching invalidity (if that changes, delete this test case).
222  std::vector<CScriptCheck> scriptchecks;
223  BOOST_CHECK(CheckInputScripts(CTransaction(spend_tx), state, &m_node.chainman->ActiveChainstate().CoinsTip(), SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_DERSIG, true, true, ptd_spend_tx, &scriptchecks));
224  BOOST_CHECK_EQUAL(scriptchecks.size(), 1U);
225 
226  // Test that CheckInputScripts returns true iff DERSIG-enforcing flags are
227  // not present. Don't add these checks to the cache, so that we can
228  // test later that block validation works fine in the absence of cached
229  // successes.
231  }
232 
233  // And if we produce a block with this tx, it should be valid (DERSIG not
234  // enabled yet), even though there's no cache entry.
235  CBlock block;
236 
237  block = CreateAndProcessBlock({spend_tx}, p2pk_scriptPubKey);
238  LOCK(cs_main);
239  BOOST_CHECK(m_node.chainman->ActiveChain().Tip()->GetBlockHash() == block.GetHash());
240  BOOST_CHECK(m_node.chainman->ActiveChainstate().CoinsTip().GetBestBlock() == block.GetHash());
241 
242  // Test P2SH: construct a transaction that is valid without P2SH, and
243  // then test validity with P2SH.
244  {
245  CMutableTransaction invalid_under_p2sh_tx;
246  invalid_under_p2sh_tx.nVersion = 1;
247  invalid_under_p2sh_tx.vin.resize(1);
248  invalid_under_p2sh_tx.vin[0].prevout.hash = spend_tx.GetHash();
249  invalid_under_p2sh_tx.vin[0].prevout.n = 0;
250  invalid_under_p2sh_tx.vout.resize(1);
251  invalid_under_p2sh_tx.vout[0].nValue = 11*CENT;
252  invalid_under_p2sh_tx.vout[0].scriptPubKey = p2pk_scriptPubKey;
253  std::vector<unsigned char> vchSig2(p2pk_scriptPubKey.begin(), p2pk_scriptPubKey.end());
254  invalid_under_p2sh_tx.vin[0].scriptSig << vchSig2;
255 
256  ValidateCheckInputsForAllFlags(CTransaction(invalid_under_p2sh_tx), SCRIPT_VERIFY_P2SH, true, m_node.chainman->ActiveChainstate().CoinsTip());
257  }
258 
259  // Test CHECKLOCKTIMEVERIFY
260  {
261  CMutableTransaction invalid_with_cltv_tx;
262  invalid_with_cltv_tx.nVersion = 1;
263  invalid_with_cltv_tx.nLockTime = 100;
264  invalid_with_cltv_tx.vin.resize(1);
265  invalid_with_cltv_tx.vin[0].prevout.hash = spend_tx.GetHash();
266  invalid_with_cltv_tx.vin[0].prevout.n = 2;
267  invalid_with_cltv_tx.vin[0].nSequence = 0;
268  invalid_with_cltv_tx.vout.resize(1);
269  invalid_with_cltv_tx.vout[0].nValue = 11*CENT;
270  invalid_with_cltv_tx.vout[0].scriptPubKey = p2pk_scriptPubKey;
271 
272  // Sign
273  std::vector<unsigned char> vchSig;
274  uint256 hash = SignatureHash(spend_tx.vout[2].scriptPubKey, invalid_with_cltv_tx, 0, SIGHASH_ALL, 0, SigVersion::BASE);
275  BOOST_CHECK(coinbaseKey.Sign(hash, vchSig));
276  vchSig.push_back((unsigned char)SIGHASH_ALL);
277  invalid_with_cltv_tx.vin[0].scriptSig = CScript() << vchSig << 101;
278 
279  ValidateCheckInputsForAllFlags(CTransaction(invalid_with_cltv_tx), SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY, true, m_node.chainman->ActiveChainstate().CoinsTip());
280 
281  // Make it valid, and check again
282  invalid_with_cltv_tx.vin[0].scriptSig = CScript() << vchSig << 100;
283  TxValidationState state;
285  BOOST_CHECK(CheckInputScripts(CTransaction(invalid_with_cltv_tx), state, m_node.chainman->ActiveChainstate().CoinsTip(), SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY, true, true, txdata, nullptr));
286  }
287 
288  // TEST CHECKSEQUENCEVERIFY
289  {
290  CMutableTransaction invalid_with_csv_tx;
291  invalid_with_csv_tx.nVersion = 2;
292  invalid_with_csv_tx.vin.resize(1);
293  invalid_with_csv_tx.vin[0].prevout.hash = spend_tx.GetHash();
294  invalid_with_csv_tx.vin[0].prevout.n = 3;
295  invalid_with_csv_tx.vin[0].nSequence = 100;
296  invalid_with_csv_tx.vout.resize(1);
297  invalid_with_csv_tx.vout[0].nValue = 11*CENT;
298  invalid_with_csv_tx.vout[0].scriptPubKey = p2pk_scriptPubKey;
299 
300  // Sign
301  std::vector<unsigned char> vchSig;
302  uint256 hash = SignatureHash(spend_tx.vout[3].scriptPubKey, invalid_with_csv_tx, 0, SIGHASH_ALL, 0, SigVersion::BASE);
303  BOOST_CHECK(coinbaseKey.Sign(hash, vchSig));
304  vchSig.push_back((unsigned char)SIGHASH_ALL);
305  invalid_with_csv_tx.vin[0].scriptSig = CScript() << vchSig << 101;
306 
307  ValidateCheckInputsForAllFlags(CTransaction(invalid_with_csv_tx), SCRIPT_VERIFY_CHECKSEQUENCEVERIFY, true, m_node.chainman->ActiveChainstate().CoinsTip());
308 
309  // Make it valid, and check again
310  invalid_with_csv_tx.vin[0].scriptSig = CScript() << vchSig << 100;
311  TxValidationState state;
313  BOOST_CHECK(CheckInputScripts(CTransaction(invalid_with_csv_tx), state, &m_node.chainman->ActiveChainstate().CoinsTip(), SCRIPT_VERIFY_CHECKSEQUENCEVERIFY, true, true, txdata, nullptr));
314  }
315 
316  // TODO: add tests for remaining script flags
317 
318  // Test that passing CheckInputScripts with a valid witness doesn't imply success
319  // for the same tx with a different witness.
320  {
321  CMutableTransaction valid_with_witness_tx;
322  valid_with_witness_tx.nVersion = 1;
323  valid_with_witness_tx.vin.resize(1);
324  valid_with_witness_tx.vin[0].prevout.hash = spend_tx.GetHash();
325  valid_with_witness_tx.vin[0].prevout.n = 1;
326  valid_with_witness_tx.vout.resize(1);
327  valid_with_witness_tx.vout[0].nValue = 11*CENT;
328  valid_with_witness_tx.vout[0].scriptPubKey = p2pk_scriptPubKey;
329 
330  // Sign
331  SignatureData sigdata;
332  BOOST_CHECK(ProduceSignature(keystore, MutableTransactionSignatureCreator(&valid_with_witness_tx, 0, 11*CENT, SIGHASH_ALL), spend_tx.vout[1].scriptPubKey, sigdata));
333  UpdateInput(valid_with_witness_tx.vin[0], sigdata);
334 
335  // This should be valid under all script flags.
336  ValidateCheckInputsForAllFlags(CTransaction(valid_with_witness_tx), 0, true, m_node.chainman->ActiveChainstate().CoinsTip());
337 
338  // Remove the witness, and check that it is now invalid.
339  valid_with_witness_tx.vin[0].scriptWitness.SetNull();
340  ValidateCheckInputsForAllFlags(CTransaction(valid_with_witness_tx), SCRIPT_VERIFY_WITNESS, true, m_node.chainman->ActiveChainstate().CoinsTip());
341  }
342 
343  {
344  // Test a transaction with multiple inputs.
346 
347  tx.nVersion = 1;
348  tx.vin.resize(2);
349  tx.vin[0].prevout.hash = spend_tx.GetHash();
350  tx.vin[0].prevout.n = 0;
351  tx.vin[1].prevout.hash = spend_tx.GetHash();
352  tx.vin[1].prevout.n = 1;
353  tx.vout.resize(1);
354  tx.vout[0].nValue = 22*CENT;
355  tx.vout[0].scriptPubKey = p2pk_scriptPubKey;
356 
357  // Sign
358  for (int i=0; i<2; ++i) {
359  SignatureData sigdata;
360  BOOST_CHECK(ProduceSignature(keystore, MutableTransactionSignatureCreator(&tx, i, 11*CENT, SIGHASH_ALL), spend_tx.vout[i].scriptPubKey, sigdata));
361  UpdateInput(tx.vin[i], sigdata);
362  }
363 
364  // This should be valid under all script flags
365  ValidateCheckInputsForAllFlags(CTransaction(tx), 0, true, m_node.chainman->ActiveChainstate().CoinsTip());
366 
367  // Check that if the second input is invalid, but the first input is
368  // valid, the transaction is not cached.
369  // Invalidate vin[1]
370  tx.vin[1].scriptWitness.SetNull();
371 
372  TxValidationState state;
374  // This transaction is now invalid under segwit, because of the second input.
375  BOOST_CHECK(!CheckInputScripts(CTransaction(tx), state, &m_node.chainman->ActiveChainstate().CoinsTip(), SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS, true, true, txdata, nullptr));
376 
377  std::vector<CScriptCheck> scriptchecks;
378  // Make sure this transaction was not cached (ie because the first
379  // input was valid)
380  BOOST_CHECK(CheckInputScripts(CTransaction(tx), state, &m_node.chainman->ActiveChainstate().CoinsTip(), SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS, true, true, txdata, &scriptchecks));
381  // Should get 2 script checks back -- caching is on a whole-transaction basis.
382  BOOST_CHECK_EQUAL(scriptchecks.size(), 2U);
383  }
384 }
385 
CMutableTransaction::vin
std::vector< CTxIn > vin
Definition: transaction.h:346
count
static int count
Definition: tests.c:31
BOOST_AUTO_TEST_SUITE
BOOST_AUTO_TEST_SUITE(cuckoocache_tests)
Test Suite for CuckooCache.
SigVersion::BASE
@ BASE
Bare scripts and BIP16 P2SH-wrapped redeemscripts.
SCRIPT_VERIFY_CLEANSTACK
@ SCRIPT_VERIFY_CLEANSTACK
Definition: interpreter.h:92
flags
int flags
Definition: bitcoin-tx.cpp:525
setup_common.h
MempoolAcceptResult::m_result_type
const ResultType m_result_type
Result type.
Definition: validation.h:169
FillableSigningProvider
Fillable signing provider that keeps keys in an address->secret map.
Definition: signingprovider.h:90
GetScriptForDestination
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
Definition: standard.cpp:310
CMutableTransaction::nVersion
int32_t nVersion
Definition: transaction.h:348
m_node
node::NodeContext m_node
Definition: bitcoin-gui.cpp:36
validation.h
OP_CHECKLOCKTIMEVERIFY
@ OP_CHECKLOCKTIMEVERIFY
Definition: script.h:190
MutableTransactionSignatureCreator
A signature creator for transactions.
Definition: sign.h:37
MakeTransactionRef
static CTransactionRef MakeTransactionRef(Tx &&txIn)
Definition: transaction.h:387
node::NodeContext::mempool
std::unique_ptr< CTxMemPool > mempool
Definition: context.h:45
BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END()
CBlockHeader::GetHash
uint256 GetHash() const
Definition: block.cpp:11
FillableSigningProvider::AddKey
virtual bool AddKey(const CKey &key)
Definition: signingprovider.h:151
CTransaction
The basic transaction that is broadcasted on the network and contained in blocks.
Definition: transaction.h:259
txmempool.h
WitnessV0KeyHash
Definition: standard.h:109
TxValidationState
Definition: validation.h:140
signingprovider.h
prevector::end
iterator end()
Definition: prevector.h:292
BOOST_FIXTURE_TEST_CASE
BOOST_FIXTURE_TEST_CASE(tx_mempool_block_doublespend, Dersig100Setup)
Definition: txvalidationcache_tests.cpp:28
Dersig100Setup
Definition: txvalidationcache_tests.cpp:16
CMutableTransaction::nLockTime
uint32_t nLockTime
Definition: transaction.h:349
ToByteVector
std::vector< unsigned char > ToByteVector(const T &in)
Definition: script.h:60
SignatureData
Definition: sign.h:63
SCRIPT_VERIFY_WITNESS
@ SCRIPT_VERIFY_WITNESS
Definition: interpreter.h:106
SCRIPT_VERIFY_CHECKSEQUENCEVERIFY
@ SCRIPT_VERIFY_CHECKSEQUENCEVERIFY
Definition: interpreter.h:102
CENT
static constexpr CAmount CENT
Definition: setup_common.h:78
sign.h
standard.h
TestChain100Setup
Testing fixture that pre-creates a 100-block REGTEST-mode block chain.
Definition: setup_common.h:124
PrecomputedTransactionData
Definition: interpreter.h:151
uint256
256-bit opaque blob.
Definition: uint256.h:124
CScript
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:405
SCRIPT_VERIFY_LOW_S
@ SCRIPT_VERIFY_LOW_S
Definition: interpreter.h:59
MempoolAcceptResult::ResultType::VALID
@ VALID
ProduceSignature
bool ProduceSignature(const SigningProvider &provider, const BaseSignatureCreator &creator, const CScript &fromPubKey, SignatureData &sigdata)
Produce a script signature using a generic signature creator.
Definition: sign.cpp:333
Dersig100Setup::Dersig100Setup
Dersig100Setup()
Definition: txvalidationcache_tests.cpp:17
CBlock
Definition: block.h:62
CMutableTransaction::vout
std::vector< CTxOut > vout
Definition: transaction.h:347
PKHash
Definition: standard.h:79
key.h
SIGHASH_ALL
@ SIGHASH_ALL
Definition: interpreter.h:28
SCRIPT_VERIFY_END_MARKER
@ SCRIPT_VERIFY_END_MARKER
Definition: interpreter.h:146
cs_main
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition: validation.cpp:138
CCoinsViewCache
CCoinsView that adds a memory cache for transactions to another CCoinsView.
Definition: coins.h:213
SignatureHash
uint256 SignatureHash(const CScript &scriptCode, const T &txTo, unsigned int nIn, int nHashType, const CAmount &amount, SigVersion sigversion, const PrecomputedTransactionData *cache)
Definition: interpreter.cpp:1593
CheckInputScripts
bool CheckInputScripts(const CTransaction &tx, TxValidationState &state, const CCoinsViewCache &inputs, unsigned int flags, bool cacheSigStore, bool cacheFullScriptStore, PrecomputedTransactionData &txdata, std::vector< CScriptCheck > *pvChecks) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Check whether all of this transaction's input scripts succeed.
Definition: validation.cpp:1617
EXCLUSIVE_LOCKS_REQUIRED
#define EXCLUSIVE_LOCKS_REQUIRED(...)
Definition: threadsafety.h:49
LOCK
#define LOCK(cs)
Definition: sync.h:226
SCRIPT_VERIFY_P2SH
@ SCRIPT_VERIFY_P2SH
Definition: interpreter.h:47
MempoolAcceptResult
Validation result for a single transaction mempool acceptance.
Definition: validation.h:160
prevector::begin
iterator begin()
Definition: prevector.h:290
InitScriptExecutionCache
void InitScriptExecutionCache()
Initializes the script-execution cache.
Definition: validation.cpp:1582
node::NodeContext::chainman
std::unique_ptr< ChainstateManager > chainman
Definition: context.h:48
FastRandomContext::randrange
uint64_t randrange(uint64_t range) noexcept
Generate a random integer in the range [0..range).
Definition: random.h:202
SCRIPT_VERIFY_DERSIG
@ SCRIPT_VERIFY_DERSIG
Definition: interpreter.h:55
FillableSigningProvider::AddCScript
virtual bool AddCScript(const CScript &redeemScript)
Definition: signingprovider.cpp:153
SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY
@ SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY
Definition: interpreter.h:97
UpdateInput
void UpdateInput(CTxIn &input, const SignatureData &data)
Definition: sign.cpp:494
CMutableTransaction::GetHash
uint256 GetHash() const
Compute the hash of this CMutableTransaction.
Definition: transaction.cpp:63
OP_DROP
@ OP_DROP
Definition: script.h:117
CMutableTransaction
A mutable version of CTransaction.
Definition: transaction.h:344
OP_CHECKSIG
@ OP_CHECKSIG
Definition: script.h:183
ValidateCheckInputsForAllFlags
static void ValidateCheckInputsForAllFlags(const CTransaction &tx, uint32_t failing_flags, bool add_to_cache, CCoinsViewCache &active_coins_tip) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Definition: txvalidationcache_tests.cpp:116
OP_CHECKSEQUENCEVERIFY
@ OP_CHECKSEQUENCEVERIFY
Definition: script.h:192
ScriptHash
Definition: standard.h:89
FastRandomContext
Fast randomness source.
Definition: random.h:131
BOOST_CHECK
#define BOOST_CHECK(expr)
Definition: object.cpp:17
BOOST_CHECK_EQUAL
#define BOOST_CHECK_EQUAL(v1, v2)
Definition: object.cpp:18
SCRIPT_VERIFY_STRICTENC
@ SCRIPT_VERIFY_STRICTENC
Definition: interpreter.h:52