5#include <test/data/script_tests.json.h>
6#include <test/data/bip341_wallet_vectors.json.h>
33#include <boost/test/unit_test.hpp>
109 BOOST_ERROR(
"Unknown scripterror enumeration value, update script_errors in script_tests.cpp.");
118 BOOST_ERROR(
"Unknown scripterror \"" <<
name <<
"\" in test description");
137 for (
int i = 0; i < 256; ++i) {
143 BOOST_CHECK_MESSAGE(
VerifyScript(scriptSig, scriptPubKey, &scriptWitness, combined_flags,
MutableTransactionSignatureChecker(&tx, 0, txCredit.
vout[0].nValue,
MissingDataBehavior::ASSERT_FAIL), &err) ==
expect, message +
strprintf(
" (with flags %x)", combined_flags.as_int()));
150 std::vector<unsigned char> r,
s;
151 r = std::vector<unsigned char>(vchSig.begin() + 4, vchSig.begin() + 4 + vchSig[3]);
152 s = std::vector<unsigned char>(vchSig.begin() + 6 + vchSig[3], vchSig.begin() + 6 + vchSig[3] + vchSig[5 + vchSig[3]]);
154 while (
s.size() < 33) {
155 s.insert(
s.begin(), 0x00);
170 vchSig.push_back(0x30);
171 vchSig.push_back(4 + r.size() +
s.size());
172 vchSig.push_back(0x02);
173 vchSig.push_back(r.size());
174 vchSig.insert(vchSig.end(), r.begin(), r.end());
175 vchSig.push_back(0x02);
176 vchSig.push_back(
s.size());
177 vchSig.insert(vchSig.end(),
s.begin(),
s.end());
182const unsigned char vchKey0[32] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1};
183const unsigned char vchKey1[32] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0};
184const unsigned char vchKey2[32] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0};
188 CKey key0, key0C, key1, key1C, key2, key2C;
189 CPubKey pubkey0, pubkey0C, pubkey0H;
195 key0.
Set(vchKey0, vchKey0 + 32,
false);
196 key0C.
Set(vchKey0, vchKey0 + 32,
true);
200 *
const_cast<unsigned char*
>(pubkey0H.
data()) = 0x06 | (pubkey0H[64] & 1);
202 key1.
Set(vchKey1, vchKey1 + 32,
false);
203 key1C.
Set(vchKey1, vchKey1 + 32,
true);
207 key2.
Set(vchKey2, vchKey2 + 32,
false);
208 key2C.
Set(vchKey2, vchKey2 + 32,
true);
214enum class WitnessMode {
232 bool havePush{
false};
233 std::vector<unsigned char> push;
242 spendTx.
vin[0].scriptSig << push;
247 void DoPush(
const std::vector<unsigned char>&
data)
258 if (wm == WitnessMode::PKH) {
263 }
else if (wm == WitnessMode::SH) {
264 witscript = scriptPubKey;
270 redeemscript = scriptPubKey;
286 spendTx.
vin[0].scriptSig << _op;
290 TestBuilder&
Num(
int num)
293 spendTx.
vin[0].scriptSig << num;
297 TestBuilder& Push(
const std::string& hex)
303 TestBuilder& Push(
const CScript& _script)
305 DoPush(std::vector<unsigned char>(_script.
begin(), _script.
end()));
312 std::vector<unsigned char> vchSig, r,
s;
315 key.
Sign(hash, vchSig,
false, iter++);
316 if ((lenS == 33) != (vchSig[5 + vchSig[3]] == 33)) {
319 r = std::vector<unsigned char>(vchSig.begin() + 4, vchSig.begin() + 4 + vchSig[3]);
320 s = std::vector<unsigned char>(vchSig.begin() + 6 + vchSig[3], vchSig.begin() + 6 + vchSig[3] + vchSig[5 + vchSig[3]]);
321 }
while (lenR != r.size() || lenS !=
s.size());
322 vchSig.push_back(
static_cast<unsigned char>(nHashType));
331 return PushSig(key, nHashType, lenR, lenS, sigversion, amount).AsWit();
334 TestBuilder& Push(
const CPubKey& pubkey)
336 DoPush(std::vector<unsigned char>(pubkey.
begin(), pubkey.
end()));
340 TestBuilder& PushRedeem()
342 DoPush(std::vector<unsigned char>(redeemscript.
begin(), redeemscript.
end()));
346 TestBuilder& PushWitRedeem()
348 DoPush(std::vector<unsigned char>(witscript.
begin(), witscript.
end()));
352 TestBuilder& EditPush(
unsigned int pos,
const std::string& hexin,
const std::string& hexout)
355 std::vector<unsigned char> datain =
ParseHex(hexin);
356 std::vector<unsigned char> dataout =
ParseHex(hexout);
357 assert(pos + datain.size() <= push.size());
358 BOOST_CHECK_MESSAGE(std::vector<unsigned char>(push.begin() + pos, push.begin() + pos + datain.size()) == datain, comment);
359 push.erase(push.begin() + pos, push.begin() + pos + datain.size());
360 push.insert(push.begin() + pos, dataout.begin(), dataout.end());
364 TestBuilder& DamagePush(
unsigned int pos)
367 assert(pos < push.size());
374 TestBuilder copy = *
this;
376 test.
DoTest(creditTx->vout[0].scriptPubKey, spendTx.
vin[0].scriptSig, scriptWitness,
flags, comment, scriptError, nValue);
384 scriptWitness.
stack.push_back(push);
393 if (!scriptWitness.
stack.empty()) {
395 for (
unsigned i = 0; i < scriptWitness.
stack.size(); i++) {
399 array.push_back(std::move(wit));
402 array.push_back(
FormatScript(creditTx->vout[0].scriptPubKey));
405 array.push_back(comment);
409 std::string GetComment()
const
415std::string JSONPrettyPrint(
const UniValue& univalue)
417 std::string
ret = univalue.
write(4);
420 while ((pos =
ret.find(
" \n", pos)) != std::string::npos) {
421 ret.replace(pos, 2,
"\n");
434 std::vector<TestBuilder>
tests;
438 ).PushSig(keys.key0));
445 ).PushSig(keys.key1).Push(keys.pubkey1C));
447 "P2PKH, bad pubkey", 0
451 "P2PK anyonecanpay", 0
454 "P2PK anyonecanpay marked with normal hashtype", 0
459 ).PushSig(keys.key0).PushRedeem());
466 ).PushSig(keys.key0).Push(keys.pubkey0).PushRedeem());
468 "P2SH(P2PKH), bad sig but no VERIFY_P2SH", 0,
true
469 ).PushSig(keys.key0).DamagePush(10).PushRedeem());
476 ).Num(0).PushSig(keys.key0).PushSig(keys.key1).PushSig(keys.key2));
483 ).Num(0).PushSig(keys.key1).PushSig(keys.key2).PushRedeem());
489 "P2PK with too much R padding but no DERSIG", 0
490 ).PushSig(keys.key1,
SIGHASH_ALL, 31, 32).EditPush(1,
"43021F",
"44022000"));
495 "P2PK with too much S padding but no DERSIG", 0
496 ).PushSig(keys.key1,
SIGHASH_ALL).EditPush(1,
"44",
"45").EditPush(37,
"20",
"2100"));
501 "P2PK with too little R padding but no DERSIG", 0
502 ).PushSig(keys.key1,
SIGHASH_ALL, 33, 32).EditPush(1,
"45022100",
"440220"));
507 "P2PK NOT with bad sig with too much R padding but no DERSIG", 0
508 ).PushSig(keys.key2,
SIGHASH_ALL, 31, 32).EditPush(1,
"43021F",
"44022000").DamagePush(10));
513 "P2PK NOT with too much R padding but no DERSIG", 0
520 "BIP66 example 1, without DERSIG", 0
521 ).PushSig(keys.key1,
SIGHASH_ALL, 33, 32).EditPush(1,
"45022100",
"440220"));
526 "BIP66 example 2, without DERSIG", 0
532 "BIP66 example 3, without DERSIG", 0
538 "BIP66 example 4, without DERSIG", 0
544 "BIP66 example 5, without DERSIG", 0
550 "BIP66 example 6, without DERSIG", 0
556 "BIP66 example 7, without DERSIG", 0
557 ).Num(0).PushSig(keys.key1,
SIGHASH_ALL, 33, 32).EditPush(1,
"45022100",
"440220").PushSig(keys.key2));
562 "BIP66 example 8, without DERSIG", 0
568 "BIP66 example 9, without DERSIG", 0
574 "BIP66 example 10, without DERSIG", 0
575 ).Num(0).Num(0).PushSig(keys.key2,
SIGHASH_ALL, 33, 32).EditPush(1,
"45022100",
"440220"));
580 "BIP66 example 11, without DERSIG", 0
586 "BIP66 example 12, without DERSIG", 0
587 ).Num(0).PushSig(keys.key1,
SIGHASH_ALL, 33, 32).EditPush(1,
"45022100",
"440220").Num(0));
590 ).Num(0).PushSig(keys.key1,
SIGHASH_ALL, 33, 32).EditPush(1,
"45022100",
"440220").Num(0));
592 "P2PK with multi-byte hashtype, without DERSIG", 0
593 ).PushSig(keys.key2,
SIGHASH_ALL).EditPush(70,
"01",
"0101"));
599 "P2PK with high S but no LOW_S", 0
606 "P2PK with hybrid pubkey but no STRICTENC", 0
612 "P2PK NOT with hybrid pubkey but no STRICTENC", 0
618 "P2PK NOT with invalid hybrid pubkey but no STRICTENC", 0
624 "1-of-2 with the second 1 hybrid pubkey and no STRICTENC", 0
634 "P2PK with undefined hashtype but no STRICTENC", 0
635 ).PushSig(keys.key1, 5));
640 "P2PK NOT with invalid sig and undefined hashtype but no STRICTENC", 0
641 ).PushSig(keys.key1, 5).DamagePush(10));
647 "3-of-3 with nonzero dummy but no NULLDUMMY", 0
648 ).Num(1).PushSig(keys.key0).PushSig(keys.key1).PushSig(keys.key2));
653 "3-of-3 NOT with invalid sig and nonzero dummy but no NULLDUMMY", 0
654 ).Num(1).PushSig(keys.key0).PushSig(keys.key1).PushSig(keys.key2).DamagePush(10));
657 ).Num(1).PushSig(keys.key0).PushSig(keys.key1).PushSig(keys.key2).DamagePush(10).ScriptError(
SCRIPT_ERR_SIG_NULLDUMMY));
660 "2-of-2 with two identical keys and sigs pushed using OP_DUP but no SIGPUSHONLY", 0
661 ).Num(0).PushSig(keys.key1).Opcode(
OP_DUP));
666 "P2SH(P2PK) with non-push scriptSig but no P2SH or SIGPUSHONLY", 0,
true
667 ).PushSig(keys.key2).Opcode(
OP_NOP8).PushRedeem());
669 "P2PK with non-push scriptSig but with P2SH validation", 0
670 ).PushSig(keys.key2).Opcode(
OP_NOP8));
679 ).Num(0).PushSig(keys.key1).PushSig(keys.key1));
682 ).Num(11).PushSig(keys.key0));
688 ).Num(11).PushSig(keys.key0).PushRedeem());
694 ).PushSig(keys.key0).PushRedeem());
698 0, 1).PushWitSig(keys.key0).PushWitRedeem());
701 0, 1).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit());
704 0, 1).PushWitSig(keys.key0).PushWitRedeem().PushRedeem());
707 0, 1).PushWitSig(keys.key0).Push(keys.pubkey0).AsWit().PushRedeem());
721 "Basic P2WSH with the wrong key but no WITNESS",
SCRIPT_VERIFY_P2SH,
false, WitnessMode::SH
722 ).PushWitSig(keys.key0).PushWitRedeem());
724 "Basic P2WPKH with the wrong key but no WITNESS",
SCRIPT_VERIFY_P2SH,
false, WitnessMode::PKH
725 ).PushWitSig(keys.key0).Push(keys.pubkey1).AsWit());
727 "Basic P2SH(P2WSH) with the wrong key but no WITNESS",
SCRIPT_VERIFY_P2SH,
true, WitnessMode::SH
728 ).PushWitSig(keys.key0).PushWitRedeem().PushRedeem());
730 "Basic P2SH(P2WPKH) with the wrong key but no WITNESS",
SCRIPT_VERIFY_P2SH,
true, WitnessMode::PKH
731 ).PushWitSig(keys.key0).Push(keys.pubkey1).AsWit().PushRedeem());
743 0, 0).PushWitSig(keys.key0, 1).Push(keys.pubkey0).AsWit().PushRedeem().ScriptError(
SCRIPT_ERR_EVAL_FALSE));
753 std::vector<unsigned char> hashBytes =
ToByteVector(hash);
754 hashBytes.pop_back();
764 tests.push_back(TestBuilder(witscript,
784 0, 1).PushWitSig(keys.key0C).PushWitRedeem());
787 0, 1).PushWitSig(keys.key0C).Push(keys.pubkey0C).AsWit());
790 0, 1).PushWitSig(keys.key0C).PushWitRedeem().PushRedeem());
793 0, 1).PushWitSig(keys.key0C).Push(keys.pubkey0C).AsWit().PushRedeem());
812 0, 1).Push(
CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem());
815 0, 1).Push(
CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem().PushRedeem());
818 0, 1).Push(
CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem());
821 0, 1).Push(
CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem().PushRedeem());
826 0, 1).Push(
CScript()).AsWit().PushWitSig(keys.key0).PushWitRedeem());
829 0, 1).Push(
CScript()).AsWit().PushWitSig(keys.key0).PushWitRedeem().PushRedeem());
838 0, 1).Push(
CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem());
841 0, 1).Push(
CScript()).AsWit().PushWitSig(keys.key1C).PushWitRedeem().PushRedeem());
851 0, 1).Push(
CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem());
854 0, 1).Push(
CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem().PushRedeem());
857 0, 1).Push(
CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem());
860 0, 1).Push(
CScript()).AsWit().PushWitSig(keys.key0C).PushWitRedeem().PushRedeem());
863 0, 1).Push(
CScript()).AsWit().PushWitSig(keys.key1).PushWitRedeem());
866 0, 1).Push(
CScript()).AsWit().PushWitSig(keys.key1).PushWitRedeem().PushRedeem());
874 std::set<std::string> tests_set;
879 for (
unsigned int idx = 0; idx < json_tests.
size(); idx++) {
880 const UniValue& tv = json_tests[idx];
881 tests_set.insert(JSONPrettyPrint(tv.
get_array()));
885#ifdef UPDATE_JSON_TESTS
888 for (TestBuilder& test :
tests) {
890 std::string str = JSONPrettyPrint(test.GetJSON());
891#ifdef UPDATE_JSON_TESTS
892 strGen += str +
",\n";
894 if (tests_set.count(str) == 0) {
895 BOOST_CHECK_MESSAGE(
false,
"Missing auto script_valid test: " + test.GetComment());
900#ifdef UPDATE_JSON_TESTS
902 fputs(strGen.c_str(), file);
919 for (
unsigned int idx = 0; idx <
tests.size(); idx++) {
921 std::string strTest = test.
write();
925 unsigned int pos = 0;
928 for (i = 0; i < test[pos].
size()-1; i++) {
929 auto element = test[pos][i].
get_str();
932 static const std::string SCRIPT_FLAG{
"#SCRIPT#"};
933 if (element.starts_with(SCRIPT_FLAG)) {
936 }
else if (element ==
"#CONTROLBLOCK#") {
942 witness.
stack.push_back(*(controlblocks.begin()));
944 const auto witness_value{TryParseHex<unsigned char>(element)};
945 if (!witness_value.has_value()) {
946 BOOST_ERROR(
"Bad witness in test: " << strTest <<
" witness is not hex: " << element);
948 witness.
stack.push_back(witness_value.value());
954 if (test.
size() < 4 + pos)
956 if (test.
size() != 1) {
957 BOOST_ERROR(
"Bad test: " << strTest);
961 std::string scriptSigString = test[pos++].
get_str();
963 std::string scriptPubKeyString = test[pos++].
get_str();
966 if (scriptPubKeyString ==
"0x51 0x20 #TAPROOTOUTPUT#") {
967 BOOST_CHECK_MESSAGE(taprootBuilder.
IsComplete(),
"Failed to autogenerate Tapscript output key");
975 DoTest(scriptPubKey, scriptSig, witness, scriptflags, strTest, scriptError, nValue);
983 static const unsigned char direct[] = { 1, 0x5a };
984 static const unsigned char pushdata1[] = {
OP_PUSHDATA1, 1, 0x5a };
985 static const unsigned char pushdata2[] = {
OP_PUSHDATA2, 1, 0, 0x5a };
986 static const unsigned char pushdata4[] = {
OP_PUSHDATA4, 1, 0, 0, 0, 0x5a };
989 std::vector<std::vector<unsigned char> > directStack;
993 std::vector<std::vector<unsigned char> > pushdata1Stack;
998 std::vector<std::vector<unsigned char> > pushdata2Stack;
1003 std::vector<std::vector<unsigned char> > pushdata4Stack;
1008 const std::vector<unsigned char> pushdata1_trunc{
OP_PUSHDATA1, 1};
1009 const std::vector<unsigned char> pushdata2_trunc{
OP_PUSHDATA2, 1, 0};
1010 const std::vector<unsigned char> pushdata4_trunc{
OP_PUSHDATA4, 1, 0, 0, 0};
1012 std::vector<std::vector<unsigned char>> stack_ignore;
1025 std::vector<std::vector<unsigned char>> stack_ignore;
1046 for (
const CKey &key : keys)
1048 std::vector<unsigned char> vchSig;
1058 std::vector<CKey> keys;
1079 txTo12.
vout[0].nValue = 2;
1106 std::vector<CKey> keys;
1107 keys.push_back(key1); keys.push_back(key2);
1113 keys.push_back(key1); keys.push_back(key3);
1119 keys.push_back(key2); keys.push_back(key3);
1125 keys.push_back(key2); keys.push_back(key2);
1131 keys.push_back(key2); keys.push_back(key1);
1137 keys.push_back(key3); keys.push_back(key2);
1143 keys.push_back(key4); keys.push_back(key2);
1149 keys.push_back(key1); keys.push_back(key4);
1163 std::vector<std::vector<uint8_t>> unused;
1164 return Solver(output_script, unused);
1167#define CHECK_SCRIPT_STATIC_SIZE(script, expected_size) \
1169 BOOST_CHECK_EQUAL((script).size(), (expected_size)); \
1170 BOOST_CHECK_EQUAL((script).capacity(), CScriptBase::STATIC_SIZE); \
1171 BOOST_CHECK_EQUAL((script).allocated_memory(), 0); \
1174#define CHECK_SCRIPT_DYNAMIC_SIZE(script, expected_size, expected_extra) \
1176 BOOST_CHECK_EQUAL((script).size(), (expected_size)); \
1177 BOOST_CHECK_EQUAL((script).capacity(), (expected_extra)); \
1178 BOOST_CHECK_EQUAL((script).allocated_memory(), (expected_extra)); \
1195 const auto script{
CScript() << OP_RETURN << std::vector<uint8_t>(10, 0xaa)};
1244 CKey uncompressed_key;
1265 data.MergeSignatureData(scriptSig1);
1266 data.MergeSignatureData(scriptSig2);
1275 std::vector<CKey> keys;
1276 std::vector<CPubKey> pubkeys;
1277 for (
int i = 0; i < 3; i++)
1280 keys.push_back(key);
1287 CScript& scriptPubKey = txFrom.
vout[0].scriptPubKey;
1321 scriptSigCopy = scriptSig;
1340 std::vector<unsigned char> sig1;
1344 std::vector<unsigned char> sig2;
1348 std::vector<unsigned char> sig3;
1400 const auto invalid_pubkey{
"173d36c8c9c9c9ffffffffffff0200000000021e1e37373721361818181818181e1e1e1e19000000000000000000b19292929292926b006c9b9b9292"_hex_u8};
1402 builder.
Add(0, {invalid_pubkey}, 0xc0);
1428 for (
int i=0; i<67000; i++) {
1431 BOOST_CHECK_MESSAGE(
script.IsPushOnly(),
"Number " << i <<
" is not pure push.");
1437 std::vector<unsigned char>
data(i,
'\111');
1440 BOOST_CHECK_MESSAGE(
script.IsPushOnly(),
"Length " << i <<
" is not pure push.");
1453 static const unsigned char direct[] = { 1 };
1464 std::string derSig(
"304502207fa7a6d1e0ee81132a269ad84e68d695483745cde8b541e3bf630749894e342a022100c1f7ab20e13e22fb95281a870f3dcf38d782e53023ee313d741ad0cfbc0c5090");
1465 std::string pubKey(
"03b0da749730dc9b4b1f4a14d6902877a92541f5368778853d9c4a0cb7802dcfb2");
1487template <
typename T>
1491 return {span.begin(), span.end()};
1496 const CScript scriptPubKey1 =
CScript() <<
"04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f"_hex_v_u8 <<
OP_CHECKSIG;
1497 const CScript scriptPubKey2 =
CScript() <<
"04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f"_hex <<
OP_CHECKSIG;
1614 script =
ToScript(
"76a9141234567890abcdefa1a2a3a4a5a6a7a8a9a0aaab88ac"_hex);
1616 script =
ToScript(
"76a914ff34567890abcdefa1a2a3a4a5a6a7a8a9a0aaab88ac"_hex);
1627 tests.read(json_tests::bip341_wallet_vectors);
1629 const auto& vectors =
tests[
"keyPathSpending"];
1631 for (
const auto& vec : vectors.getValues()) {
1632 auto txhex =
ParseHex(vec[
"given"][
"rawUnsignedTx"].get_str());
1635 std::vector<CTxOut> utxos;
1636 for (
const auto& utxo_spent : vec[
"given"][
"utxosSpent"].getValues()) {
1637 auto script_bytes =
ParseHex(utxo_spent[
"scriptPubKey"].get_str());
1639 CAmount amount{utxo_spent[
"amountSats"].getInt<
int>()};
1640 utxos.emplace_back(amount,
script);
1644 txdata.
Init(tx, std::vector<CTxOut>{utxos},
true);
1653 for (
const auto& input : vec[
"inputSpending"].getValues()) {
1654 int txinpos = input[
"given"][
"txinIndex"].getInt<
int>();
1655 int hashtype = input[
"given"][
"hashType"].getInt<
int>();
1658 auto privkey =
ParseHex(input[
"given"][
"internalPrivkey"].get_str());
1660 key.
Set(privkey.begin(), privkey.end(),
true);
1664 if (!input[
"given"][
"merkleRoot"].isNull()) {
1665 merkle_root =
uint256{
ParseHex(input[
"given"][
"merkleRoot"].get_str())};
1676 std::vector<unsigned char> signature;
1681 BOOST_CHECK_EQUAL(
HexStr(pubkey.ComputeTapTweakHash(merkle_root.
IsNull() ?
nullptr : &merkle_root)), input[
"intermediary"][
"tweak"].get_str());
1699 constexpr uint256 hash1{
"8ad69ec7cf41c2a4001fd1f738bf1e505ce2277acdcaa63fe4765192497f47a7"};
1700 constexpr uint256 hash2{
"f224a923cd0021ab202ab139cc56802ddb92dcfc172b9212261a539df79a112a"};
1701 constexpr uint256 result{
"a64c5b7b943315f9b805d7a7296bedfcfd08919270a1f7a1466e98f8693d8cd9"};
1707 constexpr uint8_t
script[6] = {
'f',
'o',
'o',
'b',
'a',
'r'};
1708 constexpr uint256 tlc0{
"edbc10c272a1215dcdcc11d605b9027b5ad6ed97cd45521203f136767b5b9c06"};
1709 constexpr uint256 tlc2{
"8b5c4f90ae6bf76e259dbef5d8a59df06359c391b59263741b25eca76451b27a"};
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
int64_t CAmount
Amount in satoshis (Can be negative)
static CAmount AmountFromValue(const UniValue &value)
A hasher class for Bitcoin's 160-bit hash (SHA-256 + RIPEMD-160).
CHash160 & Write(std::span< const unsigned char > input)
void Finalize(std::span< unsigned char > output)
An encapsulated private key.
bool Sign(const uint256 &hash, std::vector< unsigned char > &vchSig, bool grind=true, uint32_t test_case=0) const
Create a DER-serialized signature.
void MakeNewKey(bool fCompressed)
Generate a new private key using a cryptographic PRNG.
CPubKey GetPubKey() const
Compute the public key from a private key.
void Set(const T pbegin, const T pend, bool fCompressedIn)
Initialize using begin and end iterators to byte data.
An outpoint - a combination of a transaction hash and an index n into its vout.
An encapsulated public key.
const unsigned char * data() const
CKeyID GetID() const
Get the KeyID of this public key (hash of its serialization)
const unsigned char * end() const
const unsigned char * begin() const
A hasher class for SHA-256.
void Finalize(unsigned char hash[OUTPUT_SIZE])
CSHA256 & Write(const unsigned char *data, size_t len)
Serialized script, used inside transaction inputs and outputs.
A reference to a CScript: the Hash160 of its serialization.
The basic transaction that is broadcasted on the network and contained in blocks.
An output of a transaction.
Fillable signing provider that keeps keys in an address->secret map.
virtual bool AddCScript(const CScript &redeemScript)
virtual bool AddKey(const CKey &key)
A writer stream (for serialization) that computes a 256-bit hash.
A signature creator for transactions.
bool CreateSchnorrSig(const SigningProvider &provider, std::vector< unsigned char > &sig, const XOnlyPubKey &pubkey, const uint256 *leaf_hash, const uint256 *merkle_root, SigVersion sigversion) const override
uint64_t randbits(int bits) noexcept
Generate a random (bits)-bit integer.
Minimal stream for reading from an existing byte array by std::span.
Utility class to construct Taproot outputs from internal key and script tree.
WitnessV1Taproot GetOutput()
Compute scriptPubKey (after Finalize()).
TaprootSpendData GetSpendData() const
Compute spending data (after Finalize()).
bool IsComplete() const
Return whether there were either no leaves, or the leaves form a Huffman tree.
TaprootBuilder & Add(int depth, std::span< const unsigned char > script, int leaf_version, bool track=true)
Add a new script at a certain depth in the tree.
TaprootBuilder & Finalize(const XOnlyPubKey &internal_key)
Finalize the construction.
const std::string & get_str() const
std::string write(unsigned int prettyIndent=0, unsigned int indentLevel=0) const
const UniValue & get_array() const
static const XOnlyPubKey NUMS_H
Nothing Up My Sleeve point H Used as an internal key for provably disabling the key path spend see BI...
constexpr bool IsNull() const
constexpr unsigned char * begin()
Implements a drop-in replacement for std::vector<T> which stores up to N elements directly (without h...
void push_back(const T &value)
static constexpr script_verify_flags from_int(value_type f)
CScript ParseScript(const std::string &s)
std::string FormatScript(const CScript &script)
std::string ScriptToAsmStr(const CScript &script, const bool fAttemptSighashDecode=false)
Create the assembly string representation of a CScript object.
UniValue ValueFromAmount(const CAmount amount)
BOOST_FIXTURE_TEST_SUITE(cuckoocache_tests, BasicTestingSetup)
Test Suite for CuckooCache.
BOOST_AUTO_TEST_SUITE_END()
std::string HexStr(const std::span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
uint256 ComputeTapbranchHash(std::span< const unsigned char > a, std::span< const unsigned char > b)
Compute the BIP341 tapbranch hash from two branches.
bool SignatureHashSchnorr(uint256 &hash_out, ScriptExecutionData &execdata, const T &tx_to, uint32_t in_pos, uint8_t hash_type, SigVersion sigversion, const PrecomputedTransactionData &cache, MissingDataBehavior mdb)
int FindAndDelete(CScript &script, const CScript &b)
uint256 ComputeTapleafHash(uint8_t leaf_version, std::span< const unsigned char > script)
Compute the BIP341 tapleaf hash from leaf version & script.
bool EvalScript(std::vector< std::vector< unsigned char > > &stack, const CScript &script, script_verify_flags flags, const BaseSignatureChecker &checker, SigVersion sigversion, ScriptExecutionData &execdata, ScriptError *serror)
uint256 SignatureHash(const CScript &scriptCode, const T &txTo, unsigned int nIn, int32_t nHashType, const CAmount &amount, SigVersion sigversion, const PrecomputedTransactionData *cache, SigHashCache *sighash_cache)
std::vector< std::string > GetScriptFlagNames(script_verify_flags flags)
bool VerifyScript(const CScript &scriptSig, const CScript &scriptPubKey, const CScriptWitness *witness, script_verify_flags flags, const BaseSignatureChecker &checker, ScriptError *serror)
const HashWriter HASHER_TAPSIGHASH
Hasher with tag "TapSighash" pre-fed to it.
static constexpr int MAX_SCRIPT_VERIFY_FLAGS_BITS
@ TAPROOT
Witness v1 with 32-byte program, not BIP16 P2SH-wrapped, key path spending; see BIP 341.
@ BASE
Bare scripts and BIP16 P2SH-wrapped redeemscripts.
@ WITNESS_V0
Witness v0 (P2WPKH and P2WSH); see BIP 141.
GenericTransactionSignatureChecker< CMutableTransaction > MutableTransactionSignatureChecker
static constexpr uint8_t TAPROOT_LEAF_TAPSCRIPT
@ SIGHASH_DEFAULT
Taproot only; implied when sighash byte is missing, and equivalent to SIGHASH_ALL.
@ ASSERT_FAIL
Abort execution through assertion failure (for consensus code)
@ FAIL
Just act as if the signature was invalid.
@ SCRIPT_VERIFY_NULLDUMMY
@ SCRIPT_VERIFY_STRICTENC
@ SCRIPT_VERIFY_CLEANSTACK
@ SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY
@ SCRIPT_VERIFY_SIGPUSHONLY
@ SCRIPT_VERIFY_WITNESS_PUBKEYTYPE
@ SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM
@ SCRIPT_VERIFY_MINIMALDATA
UniValue read_json(std::string_view jsondata)
CKey GenerateRandomKey(bool compressed) noexcept
FILE * fopen(const fs::path &p, const char *mode)
std::pair< opcodetype, std::vector< unsigned char > > Opcode
""_hex is a compile-time user-defined literal returning a std::array<std::byte>, equivalent to ParseH...
auto Join(const C &container, const S &separator, UnaryOp unary_op)
Join all container items.
#define BOOST_CHECK_EQUAL(v1, v2)
#define BOOST_CHECK(expr)
static constexpr TransactionSerParams TX_WITH_WITNESS
static CTransactionRef MakeTransactionRef(Tx &&txIn)
std::shared_ptr< const CTransaction > CTransactionRef
static const unsigned int MAX_SCRIPT_ELEMENT_SIZE
opcodetype
Script opcodes.
std::vector< unsigned char > ToByteVector(const T &in)
std::string ScriptErrorString(const ScriptError serror)
enum ScriptError_t ScriptError
@ SCRIPT_ERR_OP_CODESEPARATOR
@ SCRIPT_ERR_SIG_PUSHONLY
@ SCRIPT_ERR_NUMEQUALVERIFY
@ SCRIPT_ERR_DISABLED_OPCODE
@ SCRIPT_ERR_INVALID_ALTSTACK_OPERATION
@ SCRIPT_ERR_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM
@ SCRIPT_ERR_UNKNOWN_ERROR
@ SCRIPT_ERR_WITNESS_PROGRAM_WRONG_LENGTH
@ SCRIPT_ERR_SIG_HASHTYPE
@ SCRIPT_ERR_CHECKSIGVERIFY
@ SCRIPT_ERR_WITNESS_MALLEATED_P2SH
@ SCRIPT_ERR_WITNESS_MALLEATED
@ SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS
@ SCRIPT_ERR_INVALID_STACK_OPERATION
@ SCRIPT_ERR_WITNESS_UNEXPECTED
@ SCRIPT_ERR_NEGATIVE_LOCKTIME
@ SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH
@ SCRIPT_ERR_SIG_NULLFAIL
@ SCRIPT_ERR_SIG_NULLDUMMY
@ SCRIPT_ERR_CHECKMULTISIGVERIFY
@ SCRIPT_ERR_UNSATISFIED_LOCKTIME
@ SCRIPT_ERR_WITNESS_PUBKEYTYPE
@ SCRIPT_ERR_SIG_FINDANDDELETE
@ SCRIPT_ERR_PUBKEY_COUNT
@ SCRIPT_ERR_WITNESS_PROGRAM_WITNESS_EMPTY
@ SCRIPT_ERR_UNBALANCED_CONDITIONAL
static std::string FormatScriptError(ScriptError_t err)
static TxoutType GetTxoutType(const CScript &output_script)
Return the TxoutType of a script without exposing Solver details.
static void NegateSignatureS(std::vector< unsigned char > &vchSig)
#define CHECK_SCRIPT_STATIC_SIZE(script, expected_size)
static ScriptError_t ParseScriptError(const std::string &name)
SignatureData CombineSignatures(const CTxOut &txout, const CMutableTransaction &tx, const SignatureData &scriptSig1, const SignatureData &scriptSig2)
static ScriptErrorDesc script_errors[]
static std::string FormatScriptFlags(script_verify_flags flags)
CScript ToScript(const T &byte_container)
#define CHECK_SCRIPT_DYNAMIC_SIZE(script, expected_size, expected_extra)
static CScript sign_multisig(const CScript &scriptPubKey, const std::vector< CKey > &keys, const CTransaction &transaction)
script_verify_flags ParseScriptFlags(std::string strFlags)
BOOST_AUTO_TEST_CASE(script_build)
static const script_verify_flags gFlags
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ec_seckey_negate(const secp256k1_context *ctx, unsigned char *seckey) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2)
Negates a secret key in place.
SECP256K1_API const secp256k1_context *const secp256k1_context_static
A built-in constant secp256k1 context object with static storage duration, to be used in conjunction ...
bool ProduceSignature(const SigningProvider &provider, const BaseSignatureCreator &creator, const CScript &fromPubKey, SignatureData &sigdata)
Produce a script signature using a generic signature creator.
static bool GetPubKey(const SigningProvider &provider, const SignatureData &sigdata, const CKeyID &address, CPubKey &pubkey)
SignatureData DataFromTransaction(const CMutableTransaction &tx, unsigned int nIn, const CTxOut &txout)
Extract signature data from a transaction input, and insert it.
std::pair< CPubKey, std::vector< unsigned char > > SigPair
const SigningProvider & DUMMY_SIGNING_PROVIDER
TxoutType Solver(const CScript &scriptPubKey, std::vector< std::vector< unsigned char > > &vSolutionsRet)
Parse a scriptPubKey and identify script type for standard scripts.
CScript GetScriptForMultisig(int nRequired, const std::vector< CPubKey > &keys)
Generate a multisig script.
CScript GetScriptForRawPubKey(const CPubKey &pubKey)
Generate a P2PK script for the given pubkey.
@ NULL_DATA
unspendable OP_RETURN script that carries data
constexpr auto MakeUCharSpan(const V &v) -> decltype(UCharSpanCast(std::span{v}))
Like the std::span constructor, but for (const) unsigned char member types only.
std::vector< Byte > ParseHex(std::string_view hex_str)
Like TryParseHex, but returns an empty vector on invalid input.
A mutable version of CTransaction.
std::vector< CTxOut > vout
Txid GetHash() const
Compute the hash of this CMutableTransaction.
std::vector< std::vector< unsigned char > > stack
std::map< CKeyID, CKey > keys
A type to represent integers in the type system.
void Init(const T &tx, std::vector< CTxOut > &&spent_outputs, bool force=false)
Initialize this PrecomputedTransactionData with transaction data.
uint256 m_sequences_single_hash
bool m_bip341_taproot_ready
Whether the 5 fields above are initialized.
uint256 m_prevouts_single_hash
uint256 m_spent_amounts_single_hash
uint256 m_spent_scripts_single_hash
uint256 m_outputs_single_hash
bool m_annex_present
Whether an annex is present.
bool m_annex_init
Whether m_annex_present and (when needed) m_annex_hash are initialized.
void DoTest(const CScript &scriptPubKey, const CScript &scriptSig, const CScriptWitness &scriptWitness, script_verify_flags flags, const std::string &message, int scriptError, CAmount nValue=0)
std::map< CKeyID, SigPair > signatures
BIP 174 style partial signatures for the input. May contain all signatures necessary for producing a ...
TaprootSpendData tr_spenddata
Taproot spending data.
CScript scriptSig
The scriptSig of an input. Contains complete signatures or the traditional partial signatures format.
std::map< std::pair< std::vector< unsigned char >, int >, std::set< std::vector< unsigned char >, ShortestVectorFirstComparator > > scripts
Map from (script, leaf_version) to (sets of) control blocks.
CMutableTransaction BuildSpendingTransaction(const CScript &scriptSig, const CScriptWitness &scriptWitness, const CTransaction &txCredit)
bool SignSignature(const SigningProvider &provider, const CScript &fromPubKey, CMutableTransaction &txTo, unsigned int nIn, const CAmount &amount, int nHashType, SignatureData &sig_data)
Produce a satisfying script (scriptSig or witness).
CMutableTransaction BuildCreditingTransaction(const CScript &scriptPubKey, int nValue)
constexpr std::array tests