Differential D2089 Diff 5906 src/test/txvalidationcache_tests.cpp

Changeset View

Standalone View

src/test/txvalidationcache_tests.cpp

Show First 20 Lines • Show All 158 Lines • ▼ Show 20 Lines	CScript p2sh_scriptPubKey =
GetScriptForDestination(CScriptID(p2pk_scriptPubKey));		GetScriptForDestination(CScriptID(p2pk_scriptPubKey));
CScript p2pkh_scriptPubKey =		CScript p2pkh_scriptPubKey =
GetScriptForDestination(coinbaseKey.GetPubKey().GetID());		GetScriptForDestination(coinbaseKey.GetPubKey().GetID());

CBasicKeyStore keystore;		CBasicKeyStore keystore;
keystore.AddKey(coinbaseKey);		keystore.AddKey(coinbaseKey);
keystore.AddCScript(p2pk_scriptPubKey);		keystore.AddCScript(p2pk_scriptPubKey);

		// Create a funding transaction that can fail NULLDUMMY checks. This is for
		// testing consensus vs non-standard rules in `checkinputs_test`.
		CMutableTransaction mutableFunding_tx;
		mutableFunding_tx.nVersion = 1;
		mutableFunding_tx.vin.resize(1);
		mutableFunding_tx.vin[0].prevout = COutPoint(coinbaseTxns[0].GetId(), 0);
		mutableFunding_tx.vout.resize(1);
		mutableFunding_tx.vout[0].nValue = 50 * COIN;

		CKey dummyKey;
		dummyKey.MakeNewKey(true);
		CScript nulldummyRedeemScript =
		CScript() << OP_1 << ToByteVector(coinbaseKey.GetPubKey())
		<< ToByteVector(dummyKey.GetPubKey()) << OP_2
		<< OP_CHECKMULTISIG;
		// Add our CScript to the keystore
		keystore.AddCScript(nulldummyRedeemScript);

		CScript p2sh_nulldummyScriptPubKey =
		GetScriptForDestination(CScriptID(nulldummyRedeemScript));
		mutableFunding_tx.vout[0].scriptPubKey = p2sh_nulldummyScriptPubKey;
		std::vector<uint8_t> nullDummyVchSig;
		uint256 p2shNulldummyHash = SignatureHash(
		p2pk_scriptPubKey, CTransaction(mutableFunding_tx), 0,
		SigHashType().withForkId(), coinbaseTxns[0].vout[0].nValue);
		BOOST_CHECK(coinbaseKey.Sign(p2shNulldummyHash, nullDummyVchSig));
		nullDummyVchSig.push_back(uint8_t(SIGHASH_ALL \| SIGHASH_FORKID));
		mutableFunding_tx.vin[0].scriptSig << nullDummyVchSig;

		// Spend the funding transaction
		const CTransaction funding_tx(mutableFunding_tx);
		{
		LOCK(cs_main);
		CBlock block = CreateAndProcessBlock({funding_tx}, p2pk_scriptPubKey);
		BOOST_CHECK(chainActive.Tip()->GetBlockHash() == block.GetHash());
		BOOST_CHECK(pcoinsTip->GetBestBlock() == block.GetHash());
		}

// flags to test: SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY,		// flags to test: SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY,
// SCRIPT_VERIFY_CHECKSEQUENCE_VERIFY, SCRIPT_VERIFY_NULLDUMMY, uncompressed		// SCRIPT_VERIFY_CHECKSEQUENCE_VERIFY, SCRIPT_VERIFY_NULLDUMMY, uncompressed
// pubkey thing		// pubkey thing

// Create 2 outputs that match the three scripts above, spending the first		// Create 2 outputs that match the three scripts above, spending the first
// coinbase tx.		// coinbase tx.
CMutableTransaction mutableSpend_tx;		CMutableTransaction mutableSpend_tx;

mutableSpend_tx.nVersion = 1;		mutableSpend_tx.nVersion = 1;
mutableSpend_tx.vin.resize(1);		mutableSpend_tx.vin.resize(1);
mutableSpend_tx.vin[0].prevout = COutPoint(coinbaseTxns[0].GetId(), 0);		mutableSpend_tx.vin[0].prevout = COutPoint(funding_tx.GetId(), 0);
mutableSpend_tx.vout.resize(4);		mutableSpend_tx.vout.resize(4);
mutableSpend_tx.vout[0].nValue = 11 * CENT;		mutableSpend_tx.vout[0].nValue = 11 * CENT;
mutableSpend_tx.vout[0].scriptPubKey = p2sh_scriptPubKey;		mutableSpend_tx.vout[0].scriptPubKey = p2sh_scriptPubKey;
mutableSpend_tx.vout[1].nValue = 11 * CENT;		mutableSpend_tx.vout[1].nValue = 11 * CENT;
mutableSpend_tx.vout[1].scriptPubKey =		mutableSpend_tx.vout[1].scriptPubKey =
CScript() << OP_CHECKLOCKTIMEVERIFY << OP_DROP		CScript() << OP_CHECKLOCKTIMEVERIFY << OP_DROP
<< ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;		<< ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
mutableSpend_tx.vout[2].nValue = 11 * CENT;		mutableSpend_tx.vout[2].nValue = 11 * CENT;
mutableSpend_tx.vout[2].scriptPubKey =		mutableSpend_tx.vout[2].scriptPubKey =
CScript() << OP_CHECKSEQUENCEVERIFY << OP_DROP		CScript() << OP_CHECKSEQUENCEVERIFY << OP_DROP
<< ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;		<< ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
mutableSpend_tx.vout[3].nValue = 11 * CENT;		mutableSpend_tx.vout[3].nValue = 11 * CENT;
mutableSpend_tx.vout[3].scriptPubKey = p2sh_scriptPubKey;		mutableSpend_tx.vout[3].scriptPubKey = p2sh_scriptPubKey;

// Sign, and push an extra element on the stack.		// Sign the main transaction that we spend from and make it fail NULLDUMMY
		// checks.
{		{
std::vector<uint8_t> vchSig;		std::vector<uint8_t> vchSig;
uint256 hash = SignatureHash(		BOOST_CHECK(SignSignature(keystore, p2sh_nulldummyScriptPubKey,
p2pk_scriptPubKey, CTransaction(mutableSpend_tx), 0,		mutableSpend_tx, 0, funding_tx.vout[0].nValue,
SigHashType().withForkId(), coinbaseTxns[0].vout[0].nValue);		SigHashType(SIGHASH_ALL \| SIGHASH_FORKID)));
BOOST_CHECK(coinbaseKey.Sign(hash, vchSig));		// Insert a non-nulldummy element into CSCript (SignSignature puts a
vchSig.push_back(uint8_t(SIGHASH_ALL \| SIGHASH_FORKID));		// NULL in the appropriate place)
mutableSpend_tx.vin[0].scriptSig << OP_TRUE << vchSig;		mutableSpend_tx.vin[0].scriptSig[0] = OP_1;
}		}

const CTransaction spend_tx(mutableSpend_tx);		const CTransaction spend_tx(mutableSpend_tx);

LOCK(cs_main);		LOCK(cs_main);

// Test that invalidity under a set of flags doesn't preclude validity under		// Test that invalidity under a set of flags doesn't preclude validity under
// other (eg consensus) flags.		// other (eg consensus) flags.
// spend_tx is invalid according to DERSIG		// spend_tx is invalid according to NULLDUMMY
{		{
CValidationState state;		CValidationState state;
PrecomputedTransactionData ptd_spend_tx(spend_tx);		PrecomputedTransactionData ptd_spend_tx(spend_tx);

BOOST_CHECK(!CheckInputs(spend_tx, state, pcoinsTip.get(), true,		BOOST_CHECK(!CheckInputs(spend_tx, state, pcoinsTip.get(), true,
MANDATORY_SCRIPT_VERIFY_FLAGS \|		MANDATORY_SCRIPT_VERIFY_FLAGS \|
SCRIPT_VERIFY_CLEANSTACK,		SCRIPT_VERIFY_NULLDUMMY,
true, true, ptd_spend_tx, nullptr));		true, true, ptd_spend_tx, nullptr));

// If we call again asking for scriptchecks (as happens in		// If we call again asking for scriptchecks (as happens in
// ConnectBlock), we should add a script check object for this -- we're		// ConnectBlock), we should add a script check object for this -- we're
// not caching invalidity (if that changes, delete this test case).		// not caching invalidity (if that changes, delete this test case).
std::vector<CScriptCheck> scriptchecks;		std::vector<CScriptCheck> scriptchecks;
BOOST_CHECK(CheckInputs(spend_tx, state, pcoinsTip.get(), true,		BOOST_CHECK(
MANDATORY_SCRIPT_VERIFY_FLAGS \|		CheckInputs(spend_tx, state, pcoinsTip.get(), true,
SCRIPT_VERIFY_CLEANSTACK,		MANDATORY_SCRIPT_VERIFY_FLAGS \| SCRIPT_VERIFY_NULLDUMMY,
true, true, ptd_spend_tx, &scriptchecks));		true, true, ptd_spend_tx, &scriptchecks));
BOOST_CHECK_EQUAL(scriptchecks.size(), 1);		BOOST_CHECK_EQUAL(scriptchecks.size(), 1);

// Test that CheckInputs returns true iff cleanstack-enforcing flags are		// Test that CheckInputs returns true iff cleanstack-enforcing flags are
// not present. Don't add these checks to the cache, so that we can test		// not present. Don't add these checks to the cache, so that we can test
// later that block validation works fine in the absence of cached		// later that block validation works fine in the absence of cached
// successes.		// successes.
ValidateCheckInputsForAllFlags(spend_tx, SCRIPT_VERIFY_CLEANSTACK,		ValidateCheckInputsForAllFlags(spend_tx, SCRIPT_VERIFY_NULLDUMMY, false,
false, false);		false);

// And if we produce a block with this tx, it should be valid (LOW_S not		// And if we produce a block with this tx, it should be valid (LOW_S not
// enabled yet), even though there's no cache entry.		// enabled yet), even though there's no cache entry.
CBlock block;		CBlock block;

block = CreateAndProcessBlock({spend_tx}, p2pk_scriptPubKey);		block = CreateAndProcessBlock({spend_tx}, p2pk_scriptPubKey);
BOOST_CHECK(chainActive.Tip()->GetBlockHash() == block.GetHash());		BOOST_CHECK(chainActive.Tip()->GetBlockHash() == block.GetHash());
BOOST_CHECK(pcoinsTip->GetBestBlock() == block.GetHash());		BOOST_CHECK(pcoinsTip->GetBestBlock() == block.GetHash());
▲ Show 20 Lines • Show All 152 Lines • Show Last 20 Lines