Page MenuHomePhabricator
Differential D2515 Diff 7229 src/test/script_tests.cpp

Changeset View

Standalone View

View Options

src/test/script_tests.cpp

Show First 20 Lines • Show All 256 Lines • ▼ Show 20 Linesprivate:
} }
void DoPush(const std::vector<uint8_t> &data) { void DoPush(const std::vector<uint8_t> &data) {
DoPush(); DoPush();
push = data; push = data;
havePush = true; havePush = true;
} }
std::vector<uint8_t> DoSign(const CKey &key, const uint256 &hash, std::vector<uint8_t> DoSignECDSA(const CKey &key, const uint256 &hash,
unsigned int lenR = 32, unsigned int lenR = 32,
unsigned int lenS = 32) const { unsigned int lenS = 32) const {
std::vector<uint8_t> vchSig, r, s; std::vector<uint8_t> vchSig, r, s;
uint32_t iter = 0; uint32_t iter = 0;
do { do {
key.SignECDSA(hash, vchSig, iter++); key.SignECDSA(hash, vchSig, iter++);
if ((lenS == 33) != (vchSig[5 + vchSig[3]] == 33)) { if ((lenS == 33) != (vchSig[5 + vchSig[3]] == 33)) {
NegateSignatureS(vchSig); NegateSignatureS(vchSig);
} }
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines TestBuilder &Push(const uint256 &hash) {
return *this; return *this;
} }
TestBuilder &Push(const CScript &_script) { TestBuilder &Push(const CScript &_script) {
DoPush(std::vector<uint8_t>(_script.begin(), _script.end())); DoPush(std::vector<uint8_t>(_script.begin(), _script.end()));
return *this; return *this;
} }
TestBuilder &PushSig(const CKey &key, TestBuilder &
SigHashType sigHashType = SigHashType(), PushSigECDSA(const CKey &key, SigHashType sigHashType = SigHashType(),
unsigned int lenR = 32, unsigned int lenS = 32, unsigned int lenR = 32, unsigned int lenS = 32,
Amount amount = Amount::zero(), Amount amount = Amount::zero(),
uint32_t sigFlags = SCRIPT_ENABLE_SIGHASH_FORKID) { uint32_t sigFlags = SCRIPT_ENABLE_SIGHASH_FORKID) {
uint256 hash = SignatureHash(script, CTransaction(spendTx), 0, uint256 hash = SignatureHash(script, CTransaction(spendTx), 0,
sigHashType, amount, nullptr, sigFlags); sigHashType, amount, nullptr, sigFlags);
std::vector<uint8_t> vchSig = DoSign(key, hash, lenR, lenS); std::vector<uint8_t> vchSig = DoSignECDSA(key, hash, lenR, lenS);
vchSig.push_back(static_cast<uint8_t>(sigHashType.getRawSigHashType())); vchSig.push_back(static_cast<uint8_t>(sigHashType.getRawSigHashType()));
DoPush(vchSig); DoPush(vchSig);
return *this; return *this;
} }
TestBuilder & TestBuilder &
PushSigSchnorr(const CKey &key, SigHashType sigHashType = SigHashType(), PushSigSchnorr(const CKey &key, SigHashType sigHashType = SigHashType(),
Amount amount = Amount::zero(), Amount amount = Amount::zero(),
uint32_t sigFlags = SCRIPT_ENABLE_SIGHASH_FORKID) { uint32_t sigFlags = SCRIPT_ENABLE_SIGHASH_FORKID) {
uint256 hash = SignatureHash(script, CTransaction(spendTx), 0, uint256 hash = SignatureHash(script, CTransaction(spendTx), 0,
sigHashType, amount, nullptr, sigFlags); sigHashType, amount, nullptr, sigFlags);
std::vector<uint8_t> vchSig = DoSignSchnorr(key, hash); std::vector<uint8_t> vchSig = DoSignSchnorr(key, hash);
vchSig.push_back(static_cast<uint8_t>(sigHashType.getRawSigHashType())); vchSig.push_back(static_cast<uint8_t>(sigHashType.getRawSigHashType()));
DoPush(vchSig); DoPush(vchSig);
return *this; return *this;
} }
TestBuilder &PushDataSig(const CKey &key, const std::vector<uint8_t> &data, TestBuilder &PushDataSigECDSA(const CKey &key,
unsigned int lenR = 32, unsigned int lenS = 32) { const std::vector<uint8_t> &data,
unsigned int lenR = 32,
unsigned int lenS = 32) {
std::vector<uint8_t> vchHash(32); std::vector<uint8_t> vchHash(32);
CSHA256().Write(data.data(), data.size()).Finalize(vchHash.data()); CSHA256().Write(data.data(), data.size()).Finalize(vchHash.data());
DoPush(DoSign(key, uint256(vchHash), lenR, lenS)); DoPush(DoSignECDSA(key, uint256(vchHash), lenR, lenS));
return *this; return *this;
} }
TestBuilder &PushDataSigSchnorr(const CKey &key, TestBuilder &PushDataSigSchnorr(const CKey &key,
const std::vector<uint8_t> &data) { const std::vector<uint8_t> &data) {
std::vector<uint8_t> vchHash(32); std::vector<uint8_t> vchHash(32);
CSHA256().Write(data.data(), data.size()).Finalize(vchHash.data()); CSHA256().Write(data.data(), data.size()).Finalize(vchHash.data());
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines
BOOST_AUTO_TEST_CASE(script_build) { BOOST_AUTO_TEST_CASE(script_build) {
const KeyData keys; const KeyData keys;
std::vector<TestBuilder> tests; std::vector<TestBuilder> tests;
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2PK", 0) "P2PK", 0)
.PushSig(keys.key0)); .PushSigECDSA(keys.key0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2PK, bad sig", 0) "P2PK, bad sig", 0)
.PushSig(keys.key0) .PushSigECDSA(keys.key0)
.DamagePush(10) .DamagePush(10)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .ScriptError(SCRIPT_ERR_EVAL_FALSE));
tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
<< ToByteVector(keys.pubkey1C.GetID()) << ToByteVector(keys.pubkey1C.GetID())
<< OP_EQUALVERIFY << OP_CHECKSIG, << OP_EQUALVERIFY << OP_CHECKSIG,
"P2PKH", 0) "P2PKH", 0)
.PushSig(keys.key1) .PushSigECDSA(keys.key1)
.Push(keys.pubkey1C)); .Push(keys.pubkey1C));
tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
<< ToByteVector(keys.pubkey2C.GetID()) << ToByteVector(keys.pubkey2C.GetID())
<< OP_EQUALVERIFY << OP_CHECKSIG, << OP_EQUALVERIFY << OP_CHECKSIG,
"P2PKH, bad pubkey", 0) "P2PKH, bad pubkey", 0)
.PushSig(keys.key2) .PushSigECDSA(keys.key2)
.Push(keys.pubkey2C) .Push(keys.pubkey2C)
.DamagePush(5) .DamagePush(5)
.ScriptError(SCRIPT_ERR_EQUALVERIFY)); .ScriptError(SCRIPT_ERR_EQUALVERIFY));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
"P2PK anyonecanpay", 0) "P2PK anyonecanpay", 0)
.PushSig(keys.key1, SigHashType().withAnyoneCanPay())); .PushSigECDSA(keys.key1, SigHashType().withAnyoneCanPay()));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
"P2PK anyonecanpay marked with normal hashtype", 0) "P2PK anyonecanpay marked with normal hashtype", 0)
.PushSig(keys.key1, SigHashType().withAnyoneCanPay()) .PushSigECDSA(keys.key1, SigHashType().withAnyoneCanPay())
.EditPush(70, "81", "01") .EditPush(70, "81", "01")
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .ScriptError(SCRIPT_ERR_EVAL_FALSE));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
"P2SH(P2PK)", SCRIPT_VERIFY_P2SH, true) "P2SH(P2PK)", SCRIPT_VERIFY_P2SH, true)
.PushSig(keys.key0) .PushSigECDSA(keys.key0)
.PushRedeem()); .PushRedeem());
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
"P2SH(P2PK), bad redeemscript", SCRIPT_VERIFY_P2SH, true) "P2SH(P2PK), bad redeemscript", SCRIPT_VERIFY_P2SH, true)
.PushSig(keys.key0) .PushSigECDSA(keys.key0)
.PushRedeem() .PushRedeem()
.DamagePush(10) .DamagePush(10)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .ScriptError(SCRIPT_ERR_EVAL_FALSE));
tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
<< ToByteVector(keys.pubkey0.GetID()) << ToByteVector(keys.pubkey0.GetID())
<< OP_EQUALVERIFY << OP_CHECKSIG, << OP_EQUALVERIFY << OP_CHECKSIG,
"P2SH(P2PKH)", SCRIPT_VERIFY_P2SH, true) "P2SH(P2PKH)", SCRIPT_VERIFY_P2SH, true)
.PushSig(keys.key0) .PushSigECDSA(keys.key0)
.Push(keys.pubkey0) .Push(keys.pubkey0)
.PushRedeem()); .PushRedeem());
tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
<< ToByteVector(keys.pubkey1.GetID()) << ToByteVector(keys.pubkey1.GetID())
<< OP_EQUALVERIFY << OP_CHECKSIG, << OP_EQUALVERIFY << OP_CHECKSIG,
"P2SH(P2PKH), bad sig but no VERIFY_P2SH", 0, "P2SH(P2PKH), bad sig but no VERIFY_P2SH", 0,
true) true)
.PushSig(keys.key0) .PushSigECDSA(keys.key0)
.DamagePush(10) .DamagePush(10)
.PushRedeem()); .PushRedeem());
tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
<< ToByteVector(keys.pubkey1.GetID()) << ToByteVector(keys.pubkey1.GetID())
<< OP_EQUALVERIFY << OP_CHECKSIG, << OP_EQUALVERIFY << OP_CHECKSIG,
"P2SH(P2PKH), bad sig", SCRIPT_VERIFY_P2SH, "P2SH(P2PKH), bad sig", SCRIPT_VERIFY_P2SH,
true) true)
.PushSig(keys.key0) .PushSigECDSA(keys.key0)
.DamagePush(10) .DamagePush(10)
.PushRedeem() .PushRedeem()
.ScriptError(SCRIPT_ERR_EQUALVERIFY)); .ScriptError(SCRIPT_ERR_EQUALVERIFY));
tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
<< ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_3 << ToByteVector(keys.pubkey2C) << OP_3
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"3-of-3", 0) "3-of-3", 0)
.Num(0) .Num(0)
.PushSig(keys.key0) .PushSigECDSA(keys.key0)
.PushSig(keys.key1) .PushSigECDSA(keys.key1)
.PushSig(keys.key2)); .PushSigECDSA(keys.key2));
tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
<< ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_3 << ToByteVector(keys.pubkey2C) << OP_3
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"3-of-3, 2 sigs", 0) "3-of-3, 2 sigs", 0)
.Num(0) .Num(0)
.PushSig(keys.key0) .PushSigECDSA(keys.key0)
.PushSig(keys.key1) .PushSigECDSA(keys.key1)
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .ScriptError(SCRIPT_ERR_EVAL_FALSE));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
<< ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_3 << ToByteVector(keys.pubkey2C) << OP_3
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"P2SH(2-of-3)", SCRIPT_VERIFY_P2SH, true) "P2SH(2-of-3)", SCRIPT_VERIFY_P2SH, true)
.Num(0) .Num(0)
.PushSig(keys.key1) .PushSigECDSA(keys.key1)
.PushSig(keys.key2) .PushSigECDSA(keys.key2)
.PushRedeem()); .PushRedeem());
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
<< ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_3 << ToByteVector(keys.pubkey2C) << OP_3
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"P2SH(2-of-3), 1 sig", SCRIPT_VERIFY_P2SH, true) "P2SH(2-of-3), 1 sig", SCRIPT_VERIFY_P2SH, true)
.Num(0) .Num(0)
.PushSig(keys.key1) .PushSigECDSA(keys.key1)
.Num(0) .Num(0)
.PushRedeem() .PushRedeem()
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .ScriptError(SCRIPT_ERR_EVAL_FALSE));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
"P2PK with too much R padding but no DERSIG", 0) "P2PK with too much R padding but no DERSIG", 0)
.PushSig(keys.key1, SigHashType(), 31, 32) .PushSigECDSA(keys.key1, SigHashType(), 31, 32)
.EditPush(1, "43021F", "44022000")); .EditPush(1, "43021F", "44022000"));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
"P2PK with too much R padding", SCRIPT_VERIFY_DERSIG) "P2PK with too much R padding", SCRIPT_VERIFY_DERSIG)
.PushSig(keys.key1, SigHashType(), 31, 32) .PushSigECDSA(keys.key1, SigHashType(), 31, 32)
.EditPush(1, "43021F", "44022000") .EditPush(1, "43021F", "44022000")
.ScriptError(SCRIPT_ERR_SIG_DER)); .ScriptError(SCRIPT_ERR_SIG_DER));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
"P2PK with too much S padding but no DERSIG", 0) "P2PK with too much S padding but no DERSIG", 0)
.PushSig(keys.key1) .PushSigECDSA(keys.key1)
.EditPush(1, "44", "45") .EditPush(1, "44", "45")
.EditPush(37, "20", "2100")); .EditPush(37, "20", "2100"));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
"P2PK with too much S padding", SCRIPT_VERIFY_DERSIG) "P2PK with too much S padding", SCRIPT_VERIFY_DERSIG)
.PushSig(keys.key1) .PushSigECDSA(keys.key1)
.EditPush(1, "44", "45") .EditPush(1, "44", "45")
.EditPush(37, "20", "2100") .EditPush(37, "20", "2100")
.ScriptError(SCRIPT_ERR_SIG_DER)); .ScriptError(SCRIPT_ERR_SIG_DER));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
"P2PK with too little R padding but no DERSIG", 0) "P2PK with too little R padding but no DERSIG", 0)
.PushSig(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220")); .EditPush(1, "45022100", "440220"));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
"P2PK with too little R padding", SCRIPT_VERIFY_DERSIG) "P2PK with too little R padding", SCRIPT_VERIFY_DERSIG)
.PushSig(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.ScriptError(SCRIPT_ERR_SIG_DER)); .ScriptError(SCRIPT_ERR_SIG_DER));
tests.push_back( tests.push_back(
TestBuilder( TestBuilder(
CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT, CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT,
"P2PK NOT with bad sig with too much R padding but no DERSIG", 0) "P2PK NOT with bad sig with too much R padding but no DERSIG", 0)
.PushSig(keys.key2, SigHashType(), 31, 32) .PushSigECDSA(keys.key2, SigHashType(), 31, 32)
.EditPush(1, "43021F", "44022000") .EditPush(1, "43021F", "44022000")
.DamagePush(10)); .DamagePush(10));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C)
<< OP_CHECKSIG << OP_NOT, << OP_CHECKSIG << OP_NOT,
"P2PK NOT with bad sig with too much R padding", "P2PK NOT with bad sig with too much R padding",
SCRIPT_VERIFY_DERSIG) SCRIPT_VERIFY_DERSIG)
.PushSig(keys.key2, SigHashType(), 31, 32) .PushSigECDSA(keys.key2, SigHashType(), 31, 32)
.EditPush(1, "43021F", "44022000") .EditPush(1, "43021F", "44022000")
.DamagePush(10) .DamagePush(10)
.ScriptError(SCRIPT_ERR_SIG_DER)); .ScriptError(SCRIPT_ERR_SIG_DER));
tests.push_back( tests.push_back(
TestBuilder(CScript() TestBuilder(CScript()
<< ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT, << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT,
"P2PK NOT with too much R padding but no DERSIG", 0) "P2PK NOT with too much R padding but no DERSIG", 0)
.PushSig(keys.key2, SigHashType(), 31, 32) .PushSigECDSA(keys.key2, SigHashType(), 31, 32)
.EditPush(1, "43021F", "44022000") .EditPush(1, "43021F", "44022000")
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .ScriptError(SCRIPT_ERR_EVAL_FALSE));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C)
<< OP_CHECKSIG << OP_NOT, << OP_CHECKSIG << OP_NOT,
"P2PK NOT with too much R padding", "P2PK NOT with too much R padding",
SCRIPT_VERIFY_DERSIG) SCRIPT_VERIFY_DERSIG)
.PushSig(keys.key2, SigHashType(), 31, 32) .PushSigECDSA(keys.key2, SigHashType(), 31, 32)
.EditPush(1, "43021F", "44022000") .EditPush(1, "43021F", "44022000")
.ScriptError(SCRIPT_ERR_SIG_DER)); .ScriptError(SCRIPT_ERR_SIG_DER));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
"BIP66 example 1, without DERSIG", 0) "BIP66 example 1, without DERSIG", 0)
.PushSig(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220")); .EditPush(1, "45022100", "440220"));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
"BIP66 example 1, with DERSIG", SCRIPT_VERIFY_DERSIG) "BIP66 example 1, with DERSIG", SCRIPT_VERIFY_DERSIG)
.PushSig(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.ScriptError(SCRIPT_ERR_SIG_DER)); .ScriptError(SCRIPT_ERR_SIG_DER));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKSIG << OP_NOT, << OP_CHECKSIG << OP_NOT,
"BIP66 example 2, without DERSIG", 0) "BIP66 example 2, without DERSIG", 0)
.PushSig(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .ScriptError(SCRIPT_ERR_EVAL_FALSE));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKSIG << OP_NOT, << OP_CHECKSIG << OP_NOT,
"BIP66 example 2, with DERSIG", "BIP66 example 2, with DERSIG",
SCRIPT_VERIFY_DERSIG) SCRIPT_VERIFY_DERSIG)
.PushSig(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.ScriptError(SCRIPT_ERR_SIG_DER)); .ScriptError(SCRIPT_ERR_SIG_DER));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
"BIP66 example 3, without DERSIG", 0) "BIP66 example 3, without DERSIG", 0)
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .ScriptError(SCRIPT_ERR_EVAL_FALSE));
tests.push_back( tests.push_back(
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
SCRIPT_VERIFY_DERSIG) SCRIPT_VERIFY_DERSIG)
.Num(1) .Num(1)
.ScriptError(SCRIPT_ERR_SIG_DER)); .ScriptError(SCRIPT_ERR_SIG_DER));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_2 << ToByteVector(keys.pubkey2C) << OP_2
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"BIP66 example 7, without DERSIG", 0) "BIP66 example 7, without DERSIG", 0)
.Num(0) .Num(0)
.PushSig(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.PushSig(keys.key2)); .PushSigECDSA(keys.key2));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_2 << ToByteVector(keys.pubkey2C) << OP_2
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"BIP66 example 7, with DERSIG", "BIP66 example 7, with DERSIG",
SCRIPT_VERIFY_DERSIG) SCRIPT_VERIFY_DERSIG)
.Num(0) .Num(0)
.PushSig(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.PushSig(keys.key2) .PushSigECDSA(keys.key2)
.ScriptError(SCRIPT_ERR_SIG_DER)); .ScriptError(SCRIPT_ERR_SIG_DER));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_2 << ToByteVector(keys.pubkey2C) << OP_2
<< OP_CHECKMULTISIG << OP_NOT, << OP_CHECKMULTISIG << OP_NOT,
"BIP66 example 8, without DERSIG", 0) "BIP66 example 8, without DERSIG", 0)
.Num(0) .Num(0)
.PushSig(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.PushSig(keys.key2) .PushSigECDSA(keys.key2)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .ScriptError(SCRIPT_ERR_EVAL_FALSE));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_2 << ToByteVector(keys.pubkey2C) << OP_2
<< OP_CHECKMULTISIG << OP_NOT, << OP_CHECKMULTISIG << OP_NOT,
"BIP66 example 8, with DERSIG", "BIP66 example 8, with DERSIG",
SCRIPT_VERIFY_DERSIG) SCRIPT_VERIFY_DERSIG)
.Num(0) .Num(0)
.PushSig(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.PushSig(keys.key2) .PushSigECDSA(keys.key2)
.ScriptError(SCRIPT_ERR_SIG_DER)); .ScriptError(SCRIPT_ERR_SIG_DER));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_2 << ToByteVector(keys.pubkey2C) << OP_2
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"BIP66 example 9, without DERSIG", 0) "BIP66 example 9, without DERSIG", 0)
.Num(0) .Num(0)
.Num(0) .Num(0)
.PushSig(keys.key2, SigHashType(), 33, 32) .PushSigECDSA(keys.key2, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .ScriptError(SCRIPT_ERR_EVAL_FALSE));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_2 << ToByteVector(keys.pubkey2C) << OP_2
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"BIP66 example 9, with DERSIG", "BIP66 example 9, with DERSIG",
SCRIPT_VERIFY_DERSIG) SCRIPT_VERIFY_DERSIG)
.Num(0) .Num(0)
.Num(0) .Num(0)
.PushSig(keys.key2, SigHashType(), 33, 32) .PushSigECDSA(keys.key2, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.ScriptError(SCRIPT_ERR_SIG_DER)); .ScriptError(SCRIPT_ERR_SIG_DER));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_2 << ToByteVector(keys.pubkey2C) << OP_2
<< OP_CHECKMULTISIG << OP_NOT, << OP_CHECKMULTISIG << OP_NOT,
"BIP66 example 10, without DERSIG", 0) "BIP66 example 10, without DERSIG", 0)
.Num(0) .Num(0)
.Num(0) .Num(0)
.PushSig(keys.key2, SigHashType(), 33, 32) .PushSigECDSA(keys.key2, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220")); .EditPush(1, "45022100", "440220"));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_2 << ToByteVector(keys.pubkey2C) << OP_2
<< OP_CHECKMULTISIG << OP_NOT, << OP_CHECKMULTISIG << OP_NOT,
"BIP66 example 10, with DERSIG", "BIP66 example 10, with DERSIG",
SCRIPT_VERIFY_DERSIG) SCRIPT_VERIFY_DERSIG)
.Num(0) .Num(0)
.Num(0) .Num(0)
.PushSig(keys.key2, SigHashType(), 33, 32) .PushSigECDSA(keys.key2, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.ScriptError(SCRIPT_ERR_SIG_DER)); .ScriptError(SCRIPT_ERR_SIG_DER));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_2 << ToByteVector(keys.pubkey2C) << OP_2
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"BIP66 example 11, without DERSIG", 0) "BIP66 example 11, without DERSIG", 0)
.Num(0) .Num(0)
.PushSig(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .ScriptError(SCRIPT_ERR_EVAL_FALSE));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_2 << ToByteVector(keys.pubkey2C) << OP_2
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"BIP66 example 11, with DERSIG", "BIP66 example 11, with DERSIG",
SCRIPT_VERIFY_DERSIG) SCRIPT_VERIFY_DERSIG)
.Num(0) .Num(0)
.PushSig(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .ScriptError(SCRIPT_ERR_EVAL_FALSE));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_2 << ToByteVector(keys.pubkey2C) << OP_2
<< OP_CHECKMULTISIG << OP_NOT, << OP_CHECKMULTISIG << OP_NOT,
"BIP66 example 12, without DERSIG", 0) "BIP66 example 12, without DERSIG", 0)
.Num(0) .Num(0)
.PushSig(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.Num(0)); .Num(0));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_2 << ToByteVector(keys.pubkey2C) << OP_2
<< OP_CHECKMULTISIG << OP_NOT, << OP_CHECKMULTISIG << OP_NOT,
"BIP66 example 12, with DERSIG", "BIP66 example 12, with DERSIG",
SCRIPT_VERIFY_DERSIG) SCRIPT_VERIFY_DERSIG)
.Num(0) .Num(0)
.PushSig(keys.key1, SigHashType(), 33, 32) .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.Num(0)); .Num(0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
"P2PK with multi-byte hashtype, without DERSIG", 0) "P2PK with multi-byte hashtype, without DERSIG", 0)
.PushSig(keys.key2) .PushSigECDSA(keys.key2)
.EditPush(70, "01", "0101")); .EditPush(70, "01", "0101"));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
"P2PK with multi-byte hashtype, with DERSIG", "P2PK with multi-byte hashtype, with DERSIG",
SCRIPT_VERIFY_DERSIG) SCRIPT_VERIFY_DERSIG)
.PushSig(keys.key2) .PushSigECDSA(keys.key2)
.EditPush(70, "01", "0101") .EditPush(70, "01", "0101")
.ScriptError(SCRIPT_ERR_SIG_DER)); .ScriptError(SCRIPT_ERR_SIG_DER));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
"P2PK with high S but no LOW_S", 0) "P2PK with high S but no LOW_S", 0)
.PushSig(keys.key2, SigHashType(), 32, 33)); .PushSigECDSA(keys.key2, SigHashType(), 32, 33));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
"P2PK with high S", SCRIPT_VERIFY_LOW_S) "P2PK with high S", SCRIPT_VERIFY_LOW_S)
.PushSig(keys.key2, SigHashType(), 32, 33) .PushSigECDSA(keys.key2, SigHashType(), 32, 33)
.ScriptError(SCRIPT_ERR_SIG_HIGH_S)); .ScriptError(SCRIPT_ERR_SIG_HIGH_S));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG,
"P2PK with hybrid pubkey but no STRICTENC", 0) "P2PK with hybrid pubkey but no STRICTENC", 0)
.PushSig(keys.key0)); .PushSigECDSA(keys.key0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG,
"P2PK with hybrid pubkey", SCRIPT_VERIFY_STRICTENC) "P2PK with hybrid pubkey", SCRIPT_VERIFY_STRICTENC)
.PushSig(keys.key0, SigHashType()) .PushSigECDSA(keys.key0, SigHashType())
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .ScriptError(SCRIPT_ERR_PUBKEYTYPE));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
<< OP_CHECKSIG << OP_NOT, << OP_CHECKSIG << OP_NOT,
"P2PK NOT with hybrid pubkey but no STRICTENC", "P2PK NOT with hybrid pubkey but no STRICTENC",
0) 0)
.PushSig(keys.key0) .PushSigECDSA(keys.key0)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .ScriptError(SCRIPT_ERR_EVAL_FALSE));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
<< OP_CHECKSIG << OP_NOT, << OP_CHECKSIG << OP_NOT,
"P2PK NOT with hybrid pubkey", "P2PK NOT with hybrid pubkey",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushSig(keys.key0) .PushSigECDSA(keys.key0)
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .ScriptError(SCRIPT_ERR_PUBKEYTYPE));
tests.push_back( tests.push_back(
TestBuilder(CScript() TestBuilder(CScript()
<< ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT, << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT,
"P2PK NOT with invalid hybrid pubkey but no STRICTENC", 0) "P2PK NOT with invalid hybrid pubkey but no STRICTENC", 0)
.PushSig(keys.key0) .PushSigECDSA(keys.key0)
.DamagePush(10)); .DamagePush(10));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
<< OP_CHECKSIG << OP_NOT, << OP_CHECKSIG << OP_NOT,
"P2PK NOT with invalid hybrid pubkey", "P2PK NOT with invalid hybrid pubkey",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushSig(keys.key0) .PushSigECDSA(keys.key0)
.DamagePush(10) .DamagePush(10)
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .ScriptError(SCRIPT_ERR_PUBKEYTYPE));
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0H) TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0H)
<< ToByteVector(keys.pubkey1C) << OP_2 << ToByteVector(keys.pubkey1C) << OP_2
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"1-of-2 with the second 1 hybrid pubkey and no STRICTENC", "1-of-2 with the second 1 hybrid pubkey and no STRICTENC",
0) 0)
.Num(0) .Num(0)
.PushSig(keys.key1)); .PushSigECDSA(keys.key1));
tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0H) tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0H)
<< ToByteVector(keys.pubkey1C) << OP_2 << ToByteVector(keys.pubkey1C) << OP_2
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"1-of-2 with the second 1 hybrid pubkey", "1-of-2 with the second 1 hybrid pubkey",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.Num(0) .Num(0)
.PushSig(keys.key1)); .PushSigECDSA(keys.key1));
tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey0H) << OP_2 << ToByteVector(keys.pubkey0H) << OP_2
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"1-of-2 with the first 1 hybrid pubkey", "1-of-2 with the first 1 hybrid pubkey",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.Num(0) .Num(0)
.PushSig(keys.key1) .PushSigECDSA(keys.key1)
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .ScriptError(SCRIPT_ERR_PUBKEYTYPE));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
"P2PK with undefined hashtype but no STRICTENC", 0) "P2PK with undefined hashtype but no STRICTENC", 0)
.PushSig(keys.key1, SigHashType(5))); .PushSigECDSA(keys.key1, SigHashType(5)));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
"P2PK with undefined hashtype", SCRIPT_VERIFY_STRICTENC) "P2PK with undefined hashtype", SCRIPT_VERIFY_STRICTENC)
.PushSig(keys.key1, SigHashType(5)) .PushSigECDSA(keys.key1, SigHashType(5))
.ScriptError(SCRIPT_ERR_SIG_HASHTYPE)); .ScriptError(SCRIPT_ERR_SIG_HASHTYPE));
// Generate P2PKH tests for invalid SigHashType // Generate P2PKH tests for invalid SigHashType
tests.push_back( tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
TestBuilder(CScript() << OP_DUP << OP_HASH160
<< ToByteVector(keys.pubkey0.GetID()) << ToByteVector(keys.pubkey0.GetID())
<< OP_EQUALVERIFY << OP_CHECKSIG, << OP_EQUALVERIFY << OP_CHECKSIG,
"P2PKH with invalid sighashtype", 0) "P2PKH with invalid sighashtype", 0)
.PushSig(keys.key0, SigHashType(0x21), 32, 32, Amount::zero(), 0) .PushSigECDSA(keys.key0, SigHashType(0x21), 32, 32,
Amount::zero(), 0)
.Push(keys.pubkey0)); .Push(keys.pubkey0));
tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
<< ToByteVector(keys.pubkey0.GetID()) << ToByteVector(keys.pubkey0.GetID())
<< OP_EQUALVERIFY << OP_CHECKSIG, << OP_EQUALVERIFY << OP_CHECKSIG,
"P2PKH with invalid sighashtype and STRICTENC", "P2PKH with invalid sighashtype and STRICTENC",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushSig(keys.key0, SigHashType(0x21), 32, 32, .PushSigECDSA(keys.key0, SigHashType(0x21), 32, 32,
Amount::zero(), SCRIPT_VERIFY_STRICTENC) Amount::zero(), SCRIPT_VERIFY_STRICTENC)
.Push(keys.pubkey0) .Push(keys.pubkey0)
// Should fail for STRICTENC // Should fail for STRICTENC
.ScriptError(SCRIPT_ERR_SIG_HASHTYPE)); .ScriptError(SCRIPT_ERR_SIG_HASHTYPE));
// Generate P2SH tests for invalid SigHashType // Generate P2SH tests for invalid SigHashType
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
"P2SH(P2PK) with invalid sighashtype", SCRIPT_VERIFY_P2SH, "P2SH(P2PK) with invalid sighashtype", SCRIPT_VERIFY_P2SH,
true) true)
.PushSig(keys.key1, SigHashType(0x21)) .PushSigECDSA(keys.key1, SigHashType(0x21))
.PushRedeem()); .PushRedeem());
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
"P2SH(P2PK) with invalid sighashtype and STRICTENC", "P2SH(P2PK) with invalid sighashtype and STRICTENC",
SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC, true) SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC, true)
.PushSig(keys.key1, SigHashType(0x21)) .PushSigECDSA(keys.key1, SigHashType(0x21))
.PushRedeem() .PushRedeem()
// Should fail for STRICTENC // Should fail for STRICTENC
.ScriptError(SCRIPT_ERR_SIG_HASHTYPE)); .ScriptError(SCRIPT_ERR_SIG_HASHTYPE));
tests.push_back( tests.push_back(
TestBuilder( TestBuilder(
CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG << OP_NOT, CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG << OP_NOT,
"P2PK NOT with invalid sig and undefined hashtype but no STRICTENC", "P2PK NOT with invalid sig and undefined hashtype but no STRICTENC",
0) 0)
.PushSig(keys.key1, SigHashType(5)) .PushSigECDSA(keys.key1, SigHashType(5))
.DamagePush(10)); .DamagePush(10));
tests.push_back( tests.push_back(
TestBuilder(CScript() TestBuilder(CScript()
<< ToByteVector(keys.pubkey1) << OP_CHECKSIG << OP_NOT, << ToByteVector(keys.pubkey1) << OP_CHECKSIG << OP_NOT,
"P2PK NOT with invalid sig and undefined hashtype", "P2PK NOT with invalid sig and undefined hashtype",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushSig(keys.key1, SigHashType(5)) .PushSigECDSA(keys.key1, SigHashType(5))
.DamagePush(10) .DamagePush(10)
.ScriptError(SCRIPT_ERR_SIG_HASHTYPE)); .ScriptError(SCRIPT_ERR_SIG_HASHTYPE));
tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
<< ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_3 << ToByteVector(keys.pubkey2C) << OP_3
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"3-of-3 with nonzero dummy but no NULLDUMMY", 0) "3-of-3 with nonzero dummy but no NULLDUMMY", 0)
.Num(1) .Num(1)
.PushSig(keys.key0) .PushSigECDSA(keys.key0)
.PushSig(keys.key1) .PushSigECDSA(keys.key1)
.PushSig(keys.key2)); .PushSigECDSA(keys.key2));
tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
<< ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_3 << ToByteVector(keys.pubkey2C) << OP_3
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"3-of-3 with nonzero dummy", "3-of-3 with nonzero dummy",
SCRIPT_VERIFY_NULLDUMMY) SCRIPT_VERIFY_NULLDUMMY)
.Num(1) .Num(1)
.PushSig(keys.key0) .PushSigECDSA(keys.key0)
.PushSig(keys.key1) .PushSigECDSA(keys.key1)
.PushSig(keys.key2) .PushSigECDSA(keys.key2)
.ScriptError(SCRIPT_ERR_SIG_NULLDUMMY)); .ScriptError(SCRIPT_ERR_SIG_NULLDUMMY));
tests.push_back( tests.push_back(
TestBuilder( TestBuilder(
CScript() << OP_3 << ToByteVector(keys.pubkey0C) CScript() << OP_3 << ToByteVector(keys.pubkey0C)
<< ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG << ToByteVector(keys.pubkey2C) << OP_3 << OP_CHECKMULTISIG
<< OP_NOT, << OP_NOT,
"3-of-3 NOT with invalid sig and nonzero dummy but no NULLDUMMY", 0) "3-of-3 NOT with invalid sig and nonzero dummy but no NULLDUMMY", 0)
.Num(1) .Num(1)
.PushSig(keys.key0) .PushSigECDSA(keys.key0)
.PushSig(keys.key1) .PushSigECDSA(keys.key1)
.PushSig(keys.key2) .PushSigECDSA(keys.key2)
.DamagePush(10)); .DamagePush(10));
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
<< ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_3 << ToByteVector(keys.pubkey2C) << OP_3
<< OP_CHECKMULTISIG << OP_NOT, << OP_CHECKMULTISIG << OP_NOT,
"3-of-3 NOT with invalid sig with nonzero dummy", "3-of-3 NOT with invalid sig with nonzero dummy",
SCRIPT_VERIFY_NULLDUMMY) SCRIPT_VERIFY_NULLDUMMY)
.Num(1) .Num(1)
.PushSig(keys.key0) .PushSigECDSA(keys.key0)
.PushSig(keys.key1) .PushSigECDSA(keys.key1)
.PushSig(keys.key2) .PushSigECDSA(keys.key2)
.DamagePush(10) .DamagePush(10)
.ScriptError(SCRIPT_ERR_SIG_NULLDUMMY)); .ScriptError(SCRIPT_ERR_SIG_NULLDUMMY));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey1C) << OP_2 << ToByteVector(keys.pubkey1C) << OP_2
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"2-of-2 with two identical keys and sigs " "2-of-2 with two identical keys and sigs "
"pushed using OP_DUP but no SIGPUSHONLY", "pushed using OP_DUP but no SIGPUSHONLY",
0) 0)
.Num(0) .Num(0)
.PushSig(keys.key1) .PushSigECDSA(keys.key1)
.Add(CScript() << OP_DUP)); .Add(CScript() << OP_DUP));
tests.push_back( tests.push_back(
TestBuilder( TestBuilder(
CScript() << OP_2 << ToByteVector(keys.pubkey1C) CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey1C) << OP_2 << ToByteVector(keys.pubkey1C) << OP_2
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"2-of-2 with two identical keys and sigs pushed using OP_DUP", "2-of-2 with two identical keys and sigs pushed using OP_DUP",
SCRIPT_VERIFY_SIGPUSHONLY) SCRIPT_VERIFY_SIGPUSHONLY)
.Num(0) .Num(0)
.PushSig(keys.key1) .PushSigECDSA(keys.key1)
.Add(CScript() << OP_DUP) .Add(CScript() << OP_DUP)
.ScriptError(SCRIPT_ERR_SIG_PUSHONLY)); .ScriptError(SCRIPT_ERR_SIG_PUSHONLY));
tests.push_back( tests.push_back(
TestBuilder( TestBuilder(
CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG, CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
"P2SH(P2PK) with non-push scriptSig but no P2SH or SIGPUSHONLY", 0, "P2SH(P2PK) with non-push scriptSig but no P2SH or SIGPUSHONLY", 0,
true) true)
.PushSig(keys.key2) .PushSigECDSA(keys.key2)
.Add(CScript() << OP_NOP8) .Add(CScript() << OP_NOP8)
.PushRedeem()); .PushRedeem());
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
"P2PK with non-push scriptSig but with P2SH validation", 0) "P2PK with non-push scriptSig but with P2SH validation", 0)
.PushSig(keys.key2) .PushSigECDSA(keys.key2)
.Add(CScript() << OP_NOP8)); .Add(CScript() << OP_NOP8));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
"P2SH(P2PK) with non-push scriptSig but no SIGPUSHONLY", "P2SH(P2PK) with non-push scriptSig but no SIGPUSHONLY",
SCRIPT_VERIFY_P2SH, true) SCRIPT_VERIFY_P2SH, true)
.PushSig(keys.key2) .PushSigECDSA(keys.key2)
.Add(CScript() << OP_NOP8) .Add(CScript() << OP_NOP8)
.PushRedeem() .PushRedeem()
.ScriptError(SCRIPT_ERR_SIG_PUSHONLY)); .ScriptError(SCRIPT_ERR_SIG_PUSHONLY));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
"P2SH(P2PK) with non-push scriptSig but not P2SH", "P2SH(P2PK) with non-push scriptSig but not P2SH",
SCRIPT_VERIFY_SIGPUSHONLY, true) SCRIPT_VERIFY_SIGPUSHONLY, true)
.PushSig(keys.key2) .PushSigECDSA(keys.key2)
.Add(CScript() << OP_NOP8) .Add(CScript() << OP_NOP8)
.PushRedeem() .PushRedeem()
.ScriptError(SCRIPT_ERR_SIG_PUSHONLY)); .ScriptError(SCRIPT_ERR_SIG_PUSHONLY));
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey1C) << OP_2 << ToByteVector(keys.pubkey1C) << OP_2
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"2-of-2 with two identical keys and sigs pushed", "2-of-2 with two identical keys and sigs pushed",
SCRIPT_VERIFY_SIGPUSHONLY) SCRIPT_VERIFY_SIGPUSHONLY)
.Num(0) .Num(0)
.PushSig(keys.key1) .PushSigECDSA(keys.key1)
.PushSig(keys.key1)); .PushSigECDSA(keys.key1));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2PK with unnecessary input but no CLEANSTACK", "P2PK with unnecessary input but no CLEANSTACK",
SCRIPT_VERIFY_P2SH) SCRIPT_VERIFY_P2SH)
.Num(11) .Num(11)
.PushSig(keys.key0)); .PushSigECDSA(keys.key0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2PK with unnecessary input", "P2PK with unnecessary input",
SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH) SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH)
.Num(11) .Num(11)
.PushSig(keys.key0) .PushSigECDSA(keys.key0)
.ScriptError(SCRIPT_ERR_CLEANSTACK)); .ScriptError(SCRIPT_ERR_CLEANSTACK));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2SH with unnecessary input but no CLEANSTACK", "P2SH with unnecessary input but no CLEANSTACK",
SCRIPT_VERIFY_P2SH, true) SCRIPT_VERIFY_P2SH, true)
.Num(11) .Num(11)
.PushSig(keys.key0) .PushSigECDSA(keys.key0)
.PushRedeem()); .PushRedeem());
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2SH with unnecessary input", "P2SH with unnecessary input",
SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH, true) SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH, true)
.Num(11) .Num(11)
.PushSig(keys.key0) .PushSigECDSA(keys.key0)
.PushRedeem() .PushRedeem()
.ScriptError(SCRIPT_ERR_CLEANSTACK)); .ScriptError(SCRIPT_ERR_CLEANSTACK));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2SH with CLEANSTACK", "P2SH with CLEANSTACK",
SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH, true) SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH, true)
.PushSig(keys.key0) .PushSigECDSA(keys.key0)
.PushRedeem()); .PushRedeem());
static const Amount TEST_AMOUNT(int64_t(12345000000000) * SATOSHI); static const Amount TEST_AMOUNT(int64_t(12345000000000) * SATOSHI);
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2PK FORKID", SCRIPT_ENABLE_SIGHASH_FORKID, false, "P2PK FORKID", SCRIPT_ENABLE_SIGHASH_FORKID, false,
TEST_AMOUNT) TEST_AMOUNT)
.PushSig(keys.key0, SigHashType().withForkId(), 32, 32, .PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32,
TEST_AMOUNT)); TEST_AMOUNT));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2PK INVALID AMOUNT", SCRIPT_ENABLE_SIGHASH_FORKID, false, "P2PK INVALID AMOUNT", SCRIPT_ENABLE_SIGHASH_FORKID, false,
TEST_AMOUNT) TEST_AMOUNT)
.PushSig(keys.key0, SigHashType().withForkId(), 32, 32, .PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32,
TEST_AMOUNT + SATOSHI) TEST_AMOUNT + SATOSHI)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .ScriptError(SCRIPT_ERR_EVAL_FALSE));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2PK INVALID FORKID", SCRIPT_VERIFY_STRICTENC, false, "P2PK INVALID FORKID", SCRIPT_VERIFY_STRICTENC, false,
TEST_AMOUNT) TEST_AMOUNT)
.PushSig(keys.key0, SigHashType().withForkId(), 32, 32, TEST_AMOUNT) .PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32,
TEST_AMOUNT)
.ScriptError(SCRIPT_ERR_ILLEGAL_FORKID)); .ScriptError(SCRIPT_ERR_ILLEGAL_FORKID));
// Test replay protection // Test replay protection
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2PK REPLAY PROTECTED", "P2PK REPLAY PROTECTED",
SCRIPT_ENABLE_SIGHASH_FORKID | SCRIPT_ENABLE_SIGHASH_FORKID |
SCRIPT_ENABLE_REPLAY_PROTECTION, SCRIPT_ENABLE_REPLAY_PROTECTION,
false, TEST_AMOUNT) false, TEST_AMOUNT)
.PushSig(keys.key0, SigHashType().withForkId(), 32, 32, TEST_AMOUNT, .PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32,
TEST_AMOUNT,
SCRIPT_ENABLE_SIGHASH_FORKID | SCRIPT_ENABLE_SIGHASH_FORKID |
SCRIPT_ENABLE_REPLAY_PROTECTION)); SCRIPT_ENABLE_REPLAY_PROTECTION));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2PK REPLAY PROTECTED", "P2PK REPLAY PROTECTED",
SCRIPT_ENABLE_SIGHASH_FORKID | SCRIPT_ENABLE_SIGHASH_FORKID |
SCRIPT_ENABLE_REPLAY_PROTECTION, SCRIPT_ENABLE_REPLAY_PROTECTION,
false, TEST_AMOUNT) false, TEST_AMOUNT)
.PushSig(keys.key0, SigHashType().withForkId(), 32, 32, TEST_AMOUNT, .PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32,
SCRIPT_ENABLE_SIGHASH_FORKID) TEST_AMOUNT, SCRIPT_ENABLE_SIGHASH_FORKID)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .ScriptError(SCRIPT_ERR_EVAL_FALSE));
// Test OP_CHECKDATASIG // Test OP_CHECKDATASIG
const uint32_t checkdatasigflags = SCRIPT_VERIFY_STRICTENC | const uint32_t checkdatasigflags = SCRIPT_VERIFY_STRICTENC |
SCRIPT_VERIFY_NULLFAIL | SCRIPT_VERIFY_NULLFAIL |
SCRIPT_ENABLE_CHECKDATASIG; SCRIPT_ENABLE_CHECKDATASIG;
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG,
"Standard CHECKDATASIG", checkdatasigflags) "Standard CHECKDATASIG", checkdatasigflags)
.PushDataSig(keys.key1, {}) .PushDataSigECDSA(keys.key1, {})
.Num(0)); .Num(0));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIG << OP_NOT, << OP_CHECKDATASIG << OP_NOT,
"CHECKDATASIG with NULLFAIL flags", "CHECKDATASIG with NULLFAIL flags",
checkdatasigflags) checkdatasigflags)
.PushDataSig(keys.key1, {}) .PushDataSigECDSA(keys.key1, {})
.Num(1) .Num(1)
.ScriptError(SCRIPT_ERR_SIG_NULLFAIL)); .ScriptError(SCRIPT_ERR_SIG_NULLFAIL));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIG << OP_NOT, << OP_CHECKDATASIG << OP_NOT,
"CHECKDATASIG without NULLFAIL flags", "CHECKDATASIG without NULLFAIL flags",
checkdatasigflags & ~SCRIPT_VERIFY_NULLFAIL) checkdatasigflags & ~SCRIPT_VERIFY_NULLFAIL)
.PushDataSig(keys.key1, {}) .PushDataSigECDSA(keys.key1, {})
.Num(1)); .Num(1));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIG << OP_NOT, << OP_CHECKDATASIG << OP_NOT,
"CHECKDATASIG empty signature", "CHECKDATASIG empty signature",
checkdatasigflags) checkdatasigflags)
.Num(0) .Num(0)
.Num(0)); .Num(0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG,
"CHECKDATASIG with High S but no Low S", checkdatasigflags) "CHECKDATASIG with High S but no Low S", checkdatasigflags)
.PushDataSig(keys.key1, {}, 32, 33) .PushDataSigECDSA(keys.key1, {}, 32, 33)
.Num(0)); .Num(0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG,
"CHECKDATASIG with High S", "CHECKDATASIG with High S",
checkdatasigflags | SCRIPT_VERIFY_LOW_S) checkdatasigflags | SCRIPT_VERIFY_LOW_S)
.PushDataSig(keys.key1, {}, 32, 33) .PushDataSigECDSA(keys.key1, {}, 32, 33)
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_SIG_HIGH_S)); .ScriptError(SCRIPT_ERR_SIG_HIGH_S));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG,
"CHECKDATASIG with too little R padding but no DERSIG", "CHECKDATASIG with too little R padding but no DERSIG",
checkdatasigflags & ~SCRIPT_VERIFY_STRICTENC) checkdatasigflags & ~SCRIPT_VERIFY_STRICTENC)
.PushDataSig(keys.key1, {}, 33, 32) .PushDataSigECDSA(keys.key1, {}, 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.Num(0)); .Num(0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG,
"CHECKDATASIG with too little R padding", checkdatasigflags) "CHECKDATASIG with too little R padding", checkdatasigflags)
.PushDataSig(keys.key1, {}, 33, 32) .PushDataSigECDSA(keys.key1, {}, 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_SIG_DER)); .ScriptError(SCRIPT_ERR_SIG_DER));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG,
"CHECKDATASIG with hybrid pubkey but no STRICTENC", "CHECKDATASIG with hybrid pubkey but no STRICTENC",
checkdatasigflags & ~SCRIPT_VERIFY_STRICTENC) checkdatasigflags & ~SCRIPT_VERIFY_STRICTENC)
.PushDataSig(keys.key0, {}) .PushDataSigECDSA(keys.key0, {})
.Num(0)); .Num(0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG,
"CHECKDATASIG with hybrid pubkey", checkdatasigflags) "CHECKDATASIG with hybrid pubkey", checkdatasigflags)
.PushDataSig(keys.key0, {}) .PushDataSigECDSA(keys.key0, {})
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .ScriptError(SCRIPT_ERR_PUBKEYTYPE));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG
<< OP_NOT, << OP_NOT,
"CHECKDATASIG with invalid hybrid pubkey but no STRICTENC", "CHECKDATASIG with invalid hybrid pubkey but no STRICTENC",
SCRIPT_ENABLE_CHECKDATASIG) SCRIPT_ENABLE_CHECKDATASIG)
.PushDataSig(keys.key0, {}) .PushDataSigECDSA(keys.key0, {})
.DamagePush(10) .DamagePush(10)
.Num(0)); .Num(0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG,
"CHECKDATASIG with invalid hybrid pubkey", "CHECKDATASIG with invalid hybrid pubkey",
checkdatasigflags) checkdatasigflags)
.PushDataSig(keys.key0, {}) .PushDataSigECDSA(keys.key0, {})
.DamagePush(10) .DamagePush(10)
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .ScriptError(SCRIPT_ERR_PUBKEYTYPE));
// Test OP_CHECKDATASIGVERIFY // Test OP_CHECKDATASIGVERIFY
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"Standard CHECKDATASIGVERIFY", "Standard CHECKDATASIGVERIFY",
checkdatasigflags) checkdatasigflags)
.PushDataSig(keys.key1, {}) .PushDataSigECDSA(keys.key1, {})
.Num(0)); .Num(0));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIGVERIFY with NULLFAIL flags", "CHECKDATASIGVERIFY with NULLFAIL flags",
checkdatasigflags) checkdatasigflags)
.PushDataSig(keys.key1, {}) .PushDataSigECDSA(keys.key1, {})
.Num(1) .Num(1)
.ScriptError(SCRIPT_ERR_SIG_NULLFAIL)); .ScriptError(SCRIPT_ERR_SIG_NULLFAIL));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIGVERIFY without NULLFAIL flags", "CHECKDATASIGVERIFY without NULLFAIL flags",
checkdatasigflags & ~SCRIPT_VERIFY_NULLFAIL) checkdatasigflags & ~SCRIPT_VERIFY_NULLFAIL)
.PushDataSig(keys.key1, {}) .PushDataSigECDSA(keys.key1, {})
.Num(1) .Num(1)
.ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY)); .ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIGVERIFY empty signature", "CHECKDATASIGVERIFY empty signature",
checkdatasigflags) checkdatasigflags)
.Num(0) .Num(0)
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY)); .ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIG with High S but no Low S", "CHECKDATASIG with High S but no Low S",
checkdatasigflags) checkdatasigflags)
.PushDataSig(keys.key1, {}, 32, 33) .PushDataSigECDSA(keys.key1, {}, 32, 33)
.Num(0)); .Num(0));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIG with High S", "CHECKDATASIG with High S",
checkdatasigflags | SCRIPT_VERIFY_LOW_S) checkdatasigflags | SCRIPT_VERIFY_LOW_S)
.PushDataSig(keys.key1, {}, 32, 33) .PushDataSigECDSA(keys.key1, {}, 32, 33)
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_SIG_HIGH_S)); .ScriptError(SCRIPT_ERR_SIG_HIGH_S));
tests.push_back( tests.push_back(
TestBuilder( TestBuilder(
CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIGVERIFY CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIGVERIFY
<< OP_TRUE, << OP_TRUE,
"CHECKDATASIGVERIFY with too little R padding but no DERSIG", "CHECKDATASIGVERIFY with too little R padding but no DERSIG",
checkdatasigflags & ~SCRIPT_VERIFY_STRICTENC) checkdatasigflags & ~SCRIPT_VERIFY_STRICTENC)
.PushDataSig(keys.key1, {}, 33, 32) .PushDataSigECDSA(keys.key1, {}, 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.Num(0)); .Num(0));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIGVERIFY with too little R padding", "CHECKDATASIGVERIFY with too little R padding",
checkdatasigflags) checkdatasigflags)
.PushDataSig(keys.key1, {}, 33, 32) .PushDataSigECDSA(keys.key1, {}, 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_SIG_DER)); .ScriptError(SCRIPT_ERR_SIG_DER));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0H) TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIGVERIFY with hybrid pubkey but no STRICTENC", "CHECKDATASIGVERIFY with hybrid pubkey but no STRICTENC",
checkdatasigflags & ~SCRIPT_VERIFY_STRICTENC) checkdatasigflags & ~SCRIPT_VERIFY_STRICTENC)
.PushDataSig(keys.key0, {}) .PushDataSigECDSA(keys.key0, {})
.Num(0)); .Num(0));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIGVERIFY with hybrid pubkey", "CHECKDATASIGVERIFY with hybrid pubkey",
checkdatasigflags) checkdatasigflags)
.PushDataSig(keys.key0, {}) .PushDataSigECDSA(keys.key0, {})
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .ScriptError(SCRIPT_ERR_PUBKEYTYPE));
tests.push_back( tests.push_back(
TestBuilder( TestBuilder(
CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIGVERIFY CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIGVERIFY
<< OP_TRUE, << OP_TRUE,
"CHECKDATASIGVERIFY with invalid hybrid pubkey but no STRICTENC", "CHECKDATASIGVERIFY with invalid hybrid pubkey but no STRICTENC",
SCRIPT_ENABLE_CHECKDATASIG) SCRIPT_ENABLE_CHECKDATASIG)
.PushDataSig(keys.key0, {}) .PushDataSigECDSA(keys.key0, {})
.DamagePush(10) .DamagePush(10)
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY)); .ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIGVERIFY with invalid hybrid pubkey", "CHECKDATASIGVERIFY with invalid hybrid pubkey",
checkdatasigflags) checkdatasigflags)
.PushDataSig(keys.key0, {}) .PushDataSigECDSA(keys.key0, {})
.DamagePush(10) .DamagePush(10)
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .ScriptError(SCRIPT_ERR_PUBKEYTYPE));
// Misc ECDSA tests duplicated with Schnorr flag on // Misc ECDSA tests duplicated with Schnorr flag on
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2PK ECDSA with Schnorr flag on", SCRIPT_ENABLE_SCHNORR) "P2PK ECDSA with Schnorr flag on", SCRIPT_ENABLE_SCHNORR)
.PushSig(keys.key0)); .PushSigECDSA(keys.key0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"P2PK, bad sig ECDSA with Schnorr flag on", "P2PK, bad sig ECDSA with Schnorr flag on",
SCRIPT_ENABLE_SCHNORR) SCRIPT_ENABLE_SCHNORR)
.PushSig(keys.key0) .PushSigECDSA(keys.key0)
.DamagePush(10) .DamagePush(10)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .ScriptError(SCRIPT_ERR_EVAL_FALSE));
tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
<< ToByteVector(keys.pubkey1C.GetID()) << ToByteVector(keys.pubkey1C.GetID())
<< OP_EQUALVERIFY << OP_CHECKSIG, << OP_EQUALVERIFY << OP_CHECKSIG,
"P2PKH ECDSA with Schnorr flag on", "P2PKH ECDSA with Schnorr flag on",
SCRIPT_ENABLE_SCHNORR) SCRIPT_ENABLE_SCHNORR)
.PushSig(keys.key1) .PushSigECDSA(keys.key1)
.Push(keys.pubkey1C)); .Push(keys.pubkey1C));
tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C) tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
<< ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_3 << ToByteVector(keys.pubkey2C) << OP_3
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"P2SH(2-of-3) ECDSA with Schnorr flag on", "P2SH(2-of-3) ECDSA with Schnorr flag on",
SCRIPT_VERIFY_P2SH | SCRIPT_ENABLE_SCHNORR, SCRIPT_VERIFY_P2SH | SCRIPT_ENABLE_SCHNORR,
true) true)
.Num(0) .Num(0)
.PushSig(keys.key1) .PushSigECDSA(keys.key1)
.PushSig(keys.key2) .PushSigECDSA(keys.key2)
.PushRedeem()); .PushRedeem());
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
"LOW_S violating ECDSA with Schnorr flag on", "LOW_S violating ECDSA with Schnorr flag on",
SCRIPT_VERIFY_LOW_S | SCRIPT_ENABLE_SCHNORR) SCRIPT_VERIFY_LOW_S | SCRIPT_ENABLE_SCHNORR)
.PushSig(keys.key2, SigHashType(), 32, 33) .PushSigECDSA(keys.key2, SigHashType(), 32, 33)
.ScriptError(SCRIPT_ERR_SIG_HIGH_S)); .ScriptError(SCRIPT_ERR_SIG_HIGH_S));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG,
"STRICTENC-violating hybrid pubkey with Schnorr flag on", "STRICTENC-violating hybrid pubkey with Schnorr flag on",
SCRIPT_VERIFY_STRICTENC | SCRIPT_ENABLE_SCHNORR) SCRIPT_VERIFY_STRICTENC | SCRIPT_ENABLE_SCHNORR)
.PushSig(keys.key0, SigHashType()) .PushSigECDSA(keys.key0, SigHashType())
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .ScriptError(SCRIPT_ERR_PUBKEYTYPE));
// Duplicated test OP_CHECKDATASIG with Schnorr flag on // Duplicated test OP_CHECKDATASIG with Schnorr flag on
const uint32_t checkdatasigschnorrflags = const uint32_t checkdatasigschnorrflags =
SCRIPT_VERIFY_STRICTENC | SCRIPT_VERIFY_NULLFAIL | SCRIPT_VERIFY_STRICTENC | SCRIPT_VERIFY_NULLFAIL |
SCRIPT_ENABLE_CHECKDATASIG | SCRIPT_ENABLE_SCHNORR; SCRIPT_ENABLE_CHECKDATASIG | SCRIPT_ENABLE_SCHNORR;
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG,
"Standard CHECKDATASIG", checkdatasigschnorrflags) "Standard CHECKDATASIG", checkdatasigschnorrflags)
.PushDataSig(keys.key1, {}) .PushDataSigECDSA(keys.key1, {})
.Num(0)); .Num(0));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIG << OP_NOT, << OP_CHECKDATASIG << OP_NOT,
"CHECKDATASIG with NULLFAIL flags", "CHECKDATASIG with NULLFAIL flags",
checkdatasigschnorrflags) checkdatasigschnorrflags)
.PushDataSig(keys.key1, {}) .PushDataSigECDSA(keys.key1, {})
.Num(1) .Num(1)
.ScriptError(SCRIPT_ERR_SIG_NULLFAIL)); .ScriptError(SCRIPT_ERR_SIG_NULLFAIL));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG
<< OP_NOT, << OP_NOT,
"CHECKDATASIG without NULLFAIL flags", "CHECKDATASIG without NULLFAIL flags",
checkdatasigschnorrflags & ~SCRIPT_VERIFY_NULLFAIL) checkdatasigschnorrflags & ~SCRIPT_VERIFY_NULLFAIL)
.PushDataSig(keys.key1, {}) .PushDataSigECDSA(keys.key1, {})
.Num(1)); .Num(1));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIG << OP_NOT, << OP_CHECKDATASIG << OP_NOT,
"CHECKDATASIG empty signature", "CHECKDATASIG empty signature",
checkdatasigschnorrflags) checkdatasigschnorrflags)
.Num(0) .Num(0)
.Num(0)); .Num(0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG,
"CHECKDATASIG with High S but no Low S", "CHECKDATASIG with High S but no Low S",
checkdatasigschnorrflags) checkdatasigschnorrflags)
.PushDataSig(keys.key1, {}, 32, 33) .PushDataSigECDSA(keys.key1, {}, 32, 33)
.Num(0)); .Num(0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG,
"CHECKDATASIG with High S", "CHECKDATASIG with High S",
checkdatasigschnorrflags | SCRIPT_VERIFY_LOW_S) checkdatasigschnorrflags | SCRIPT_VERIFY_LOW_S)
.PushDataSig(keys.key1, {}, 32, 33) .PushDataSigECDSA(keys.key1, {}, 32, 33)
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_SIG_HIGH_S)); .ScriptError(SCRIPT_ERR_SIG_HIGH_S));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG,
"CHECKDATASIG with too little R padding but no DERSIG", "CHECKDATASIG with too little R padding but no DERSIG",
checkdatasigschnorrflags & ~SCRIPT_VERIFY_STRICTENC) checkdatasigschnorrflags & ~SCRIPT_VERIFY_STRICTENC)
.PushDataSig(keys.key1, {}, 33, 32) .PushDataSigECDSA(keys.key1, {}, 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.Num(0)); .Num(0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG,
"CHECKDATASIG with too little R padding", "CHECKDATASIG with too little R padding",
checkdatasigschnorrflags) checkdatasigschnorrflags)
.PushDataSig(keys.key1, {}, 33, 32) .PushDataSigECDSA(keys.key1, {}, 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_SIG_DER)); .ScriptError(SCRIPT_ERR_SIG_DER));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG,
"CHECKDATASIG with hybrid pubkey but no STRICTENC", "CHECKDATASIG with hybrid pubkey but no STRICTENC",
checkdatasigschnorrflags & ~SCRIPT_VERIFY_STRICTENC) checkdatasigschnorrflags & ~SCRIPT_VERIFY_STRICTENC)
.PushDataSig(keys.key0, {}) .PushDataSigECDSA(keys.key0, {})
.Num(0)); .Num(0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG,
"CHECKDATASIG with hybrid pubkey", checkdatasigschnorrflags) "CHECKDATASIG with hybrid pubkey", checkdatasigschnorrflags)
.PushDataSig(keys.key0, {}) .PushDataSigECDSA(keys.key0, {})
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .ScriptError(SCRIPT_ERR_PUBKEYTYPE));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG
<< OP_NOT, << OP_NOT,
"CHECKDATASIG with invalid hybrid pubkey but no STRICTENC", "CHECKDATASIG with invalid hybrid pubkey but no STRICTENC",
SCRIPT_ENABLE_CHECKDATASIG) SCRIPT_ENABLE_CHECKDATASIG)
.PushDataSig(keys.key0, {}) .PushDataSigECDSA(keys.key0, {})
.DamagePush(10) .DamagePush(10)
.Num(0)); .Num(0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG,
"CHECKDATASIG with invalid hybrid pubkey", "CHECKDATASIG with invalid hybrid pubkey",
checkdatasigschnorrflags) checkdatasigschnorrflags)
.PushDataSig(keys.key0, {}) .PushDataSigECDSA(keys.key0, {})
.DamagePush(10) .DamagePush(10)
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .ScriptError(SCRIPT_ERR_PUBKEYTYPE));
// Duplicated test OP_CHECKDATASIGVERIFY with Schnorr flag on // Duplicated test OP_CHECKDATASIGVERIFY with Schnorr flag on
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"Standard CHECKDATASIGVERIFY", "Standard CHECKDATASIGVERIFY",
checkdatasigschnorrflags) checkdatasigschnorrflags)
.PushDataSig(keys.key1, {}) .PushDataSigECDSA(keys.key1, {})
.Num(0)); .Num(0));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIGVERIFY with NULLFAIL flags", "CHECKDATASIGVERIFY with NULLFAIL flags",
checkdatasigschnorrflags) checkdatasigschnorrflags)
.PushDataSig(keys.key1, {}) .PushDataSigECDSA(keys.key1, {})
.Num(1) .Num(1)
.ScriptError(SCRIPT_ERR_SIG_NULLFAIL)); .ScriptError(SCRIPT_ERR_SIG_NULLFAIL));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1C) TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIGVERIFY without NULLFAIL flags", "CHECKDATASIGVERIFY without NULLFAIL flags",
checkdatasigschnorrflags & ~SCRIPT_VERIFY_NULLFAIL) checkdatasigschnorrflags & ~SCRIPT_VERIFY_NULLFAIL)
.PushDataSig(keys.key1, {}) .PushDataSigECDSA(keys.key1, {})
.Num(1) .Num(1)
.ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY)); .ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIGVERIFY empty signature", "CHECKDATASIGVERIFY empty signature",
checkdatasigschnorrflags) checkdatasigschnorrflags)
.Num(0) .Num(0)
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY)); .ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIG with High S but no Low S", "CHECKDATASIG with High S but no Low S",
checkdatasigschnorrflags) checkdatasigschnorrflags)
.PushDataSig(keys.key1, {}, 32, 33) .PushDataSigECDSA(keys.key1, {}, 32, 33)
.Num(0)); .Num(0));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIG with High S", "CHECKDATASIG with High S",
checkdatasigschnorrflags | SCRIPT_VERIFY_LOW_S) checkdatasigschnorrflags | SCRIPT_VERIFY_LOW_S)
.PushDataSig(keys.key1, {}, 32, 33) .PushDataSigECDSA(keys.key1, {}, 32, 33)
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_SIG_HIGH_S)); .ScriptError(SCRIPT_ERR_SIG_HIGH_S));
tests.push_back( tests.push_back(
TestBuilder( TestBuilder(
CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIGVERIFY CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIGVERIFY
<< OP_TRUE, << OP_TRUE,
"CHECKDATASIGVERIFY with too little R padding but no DERSIG", "CHECKDATASIGVERIFY with too little R padding but no DERSIG",
checkdatasigschnorrflags & ~SCRIPT_VERIFY_STRICTENC) checkdatasigschnorrflags & ~SCRIPT_VERIFY_STRICTENC)
.PushDataSig(keys.key1, {}, 33, 32) .PushDataSigECDSA(keys.key1, {}, 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.Num(0)); .Num(0));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIGVERIFY with too little R padding", "CHECKDATASIGVERIFY with too little R padding",
checkdatasigschnorrflags) checkdatasigschnorrflags)
.PushDataSig(keys.key1, {}, 33, 32) .PushDataSigECDSA(keys.key1, {}, 33, 32)
.EditPush(1, "45022100", "440220") .EditPush(1, "45022100", "440220")
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_SIG_DER)); .ScriptError(SCRIPT_ERR_SIG_DER));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0H) TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIGVERIFY with hybrid pubkey but no STRICTENC", "CHECKDATASIGVERIFY with hybrid pubkey but no STRICTENC",
checkdatasigschnorrflags & ~SCRIPT_VERIFY_STRICTENC) checkdatasigschnorrflags & ~SCRIPT_VERIFY_STRICTENC)
.PushDataSig(keys.key0, {}) .PushDataSigECDSA(keys.key0, {})
.Num(0)); .Num(0));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIGVERIFY with hybrid pubkey", "CHECKDATASIGVERIFY with hybrid pubkey",
checkdatasigschnorrflags) checkdatasigschnorrflags)
.PushDataSig(keys.key0, {}) .PushDataSigECDSA(keys.key0, {})
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .ScriptError(SCRIPT_ERR_PUBKEYTYPE));
tests.push_back( tests.push_back(
TestBuilder( TestBuilder(
CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIGVERIFY CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIGVERIFY
<< OP_TRUE, << OP_TRUE,
"CHECKDATASIGVERIFY with invalid hybrid pubkey but no STRICTENC", "CHECKDATASIGVERIFY with invalid hybrid pubkey but no STRICTENC",
SCRIPT_ENABLE_CHECKDATASIG) SCRIPT_ENABLE_CHECKDATASIG)
.PushDataSig(keys.key0, {}) .PushDataSigECDSA(keys.key0, {})
.DamagePush(10) .DamagePush(10)
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY)); .ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
<< OP_CHECKDATASIGVERIFY << OP_TRUE, << OP_CHECKDATASIGVERIFY << OP_TRUE,
"CHECKDATASIGVERIFY with invalid hybrid pubkey", "CHECKDATASIGVERIFY with invalid hybrid pubkey",
checkdatasigschnorrflags) checkdatasigschnorrflags)
.PushDataSig(keys.key0, {}) .PushDataSigECDSA(keys.key0, {})
.DamagePush(10) .DamagePush(10)
.Num(0) .Num(0)
.ScriptError(SCRIPT_ERR_PUBKEYTYPE)); .ScriptError(SCRIPT_ERR_PUBKEYTYPE));
// Test all six CHECK*SIG* opcodes with Schnorr signatures. // Test all six CHECK*SIG* opcodes with Schnorr signatures.
// - Schnorr/ECDSA signatures with varying flags SCHNORR / STRICTENC. // - Schnorr/ECDSA signatures with varying flags SCHNORR / STRICTENC.
// - test with different key / mismatching key // - test with different key / mismatching key
// CHECKSIG // CHECKSIG
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"CHECKSIG Schnorr w/ neither STRICTENC,SCHNORR", 0) "CHECKSIG Schnorr w/ neither STRICTENC,SCHNORR", 0)
.PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key0)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .ScriptError(SCRIPT_ERR_EVAL_FALSE));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"CHECKSIG ECDSA w/ neither STRICTENC,SCHNORR", 0) "CHECKSIG ECDSA w/ neither STRICTENC,SCHNORR", 0)
.PushSig(keys.key0)); .PushSigECDSA(keys.key0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"CHECKSIG Schnorr w/ SCHNORR", SCRIPT_ENABLE_SCHNORR) "CHECKSIG Schnorr w/ SCHNORR", SCRIPT_ENABLE_SCHNORR)
.PushSigSchnorr(keys.key0)); .PushSigSchnorr(keys.key0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"CHECKSIG ECDSA w/ SCHNORR", SCRIPT_ENABLE_SCHNORR) "CHECKSIG ECDSA w/ SCHNORR", SCRIPT_ENABLE_SCHNORR)
.PushSig(keys.key0)); .PushSigECDSA(keys.key0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"CHECKSIG Schnorr w/ STRICTENC", SCRIPT_VERIFY_STRICTENC) "CHECKSIG Schnorr w/ STRICTENC", SCRIPT_VERIFY_STRICTENC)
.PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key0)
.ScriptError(SCRIPT_ERR_SIG_DER)); .ScriptError(SCRIPT_ERR_SIG_DER));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"CHECKSIG ECDSA w/ STRICTENC", SCRIPT_VERIFY_STRICTENC) "CHECKSIG ECDSA w/ STRICTENC", SCRIPT_VERIFY_STRICTENC)
.PushSig(keys.key0)); .PushSigECDSA(keys.key0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"CHECKSIG Schnorr w/ STRICTENC,SCHNORR", "CHECKSIG Schnorr w/ STRICTENC,SCHNORR",
SCRIPT_ENABLE_SCHNORR | SCRIPT_VERIFY_STRICTENC) SCRIPT_ENABLE_SCHNORR | SCRIPT_VERIFY_STRICTENC)
.PushSigSchnorr(keys.key0)); .PushSigSchnorr(keys.key0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
"CHECKSIG ECDSA w/ STRICTENC,SCHNORR", "CHECKSIG ECDSA w/ STRICTENC,SCHNORR",
SCRIPT_ENABLE_SCHNORR | SCRIPT_VERIFY_STRICTENC) SCRIPT_ENABLE_SCHNORR | SCRIPT_VERIFY_STRICTENC)
.PushSig(keys.key0)); .PushSigECDSA(keys.key0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG, TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
"CHECKSIG Schnorr other key", "CHECKSIG Schnorr other key",
SCRIPT_ENABLE_SCHNORR | SCRIPT_VERIFY_STRICTENC) SCRIPT_ENABLE_SCHNORR | SCRIPT_VERIFY_STRICTENC)
.PushSigSchnorr(keys.key1)); .PushSigSchnorr(keys.key1));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
<< OP_CHECKSIG << OP_NOT, << OP_CHECKSIG << OP_NOT,
"CHECKSIG Schnorr mismatched key", "CHECKSIG Schnorr mismatched key",
SCRIPT_ENABLE_SCHNORR | SCRIPT_VERIFY_STRICTENC) SCRIPT_ENABLE_SCHNORR | SCRIPT_VERIFY_STRICTENC)
.PushSigSchnorr(keys.key1)); .PushSigSchnorr(keys.key1));
// CHECKSIGVERIFY // CHECKSIGVERIFY
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIGVERIFY TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIGVERIFY
<< OP_1, << OP_1,
"CHECKSIGVERIFY Schnorr w/ neither STRICTENC,SCHNORR", 0) "CHECKSIGVERIFY Schnorr w/ neither STRICTENC,SCHNORR", 0)
.PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key0)
.ScriptError(SCRIPT_ERR_CHECKSIGVERIFY)); .ScriptError(SCRIPT_ERR_CHECKSIGVERIFY));
tests.push_back( tests.push_back(
TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIGVERIFY TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIGVERIFY
<< OP_1, << OP_1,
"CHECKSIGVERIFY ECDSA w/ neither STRICTENC,SCHNORR", 0) "CHECKSIGVERIFY ECDSA w/ neither STRICTENC,SCHNORR", 0)
.PushSig(keys.key0)); .PushSigECDSA(keys.key0));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
<< OP_CHECKSIGVERIFY << OP_1, << OP_CHECKSIGVERIFY << OP_1,
"CHECKSIGVERIFY Schnorr w/ SCHNORR", "CHECKSIGVERIFY Schnorr w/ SCHNORR",
SCRIPT_ENABLE_SCHNORR) SCRIPT_ENABLE_SCHNORR)
.PushSigSchnorr(keys.key0)); .PushSigSchnorr(keys.key0));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
<< OP_CHECKSIGVERIFY << OP_1, << OP_CHECKSIGVERIFY << OP_1,
"CHECKSIGVERIFY ECDSA w/ SCHNORR", "CHECKSIGVERIFY ECDSA w/ SCHNORR",
SCRIPT_ENABLE_SCHNORR) SCRIPT_ENABLE_SCHNORR)
.PushSig(keys.key0)); .PushSigECDSA(keys.key0));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
<< OP_CHECKSIGVERIFY << OP_1, << OP_CHECKSIGVERIFY << OP_1,
"CHECKSIGVERIFY Schnorr w/ STRICTENC", "CHECKSIGVERIFY Schnorr w/ STRICTENC",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key0)
.ScriptError(SCRIPT_ERR_SIG_DER)); .ScriptError(SCRIPT_ERR_SIG_DER));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
<< OP_CHECKSIGVERIFY << OP_1, << OP_CHECKSIGVERIFY << OP_1,
"CHECKSIGVERIFY ECDSA w/ STRICTENC", "CHECKSIGVERIFY ECDSA w/ STRICTENC",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushSig(keys.key0)); .PushSigECDSA(keys.key0));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
<< OP_CHECKSIGVERIFY << OP_1, << OP_CHECKSIGVERIFY << OP_1,
"CHECKSIGVERIFY Schnorr w/ STRICTENC,SCHNORR", "CHECKSIGVERIFY Schnorr w/ STRICTENC,SCHNORR",
SCRIPT_ENABLE_SCHNORR | SCRIPT_VERIFY_STRICTENC) SCRIPT_ENABLE_SCHNORR | SCRIPT_VERIFY_STRICTENC)
.PushSigSchnorr(keys.key0)); .PushSigSchnorr(keys.key0));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
<< OP_CHECKSIGVERIFY << OP_1, << OP_CHECKSIGVERIFY << OP_1,
"CHECKSIGVERIFY ECDSA w/ STRICTENC,SCHNORR", "CHECKSIGVERIFY ECDSA w/ STRICTENC,SCHNORR",
SCRIPT_ENABLE_SCHNORR | SCRIPT_VERIFY_STRICTENC) SCRIPT_ENABLE_SCHNORR | SCRIPT_VERIFY_STRICTENC)
.PushSig(keys.key0)); .PushSigECDSA(keys.key0));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1)
<< OP_CHECKSIGVERIFY << OP_1, << OP_CHECKSIGVERIFY << OP_1,
"CHECKSIGVERIFY Schnorr other key", "CHECKSIGVERIFY Schnorr other key",
SCRIPT_ENABLE_SCHNORR | SCRIPT_VERIFY_STRICTENC) SCRIPT_ENABLE_SCHNORR | SCRIPT_VERIFY_STRICTENC)
.PushSigSchnorr(keys.key1)); .PushSigSchnorr(keys.key1));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
<< OP_CHECKSIGVERIFY << OP_1, << OP_CHECKSIGVERIFY << OP_1,
"CHECKSIGVERIFY Schnorr mismatched key", "CHECKSIGVERIFY Schnorr mismatched key",
Show All 9 Lines tests.push_back(
SCRIPT_ENABLE_CHECKDATASIG) SCRIPT_ENABLE_CHECKDATASIG)
.PushDataSigSchnorr(keys.key0, {}) .PushDataSigSchnorr(keys.key0, {})
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .ScriptError(SCRIPT_ERR_EVAL_FALSE));
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0) TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
<< OP_CHECKDATASIG, << OP_CHECKDATASIG,
"CHECKDATASIG ECDSA w/ neither STRICTENC,SCHNORR", "CHECKDATASIG ECDSA w/ neither STRICTENC,SCHNORR",
SCRIPT_ENABLE_CHECKDATASIG) SCRIPT_ENABLE_CHECKDATASIG)
.PushDataSig(keys.key0, {})); .PushDataSigECDSA(keys.key0, {}));
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0) TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
<< OP_CHECKDATASIG, << OP_CHECKDATASIG,
"CHECKDATASIG Schnorr w/ SCHNORR", "CHECKDATASIG Schnorr w/ SCHNORR",
SCRIPT_ENABLE_CHECKDATASIG | SCRIPT_ENABLE_SCHNORR) SCRIPT_ENABLE_CHECKDATASIG | SCRIPT_ENABLE_SCHNORR)
.PushDataSigSchnorr(keys.key0, {})); .PushDataSigSchnorr(keys.key0, {}));
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0) TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
<< OP_CHECKDATASIG, << OP_CHECKDATASIG,
"CHECKDATASIG ECDSA w/ SCHNORR", "CHECKDATASIG ECDSA w/ SCHNORR",
SCRIPT_ENABLE_CHECKDATASIG | SCRIPT_ENABLE_SCHNORR) SCRIPT_ENABLE_CHECKDATASIG | SCRIPT_ENABLE_SCHNORR)
.PushDataSig(keys.key0, {})); .PushDataSigECDSA(keys.key0, {}));
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0) TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
<< OP_CHECKDATASIG, << OP_CHECKDATASIG,
"CHECKDATASIG Schnorr w/ STRICTENC", "CHECKDATASIG Schnorr w/ STRICTENC",
SCRIPT_ENABLE_CHECKDATASIG | SCRIPT_VERIFY_STRICTENC) SCRIPT_ENABLE_CHECKDATASIG | SCRIPT_VERIFY_STRICTENC)
.PushDataSigSchnorr(keys.key0, {}) .PushDataSigSchnorr(keys.key0, {})
.ScriptError(SCRIPT_ERR_SIG_DER)); .ScriptError(SCRIPT_ERR_SIG_DER));
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0) TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
<< OP_CHECKDATASIG, << OP_CHECKDATASIG,
"CHECKDATASIG ECDSA w/ STRICTENC", "CHECKDATASIG ECDSA w/ STRICTENC",
SCRIPT_ENABLE_CHECKDATASIG | SCRIPT_VERIFY_STRICTENC) SCRIPT_ENABLE_CHECKDATASIG | SCRIPT_VERIFY_STRICTENC)
.PushDataSig(keys.key0, {})); .PushDataSigECDSA(keys.key0, {}));
tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
<< OP_CHECKDATASIG, << OP_CHECKDATASIG,
"CHECKDATASIG Schnorr w/ STRICTENC,SCHNORR", "CHECKDATASIG Schnorr w/ STRICTENC,SCHNORR",
SCRIPT_ENABLE_CHECKDATASIG | SCRIPT_ENABLE_CHECKDATASIG |
SCRIPT_ENABLE_SCHNORR | SCRIPT_ENABLE_SCHNORR |
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushDataSigSchnorr(keys.key0, {})); .PushDataSigSchnorr(keys.key0, {}));
tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
<< OP_CHECKDATASIG, << OP_CHECKDATASIG,
"CHECKDATASIG ECDSA w/ STRICTENC,SCHNORR", "CHECKDATASIG ECDSA w/ STRICTENC,SCHNORR",
SCRIPT_ENABLE_CHECKDATASIG | SCRIPT_ENABLE_CHECKDATASIG |
SCRIPT_ENABLE_SCHNORR | SCRIPT_ENABLE_SCHNORR |
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushDataSig(keys.key0, {})); .PushDataSigECDSA(keys.key0, {}));
tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey1) tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey1)
<< OP_CHECKDATASIG, << OP_CHECKDATASIG,
"CHECKDATASIG Schnorr other key", "CHECKDATASIG Schnorr other key",
SCRIPT_ENABLE_CHECKDATASIG | SCRIPT_ENABLE_CHECKDATASIG |
SCRIPT_ENABLE_SCHNORR | SCRIPT_ENABLE_SCHNORR |
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushDataSigSchnorr(keys.key1, {})); .PushDataSigSchnorr(keys.key1, {}));
tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
Show All 26 Lines tests.push_back(
SCRIPT_ENABLE_CHECKDATASIG) SCRIPT_ENABLE_CHECKDATASIG)
.PushDataSigSchnorr(keys.key0, {}) .PushDataSigSchnorr(keys.key0, {})
.ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY)); .ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY));
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0) TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
<< OP_CHECKDATASIGVERIFY << OP_1, << OP_CHECKDATASIGVERIFY << OP_1,
"CHECKDATASIGVERIFY ECDSA w/ neither STRICTENC,SCHNORR", "CHECKDATASIGVERIFY ECDSA w/ neither STRICTENC,SCHNORR",
SCRIPT_ENABLE_CHECKDATASIG) SCRIPT_ENABLE_CHECKDATASIG)
.PushDataSig(keys.key0, {})); .PushDataSigECDSA(keys.key0, {}));
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0) TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
<< OP_CHECKDATASIGVERIFY << OP_1, << OP_CHECKDATASIGVERIFY << OP_1,
"CHECKDATASIGVERIFY Schnorr w/ SCHNORR", "CHECKDATASIGVERIFY Schnorr w/ SCHNORR",
SCRIPT_ENABLE_CHECKDATASIG | SCRIPT_ENABLE_SCHNORR) SCRIPT_ENABLE_CHECKDATASIG | SCRIPT_ENABLE_SCHNORR)
.PushDataSigSchnorr(keys.key0, {})); .PushDataSigSchnorr(keys.key0, {}));
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0) TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
<< OP_CHECKDATASIGVERIFY << OP_1, << OP_CHECKDATASIGVERIFY << OP_1,
"CHECKDATASIGVERIFY ECDSA w/ SCHNORR", "CHECKDATASIGVERIFY ECDSA w/ SCHNORR",
SCRIPT_ENABLE_CHECKDATASIG | SCRIPT_ENABLE_SCHNORR) SCRIPT_ENABLE_CHECKDATASIG | SCRIPT_ENABLE_SCHNORR)
.PushDataSig(keys.key0, {})); .PushDataSigECDSA(keys.key0, {}));
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0) TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
<< OP_CHECKDATASIGVERIFY << OP_1, << OP_CHECKDATASIGVERIFY << OP_1,
"CHECKDATASIGVERIFY Schnorr w/ STRICTENC", "CHECKDATASIGVERIFY Schnorr w/ STRICTENC",
SCRIPT_ENABLE_CHECKDATASIG | SCRIPT_VERIFY_STRICTENC) SCRIPT_ENABLE_CHECKDATASIG | SCRIPT_VERIFY_STRICTENC)
.PushDataSigSchnorr(keys.key0, {}) .PushDataSigSchnorr(keys.key0, {})
.ScriptError(SCRIPT_ERR_SIG_DER)); .ScriptError(SCRIPT_ERR_SIG_DER));
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0) TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
<< OP_CHECKDATASIGVERIFY << OP_1, << OP_CHECKDATASIGVERIFY << OP_1,
"CHECKDATASIGVERIFY ECDSA w/ STRICTENC", "CHECKDATASIGVERIFY ECDSA w/ STRICTENC",
SCRIPT_ENABLE_CHECKDATASIG | SCRIPT_VERIFY_STRICTENC) SCRIPT_ENABLE_CHECKDATASIG | SCRIPT_VERIFY_STRICTENC)
.PushDataSig(keys.key0, {})); .PushDataSigECDSA(keys.key0, {}));
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0) TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
<< OP_CHECKDATASIGVERIFY << OP_1, << OP_CHECKDATASIGVERIFY << OP_1,
"CHECKDATASIGVERIFY Schnorr w/ STRICTENC,SCHNORR", "CHECKDATASIGVERIFY Schnorr w/ STRICTENC,SCHNORR",
SCRIPT_ENABLE_CHECKDATASIG | SCRIPT_ENABLE_SCHNORR | SCRIPT_ENABLE_CHECKDATASIG | SCRIPT_ENABLE_SCHNORR |
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushDataSigSchnorr(keys.key0, {})); .PushDataSigSchnorr(keys.key0, {}));
tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
<< OP_CHECKDATASIGVERIFY << OP_1, << OP_CHECKDATASIGVERIFY << OP_1,
"CHECKDATASIGVERIFY ECDSA w/ STRICTENC,SCHNORR", "CHECKDATASIGVERIFY ECDSA w/ STRICTENC,SCHNORR",
SCRIPT_ENABLE_CHECKDATASIG | SCRIPT_ENABLE_CHECKDATASIG |
SCRIPT_ENABLE_SCHNORR | SCRIPT_ENABLE_SCHNORR |
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushDataSig(keys.key0, {})); .PushDataSigECDSA(keys.key0, {}));
tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey1) tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey1)
<< OP_CHECKDATASIGVERIFY << OP_1, << OP_CHECKDATASIGVERIFY << OP_1,
"CHECKDATASIGVERIFY Schnorr other key", "CHECKDATASIGVERIFY Schnorr other key",
SCRIPT_ENABLE_CHECKDATASIG | SCRIPT_ENABLE_CHECKDATASIG |
SCRIPT_ENABLE_SCHNORR | SCRIPT_ENABLE_SCHNORR |
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.PushDataSigSchnorr(keys.key1, {})); .PushDataSigSchnorr(keys.key1, {}));
tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
Show All 28 Lines tests.push_back(
.Num(0) .Num(0)
.PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key0)
.ScriptError(SCRIPT_ERR_EVAL_FALSE)); .ScriptError(SCRIPT_ERR_EVAL_FALSE));
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1 TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"CHECKMULTISIG ECDSA w/ neither STRICTENC,SCHNORR", 0) "CHECKMULTISIG ECDSA w/ neither STRICTENC,SCHNORR", 0)
.Num(0) .Num(0)
.PushSig(keys.key0)); .PushSigECDSA(keys.key0));
tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0)
<< OP_1 << OP_CHECKMULTISIG, << OP_1 << OP_CHECKMULTISIG,
"CHECKMULTISIG Schnorr w/ SCHNORR", "CHECKMULTISIG Schnorr w/ SCHNORR",
SCRIPT_ENABLE_SCHNORR) SCRIPT_ENABLE_SCHNORR)
.Num(0) .Num(0)
.PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key0)
.ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); .ScriptError(SCRIPT_ERR_SIG_BADLENGTH));
tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0)
<< OP_1 << OP_CHECKMULTISIG, << OP_1 << OP_CHECKMULTISIG,
"CHECKMULTISIG ECDSA w/ SCHNORR", "CHECKMULTISIG ECDSA w/ SCHNORR",
SCRIPT_ENABLE_SCHNORR) SCRIPT_ENABLE_SCHNORR)
.Num(0) .Num(0)
.PushSig(keys.key0)); .PushSigECDSA(keys.key0));
tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0)
<< OP_1 << OP_CHECKMULTISIG, << OP_1 << OP_CHECKMULTISIG,
"CHECKMULTISIG Schnorr w/ STRICTENC", "CHECKMULTISIG Schnorr w/ STRICTENC",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.Num(0) .Num(0)
.PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key0)
.ScriptError(SCRIPT_ERR_SIG_DER)); .ScriptError(SCRIPT_ERR_SIG_DER));
tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0)
<< OP_1 << OP_CHECKMULTISIG, << OP_1 << OP_CHECKMULTISIG,
"CHECKMULTISIG ECDSA w/ STRICTENC", "CHECKMULTISIG ECDSA w/ STRICTENC",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.Num(0) .Num(0)
.PushSig(keys.key0)); .PushSigECDSA(keys.key0));
tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0)
<< OP_1 << OP_CHECKMULTISIG, << OP_1 << OP_CHECKMULTISIG,
"CHECKMULTISIG Schnorr w/ STRICTENC,SCHNORR", "CHECKMULTISIG Schnorr w/ STRICTENC,SCHNORR",
SCRIPT_ENABLE_SCHNORR | SCRIPT_VERIFY_STRICTENC) SCRIPT_ENABLE_SCHNORR | SCRIPT_VERIFY_STRICTENC)
.Num(0) .Num(0)
.PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key0)
.ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); .ScriptError(SCRIPT_ERR_SIG_BADLENGTH));
tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0)
<< OP_1 << OP_CHECKMULTISIG, << OP_1 << OP_CHECKMULTISIG,
"CHECKMULTISIG ECDSA w/ STRICTENC,SCHNORR", "CHECKMULTISIG ECDSA w/ STRICTENC,SCHNORR",
SCRIPT_ENABLE_SCHNORR | SCRIPT_VERIFY_STRICTENC) SCRIPT_ENABLE_SCHNORR | SCRIPT_VERIFY_STRICTENC)
.Num(0) .Num(0)
.PushSig(keys.key0)); .PushSigECDSA(keys.key0));
// Test multisig with multiple Schnorr signatures // Test multisig with multiple Schnorr signatures
tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
<< ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_3 << ToByteVector(keys.pubkey2C) << OP_3
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"Schnorr 3-of-3 without SCHNORR flag", 0) "Schnorr 3-of-3 without SCHNORR flag", 0)
.Num(0) .Num(0)
Show All 16 Lines
tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
<< ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C)
<< ToByteVector(keys.pubkey2C) << OP_3 << ToByteVector(keys.pubkey2C) << OP_3
<< OP_CHECKMULTISIG, << OP_CHECKMULTISIG,
"Schnorr-ECDSA-mixed 3-of-3 with SCHNORR flag", "Schnorr-ECDSA-mixed 3-of-3 with SCHNORR flag",
SCRIPT_ENABLE_SCHNORR) SCRIPT_ENABLE_SCHNORR)
.Num(0) .Num(0)
.PushSig(keys.key0) .PushSigECDSA(keys.key0)
.PushSig(keys.key1) .PushSigECDSA(keys.key1)
.PushSigSchnorr(keys.key2) .PushSigSchnorr(keys.key2)
.ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); .ScriptError(SCRIPT_ERR_SIG_BADLENGTH));
// CHECKMULTISIGVERIFY 1-of-1 // CHECKMULTISIGVERIFY 1-of-1
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1 TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1
<< OP_CHECKMULTISIGVERIFY << OP_1, << OP_CHECKMULTISIGVERIFY << OP_1,
"CHECKMULTISIGVERIFY Schnorr w/ neither STRICTENC,SCHNORR", "CHECKMULTISIGVERIFY Schnorr w/ neither STRICTENC,SCHNORR",
0) 0)
.Num(0) .Num(0)
.PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key0)
.ScriptError(SCRIPT_ERR_CHECKMULTISIGVERIFY)); .ScriptError(SCRIPT_ERR_CHECKMULTISIGVERIFY));
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1 TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1
<< OP_CHECKMULTISIGVERIFY << OP_1, << OP_CHECKMULTISIGVERIFY << OP_1,
"CHECKMULTISIGVERIFY ECDSA w/ neither STRICTENC,SCHNORR", 0) "CHECKMULTISIGVERIFY ECDSA w/ neither STRICTENC,SCHNORR", 0)
.Num(0) .Num(0)
.PushSig(keys.key0)); .PushSigECDSA(keys.key0));
tests.push_back(TestBuilder(CScript() tests.push_back(TestBuilder(CScript()
<< OP_1 << ToByteVector(keys.pubkey0) << OP_1 << ToByteVector(keys.pubkey0)
<< OP_1 << OP_CHECKMULTISIGVERIFY << OP_1, << OP_1 << OP_CHECKMULTISIGVERIFY << OP_1,
"CHECKMULTISIGVERIFY Schnorr w/ SCHNORR", "CHECKMULTISIGVERIFY Schnorr w/ SCHNORR",
SCRIPT_ENABLE_SCHNORR) SCRIPT_ENABLE_SCHNORR)
.Num(0) .Num(0)
.PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key0)
.ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); .ScriptError(SCRIPT_ERR_SIG_BADLENGTH));
tests.push_back(TestBuilder(CScript() tests.push_back(TestBuilder(CScript()
<< OP_1 << ToByteVector(keys.pubkey0) << OP_1 << ToByteVector(keys.pubkey0)
<< OP_1 << OP_CHECKMULTISIGVERIFY << OP_1, << OP_1 << OP_CHECKMULTISIGVERIFY << OP_1,
"CHECKMULTISIGVERIFY ECDSA w/ SCHNORR", "CHECKMULTISIGVERIFY ECDSA w/ SCHNORR",
SCRIPT_ENABLE_SCHNORR) SCRIPT_ENABLE_SCHNORR)
.Num(0) .Num(0)
.PushSig(keys.key0)); .PushSigECDSA(keys.key0));
tests.push_back(TestBuilder(CScript() tests.push_back(TestBuilder(CScript()
<< OP_1 << ToByteVector(keys.pubkey0) << OP_1 << ToByteVector(keys.pubkey0)
<< OP_1 << OP_CHECKMULTISIGVERIFY << OP_1, << OP_1 << OP_CHECKMULTISIGVERIFY << OP_1,
"CHECKMULTISIGVERIFY Schnorr w/ STRICTENC", "CHECKMULTISIGVERIFY Schnorr w/ STRICTENC",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.Num(0) .Num(0)
.PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key0)
.ScriptError(SCRIPT_ERR_SIG_DER)); .ScriptError(SCRIPT_ERR_SIG_DER));
tests.push_back(TestBuilder(CScript() tests.push_back(TestBuilder(CScript()
<< OP_1 << ToByteVector(keys.pubkey0) << OP_1 << ToByteVector(keys.pubkey0)
<< OP_1 << OP_CHECKMULTISIGVERIFY << OP_1, << OP_1 << OP_CHECKMULTISIGVERIFY << OP_1,
"CHECKMULTISIGVERIFY ECDSA w/ STRICTENC", "CHECKMULTISIGVERIFY ECDSA w/ STRICTENC",
SCRIPT_VERIFY_STRICTENC) SCRIPT_VERIFY_STRICTENC)
.Num(0) .Num(0)
.PushSig(keys.key0)); .PushSigECDSA(keys.key0));
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1 TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1
<< OP_CHECKMULTISIGVERIFY << OP_1, << OP_CHECKMULTISIGVERIFY << OP_1,
"CHECKMULTISIGVERIFY Schnorr w/ STRICTENC,SCHNORR", "CHECKMULTISIGVERIFY Schnorr w/ STRICTENC,SCHNORR",
SCRIPT_ENABLE_SCHNORR | SCRIPT_VERIFY_STRICTENC) SCRIPT_ENABLE_SCHNORR | SCRIPT_VERIFY_STRICTENC)
.Num(0) .Num(0)
.PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key0)
.ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); .ScriptError(SCRIPT_ERR_SIG_BADLENGTH));
tests.push_back( tests.push_back(
TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1 TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1
<< OP_CHECKMULTISIGVERIFY << OP_1, << OP_CHECKMULTISIGVERIFY << OP_1,
"CHECKMULTISIGVERIFY ECDSA w/ STRICTENC,SCHNORR", "CHECKMULTISIGVERIFY ECDSA w/ STRICTENC,SCHNORR",
SCRIPT_ENABLE_SCHNORR | SCRIPT_VERIFY_STRICTENC) SCRIPT_ENABLE_SCHNORR | SCRIPT_VERIFY_STRICTENC)
.Num(0) .Num(0)
.PushSig(keys.key0)); .PushSigECDSA(keys.key0));
// Test damaged Schnorr signatures // Test damaged Schnorr signatures
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
<< OP_CHECKSIG << OP_NOT, << OP_CHECKSIG << OP_NOT,
"Schnorr P2PK, bad sig", SCRIPT_ENABLE_SCHNORR) "Schnorr P2PK, bad sig", SCRIPT_ENABLE_SCHNORR)
.PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key0)
.DamagePush(10)); .DamagePush(10));
tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
▲ Show 20 Lines • Show All 1,026 Lines • Show Last 20 Lines