Page MenuHomePhabricator
Differential D9126 Diff 27467 src/test/script_standard_tests.cpp

Changeset View

Standalone View

View Options

src/test/script_standard_tests.cpp

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 LinesBOOST_AUTO_TEST_CASE(script_standard_Solver_success) {
for (int i = 0; i < 3; i++) { for (int i = 0; i < 3; i++) {
keys[i].MakeNewKey(true); keys[i].MakeNewKey(true);
pubkeys[i] = keys[i].GetPubKey(); pubkeys[i] = keys[i].GetPubKey();
} }
CScript s; CScript s;
std::vector<std::vector<uint8_t>> solutions; std::vector<std::vector<uint8_t>> solutions;
// TX_PUBKEY // TxoutType::PUBKEY
s.clear(); s.clear();
s << ToByteVector(pubkeys[0]) << OP_CHECKSIG; s << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_PUBKEY); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::PUBKEY);
BOOST_CHECK_EQUAL(solutions.size(), 1U); BOOST_CHECK_EQUAL(solutions.size(), 1U);
BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0])); BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0]));
// TX_PUBKEYHASH // TxoutType::PUBKEYHASH
s.clear(); s.clear();
s << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID()) s << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID())
<< OP_EQUALVERIFY << OP_CHECKSIG; << OP_EQUALVERIFY << OP_CHECKSIG;
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_PUBKEYHASH); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::PUBKEYHASH);
BOOST_CHECK_EQUAL(solutions.size(), 1U); BOOST_CHECK_EQUAL(solutions.size(), 1U);
BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0].GetID())); BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0].GetID()));
// TX_SCRIPTHASH // TxoutType::SCRIPTHASH
CScript redeemScript(s); // initialize with leftover P2PKH script CScript redeemScript(s); // initialize with leftover P2PKH script
s.clear(); s.clear();
s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL; s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_SCRIPTHASH); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::SCRIPTHASH);
BOOST_CHECK_EQUAL(solutions.size(), 1U); BOOST_CHECK_EQUAL(solutions.size(), 1U);
BOOST_CHECK(solutions[0] == ToByteVector(CScriptID(redeemScript))); BOOST_CHECK(solutions[0] == ToByteVector(CScriptID(redeemScript)));
// TX_MULTISIG // TxoutType::MULTISIG
s.clear(); s.clear();
s << OP_1 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1]) << OP_2 s << OP_1 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1]) << OP_2
<< OP_CHECKMULTISIG; << OP_CHECKMULTISIG;
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_MULTISIG); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::MULTISIG);
BOOST_CHECK_EQUAL(solutions.size(), 4U); BOOST_CHECK_EQUAL(solutions.size(), 4U);
BOOST_CHECK(solutions[0] == std::vector<uint8_t>({1})); BOOST_CHECK(solutions[0] == std::vector<uint8_t>({1}));
BOOST_CHECK(solutions[1] == ToByteVector(pubkeys[0])); BOOST_CHECK(solutions[1] == ToByteVector(pubkeys[0]));
BOOST_CHECK(solutions[2] == ToByteVector(pubkeys[1])); BOOST_CHECK(solutions[2] == ToByteVector(pubkeys[1]));
BOOST_CHECK(solutions[3] == std::vector<uint8_t>({2})); BOOST_CHECK(solutions[3] == std::vector<uint8_t>({2}));
s.clear(); s.clear();
s << OP_2 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1]) s << OP_2 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1])
<< ToByteVector(pubkeys[2]) << OP_3 << OP_CHECKMULTISIG; << ToByteVector(pubkeys[2]) << OP_3 << OP_CHECKMULTISIG;
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_MULTISIG); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::MULTISIG);
BOOST_CHECK_EQUAL(solutions.size(), 5U); BOOST_CHECK_EQUAL(solutions.size(), 5U);
BOOST_CHECK(solutions[0] == std::vector<uint8_t>({2})); BOOST_CHECK(solutions[0] == std::vector<uint8_t>({2}));
BOOST_CHECK(solutions[1] == ToByteVector(pubkeys[0])); BOOST_CHECK(solutions[1] == ToByteVector(pubkeys[0]));
BOOST_CHECK(solutions[2] == ToByteVector(pubkeys[1])); BOOST_CHECK(solutions[2] == ToByteVector(pubkeys[1]));
BOOST_CHECK(solutions[3] == ToByteVector(pubkeys[2])); BOOST_CHECK(solutions[3] == ToByteVector(pubkeys[2]));
BOOST_CHECK(solutions[4] == std::vector<uint8_t>({3})); BOOST_CHECK(solutions[4] == std::vector<uint8_t>({3}));
// TX_NULL_DATA // TxoutType::NULL_DATA
s.clear(); s.clear();
s << OP_RETURN << std::vector<uint8_t>({0}) << std::vector<uint8_t>({75}) s << OP_RETURN << std::vector<uint8_t>({0}) << std::vector<uint8_t>({75})
<< std::vector<uint8_t>({255}); << std::vector<uint8_t>({255});
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NULL_DATA); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NULL_DATA);
BOOST_CHECK_EQUAL(solutions.size(), 0U); BOOST_CHECK_EQUAL(solutions.size(), 0U);
// TX_WITNESS_V0_KEYHASH // TxoutType::WITNESS_V0_KEYHASH
s.clear(); s.clear();
s << OP_0 << ToByteVector(pubkeys[0].GetID()); s << OP_0 << ToByteVector(pubkeys[0].GetID());
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
BOOST_CHECK_EQUAL(solutions.size(), 0U); BOOST_CHECK_EQUAL(solutions.size(), 0U);
// TX_WITNESS_V0_SCRIPTHASH // TxoutType::WITNESS_V0_SCRIPTHASH
uint256 scriptHash; uint256 scriptHash;
CSHA256() CSHA256()
.Write(&redeemScript[0], redeemScript.size()) .Write(&redeemScript[0], redeemScript.size())
.Finalize(scriptHash.begin()); .Finalize(scriptHash.begin());
s.clear(); s.clear();
s << OP_0 << ToByteVector(scriptHash); s << OP_0 << ToByteVector(scriptHash);
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
BOOST_CHECK_EQUAL(solutions.size(), 0U); BOOST_CHECK_EQUAL(solutions.size(), 0U);
// TX_NONSTANDARD // TxoutType::NONSTANDARD
s.clear(); s.clear();
s << OP_9 << OP_ADD << OP_11 << OP_EQUAL; s << OP_9 << OP_ADD << OP_11 << OP_EQUAL;
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
BOOST_CHECK_EQUAL(solutions.size(), 0); BOOST_CHECK_EQUAL(solutions.size(), 0);
// Try some non-minimal PUSHDATA pushes in various standard scripts // Try some non-minimal PUSHDATA pushes in various standard scripts
for (auto pushdataop : {OP_PUSHDATA1, OP_PUSHDATA2, OP_PUSHDATA4}) { for (auto pushdataop : {OP_PUSHDATA1, OP_PUSHDATA2, OP_PUSHDATA4}) {
// mutated TX_PUBKEY // mutated TxoutType::PUBKEY
s.clear(); s.clear();
AppendPush(s, pushdataop, ToByteVector(pubkeys[0])); AppendPush(s, pushdataop, ToByteVector(pubkeys[0]));
s << OP_CHECKSIG; s << OP_CHECKSIG;
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
BOOST_CHECK_EQUAL(solutions.size(), 0); BOOST_CHECK_EQUAL(solutions.size(), 0);
// mutated TX_PUBKEYHASH // mutated TxoutType::PUBKEYHASH
s.clear(); s.clear();
s << OP_DUP << OP_HASH160; s << OP_DUP << OP_HASH160;
AppendPush(s, pushdataop, ToByteVector(pubkeys[0].GetID())); AppendPush(s, pushdataop, ToByteVector(pubkeys[0].GetID()));
s << OP_EQUALVERIFY << OP_CHECKSIG; s << OP_EQUALVERIFY << OP_CHECKSIG;
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
BOOST_CHECK_EQUAL(solutions.size(), 0); BOOST_CHECK_EQUAL(solutions.size(), 0);
// mutated TX_SCRIPTHASH // mutated TxoutType::SCRIPTHASH
s.clear(); s.clear();
s << OP_HASH160; s << OP_HASH160;
AppendPush(s, pushdataop, ToByteVector(CScriptID(redeemScript))); AppendPush(s, pushdataop, ToByteVector(CScriptID(redeemScript)));
s << OP_EQUAL; s << OP_EQUAL;
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
BOOST_CHECK_EQUAL(solutions.size(), 0); BOOST_CHECK_EQUAL(solutions.size(), 0);
// mutated TX_MULTISIG -- pubkey // mutated TxoutType::MULTISIG -- pubkey
s.clear(); s.clear();
s << OP_1; s << OP_1;
AppendPush(s, pushdataop, ToByteVector(pubkeys[0])); AppendPush(s, pushdataop, ToByteVector(pubkeys[0]));
s << ToByteVector(pubkeys[1]) << OP_2 << OP_CHECKMULTISIG; s << ToByteVector(pubkeys[1]) << OP_2 << OP_CHECKMULTISIG;
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
BOOST_CHECK_EQUAL(solutions.size(), 0); BOOST_CHECK_EQUAL(solutions.size(), 0);
// mutated TX_MULTISIG -- num_signatures // mutated TxoutType::MULTISIG -- num_signatures
s.clear(); s.clear();
AppendPush(s, pushdataop, {1}); AppendPush(s, pushdataop, {1});
s << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1]) << OP_2 s << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1]) << OP_2
<< OP_CHECKMULTISIG; << OP_CHECKMULTISIG;
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
BOOST_CHECK_EQUAL(solutions.size(), 0); BOOST_CHECK_EQUAL(solutions.size(), 0);
// mutated TX_MULTISIG -- num_pubkeys // mutated TxoutType::MULTISIG -- num_pubkeys
s.clear(); s.clear();
s << OP_1 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1]); s << OP_1 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1]);
AppendPush(s, pushdataop, {2}); AppendPush(s, pushdataop, {2});
s << OP_CHECKMULTISIG; s << OP_CHECKMULTISIG;
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
BOOST_CHECK_EQUAL(solutions.size(), 0); BOOST_CHECK_EQUAL(solutions.size(), 0);
} }
// also try pushing the num_signatures and num_pubkeys using PUSH_N opcode // also try pushing the num_signatures and num_pubkeys using PUSH_N opcode
// instead of OP_N opcode: // instead of OP_N opcode:
s.clear(); s.clear();
s << std::vector<uint8_t>{1} << ToByteVector(pubkeys[0]) s << std::vector<uint8_t>{1} << ToByteVector(pubkeys[0])
<< ToByteVector(pubkeys[1]) << OP_2 << OP_CHECKMULTISIG; << ToByteVector(pubkeys[1]) << OP_2 << OP_CHECKMULTISIG;
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
BOOST_CHECK_EQUAL(solutions.size(), 0); BOOST_CHECK_EQUAL(solutions.size(), 0);
s.clear(); s.clear();
s << OP_1 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1]) s << OP_1 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1])
<< std::vector<uint8_t>{2} << OP_CHECKMULTISIG; << std::vector<uint8_t>{2} << OP_CHECKMULTISIG;
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
BOOST_CHECK_EQUAL(solutions.size(), 0); BOOST_CHECK_EQUAL(solutions.size(), 0);
// Non-minimal pushes in OP_RETURN scripts are standard (some OP_RETURN // Non-minimal pushes in OP_RETURN scripts are standard (some OP_RETURN
// protocols like SLP rely on this). Also it turns out OP_RESERVED gets past // protocols like SLP rely on this). Also it turns out OP_RESERVED gets past
// IsPushOnly and thus is standard here. // IsPushOnly and thus is standard here.
std::vector<uint8_t> op_return_nonminimal{ std::vector<uint8_t> op_return_nonminimal{
OP_RETURN, OP_RESERVED, OP_PUSHDATA1, 0x00, 0x01, 0x01, OP_RETURN, OP_RESERVED, OP_PUSHDATA1, 0x00, 0x01, 0x01,
OP_PUSHDATA4, 0x01, 0x00, 0x00, 0x00, 0xaa}; OP_PUSHDATA4, 0x01, 0x00, 0x00, 0x00, 0xaa};
s.assign(op_return_nonminimal.begin(), op_return_nonminimal.end()); s.assign(op_return_nonminimal.begin(), op_return_nonminimal.end());
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NULL_DATA); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NULL_DATA);
BOOST_CHECK_EQUAL(solutions.size(), 0); BOOST_CHECK_EQUAL(solutions.size(), 0);
} }
BOOST_AUTO_TEST_CASE(script_standard_Solver_failure) { BOOST_AUTO_TEST_CASE(script_standard_Solver_failure) {
CKey key; CKey key;
CPubKey pubkey; CPubKey pubkey;
key.MakeNewKey(true); key.MakeNewKey(true);
pubkey = key.GetPubKey(); pubkey = key.GetPubKey();
CScript s; CScript s;
std::vector<std::vector<uint8_t>> solutions; std::vector<std::vector<uint8_t>> solutions;
// TX_PUBKEY with incorrectly sized pubkey // TxoutType::PUBKEY with incorrectly sized pubkey
s.clear(); s.clear();
s << std::vector<uint8_t>(30, 0x01) << OP_CHECKSIG; s << std::vector<uint8_t>(30, 0x01) << OP_CHECKSIG;
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
// TX_PUBKEYHASH with incorrectly sized key hash // TxoutType::PUBKEYHASH with incorrectly sized key hash
s.clear(); s.clear();
s << OP_DUP << OP_HASH160 << ToByteVector(pubkey) << OP_EQUALVERIFY s << OP_DUP << OP_HASH160 << ToByteVector(pubkey) << OP_EQUALVERIFY
<< OP_CHECKSIG; << OP_CHECKSIG;
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
// TX_SCRIPTHASH with incorrectly sized script hash // TxoutType::SCRIPTHASH with incorrectly sized script hash
s.clear(); s.clear();
s << OP_HASH160 << std::vector<uint8_t>(21, 0x01) << OP_EQUAL; s << OP_HASH160 << std::vector<uint8_t>(21, 0x01) << OP_EQUAL;
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
// TX_MULTISIG 0/2 // TxoutType::MULTISIG 0/2
s.clear(); s.clear();
s << OP_0 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG; s << OP_0 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
// TX_MULTISIG 2/1 // TxoutType::MULTISIG 2/1
s.clear(); s.clear();
s << OP_2 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG; s << OP_2 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
// TX_MULTISIG n = 2 with 1 pubkey // TxoutType::MULTISIG n = 2 with 1 pubkey
s.clear(); s.clear();
s << OP_1 << ToByteVector(pubkey) << OP_2 << OP_CHECKMULTISIG; s << OP_1 << ToByteVector(pubkey) << OP_2 << OP_CHECKMULTISIG;
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
// TX_MULTISIG n = 1 with 0 pubkeys // TxoutType::MULTISIG n = 1 with 0 pubkeys
s.clear(); s.clear();
s << OP_1 << OP_1 << OP_CHECKMULTISIG; s << OP_1 << OP_1 << OP_CHECKMULTISIG;
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
// TX_NULL_DATA with other opcodes // TxoutType::NULL_DATA with other opcodes
s.clear(); s.clear();
s << OP_RETURN << std::vector<uint8_t>({75}) << OP_ADD; s << OP_RETURN << std::vector<uint8_t>({75}) << OP_ADD;
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
// TX_WITNESS with unknown version // TxoutType::WITNESS_UNKNOWN with unknown version
s.clear(); s.clear();
s << OP_1 << ToByteVector(pubkey); s << OP_1 << ToByteVector(pubkey);
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
// TX_WITNESS with incorrect program size // TxoutType::WITNESS_UNKNOWN with incorrect program size
s.clear(); s.clear();
s << OP_0 << std::vector<uint8_t>(19, 0x01); s << OP_0 << std::vector<uint8_t>(19, 0x01);
BOOST_CHECK_EQUAL(Solver(s, solutions), TX_NONSTANDARD); BOOST_CHECK_EQUAL(Solver(s, solutions), TxoutType::NONSTANDARD);
} }
BOOST_AUTO_TEST_CASE(script_standard_ExtractDestination) { BOOST_AUTO_TEST_CASE(script_standard_ExtractDestination) {
CKey key; CKey key;
CPubKey pubkey; CPubKey pubkey;
key.MakeNewKey(true); key.MakeNewKey(true);
pubkey = key.GetPubKey(); pubkey = key.GetPubKey();
CScript s; CScript s;
CTxDestination address; CTxDestination address;
// TX_PUBKEY // TxoutType::PUBKEY
s.clear(); s.clear();
s << ToByteVector(pubkey) << OP_CHECKSIG; s << ToByteVector(pubkey) << OP_CHECKSIG;
BOOST_CHECK(ExtractDestination(s, address)); BOOST_CHECK(ExtractDestination(s, address));
BOOST_CHECK(boost::get<PKHash>(&address) && BOOST_CHECK(boost::get<PKHash>(&address) &&
*boost::get<PKHash>(&address) == PKHash(pubkey)); *boost::get<PKHash>(&address) == PKHash(pubkey));
// TX_PUBKEYHASH // TxoutType::PUBKEYHASH
s.clear(); s.clear();
s << OP_DUP << OP_HASH160 << ToByteVector(pubkey.GetID()) << OP_EQUALVERIFY s << OP_DUP << OP_HASH160 << ToByteVector(pubkey.GetID()) << OP_EQUALVERIFY
<< OP_CHECKSIG; << OP_CHECKSIG;
BOOST_CHECK(ExtractDestination(s, address)); BOOST_CHECK(ExtractDestination(s, address));
BOOST_CHECK(boost::get<PKHash>(&address) && BOOST_CHECK(boost::get<PKHash>(&address) &&
*boost::get<PKHash>(&address) == PKHash(pubkey)); *boost::get<PKHash>(&address) == PKHash(pubkey));
// TX_SCRIPTHASH // TxoutType::SCRIPTHASH
CScript redeemScript(s); // initialize with leftover P2PKH script CScript redeemScript(s); // initialize with leftover P2PKH script
s.clear(); s.clear();
s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL; s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
BOOST_CHECK(ExtractDestination(s, address)); BOOST_CHECK(ExtractDestination(s, address));
BOOST_CHECK(boost::get<ScriptHash>(&address) && BOOST_CHECK(boost::get<ScriptHash>(&address) &&
*boost::get<ScriptHash>(&address) == ScriptHash(redeemScript)); *boost::get<ScriptHash>(&address) == ScriptHash(redeemScript));
// TX_MULTISIG // TxoutType::MULTISIG
s.clear(); s.clear();
s << OP_1 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG; s << OP_1 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
BOOST_CHECK(!ExtractDestination(s, address)); BOOST_CHECK(!ExtractDestination(s, address));
// TX_NULL_DATA // TxoutType::NULL_DATA
s.clear(); s.clear();
s << OP_RETURN << std::vector<uint8_t>({75}); s << OP_RETURN << std::vector<uint8_t>({75});
BOOST_CHECK(!ExtractDestination(s, address)); BOOST_CHECK(!ExtractDestination(s, address));
// TX_WITNESS_V0_KEYHASH // TxoutType::WITNESS_V0_KEYHASH
s.clear(); s.clear();
s << OP_0 << ToByteVector(pubkey); s << OP_0 << ToByteVector(pubkey);
BOOST_CHECK(!ExtractDestination(s, address)); BOOST_CHECK(!ExtractDestination(s, address));
// TX_WITNESS_V0_SCRIPTHASH // TxoutType::WITNESS_V0_SCRIPTHASH
s.clear(); s.clear();
s << OP_0 << ToByteVector(CScriptID(redeemScript)); s << OP_0 << ToByteVector(CScriptID(redeemScript));
BOOST_CHECK(!ExtractDestination(s, address)); BOOST_CHECK(!ExtractDestination(s, address));
} }
BOOST_AUTO_TEST_CASE(script_standard_ExtractDestinations) { BOOST_AUTO_TEST_CASE(script_standard_ExtractDestinations) {
CKey keys[3]; CKey keys[3];
CPubKey pubkeys[3]; CPubKey pubkeys[3];
for (int i = 0; i < 3; i++) { for (int i = 0; i < 3; i++) {
keys[i].MakeNewKey(true); keys[i].MakeNewKey(true);
pubkeys[i] = keys[i].GetPubKey(); pubkeys[i] = keys[i].GetPubKey();
} }
CScript s; CScript s;
txnouttype whichType; TxoutType whichType;
std::vector<CTxDestination> addresses; std::vector<CTxDestination> addresses;
int nRequired; int nRequired;
// TX_PUBKEY // TxoutType::PUBKEY
s.clear(); s.clear();
s << ToByteVector(pubkeys[0]) << OP_CHECKSIG; s << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired)); BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
BOOST_CHECK_EQUAL(whichType, TX_PUBKEY); BOOST_CHECK_EQUAL(whichType, TxoutType::PUBKEY);
BOOST_CHECK_EQUAL(addresses.size(), 1U); BOOST_CHECK_EQUAL(addresses.size(), 1U);
BOOST_CHECK_EQUAL(nRequired, 1); BOOST_CHECK_EQUAL(nRequired, 1);
BOOST_CHECK(boost::get<PKHash>(&addresses[0]) && BOOST_CHECK(boost::get<PKHash>(&addresses[0]) &&
*boost::get<PKHash>(&addresses[0]) == PKHash(pubkeys[0])); *boost::get<PKHash>(&addresses[0]) == PKHash(pubkeys[0]));
// TX_PUBKEYHASH // TxoutType::PUBKEYHASH
s.clear(); s.clear();
s << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID()) s << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID())
<< OP_EQUALVERIFY << OP_CHECKSIG; << OP_EQUALVERIFY << OP_CHECKSIG;
BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired)); BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
BOOST_CHECK_EQUAL(whichType, TX_PUBKEYHASH); BOOST_CHECK_EQUAL(whichType, TxoutType::PUBKEYHASH);
BOOST_CHECK_EQUAL(addresses.size(), 1U); BOOST_CHECK_EQUAL(addresses.size(), 1U);
BOOST_CHECK_EQUAL(nRequired, 1); BOOST_CHECK_EQUAL(nRequired, 1);
BOOST_CHECK(boost::get<PKHash>(&addresses[0]) && BOOST_CHECK(boost::get<PKHash>(&addresses[0]) &&
*boost::get<PKHash>(&addresses[0]) == PKHash(pubkeys[0])); *boost::get<PKHash>(&addresses[0]) == PKHash(pubkeys[0]));
// TX_SCRIPTHASH // TxoutType::SCRIPTHASH
// initialize with leftover P2PKH script // initialize with leftover P2PKH script
CScript redeemScript(s); CScript redeemScript(s);
s.clear(); s.clear();
s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL; s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired)); BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
BOOST_CHECK_EQUAL(whichType, TX_SCRIPTHASH); BOOST_CHECK_EQUAL(whichType, TxoutType::SCRIPTHASH);
BOOST_CHECK_EQUAL(addresses.size(), 1U); BOOST_CHECK_EQUAL(addresses.size(), 1U);
BOOST_CHECK_EQUAL(nRequired, 1); BOOST_CHECK_EQUAL(nRequired, 1);
BOOST_CHECK(boost::get<ScriptHash>(&addresses[0]) && BOOST_CHECK(boost::get<ScriptHash>(&addresses[0]) &&
*boost::get<ScriptHash>(&addresses[0]) == *boost::get<ScriptHash>(&addresses[0]) ==
ScriptHash(redeemScript)); ScriptHash(redeemScript));
// TX_MULTISIG // TxoutType::MULTISIG
s.clear(); s.clear();
s << OP_2 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1]) << OP_2 s << OP_2 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1]) << OP_2
<< OP_CHECKMULTISIG; << OP_CHECKMULTISIG;
BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired)); BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
BOOST_CHECK_EQUAL(whichType, TX_MULTISIG); BOOST_CHECK_EQUAL(whichType, TxoutType::MULTISIG);
BOOST_CHECK_EQUAL(addresses.size(), 2U); BOOST_CHECK_EQUAL(addresses.size(), 2U);
BOOST_CHECK_EQUAL(nRequired, 2); BOOST_CHECK_EQUAL(nRequired, 2);
BOOST_CHECK(boost::get<PKHash>(&addresses[0]) && BOOST_CHECK(boost::get<PKHash>(&addresses[0]) &&
*boost::get<PKHash>(&addresses[0]) == PKHash(pubkeys[0])); *boost::get<PKHash>(&addresses[0]) == PKHash(pubkeys[0]));
BOOST_CHECK(boost::get<PKHash>(&addresses[1]) && BOOST_CHECK(boost::get<PKHash>(&addresses[1]) &&
*boost::get<PKHash>(&addresses[1]) == PKHash(pubkeys[1])); *boost::get<PKHash>(&addresses[1]) == PKHash(pubkeys[1]));
// TX_NULL_DATA // TxoutType::NULL_DATA
s.clear(); s.clear();
s << OP_RETURN << std::vector<uint8_t>({75}); s << OP_RETURN << std::vector<uint8_t>({75});
BOOST_CHECK(!ExtractDestinations(s, whichType, addresses, nRequired)); BOOST_CHECK(!ExtractDestinations(s, whichType, addresses, nRequired));
// TX_WITNESS_V0_KEYHASH // TxoutType::WITNESS_V0_KEYHASH
s.clear(); s.clear();
s << OP_0 << ToByteVector(pubkeys[0].GetID()); s << OP_0 << ToByteVector(pubkeys[0].GetID());
BOOST_CHECK(!ExtractDestinations(s, whichType, addresses, nRequired)); BOOST_CHECK(!ExtractDestinations(s, whichType, addresses, nRequired));
// TX_WITNESS_V0_SCRIPTHASH // TxoutType::WITNESS_V0_SCRIPTHASH
s.clear(); s.clear();
s << OP_0 << ToByteVector(CScriptID(redeemScript)); s << OP_0 << ToByteVector(CScriptID(redeemScript));
BOOST_CHECK(!ExtractDestinations(s, whichType, addresses, nRequired)); BOOST_CHECK(!ExtractDestinations(s, whichType, addresses, nRequired));
} }
BOOST_AUTO_TEST_CASE(script_standard_GetScriptFor_) { BOOST_AUTO_TEST_CASE(script_standard_GetScriptFor_) {
CKey keys[3]; CKey keys[3];
CPubKey pubkeys[3]; CPubKey pubkeys[3];
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines