Differential D2089 Diff 5903 src/test/txvalidationcache_tests.cpp

Changeset View

Standalone View

src/test/txvalidationcache_tests.cpp

Show All 13 Lines
#include "script/sign.h"		#include "script/sign.h"
#include "script/standard.h"		#include "script/standard.h"
#include "test/sigutil.h"		#include "test/sigutil.h"
#include "test/test_bitcoin.h"		#include "test/test_bitcoin.h"
#include "txmempool.h"		#include "txmempool.h"
#include "utiltime.h"		#include "utiltime.h"
#include "validation.h"		#include "validation.h"

		#include "core_io.h"

#include <boost/test/unit_test.hpp>		#include <boost/test/unit_test.hpp>

BOOST_AUTO_TEST_SUITE(txvalidationcache_tests)		BOOST_AUTO_TEST_SUITE(txvalidationcache_tests)

static bool ToMemPool(const CMutableTransaction &tx) {		static bool ToMemPool(const CMutableTransaction &tx) {
LOCK(cs_main);		LOCK(cs_main);

CValidationState state;		CValidationState state;
▲ Show 20 Lines • Show All 129 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);

		// Creat 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);
		deadalnixUnsubmitted Not Done Inline Actions There is no point in bringing the key store in there. You are building the script to begin with so anything you'll pull of the store you already have. deadalnix: There is no point in bringing the key store in there. You are building the script to begin with…

		CScript p2sh_nulldummyScriptPubKey =
		GetScriptForDestination(CScriptID(nulldummyRedeemScript));
		deadalnixUnsubmitted Not Done Inline Actions I'm not sure why you want to do P2SH here instead of bare multisig. If there is a reason, it should be mentioned. if there is no reason, then don't do it. deadalnix: I'm not sure why you want to do P2SH here instead of bare multisig. If there is a reason, it…
		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));
		// First item will be dropped by CHECKMULTISIG This is to check
		// nulldummy enforcement. It is OP_1 instead of OP_0.
		// Also pass a null signature so we don't hit NULLFAIL
		mutableFunding_tx.vin[0].scriptSig << nullDummyVchSig;
		deadalnixUnsubmitted Not Done Inline Actions This would benefit being scoped to destruct the temporaries. deadalnix: This would benefit being scoped to destruct the temporaries.

		// Spend the funding transaction
		deadalnixUnsubmitted Not Done Inline Actions This is not spending, this is mining. deadalnix: This is not spending, this is mining.
		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(		CScript coinbaseP2SH_scriptPubKey =
p2pk_scriptPubKey, CTransaction(mutableSpend_tx), 0,		GetScriptForDestination(CScriptID(nulldummyRedeemScript));
SigHashType().withForkId(), coinbaseTxns[0].vout[0].nValue);		BOOST_CHECK(SignSignature(keystore, p2sh_nulldummyScriptPubKey,
BOOST_CHECK(coinbaseKey.Sign(hash, vchSig));		mutableSpend_tx, 0, funding_tx.vout[0].nValue,
vchSig.push_back(uint8_t(SIGHASH_ALL \| SIGHASH_FORKID));		SigHashType(SIGHASH_ALL \| SIGHASH_FORKID)));
		deadalnixUnsubmitted Not Done Inline Actions You can sign the exact same ways as before. You just need to push the non nulldummy element. deadalnix: You can sign the exact same ways as before. You just need to push the non nulldummy element.
		jasonbcoxAuthorUnsubmitted Not Done Inline Actions +1. doing this a different way is confusing jasonbcox: +1. doing this a different way is confusing
		schancelUnsubmitted Done Inline Actions I did that schancel: I did that
mutableSpend_tx.vin[0].scriptSig << OP_TRUE << vchSig;		// Insert a non-nulldummy element into CSCript (SignSignature puts a
		// NULL in the appropriate place)
		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