No OneTemporary
Actions

Size

36 KB

Subscribers

None

View Options

	diff --git a/src/Makefile.test.include b/src/Makefile.test.include
	index 0ebd3c9cd..c37a5386f 100644
	--- a/src/Makefile.test.include
	+++ b/src/Makefile.test.include
	@@ -1,207 +1,208 @@
	# Copyright (c) 2013-2016 The Bitcoin Core developers
	# Distributed under the MIT software license, see the accompanying
	# file COPYING or http://www.opensource.org/licenses/mit-license.php.

	TESTS += test/test_bitcoin
	LOG_DRIVER = $(srcdir)/test/test-bitcoin-driver
	EXTRA_DIST += test/test-bitcoin-driver
	bin_PROGRAMS += test/test_bitcoin
	noinst_PROGRAMS += test/test_bitcoin_fuzzy
	TEST_SRCDIR = test
	TEST_BINARY=test/test_bitcoin$(EXEEXT)

	JSON_TEST_FILES = \
	test/data/script_tests.json \
	test/data/base58_keys_valid.json \
	test/data/base58_encode_decode.json \
	test/data/base58_keys_invalid.json \
	test/data/blockfilters.json \
	test/data/tx_invalid.json \
	test/data/tx_valid.json \
	test/data/sighash.json

	RAW_TEST_FILES =

	GENERATED_TEST_FILES = $(JSON_TEST_FILES:.json=.json.h) $(RAW_TEST_FILES:.raw=.raw.h)

	# test_bitcoin binary #
	BITCOIN_TESTS =\
	test/scriptnum10.h \
	test/activation_tests.cpp \
	test/addrman_tests.cpp \
	test/allocator_tests.cpp \
	test/amount_tests.cpp \
	test/arith_uint256_tests.cpp \
	test/avalanche_tests.cpp \
	test/base32_tests.cpp \
	test/base58_tests.cpp \
	test/base64_tests.cpp \
	test/bip32_tests.cpp \
	test/blockcheck_tests.cpp \
	test/blockencodings_tests.cpp \
	test/blockfilter_tests.cpp \
	test/blockindex_tests.cpp \
	test/blockstatus_tests.cpp \
	test/bloom_tests.cpp \
	test/bswap_tests.cpp \
	test/cashaddr_tests.cpp \
	test/cashaddrenc_tests.cpp \
	test/checkdatasig_tests.cpp \
	test/checkpoints_tests.cpp \
	test/checkqueue_tests.cpp \
	test/coins_tests.cpp \
	test/compress_tests.cpp \
	test/config_tests.cpp \
	test/core_io_tests.cpp \
	test/crypto_tests.cpp \
	test/cuckoocache_tests.cpp \
	test/dbwrapper_tests.cpp \
	test/DoS_tests.cpp \
	test/dstencode_tests.cpp \
	test/excessiveblock_tests.cpp \
	test/feerate_tests.cpp \
	test/finalization_tests.cpp \
	test/getarg_tests.cpp \
	test/hash_tests.cpp \
	test/inv_tests.cpp \
	test/jsonutil.cpp \
	test/jsonutil.h \
	test/key_tests.cpp \
	test/lcg_tests.cpp \
	test/lcg.h \
	test/limitedmap_tests.cpp \
	test/main_tests.cpp \
	test/mempool_tests.cpp \
	test/merkle_tests.cpp \
	test/miner_tests.cpp \
	test/monolith_opcodes_tests.cpp \
	test/multisig_tests.cpp \
	test/net_tests.cpp \
	test/netbase_tests.cpp \
	test/pmt_tests.cpp \
	test/policyestimator_tests.cpp \
	test/pow_tests.cpp \
	test/prevector_tests.cpp \
	test/radix_tests.cpp \
	test/raii_event_tests.cpp \
	test/random_tests.cpp \
	test/rcu_tests.cpp \
	test/reverselock_tests.cpp \
	test/rpc_tests.cpp \
	test/rpc_server_tests.cpp \
	test/rwcollection_tests.cpp \
	test/sanity_tests.cpp \
	test/scheduler_tests.cpp \
	test/schnorr_tests.cpp \
	test/script_commitment_tests.cpp \
	test/script_P2SH_tests.cpp \
	+ test/script_standard_tests.cpp \
	test/script_tests.cpp \
	test/scriptflags.cpp \
	test/scriptflags.h \
	test/scriptnum_tests.cpp \
	test/serialize_tests.cpp \
	test/sigcache_tests.cpp \
	test/sigencoding_tests.cpp \
	test/sighash_tests.cpp \
	test/sighashtype_tests.cpp \
	test/sigopcount_tests.cpp \
	test/sigutil.cpp \
	test/sigutil.h \
	test/skiplist_tests.cpp \
	test/streams_tests.cpp \
	test/sync_tests.cpp \
	test/test_bitcoin.cpp \
	test/test_bitcoin.h \
	test/test_bitcoin_main.cpp \
	test/timedata_tests.cpp \
	test/transaction_tests.cpp \
	test/txindex_tests.cpp \
	test/txvalidationcache_tests.cpp \
	test/uint256_tests.cpp \
	test/undo_tests.cpp \
	test/univalue_tests.cpp \
	test/util_tests.cpp \
	test/validation_tests.cpp \
	test/work_comparator_tests.cpp \
	rpc/test/server_tests.cpp

	if ENABLE_WALLET
	BITCOIN_TESTS += \
	wallet/test/wallet_test_fixture.cpp \
	wallet/test/wallet_test_fixture.h \
	wallet/test/accounting_tests.cpp \
	wallet/test/wallet_tests.cpp \
	wallet/test/walletdb_tests.cpp \
	wallet/test/wallet_crypto_tests.cpp
	endif

	test_test_bitcoin_SOURCES = $(BITCOIN_TESTS) $(JSON_TEST_FILES) $(RAW_TEST_FILES)
	test_test_bitcoin_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) $(TESTDEFS) $(EVENT_CFLAGS)
	test_test_bitcoin_LDADD =
	if ENABLE_WALLET
	test_test_bitcoin_LDADD += $(LIBBITCOIN_WALLET)
	endif

	test_test_bitcoin_LDADD += $(LIBBITCOIN_SERVER) $(LIBBITCOIN_CLI) $(LIBBITCOIN_COMMON) $(LIBBITCOIN_UTIL) $(LIBBITCOIN_CONSENSUS) $(LIBBITCOIN_CRYPTO) $(LIBUNIVALUE) \
	$(LIBLEVELDB) $(LIBLEVELDB_SSE42) $(LIBMEMENV) $(BOOST_LIBS) $(BOOST_UNIT_TEST_FRAMEWORK_LIB) $(LIBSECP256K1) $(EVENT_LIBS) $(EVENT_PTHREADS_LIBS)
	test_test_bitcoin_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)

	test_test_bitcoin_LDADD += $(LIBBITCOIN_CONSENSUS) $(BDB_LIBS) $(SSL_LIBS) $(CRYPTO_LIBS) $(MINIUPNPC_LIBS)
	test_test_bitcoin_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS) -static

	if ENABLE_ZMQ
	test_test_bitcoin_LDADD += $(ZMQ_LIBS)
	endif
	#

	# test_bitcoin_fuzzy binary #
	test_test_bitcoin_fuzzy_SOURCES = test/test_bitcoin_fuzzy.cpp
	test_test_bitcoin_fuzzy_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES)
	test_test_bitcoin_fuzzy_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
	test_test_bitcoin_fuzzy_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)

	test_test_bitcoin_fuzzy_LDADD = \
	$(LIBUNIVALUE) \
	$(LIBBITCOIN_SERVER) \
	$(LIBBITCOIN_COMMON) \
	$(LIBBITCOIN_UTIL) \
	$(LIBBITCOIN_CONSENSUS) \
	$(LIBBITCOIN_CRYPTO) \
	$(LIBSECP256K1)

	test_test_bitcoin_fuzzy_LDADD += $(BOOST_LIBS) $(CRYPTO_LIBS)
	#

	nodist_test_test_bitcoin_SOURCES = $(GENERATED_TEST_FILES)

	$(BITCOIN_TESTS): $(GENERATED_TEST_FILES)

	CLEAN_BITCOIN_TEST = test/.gcda test/.gcno $(GENERATED_TEST_FILES)

	CLEANFILES += $(CLEAN_BITCOIN_TEST)

	bitcoin_test: $(TEST_BINARY)

	bitcoin_test_check: $(TEST_BINARY) FORCE
	$(MAKE) check-TESTS TESTS=$^

	bitcoin_test_clean : FORCE
	rm -f $(CLEAN_BITCOIN_TEST) $(test_test_bitcoin_OBJECTS) $(TEST_BINARY)

	check-local:
	@echo "Running test/util/bitcoin-util-test.py..."
	$(top_builddir)/test/util/bitcoin-util-test.py
	$(AM_V_at)$(MAKE) $(AM_MAKEFLAGS) -C secp256k1 check
	if EMBEDDED_UNIVALUE
	$(AM_V_at)$(MAKE) $(AM_MAKEFLAGS) -C univalue check
	endif

	%.json.h: %.json
	@$(MKDIR_P) $(@D)
	@{ \
	echo "namespace json_tests{" && \
	echo "static unsigned const char $(*F)[] = {" && \
	$(HEXDUMP) -v -e '8/1 "0x%02x, "' -e '"\n"' $< \| $(SED) -e 's/0x ,//g' && \
	echo "};};"; \
	} > "$@.new" && mv -f "$@.new" "$@"
	@echo "Generated $@"
	diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
	index 6c771eed5..73db778e1 100644
	--- a/src/test/CMakeLists.txt
	+++ b/src/test/CMakeLists.txt
	@@ -1,172 +1,173 @@
	# Copyright (c) 2018 The Bitcoin developers

	project(bitcoin-test)

	# Process json files.
	file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/data")

	find_program(PYTHON python)
	function(gen_json_header NAME)
	set(HEADERS "")
	foreach(f ${ARGN})
	set(h "${CMAKE_CURRENT_BINARY_DIR}/${f}.h")

	# Get the proper name for the test variable.
	get_filename_component(TEST_NAME ${f} NAME_WE)
	add_custom_command(OUTPUT ${h}
	COMMAND ${PYTHON}
	ARGS
	"${CMAKE_CURRENT_SOURCE_DIR}/data/generate_header.py"
	"${TEST_NAME}"
	"${CMAKE_CURRENT_SOURCE_DIR}/${f}" > ${h}
	MAIN_DEPENDENCY ${f}
	DEPENDS
	"data/generate_header.py"
	VERBATIM
	)
	list(APPEND HEADERS ${h})
	endforeach(f)
	set(${NAME} "${HEADERS}" PARENT_SCOPE)
	endfunction()

	gen_json_header(JSON_HEADERS
	data/script_tests.json
	data/base58_keys_valid.json
	data/base58_encode_decode.json
	data/base58_keys_invalid.json
	data/blockfilters.json
	data/tx_invalid.json
	data/tx_valid.json
	data/sighash.json
	)

	include(TestSuite)
	create_test_suite(bitcoin)
	add_dependencies(check check-bitcoin)

	add_test_to_suite(bitcoin test_bitcoin
	activation_tests.cpp
	addrman_tests.cpp
	allocator_tests.cpp
	amount_tests.cpp
	arith_uint256_tests.cpp
	avalanche_tests.cpp
	base32_tests.cpp
	base58_tests.cpp
	base64_tests.cpp
	bip32_tests.cpp
	blockcheck_tests.cpp
	blockencodings_tests.cpp
	blockfilter_tests.cpp
	blockindex_tests.cpp
	blockstatus_tests.cpp
	bloom_tests.cpp
	bswap_tests.cpp
	cashaddr_tests.cpp
	cashaddrenc_tests.cpp
	checkdatasig_tests.cpp
	checkpoints_tests.cpp
	checkqueue_tests.cpp
	coins_tests.cpp
	compress_tests.cpp
	config_tests.cpp
	core_io_tests.cpp
	crypto_tests.cpp
	cuckoocache_tests.cpp
	dbwrapper_tests.cpp
	DoS_tests.cpp
	dstencode_tests.cpp
	excessiveblock_tests.cpp
	feerate_tests.cpp
	finalization_tests.cpp
	getarg_tests.cpp
	hash_tests.cpp
	inv_tests.cpp
	jsonutil.cpp
	key_tests.cpp
	lcg_tests.cpp
	limitedmap_tests.cpp
	main_tests.cpp
	mempool_tests.cpp
	merkle_tests.cpp
	miner_tests.cpp
	monolith_opcodes_tests.cpp
	multisig_tests.cpp
	net_tests.cpp
	netbase_tests.cpp
	pmt_tests.cpp
	policyestimator_tests.cpp
	pow_tests.cpp
	prevector_tests.cpp
	radix_tests.cpp
	raii_event_tests.cpp
	random_tests.cpp
	rcu_tests.cpp
	reverselock_tests.cpp
	rpc_tests.cpp
	rpc_server_tests.cpp
	rwcollection_tests.cpp
	sanity_tests.cpp
	scheduler_tests.cpp
	schnorr_tests.cpp
	script_commitment_tests.cpp
	script_P2SH_tests.cpp
	+ script_standard_tests.cpp
	script_tests.cpp
	scriptflags.cpp
	scriptnum_tests.cpp
	serialize_tests.cpp
	sigcache_tests.cpp
	sigencoding_tests.cpp
	sighash_tests.cpp
	sighashtype_tests.cpp
	sigopcount_tests.cpp
	sigutil.cpp
	skiplist_tests.cpp
	streams_tests.cpp
	sync_tests.cpp
	test_bitcoin.cpp
	test_bitcoin_main.cpp
	timedata_tests.cpp
	transaction_tests.cpp
	txindex_tests.cpp
	txvalidationcache_tests.cpp
	uint256_tests.cpp
	undo_tests.cpp
	univalue_tests.cpp
	util_tests.cpp
	validation_tests.cpp
	work_comparator_tests.cpp

	# RPC Tests
	../rpc/test/server_tests.cpp

	# Tests generated from JSON
	${JSON_HEADERS}
	)

	find_package(Boost 1.58 REQUIRED unit_test_framework)

	target_link_libraries(test_bitcoin Boost::unit_test_framework rpcclient server)

	# We need to detect if the BOOST_TEST_DYN_LINK flag is required.
	set(CMAKE_REQUIRED_LIBRARIES Boost::unit_test_framework)
	check_cxx_source_compiles("
	#define BOOST_TEST_DYN_LINK
	#define BOOST_TEST_MAIN
	#include <boost/test/unit_test.hpp>
	" BOOST_TEST_DYN_LINK)

	if(BOOST_TEST_DYN_LINK)
	target_compile_definitions(test_bitcoin PRIVATE BOOST_TEST_DYN_LINK)
	endif(BOOST_TEST_DYN_LINK)

	if(BUILD_BITCOIN_WALLET)
	target_sources(test_bitcoin
	PRIVATE
	../wallet/test/wallet_test_fixture.cpp
	../wallet/test/accounting_tests.cpp
	../wallet/test/wallet_tests.cpp
	../wallet/test/walletdb_tests.cpp
	../wallet/test/wallet_crypto_tests.cpp
	)
	endif()
	diff --git a/src/test/multisig_tests.cpp b/src/test/multisig_tests.cpp
	index 64f44a691..261939b7e 100644
	--- a/src/test/multisig_tests.cpp
	+++ b/src/test/multisig_tests.cpp
	@@ -1,362 +1,269 @@
	// Copyright (c) 2011-2016 The Bitcoin Core developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include <key.h>
	#include <keystore.h>
	#include <policy/policy.h>
	#include <script/interpreter.h>
	#include <script/ismine.h>
	#include <script/script.h>
	#include <script/script_error.h>
	#include <script/sighashtype.h>
	#include <script/sign.h>
	#include <tinyformat.h>
	#include <uint256.h>

	#include <test/test_bitcoin.h>

	#include <boost/test/unit_test.hpp>

	-typedef std::vector<uint8_t> valtype;
	-
	BOOST_FIXTURE_TEST_SUITE(multisig_tests, BasicTestingSetup)

	CScript sign_multisig(CScript scriptPubKey, std::vector<CKey> keys,
	CMutableTransaction mutableTransaction, int whichIn) {
	uint256 hash = SignatureHash(scriptPubKey, CTransaction(mutableTransaction),
	whichIn, SigHashType(), Amount::zero());

	CScript result;
	// CHECKMULTISIG bug workaround
	result << OP_0;
	for (const CKey &key : keys) {
	std::vector<uint8_t> vchSig;
	BOOST_CHECK(key.SignECDSA(hash, vchSig));
	vchSig.push_back(uint8_t(SIGHASH_ALL));
	result << vchSig;
	}
	return result;
	}

	BOOST_AUTO_TEST_CASE(multisig_verify) {
	uint32_t flags = SCRIPT_VERIFY_P2SH \| SCRIPT_VERIFY_STRICTENC;

	ScriptError err;
	CKey key[4];
	Amount amount = Amount::zero();
	for (int i = 0; i < 4; i++) {
	key[i].MakeNewKey(true);
	}

	CScript a_and_b;
	a_and_b << OP_2 << ToByteVector(key[0].GetPubKey())
	<< ToByteVector(key[1].GetPubKey()) << OP_2 << OP_CHECKMULTISIG;

	CScript a_or_b;
	a_or_b << OP_1 << ToByteVector(key[0].GetPubKey())
	<< ToByteVector(key[1].GetPubKey()) << OP_2 << OP_CHECKMULTISIG;

	CScript escrow;
	escrow << OP_2 << ToByteVector(key[0].GetPubKey())
	<< ToByteVector(key[1].GetPubKey())
	<< ToByteVector(key[2].GetPubKey()) << OP_3 << OP_CHECKMULTISIG;

	// Funding transaction
	CMutableTransaction txFrom;
	txFrom.vout.resize(3);
	txFrom.vout[0].scriptPubKey = a_and_b;
	txFrom.vout[1].scriptPubKey = a_or_b;
	txFrom.vout[2].scriptPubKey = escrow;

	// Spending transaction
	CMutableTransaction txTo[3];
	for (int i = 0; i < 3; i++) {
	txTo[i].vin.resize(1);
	txTo[i].vout.resize(1);
	txTo[i].vin[0].prevout = COutPoint(txFrom.GetId(), i);
	txTo[i].vout[0].nValue = SATOSHI;
	}

	std::vector<CKey> keys;
	CScript s;

	// Test a AND b:
	keys.assign(1, key[0]);
	keys.push_back(key[1]);
	s = sign_multisig(a_and_b, keys, txTo[0], 0);
	BOOST_CHECK(VerifyScript(
	s, a_and_b, flags,
	MutableTransactionSignatureChecker(&txTo[0], 0, amount), &err));
	BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));

	for (int i = 0; i < 4; i++) {
	keys.assign(1, key[i]);
	s = sign_multisig(a_and_b, keys, txTo[0], 0);
	BOOST_CHECK_MESSAGE(
	!VerifyScript(
	s, a_and_b, flags,
	MutableTransactionSignatureChecker(&txTo[0], 0, amount), &err),
	strprintf("a&b 1: %d", i));
	BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_INVALID_STACK_OPERATION,
	ScriptErrorString(err));

	keys.assign(1, key[1]);
	keys.push_back(key[i]);
	s = sign_multisig(a_and_b, keys, txTo[0], 0);
	BOOST_CHECK_MESSAGE(
	!VerifyScript(
	s, a_and_b, flags,
	MutableTransactionSignatureChecker(&txTo[0], 0, amount), &err),
	strprintf("a&b 2: %d", i));
	BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE,
	ScriptErrorString(err));
	}

	// Test a OR b:
	for (int i = 0; i < 4; i++) {
	keys.assign(1, key[i]);
	s = sign_multisig(a_or_b, keys, txTo[1], 0);
	if (i == 0 \|\| i == 1) {
	BOOST_CHECK_MESSAGE(VerifyScript(s, a_or_b, flags,
	MutableTransactionSignatureChecker(
	&txTo[1], 0, amount),
	&err),
	strprintf("a\|b: %d", i));
	BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
	} else {
	BOOST_CHECK_MESSAGE(
	!VerifyScript(
	s, a_or_b, flags,
	MutableTransactionSignatureChecker(&txTo[1], 0, amount),
	&err),
	strprintf("a\|b: %d", i));
	BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE,
	ScriptErrorString(err));
	}
	}
	s.clear();
	s << OP_0 << OP_1;
	BOOST_CHECK(!VerifyScript(
	s, a_or_b, flags,
	MutableTransactionSignatureChecker(&txTo[1], 0, amount), &err));
	BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_SIG_DER, ScriptErrorString(err));

	for (int i = 0; i < 4; i++)
	for (int j = 0; j < 4; j++) {
	keys.assign(1, key[i]);
	keys.push_back(key[j]);
	s = sign_multisig(escrow, keys, txTo[2], 0);
	if (i < j && i < 3 && j < 3) {
	BOOST_CHECK_MESSAGE(
	VerifyScript(
	s, escrow, flags,
	MutableTransactionSignatureChecker(&txTo[2], 0, amount),
	&err),
	strprintf("escrow 1: %d %d", i, j));
	BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK,
	ScriptErrorString(err));
	} else {
	BOOST_CHECK_MESSAGE(
	!VerifyScript(
	s, escrow, flags,
	MutableTransactionSignatureChecker(&txTo[2], 0, amount),
	&err),
	strprintf("escrow 2: %d %d", i, j));
	BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE,
	ScriptErrorString(err));
	}
	}
	}

	BOOST_AUTO_TEST_CASE(multisig_IsStandard) {
	CKey key[4];
	for (int i = 0; i < 4; i++)
	key[i].MakeNewKey(true);

	txnouttype whichType;

	CScript a_and_b;
	a_and_b << OP_2 << ToByteVector(key[0].GetPubKey())
	<< ToByteVector(key[1].GetPubKey()) << OP_2 << OP_CHECKMULTISIG;
	BOOST_CHECK(::IsStandard(a_and_b, whichType));

	CScript a_or_b;
	a_or_b << OP_1 << ToByteVector(key[0].GetPubKey())
	<< ToByteVector(key[1].GetPubKey()) << OP_2 << OP_CHECKMULTISIG;
	BOOST_CHECK(::IsStandard(a_or_b, whichType));

	CScript escrow;
	escrow << OP_2 << ToByteVector(key[0].GetPubKey())
	<< ToByteVector(key[1].GetPubKey())
	<< ToByteVector(key[2].GetPubKey()) << OP_3 << OP_CHECKMULTISIG;
	BOOST_CHECK(::IsStandard(escrow, whichType));

	CScript one_of_four;
	one_of_four << OP_1 << ToByteVector(key[0].GetPubKey())
	<< ToByteVector(key[1].GetPubKey())
	<< ToByteVector(key[2].GetPubKey())
	<< ToByteVector(key[3].GetPubKey()) << OP_4 << OP_CHECKMULTISIG;
	BOOST_CHECK(!::IsStandard(one_of_four, whichType));

	CScript malformed[6];
	malformed[0] << OP_3 << ToByteVector(key[0].GetPubKey())
	<< ToByteVector(key[1].GetPubKey()) << OP_2
	<< OP_CHECKMULTISIG;
	malformed[1] << OP_2 << ToByteVector(key[0].GetPubKey())
	<< ToByteVector(key[1].GetPubKey()) << OP_3
	<< OP_CHECKMULTISIG;
	malformed[2] << OP_0 << ToByteVector(key[0].GetPubKey())
	<< ToByteVector(key[1].GetPubKey()) << OP_2
	<< OP_CHECKMULTISIG;
	malformed[3] << OP_1 << ToByteVector(key[0].GetPubKey())
	<< ToByteVector(key[1].GetPubKey()) << OP_0
	<< OP_CHECKMULTISIG;
	malformed[4] << OP_1 << ToByteVector(key[0].GetPubKey())
	<< ToByteVector(key[1].GetPubKey()) << OP_CHECKMULTISIG;
	malformed[5] << OP_1 << ToByteVector(key[0].GetPubKey())
	<< ToByteVector(key[1].GetPubKey());

	for (int i = 0; i < 6; i++)
	BOOST_CHECK(!::IsStandard(malformed[i], whichType));
	}

	-BOOST_AUTO_TEST_CASE(multisig_Solver1) {
	- // Tests Solver() that returns lists of keys that are required to satisfy a
	- // ScriptPubKey
	- //
	- // Also tests IsMine() and ExtractDestination()
	- //
	- // Note: ExtractDestination for the multisignature transactions always
	- // returns false for this release, even if you have one key that would
	- // satisfy an (a\|b) or 2-of-3 keys needed to spend an escrow transaction.
	- //
	- CBasicKeyStore keystore, emptykeystore, partialkeystore;
	- CKey key[3];
	- CTxDestination keyaddr[3];
	- for (int i = 0; i < 3; i++) {
	- key[i].MakeNewKey(true);
	- keystore.AddKey(key[i]);
	- keyaddr[i] = key[i].GetPubKey().GetID();
	- }
	- partialkeystore.AddKey(key[0]);
	-
	- {
	- std::vector<valtype> solutions;
	- txnouttype whichType;
	- CScript s;
	- s << ToByteVector(key[0].GetPubKey()) << OP_CHECKSIG;
	- BOOST_CHECK(Solver(s, whichType, solutions));
	- BOOST_CHECK(solutions.size() == 1);
	- CTxDestination addr;
	- BOOST_CHECK(ExtractDestination(s, addr));
	- BOOST_CHECK(addr == keyaddr[0]);
	- BOOST_CHECK(IsMine(keystore, s));
	- BOOST_CHECK(!IsMine(emptykeystore, s));
	- }
	- {
	- std::vector<valtype> solutions;
	- txnouttype whichType;
	- CScript s;
	- s << OP_DUP << OP_HASH160 << ToByteVector(key[0].GetPubKey().GetID())
	- << OP_EQUALVERIFY << OP_CHECKSIG;
	- BOOST_CHECK(Solver(s, whichType, solutions));
	- BOOST_CHECK(solutions.size() == 1);
	- CTxDestination addr;
	- BOOST_CHECK(ExtractDestination(s, addr));
	- BOOST_CHECK(addr == keyaddr[0]);
	- BOOST_CHECK(IsMine(keystore, s));
	- BOOST_CHECK(!IsMine(emptykeystore, s));
	- }
	- {
	- std::vector<valtype> solutions;
	- txnouttype whichType;
	- CScript s;
	- s << OP_2 << ToByteVector(key[0].GetPubKey())
	- << ToByteVector(key[1].GetPubKey()) << OP_2 << OP_CHECKMULTISIG;
	- BOOST_CHECK(Solver(s, whichType, solutions));
	- BOOST_CHECK_EQUAL(solutions.size(), 4U);
	- CTxDestination addr;
	- BOOST_CHECK(!ExtractDestination(s, addr));
	- BOOST_CHECK(IsMine(keystore, s));
	- BOOST_CHECK(!IsMine(emptykeystore, s));
	- BOOST_CHECK(!IsMine(partialkeystore, s));
	- }
	- {
	- std::vector<valtype> solutions;
	- txnouttype whichType;
	- CScript s;
	- s << OP_1 << ToByteVector(key[0].GetPubKey())
	- << ToByteVector(key[1].GetPubKey()) << OP_2 << OP_CHECKMULTISIG;
	- BOOST_CHECK(Solver(s, whichType, solutions));
	- BOOST_CHECK_EQUAL(solutions.size(), 4U);
	- std::vector<CTxDestination> addrs;
	- int nRequired;
	- BOOST_CHECK(ExtractDestinations(s, whichType, addrs, nRequired));
	- BOOST_CHECK(addrs[0] == keyaddr[0]);
	- BOOST_CHECK(addrs[1] == keyaddr[1]);
	- BOOST_CHECK(nRequired == 1);
	- BOOST_CHECK(IsMine(keystore, s));
	- BOOST_CHECK(!IsMine(emptykeystore, s));
	- BOOST_CHECK(!IsMine(partialkeystore, s));
	- }
	- {
	- std::vector<valtype> solutions;
	- txnouttype whichType;
	- CScript s;
	- s << OP_2 << ToByteVector(key[0].GetPubKey())
	- << ToByteVector(key[1].GetPubKey())
	- << ToByteVector(key[2].GetPubKey()) << OP_3 << OP_CHECKMULTISIG;
	- BOOST_CHECK(Solver(s, whichType, solutions));
	- BOOST_CHECK(solutions.size() == 5);
	- }
	-}
	-
	BOOST_AUTO_TEST_CASE(multisig_Sign) {
	// Test SignSignature() (and therefore the version of Solver() that signs
	// transactions)
	CBasicKeyStore keystore;
	CKey key[4];
	for (int i = 0; i < 4; i++) {
	key[i].MakeNewKey(true);
	keystore.AddKey(key[i]);
	}

	CScript a_and_b;
	a_and_b << OP_2 << ToByteVector(key[0].GetPubKey())
	<< ToByteVector(key[1].GetPubKey()) << OP_2 << OP_CHECKMULTISIG;

	CScript a_or_b;
	a_or_b << OP_1 << ToByteVector(key[0].GetPubKey())
	<< ToByteVector(key[1].GetPubKey()) << OP_2 << OP_CHECKMULTISIG;

	CScript escrow;
	escrow << OP_2 << ToByteVector(key[0].GetPubKey())
	<< ToByteVector(key[1].GetPubKey())
	<< ToByteVector(key[2].GetPubKey()) << OP_3 << OP_CHECKMULTISIG;

	// Funding transaction
	CMutableTransaction txFrom;
	txFrom.vout.resize(3);
	txFrom.vout[0].scriptPubKey = a_and_b;
	txFrom.vout[1].scriptPubKey = a_or_b;
	txFrom.vout[2].scriptPubKey = escrow;

	// Spending transaction
	CMutableTransaction txTo[3];
	for (int i = 0; i < 3; i++) {
	txTo[i].vin.resize(1);
	txTo[i].vout.resize(1);
	txTo[i].vin[0].prevout = COutPoint(txFrom.GetId(), i);
	txTo[i].vout[0].nValue = SATOSHI;
	}

	for (int i = 0; i < 3; i++) {
	BOOST_CHECK_MESSAGE(SignSignature(keystore, CTransaction(txFrom),
	txTo[i], 0,
	SigHashType().withForkId()),
	strprintf("SignSignature %d", i));
	}
	}

	BOOST_AUTO_TEST_SUITE_END()
	diff --git a/src/test/script_standard_tests.cpp b/src/test/script_standard_tests.cpp
	new file mode 100644
	index 000000000..6d4154719
	--- /dev/null
	+++ b/src/test/script_standard_tests.cpp
	@@ -0,0 +1,351 @@
	+// Copyright (c) 2017 The Bitcoin Core developers
	+// Distributed under the MIT software license, see the accompanying
	+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
	+
	+#include <key.h>
	+#include <script/script.h>
	+#include <script/script_error.h>
	+#include <script/standard.h>
	+#include <test/test_bitcoin.h>
	+
	+#include <boost/test/unit_test.hpp>
	+
	+BOOST_FIXTURE_TEST_SUITE(script_standard_tests, BasicTestingSetup)
	+
	+BOOST_AUTO_TEST_CASE(script_standard_Solver_success) {
	+ CKey keys[3];
	+ CPubKey pubkeys[3];
	+ for (int i = 0; i < 3; i++) {
	+ keys[i].MakeNewKey(true);
	+ pubkeys[i] = keys[i].GetPubKey();
	+ }
	+
	+ CScript s;
	+ txnouttype whichType;
	+ std::vector<std::vector<uint8_t>> solutions;
	+
	+ // TX_PUBKEY
	+ s.clear();
	+ s << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
	+ BOOST_CHECK(Solver(s, whichType, solutions));
	+ BOOST_CHECK_EQUAL(whichType, TX_PUBKEY);
	+ BOOST_CHECK_EQUAL(solutions.size(), 1);
	+ BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0]));
	+
	+ // TX_PUBKEYHASH
	+ s.clear();
	+ s << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID())
	+ << OP_EQUALVERIFY << OP_CHECKSIG;
	+ BOOST_CHECK(Solver(s, whichType, solutions));
	+ BOOST_CHECK_EQUAL(whichType, TX_PUBKEYHASH);
	+ BOOST_CHECK_EQUAL(solutions.size(), 1);
	+ BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0].GetID()));
	+
	+ // TX_SCRIPTHASH
	+ CScript redeemScript(s); // initialize with leftover P2PKH script
	+ s.clear();
	+ s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
	+ BOOST_CHECK(Solver(s, whichType, solutions));
	+ BOOST_CHECK_EQUAL(whichType, TX_SCRIPTHASH);
	+ BOOST_CHECK_EQUAL(solutions.size(), 1);
	+ BOOST_CHECK(solutions[0] == ToByteVector(CScriptID(redeemScript)));
	+
	+ // TX_MULTISIG
	+ s.clear();
	+ s << OP_1 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1]) << OP_2
	+ << OP_CHECKMULTISIG;
	+ BOOST_CHECK(Solver(s, whichType, solutions));
	+ BOOST_CHECK_EQUAL(whichType, TX_MULTISIG);
	+ BOOST_CHECK_EQUAL(solutions.size(), 4);
	+ BOOST_CHECK(solutions[0] == std::vector<uint8_t>({1}));
	+ BOOST_CHECK(solutions[1] == ToByteVector(pubkeys[0]));
	+ BOOST_CHECK(solutions[2] == ToByteVector(pubkeys[1]));
	+ BOOST_CHECK(solutions[3] == std::vector<uint8_t>({2}));
	+
	+ s.clear();
	+ s << OP_2 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1])
	+ << ToByteVector(pubkeys[2]) << OP_3 << OP_CHECKMULTISIG;
	+ BOOST_CHECK(Solver(s, whichType, solutions));
	+ BOOST_CHECK_EQUAL(whichType, TX_MULTISIG);
	+ BOOST_CHECK_EQUAL(solutions.size(), 5);
	+ BOOST_CHECK(solutions[0] == std::vector<uint8_t>({2}));
	+ BOOST_CHECK(solutions[1] == ToByteVector(pubkeys[0]));
	+ BOOST_CHECK(solutions[2] == ToByteVector(pubkeys[1]));
	+ BOOST_CHECK(solutions[3] == ToByteVector(pubkeys[2]));
	+ BOOST_CHECK(solutions[4] == std::vector<uint8_t>({3}));
	+
	+ // TX_NULL_DATA
	+ solutions.clear();
	+ s.clear();
	+ s << OP_RETURN << std::vector<uint8_t>({0}) << std::vector<uint8_t>({75})
	+ << std::vector<uint8_t>({255});
	+ BOOST_CHECK(Solver(s, whichType, solutions));
	+ BOOST_CHECK_EQUAL(whichType, TX_NULL_DATA);
	+ BOOST_CHECK_EQUAL(solutions.size(), 0);
	+
	+ // TX_WITNESS_V0_KEYHASH
	+ solutions.clear();
	+ s.clear();
	+ s << OP_0 << ToByteVector(pubkeys[0].GetID());
	+ BOOST_CHECK(!Solver(s, whichType, solutions));
	+ BOOST_CHECK_EQUAL(whichType, TX_NONSTANDARD);
	+ BOOST_CHECK_EQUAL(solutions.size(), 0);
	+
	+ // TX_WITNESS_V0_SCRIPTHASH
	+ uint256 scriptHash;
	+ CSHA256()
	+ .Write(&redeemScript[0], redeemScript.size())
	+ .Finalize(scriptHash.begin());
	+
	+ solutions.clear();
	+ s.clear();
	+ s << OP_0 << ToByteVector(scriptHash);
	+ BOOST_CHECK(!Solver(s, whichType, solutions));
	+ BOOST_CHECK_EQUAL(whichType, TX_NONSTANDARD);
	+ BOOST_CHECK_EQUAL(solutions.size(), 0);
	+
	+ // TX_NONSTANDARD
	+ solutions.clear();
	+ s.clear();
	+ s << OP_9 << OP_ADD << OP_11 << OP_EQUAL;
	+ BOOST_CHECK(!Solver(s, whichType, solutions));
	+ BOOST_CHECK_EQUAL(whichType, TX_NONSTANDARD);
	+ BOOST_CHECK_EQUAL(solutions.size(), 0);
	+}
	+
	+BOOST_AUTO_TEST_CASE(script_standard_Solver_failure) {
	+ CKey key;
	+ CPubKey pubkey;
	+ key.MakeNewKey(true);
	+ pubkey = key.GetPubKey();
	+
	+ CScript s;
	+ txnouttype whichType;
	+ std::vector<std::vector<uint8_t>> solutions;
	+
	+ // TX_PUBKEY with incorrectly sized pubkey
	+ s.clear();
	+ s << std::vector<uint8_t>(30, 0x01) << OP_CHECKSIG;
	+ BOOST_CHECK(!Solver(s, whichType, solutions));
	+
	+ // TX_PUBKEYHASH with incorrectly sized key hash
	+ s.clear();
	+ s << OP_DUP << OP_HASH160 << ToByteVector(pubkey) << OP_EQUALVERIFY
	+ << OP_CHECKSIG;
	+ BOOST_CHECK(!Solver(s, whichType, solutions));
	+
	+ // TX_SCRIPTHASH with incorrectly sized script hash
	+ s.clear();
	+ s << OP_HASH160 << std::vector<uint8_t>(21, 0x01) << OP_EQUAL;
	+ BOOST_CHECK(!Solver(s, whichType, solutions));
	+
	+ // TX_MULTISIG 0/2
	+ s.clear();
	+ s << OP_0 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
	+ BOOST_CHECK(!Solver(s, whichType, solutions));
	+
	+ // TX_MULTISIG 2/1
	+ s.clear();
	+ s << OP_2 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
	+ BOOST_CHECK(!Solver(s, whichType, solutions));
	+
	+ // TX_MULTISIG n = 2 with 1 pubkey
	+ s.clear();
	+ s << OP_1 << ToByteVector(pubkey) << OP_2 << OP_CHECKMULTISIG;
	+ BOOST_CHECK(!Solver(s, whichType, solutions));
	+
	+ // TX_MULTISIG n = 1 with 0 pubkeys
	+ s.clear();
	+ s << OP_1 << OP_1 << OP_CHECKMULTISIG;
	+ BOOST_CHECK(!Solver(s, whichType, solutions));
	+
	+ // TX_NULL_DATA with other opcodes
	+ s.clear();
	+ s << OP_RETURN << std::vector<uint8_t>({75}) << OP_ADD;
	+ BOOST_CHECK(!Solver(s, whichType, solutions));
	+
	+ // TX_WITNESS with unknown version
	+ s.clear();
	+ s << OP_1 << ToByteVector(pubkey);
	+ BOOST_CHECK(!Solver(s, whichType, solutions));
	+
	+ // TX_WITNESS with incorrect program size
	+ s.clear();
	+ s << OP_0 << std::vector<uint8_t>(19, 0x01);
	+ BOOST_CHECK(!Solver(s, whichType, solutions));
	+}
	+
	+BOOST_AUTO_TEST_CASE(script_standard_ExtractDestination) {
	+ CKey key;
	+ CPubKey pubkey;
	+ key.MakeNewKey(true);
	+ pubkey = key.GetPubKey();
	+
	+ CScript s;
	+ CTxDestination address;
	+
	+ // TX_PUBKEY
	+ s.clear();
	+ s << ToByteVector(pubkey) << OP_CHECKSIG;
	+ BOOST_CHECK(ExtractDestination(s, address));
	+ BOOST_CHECK(boost::get<CKeyID>(&address) &&
	+ *boost::get<CKeyID>(&address) == pubkey.GetID());
	+
	+ // TX_PUBKEYHASH
	+ s.clear();
	+ s << OP_DUP << OP_HASH160 << ToByteVector(pubkey.GetID()) << OP_EQUALVERIFY
	+ << OP_CHECKSIG;
	+ BOOST_CHECK(ExtractDestination(s, address));
	+ BOOST_CHECK(boost::get<CKeyID>(&address) &&
	+ *boost::get<CKeyID>(&address) == pubkey.GetID());
	+
	+ // TX_SCRIPTHASH
	+ CScript redeemScript(s); // initialize with leftover P2PKH script
	+ s.clear();
	+ s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
	+ BOOST_CHECK(ExtractDestination(s, address));
	+ BOOST_CHECK(boost::get<CScriptID>(&address) &&
	+ *boost::get<CScriptID>(&address) == CScriptID(redeemScript));
	+
	+ // TX_MULTISIG
	+ s.clear();
	+ s << OP_1 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
	+ BOOST_CHECK(!ExtractDestination(s, address));
	+
	+ // TX_NULL_DATA
	+ s.clear();
	+ s << OP_RETURN << std::vector<uint8_t>({75});
	+ BOOST_CHECK(!ExtractDestination(s, address));
	+
	+ // TX_WITNESS_V0_KEYHASH
	+ s.clear();
	+ s << OP_0 << ToByteVector(pubkey);
	+ BOOST_CHECK(!ExtractDestination(s, address));
	+
	+ // TX_WITNESS_V0_SCRIPTHASH
	+ s.clear();
	+ s << OP_0 << ToByteVector(CScriptID(redeemScript));
	+ BOOST_CHECK(!ExtractDestination(s, address));
	+}
	+
	+BOOST_AUTO_TEST_CASE(script_standard_ExtractDestinations) {
	+ CKey keys[3];
	+ CPubKey pubkeys[3];
	+ for (int i = 0; i < 3; i++) {
	+ keys[i].MakeNewKey(true);
	+ pubkeys[i] = keys[i].GetPubKey();
	+ }
	+
	+ CScript s;
	+ txnouttype whichType;
	+ std::vector<CTxDestination> addresses;
	+ int nRequired;
	+
	+ // TX_PUBKEY
	+ s.clear();
	+ s << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
	+ BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
	+ BOOST_CHECK_EQUAL(whichType, TX_PUBKEY);
	+ BOOST_CHECK_EQUAL(addresses.size(), 1);
	+ BOOST_CHECK_EQUAL(nRequired, 1);
	+ BOOST_CHECK(boost::get<CKeyID>(&addresses[0]) &&
	+ *boost::get<CKeyID>(&addresses[0]) == pubkeys[0].GetID());
	+
	+ // TX_PUBKEYHASH
	+ s.clear();
	+ s << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID())
	+ << OP_EQUALVERIFY << OP_CHECKSIG;
	+ BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
	+ BOOST_CHECK_EQUAL(whichType, TX_PUBKEYHASH);
	+ BOOST_CHECK_EQUAL(addresses.size(), 1);
	+ BOOST_CHECK_EQUAL(nRequired, 1);
	+ BOOST_CHECK(boost::get<CKeyID>(&addresses[0]) &&
	+ *boost::get<CKeyID>(&addresses[0]) == pubkeys[0].GetID());
	+
	+ // TX_SCRIPTHASH
	+ // initialize with leftover P2PKH script
	+ CScript redeemScript(s);
	+ s.clear();
	+ s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
	+ BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
	+ BOOST_CHECK_EQUAL(whichType, TX_SCRIPTHASH);
	+ BOOST_CHECK_EQUAL(addresses.size(), 1);
	+ BOOST_CHECK_EQUAL(nRequired, 1);
	+ BOOST_CHECK(boost::get<CScriptID>(&addresses[0]) &&
	+ *boost::get<CScriptID>(&addresses[0]) ==
	+ CScriptID(redeemScript));
	+
	+ // TX_MULTISIG
	+ s.clear();
	+ s << OP_2 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1]) << OP_2
	+ << OP_CHECKMULTISIG;
	+ BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
	+ BOOST_CHECK_EQUAL(whichType, TX_MULTISIG);
	+ BOOST_CHECK_EQUAL(addresses.size(), 2);
	+ BOOST_CHECK_EQUAL(nRequired, 2);
	+ BOOST_CHECK(boost::get<CKeyID>(&addresses[0]) &&
	+ *boost::get<CKeyID>(&addresses[0]) == pubkeys[0].GetID());
	+ BOOST_CHECK(boost::get<CKeyID>(&addresses[1]) &&
	+ *boost::get<CKeyID>(&addresses[1]) == pubkeys[1].GetID());
	+
	+ // TX_NULL_DATA
	+ s.clear();
	+ s << OP_RETURN << std::vector<uint8_t>({75});
	+ BOOST_CHECK(!ExtractDestinations(s, whichType, addresses, nRequired));
	+
	+ // TX_WITNESS_V0_KEYHASH
	+ s.clear();
	+ s << OP_0 << ToByteVector(pubkeys[0].GetID());
	+ BOOST_CHECK(!ExtractDestinations(s, whichType, addresses, nRequired));
	+
	+ // TX_WITNESS_V0_SCRIPTHASH
	+ s.clear();
	+ s << OP_0 << ToByteVector(CScriptID(redeemScript));
	+ BOOST_CHECK(!ExtractDestinations(s, whichType, addresses, nRequired));
	+}
	+
	+BOOST_AUTO_TEST_CASE(script_standard_GetScriptFor_) {
	+ CKey keys[3];
	+ CPubKey pubkeys[3];
	+ for (int i = 0; i < 3; i++) {
	+ keys[i].MakeNewKey(true);
	+ pubkeys[i] = keys[i].GetPubKey();
	+ }
	+
	+ CScript expected, result;
	+
	+ // CKeyID
	+ expected.clear();
	+ expected << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID())
	+ << OP_EQUALVERIFY << OP_CHECKSIG;
	+ result = GetScriptForDestination(pubkeys[0].GetID());
	+ BOOST_CHECK(result == expected);
	+
	+ // CScriptID
	+ CScript redeemScript(result);
	+ expected.clear();
	+ expected << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
	+ result = GetScriptForDestination(CScriptID(redeemScript));
	+ BOOST_CHECK(result == expected);
	+
	+ // CNoDestination
	+ expected.clear();
	+ result = GetScriptForDestination(CNoDestination());
	+ BOOST_CHECK(result == expected);
	+
	+ // GetScriptForRawPubKey
	+ expected.clear();
	+ expected << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
	+ result = GetScriptForRawPubKey(pubkeys[0]);
	+ BOOST_CHECK(result == expected);
	+
	+ // GetScriptForMultisig
	+ expected.clear();
	+ expected << OP_2 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1])
	+ << ToByteVector(pubkeys[2]) << OP_3 << OP_CHECKMULTISIG;
	+ result =
	+ GetScriptForMultisig(2, std::vector<CPubKey>(pubkeys, pubkeys + 3));
	+ BOOST_CHECK(result == expected);
	+}
	+
	+BOOST_AUTO_TEST_SUITE_END()

File Metadata

Mime Type: text/x-diff
Expires: Sun, Mar 2, 08:35 (18 h, 27 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5187096
Default Alt Text: (36 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions