diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp --- a/src/rpc/rawtransaction.cpp +++ b/src/rpc/rawtransaction.cpp @@ -996,11 +996,11 @@ UpdateTransaction(mtx, i, sigdata); - ScriptError serror = SCRIPT_ERR_OK; + ScriptError serror = ScriptError::OK; if (!VerifyScript( txin.scriptSig, prevPubKey, STANDARD_SCRIPT_VERIFY_FLAGS, TransactionSignatureChecker(&txConst, i, amount), &serror)) { - if (serror == SCRIPT_ERR_INVALID_STACK_OPERATION) { + if (serror == ScriptError::INVALID_STACK_OPERATION) { // Unable to sign input and verification failed (possible // attempt to partially sign). TxInErrorToJSON(txin, vErrors, diff --git a/src/script/interpreter.cpp b/src/script/interpreter.cpp --- a/src/script/interpreter.cpp +++ b/src/script/interpreter.cpp @@ -114,9 +114,9 @@ valtype vchPushValue; std::vector vfExec; std::vector altstack; - set_error(serror, SCRIPT_ERR_UNKNOWN_ERROR); + set_error(serror, ScriptError::UNKNOWN); if (script.size() > MAX_SCRIPT_SIZE) { - return set_error(serror, SCRIPT_ERR_SCRIPT_SIZE); + return set_error(serror, ScriptError::SCRIPT_SIZE); } int nOpCount = 0; bool fRequireMinimal = (flags & SCRIPT_VERIFY_MINIMALDATA) != 0; @@ -129,26 +129,26 @@ // Read instruction // if (!script.GetOp(pc, opcode, vchPushValue)) { - return set_error(serror, SCRIPT_ERR_BAD_OPCODE); + return set_error(serror, ScriptError::BAD_OPCODE); } if (vchPushValue.size() > MAX_SCRIPT_ELEMENT_SIZE) { - return set_error(serror, SCRIPT_ERR_PUSH_SIZE); + return set_error(serror, ScriptError::PUSH_SIZE); } // Note how OP_RESERVED does not count towards the opcode limit. if (opcode > OP_16 && ++nOpCount > MAX_OPS_PER_SCRIPT) { - return set_error(serror, SCRIPT_ERR_OP_COUNT); + return set_error(serror, ScriptError::OP_COUNT); } // Some opcodes are disabled. if (IsOpcodeDisabled(opcode, flags)) { - return set_error(serror, SCRIPT_ERR_DISABLED_OPCODE); + return set_error(serror, ScriptError::DISABLED_OPCODE); } if (fExec && 0 <= opcode && opcode <= OP_PUSHDATA4) { if (fRequireMinimal && !CheckMinimalPush(vchPushValue, opcode)) { - return set_error(serror, SCRIPT_ERR_MINIMALDATA); + return set_error(serror, ScriptError::MINIMALDATA); } stack.push_back(vchPushValue); } else if (fExec || (OP_IF <= opcode && opcode <= OP_ENDIF)) { @@ -194,14 +194,14 @@ SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS) { return set_error( serror, - SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS); + ScriptError::DISCOURAGE_UPGRADABLE_NOPS); } break; } if (stack.size() < 1) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } // Note that elsewhere numeric opcodes are limited to @@ -227,14 +227,14 @@ // 0 MAX CHECKLOCKTIMEVERIFY. if (nLockTime < 0) { return set_error(serror, - SCRIPT_ERR_NEGATIVE_LOCKTIME); + ScriptError::NEGATIVE_LOCKTIME); } // Actually compare the specified lock time with the // transaction. if (!checker.CheckLockTime(nLockTime)) { return set_error(serror, - SCRIPT_ERR_UNSATISFIED_LOCKTIME); + ScriptError::UNSATISFIED_LOCKTIME); } break; @@ -247,14 +247,14 @@ SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS) { return set_error( serror, - SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS); + ScriptError::DISCOURAGE_UPGRADABLE_NOPS); } break; } if (stack.size() < 1) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } // nSequence, like nLockTime, is a 32-bit unsigned @@ -268,7 +268,7 @@ // 0 MAX CHECKSEQUENCEVERIFY. if (nSequence < 0) { return set_error(serror, - SCRIPT_ERR_NEGATIVE_LOCKTIME); + ScriptError::NEGATIVE_LOCKTIME); } // To provide for future soft-fork extensibility, if the @@ -282,7 +282,7 @@ // Compare the specified sequence number with the input. if (!checker.CheckSequence(nSequence)) { return set_error(serror, - SCRIPT_ERR_UNSATISFIED_LOCKTIME); + ScriptError::UNSATISFIED_LOCKTIME); } break; @@ -298,7 +298,8 @@ case OP_NOP10: { if (flags & SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS) { return set_error( - serror, SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS); + serror, + ScriptError::DISCOURAGE_UPGRADABLE_NOPS); } } break; @@ -310,17 +311,18 @@ if (fExec) { if (stack.size() < 1) { return set_error( - serror, SCRIPT_ERR_UNBALANCED_CONDITIONAL); + serror, + ScriptError::UNBALANCED_CONDITIONAL); } valtype &vch = stacktop(-1); if (flags & SCRIPT_VERIFY_MINIMALIF) { if (vch.size() > 1) { return set_error(serror, - SCRIPT_ERR_MINIMALIF); + ScriptError::MINIMALIF); } if (vch.size() == 1 && vch[0] != 1) { return set_error(serror, - SCRIPT_ERR_MINIMALIF); + ScriptError::MINIMALIF); } } fValue = CastToBool(vch); @@ -334,16 +336,16 @@ case OP_ELSE: { if (vfExec.empty()) { - return set_error(serror, - SCRIPT_ERR_UNBALANCED_CONDITIONAL); + return set_error( + serror, ScriptError::UNBALANCED_CONDITIONAL); } vfExec.back() = !vfExec.back(); } break; case OP_ENDIF: { if (vfExec.empty()) { - return set_error(serror, - SCRIPT_ERR_UNBALANCED_CONDITIONAL); + return set_error( + serror, ScriptError::UNBALANCED_CONDITIONAL); } vfExec.pop_back(); } break; @@ -353,18 +355,18 @@ // (false -- false) and return if (stack.size() < 1) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } bool fValue = CastToBool(stacktop(-1)); if (fValue) { popstack(stack); } else { - return set_error(serror, SCRIPT_ERR_VERIFY); + return set_error(serror, ScriptError::VERIFY); } } break; case OP_RETURN: { - return set_error(serror, SCRIPT_ERR_OP_RETURN); + return set_error(serror, ScriptError::OP_RETURN); } break; // @@ -373,7 +375,7 @@ case OP_TOALTSTACK: { if (stack.size() < 1) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } altstack.push_back(stacktop(-1)); popstack(stack); @@ -382,7 +384,8 @@ case OP_FROMALTSTACK: { if (altstack.size() < 1) { return set_error( - serror, SCRIPT_ERR_INVALID_ALTSTACK_OPERATION); + serror, + ScriptError::INVALID_ALTSTACK_OPERATION); } stack.push_back(altstacktop(-1)); popstack(altstack); @@ -392,7 +395,7 @@ // (x1 x2 -- ) if (stack.size() < 2) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } popstack(stack); popstack(stack); @@ -402,7 +405,7 @@ // (x1 x2 -- x1 x2 x1 x2) if (stack.size() < 2) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } valtype vch1 = stacktop(-2); valtype vch2 = stacktop(-1); @@ -414,7 +417,7 @@ // (x1 x2 x3 -- x1 x2 x3 x1 x2 x3) if (stack.size() < 3) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } valtype vch1 = stacktop(-3); valtype vch2 = stacktop(-2); @@ -428,7 +431,7 @@ // (x1 x2 x3 x4 -- x1 x2 x3 x4 x1 x2) if (stack.size() < 4) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } valtype vch1 = stacktop(-4); valtype vch2 = stacktop(-3); @@ -440,7 +443,7 @@ // (x1 x2 x3 x4 x5 x6 -- x3 x4 x5 x6 x1 x2) if (stack.size() < 6) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } valtype vch1 = stacktop(-6); valtype vch2 = stacktop(-5); @@ -453,7 +456,7 @@ // (x1 x2 x3 x4 -- x3 x4 x1 x2) if (stack.size() < 4) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } swap(stacktop(-4), stacktop(-2)); swap(stacktop(-3), stacktop(-1)); @@ -463,7 +466,7 @@ // (x - 0 | x x) if (stack.size() < 1) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } valtype vch = stacktop(-1); if (CastToBool(vch)) { @@ -481,7 +484,7 @@ // (x -- ) if (stack.size() < 1) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } popstack(stack); } break; @@ -490,7 +493,7 @@ // (x -- x x) if (stack.size() < 1) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } valtype vch = stacktop(-1); stack.push_back(vch); @@ -500,7 +503,7 @@ // (x1 x2 -- x2) if (stack.size() < 2) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } stack.erase(stack.end() - 2); } break; @@ -509,7 +512,7 @@ // (x1 x2 -- x1 x2 x1) if (stack.size() < 2) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } valtype vch = stacktop(-2); stack.push_back(vch); @@ -521,14 +524,14 @@ // (xn ... x2 x1 x0 n - ... x2 x1 x0 xn) if (stack.size() < 2) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } int n = CScriptNum(stacktop(-1), fRequireMinimal).getint(); popstack(stack); if (n < 0 || n >= (int)stack.size()) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } valtype vch = stacktop(-n - 1); if (opcode == OP_ROLL) { @@ -543,7 +546,7 @@ // x2 x3 x1 after second swap if (stack.size() < 3) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } swap(stacktop(-3), stacktop(-2)); swap(stacktop(-2), stacktop(-1)); @@ -553,7 +556,7 @@ // (x1 x2 -- x2 x1) if (stack.size() < 2) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } swap(stacktop(-2), stacktop(-1)); } break; @@ -562,7 +565,7 @@ // (x1 x2 -- x2 x1 x2) if (stack.size() < 2) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } valtype vch = stacktop(-1); stack.insert(stack.end() - 2, vch); @@ -572,7 +575,7 @@ // (in -- in size) if (stack.size() < 1) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } CScriptNum bn(stacktop(-1).size()); stack.push_back(bn.getvch()); @@ -587,7 +590,7 @@ // (x1 x2 - out) if (stack.size() < 2) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } valtype &vch1 = stacktop(-2); valtype &vch2 = stacktop(-1); @@ -595,7 +598,7 @@ // Inputs must be the same size if (vch1.size() != vch2.size()) { return set_error(serror, - SCRIPT_ERR_INVALID_OPERAND_SIZE); + ScriptError::INVALID_OPERAND_SIZE); } // To avoid allocating, we modify vch1 in place. @@ -630,7 +633,8 @@ // (x1 x2 - bool) if (stack.size() < 2) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, + ScriptError::INVALID_STACK_OPERATION); } valtype &vch1 = stacktop(-2); valtype &vch2 = stacktop(-1); @@ -650,7 +654,7 @@ popstack(stack); } else { return set_error(serror, - SCRIPT_ERR_EQUALVERIFY); + ScriptError::EQUALVERIFY); } } } @@ -668,7 +672,7 @@ // (in -- out) if (stack.size() < 1) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } CScriptNum bn(stacktop(-1), fRequireMinimal); switch (opcode) { @@ -718,7 +722,7 @@ // (x1 x2 -- out) if (stack.size() < 2) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } CScriptNum bn1(stacktop(-2), fRequireMinimal); CScriptNum bn2(stacktop(-1), fRequireMinimal); @@ -736,7 +740,7 @@ // denominator must not be 0 if (bn2 == 0) { return set_error(serror, - SCRIPT_ERR_DIV_BY_ZERO); + ScriptError::DIV_BY_ZERO); } bn = bn1 / bn2; break; @@ -745,7 +749,7 @@ // divisor must not be 0 if (bn2 == 0) { return set_error(serror, - SCRIPT_ERR_MOD_BY_ZERO); + ScriptError::MOD_BY_ZERO); } bn = bn1 % bn2; break; @@ -796,7 +800,7 @@ popstack(stack); } else { return set_error(serror, - SCRIPT_ERR_NUMEQUALVERIFY); + ScriptError::NUMEQUALVERIFY); } } } break; @@ -805,7 +809,7 @@ // (x min max -- out) if (stack.size() < 3) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } CScriptNum bn1(stacktop(-3), fRequireMinimal); CScriptNum bn2(stacktop(-2), fRequireMinimal); @@ -828,7 +832,7 @@ // (in -- hash) if (stack.size() < 1) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } valtype &vch = stacktop(-1); valtype vchHash((opcode == OP_RIPEMD160 || @@ -871,7 +875,7 @@ // (sig pubkey -- bool) if (stack.size() < 2) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } valtype &vchSig = stacktop(-2); valtype &vchPubKey = stacktop(-1); @@ -895,7 +899,7 @@ if (!fSuccess && (flags & SCRIPT_VERIFY_NULLFAIL) && vchSig.size()) { - return set_error(serror, SCRIPT_ERR_SIG_NULLFAIL); + return set_error(serror, ScriptError::SIG_NULLFAIL); } popstack(stack); @@ -906,7 +910,7 @@ popstack(stack); } else { return set_error(serror, - SCRIPT_ERR_CHECKSIGVERIFY); + ScriptError::CHECKSIGVERIFY); } } } break; @@ -916,7 +920,7 @@ // (sig message pubkey -- bool) if (stack.size() < 3) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } valtype &vchSig = stacktop(-3); @@ -942,7 +946,7 @@ if (!fSuccess && (flags & SCRIPT_VERIFY_NULLFAIL) && vchSig.size()) { - return set_error(serror, SCRIPT_ERR_SIG_NULLFAIL); + return set_error(serror, ScriptError::SIG_NULLFAIL); } popstack(stack); @@ -953,8 +957,8 @@ if (fSuccess) { popstack(stack); } else { - return set_error(serror, - SCRIPT_ERR_CHECKDATASIGVERIFY); + return set_error( + serror, ScriptError::CHECKDATASIGVERIFY); } } } break; @@ -966,18 +970,18 @@ const size_t idxKeyCount = 1; if (stack.size() < idxKeyCount) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } const int nKeysCount = CScriptNum(stacktop(-idxKeyCount), fRequireMinimal) .getint(); if (nKeysCount < 0 || nKeysCount > MAX_PUBKEYS_PER_MULTISIG) { - return set_error(serror, SCRIPT_ERR_PUBKEY_COUNT); + return set_error(serror, ScriptError::PUBKEY_COUNT); } nOpCount += nKeysCount; if (nOpCount > MAX_OPS_PER_SCRIPT) { - return set_error(serror, SCRIPT_ERR_OP_COUNT); + return set_error(serror, ScriptError::OP_COUNT); } // stack depth of the top pubkey @@ -987,13 +991,13 @@ const size_t idxSigCount = idxTopKey + nKeysCount; if (stack.size() < idxSigCount) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } const int nSigsCount = CScriptNum(stacktop(-idxSigCount), fRequireMinimal) .getint(); if (nSigsCount < 0 || nSigsCount > nKeysCount) { - return set_error(serror, SCRIPT_ERR_SIG_COUNT); + return set_error(serror, ScriptError::SIG_COUNT); } // stack depth of the top signature @@ -1003,7 +1007,7 @@ const size_t idxDummy = idxTopSig + nSigsCount; if (stack.size() < idxDummy) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } // A bug causes CHECKMULTISIG to consume one extra @@ -1014,7 +1018,8 @@ // to zero. if ((flags & SCRIPT_VERIFY_NULLDUMMY) && stacktop(-idxDummy).size()) { - return set_error(serror, SCRIPT_ERR_SIG_NULLDUMMY); + return set_error(serror, + ScriptError::SIG_NULLDUMMY); } // Subset of script starting at the most recent @@ -1071,7 +1076,7 @@ for (int i = 0; i < nSigsCount; i++) { if (stacktop(-idxTopSig - i).size()) { return set_error(serror, - SCRIPT_ERR_SIG_NULLFAIL); + ScriptError::SIG_NULLFAIL); } } } @@ -1087,7 +1092,7 @@ popstack(stack); } else { return set_error( - serror, SCRIPT_ERR_CHECKMULTISIGVERIFY); + serror, ScriptError::CHECKMULTISIGVERIFY); } } } break; @@ -1099,13 +1104,13 @@ // (x1 x2 -- out) if (stack.size() < 2) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } valtype &vch1 = stacktop(-2); valtype &vch2 = stacktop(-1); if (vch1.size() + vch2.size() > MAX_SCRIPT_ELEMENT_SIZE) { - return set_error(serror, SCRIPT_ERR_PUSH_SIZE); + return set_error(serror, ScriptError::PUSH_SIZE); } vch1.insert(vch1.end(), vch2.begin(), vch2.end()); popstack(stack); @@ -1115,7 +1120,7 @@ // (in position -- x1 x2) if (stack.size() < 2) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } const valtype &data = stacktop(-2); @@ -1125,7 +1130,7 @@ CScriptNum(stacktop(-1), fRequireMinimal).getint(); if (position > data.size()) { return set_error(serror, - SCRIPT_ERR_INVALID_SPLIT_RANGE); + ScriptError::INVALID_SPLIT_RANGE); } // Prepare the results in their own buffer as `data` @@ -1145,13 +1150,13 @@ // (in size -- out) if (stack.size() < 2) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } uint64_t size = CScriptNum(stacktop(-1), fRequireMinimal).getint(); if (size > MAX_SCRIPT_ELEMENT_SIZE) { - return set_error(serror, SCRIPT_ERR_PUSH_SIZE); + return set_error(serror, ScriptError::PUSH_SIZE); } popstack(stack); @@ -1163,7 +1168,7 @@ if (rawnum.size() > size) { // We definitively cannot. return set_error(serror, - SCRIPT_ERR_IMPOSSIBLE_ENCODING); + ScriptError::IMPOSSIBLE_ENCODING); } // We already have an element of the right size, we @@ -1190,7 +1195,7 @@ // (in -- out) if (stack.size() < 1) { return set_error( - serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + serror, ScriptError::INVALID_STACK_OPERATION); } valtype &n = stacktop(-1); @@ -1199,26 +1204,26 @@ // The resulting number must be a valid number. if (!CScriptNum::IsMinimallyEncoded(n)) { return set_error(serror, - SCRIPT_ERR_INVALID_NUMBER_RANGE); + ScriptError::INVALID_NUMBER_RANGE); } } break; default: - return set_error(serror, SCRIPT_ERR_BAD_OPCODE); + return set_error(serror, ScriptError::BAD_OPCODE); } } // Size limits if (stack.size() + altstack.size() > MAX_STACK_SIZE) { - return set_error(serror, SCRIPT_ERR_STACK_SIZE); + return set_error(serror, ScriptError::STACK_SIZE); } } } catch (...) { - return set_error(serror, SCRIPT_ERR_UNKNOWN_ERROR); + return set_error(serror, ScriptError::UNKNOWN); } if (!vfExec.empty()) { - return set_error(serror, SCRIPT_ERR_UNBALANCED_CONDITIONAL); + return set_error(serror, ScriptError::UNBALANCED_CONDITIONAL); } return set_success(serror); @@ -1583,7 +1588,7 @@ bool VerifyScript(const CScript &scriptSig, const CScript &scriptPubKey, uint32_t flags, const BaseSignatureChecker &checker, ScriptError *serror) { - set_error(serror, SCRIPT_ERR_UNKNOWN_ERROR); + set_error(serror, ScriptError::UNKNOWN); // If FORKID is enabled, we also ensure strict encoding. if (flags & SCRIPT_ENABLE_SIGHASH_FORKID) { @@ -1591,7 +1596,7 @@ } if ((flags & SCRIPT_VERIFY_SIGPUSHONLY) != 0 && !scriptSig.IsPushOnly()) { - return set_error(serror, SCRIPT_ERR_SIG_PUSHONLY); + return set_error(serror, ScriptError::SIG_PUSHONLY); } std::vector stack, stackCopy; @@ -1607,17 +1612,17 @@ return false; } if (stack.empty()) { - return set_error(serror, SCRIPT_ERR_EVAL_FALSE); + return set_error(serror, ScriptError::EVAL_FALSE); } if (CastToBool(stack.back()) == false) { - return set_error(serror, SCRIPT_ERR_EVAL_FALSE); + return set_error(serror, ScriptError::EVAL_FALSE); } // Additional validation for spend-to-script-hash transactions: if ((flags & SCRIPT_VERIFY_P2SH) && scriptPubKey.IsPayToScriptHash()) { // scriptSig must be literals-only or validation fails if (!scriptSig.IsPushOnly()) { - return set_error(serror, SCRIPT_ERR_SIG_PUSHONLY); + return set_error(serror, ScriptError::SIG_PUSHONLY); } // Restore stack. @@ -1645,10 +1650,10 @@ return false; } if (stack.empty()) { - return set_error(serror, SCRIPT_ERR_EVAL_FALSE); + return set_error(serror, ScriptError::EVAL_FALSE); } if (!CastToBool(stack.back())) { - return set_error(serror, SCRIPT_ERR_EVAL_FALSE); + return set_error(serror, ScriptError::EVAL_FALSE); } } @@ -1662,7 +1667,7 @@ // softfork (and P2SH should be one). assert((flags & SCRIPT_VERIFY_P2SH) != 0); if (stack.size() != 1) { - return set_error(serror, SCRIPT_ERR_CLEANSTACK); + return set_error(serror, ScriptError::CLEANSTACK); } } diff --git a/src/script/script_error.h b/src/script/script_error.h --- a/src/script/script_error.h +++ b/src/script/script_error.h @@ -6,79 +6,79 @@ #ifndef BITCOIN_SCRIPT_SCRIPT_ERROR_H #define BITCOIN_SCRIPT_SCRIPT_ERROR_H -typedef enum ScriptError_t { - SCRIPT_ERR_OK = 0, - SCRIPT_ERR_UNKNOWN_ERROR, - SCRIPT_ERR_EVAL_FALSE, - SCRIPT_ERR_OP_RETURN, +enum class ScriptError { + OK = 0, + UNKNOWN, + EVAL_FALSE, + OP_RETURN, /* Max sizes */ - SCRIPT_ERR_SCRIPT_SIZE, - SCRIPT_ERR_PUSH_SIZE, - SCRIPT_ERR_OP_COUNT, - SCRIPT_ERR_STACK_SIZE, - SCRIPT_ERR_SIG_COUNT, - SCRIPT_ERR_PUBKEY_COUNT, + SCRIPT_SIZE, + PUSH_SIZE, + OP_COUNT, + STACK_SIZE, + SIG_COUNT, + PUBKEY_COUNT, /* Operands checks */ - SCRIPT_ERR_INVALID_OPERAND_SIZE, - SCRIPT_ERR_INVALID_NUMBER_RANGE, - SCRIPT_ERR_IMPOSSIBLE_ENCODING, - SCRIPT_ERR_INVALID_SPLIT_RANGE, + INVALID_OPERAND_SIZE, + INVALID_NUMBER_RANGE, + IMPOSSIBLE_ENCODING, + INVALID_SPLIT_RANGE, /* Failed verify operations */ - SCRIPT_ERR_VERIFY, - SCRIPT_ERR_EQUALVERIFY, - SCRIPT_ERR_CHECKMULTISIGVERIFY, - SCRIPT_ERR_CHECKSIGVERIFY, - SCRIPT_ERR_CHECKDATASIGVERIFY, - SCRIPT_ERR_NUMEQUALVERIFY, + VERIFY, + EQUALVERIFY, + CHECKMULTISIGVERIFY, + CHECKSIGVERIFY, + CHECKDATASIGVERIFY, + NUMEQUALVERIFY, /* Logical/Format/Canonical errors */ - SCRIPT_ERR_BAD_OPCODE, - SCRIPT_ERR_DISABLED_OPCODE, - SCRIPT_ERR_INVALID_STACK_OPERATION, - SCRIPT_ERR_INVALID_ALTSTACK_OPERATION, - SCRIPT_ERR_UNBALANCED_CONDITIONAL, + BAD_OPCODE, + DISABLED_OPCODE, + INVALID_STACK_OPERATION, + INVALID_ALTSTACK_OPERATION, + UNBALANCED_CONDITIONAL, /* Divisor errors */ - SCRIPT_ERR_DIV_BY_ZERO, - SCRIPT_ERR_MOD_BY_ZERO, + DIV_BY_ZERO, + MOD_BY_ZERO, /* CHECKLOCKTIMEVERIFY and CHECKSEQUENCEVERIFY */ - SCRIPT_ERR_NEGATIVE_LOCKTIME, - SCRIPT_ERR_UNSATISFIED_LOCKTIME, + NEGATIVE_LOCKTIME, + UNSATISFIED_LOCKTIME, /* Malleability */ - SCRIPT_ERR_SIG_HASHTYPE, - SCRIPT_ERR_SIG_DER, - SCRIPT_ERR_MINIMALDATA, - SCRIPT_ERR_SIG_PUSHONLY, - SCRIPT_ERR_SIG_HIGH_S, - SCRIPT_ERR_SIG_NULLDUMMY, - SCRIPT_ERR_PUBKEYTYPE, - SCRIPT_ERR_CLEANSTACK, - SCRIPT_ERR_MINIMALIF, - SCRIPT_ERR_SIG_NULLFAIL, + SIG_HASHTYPE, + SIG_DER, + MINIMALDATA, + SIG_PUSHONLY, + SIG_HIGH_S, + SIG_NULLDUMMY, + PUBKEYTYPE, + CLEANSTACK, + MINIMALIF, + SIG_NULLFAIL, /* Schnorr */ - SCRIPT_ERR_SIG_BADLENGTH, - SCRIPT_ERR_SIG_NONSCHNORR, + SIG_BADLENGTH, + SIG_NONSCHNORR, /* softfork safeness */ - SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS, + DISCOURAGE_UPGRADABLE_NOPS, /* misc */ - SCRIPT_ERR_NONCOMPRESSED_PUBKEY, + NONCOMPRESSED_PUBKEY, /* anti replay */ - SCRIPT_ERR_ILLEGAL_FORKID, - SCRIPT_ERR_MUST_USE_FORKID, + ILLEGAL_FORKID, + MUST_USE_FORKID, - SCRIPT_ERR_ERROR_COUNT -} ScriptError; + ERROR_COUNT, +}; -#define SCRIPT_ERR_LAST SCRIPT_ERR_ERROR_COUNT +#define SCRIPT_ERR_LAST ScriptError::ERROR_COUNT const char *ScriptErrorString(const ScriptError error); @@ -86,7 +86,7 @@ inline bool set_success(ScriptError *ret) { if (ret) { - *ret = SCRIPT_ERR_OK; + *ret = ScriptError::OK; } return true; } diff --git a/src/script/script_error.cpp b/src/script/script_error.cpp --- a/src/script/script_error.cpp +++ b/src/script/script_error.cpp @@ -7,99 +7,99 @@ const char *ScriptErrorString(const ScriptError serror) { switch (serror) { - case SCRIPT_ERR_OK: + case ScriptError::OK: return "No error"; - case SCRIPT_ERR_EVAL_FALSE: + case ScriptError::EVAL_FALSE: return "Script evaluated without error but finished with a " "false/empty top stack element"; - case SCRIPT_ERR_VERIFY: + case ScriptError::VERIFY: return "Script failed an OP_VERIFY operation"; - case SCRIPT_ERR_EQUALVERIFY: + case ScriptError::EQUALVERIFY: return "Script failed an OP_EQUALVERIFY operation"; - case SCRIPT_ERR_CHECKMULTISIGVERIFY: + case ScriptError::CHECKMULTISIGVERIFY: return "Script failed an OP_CHECKMULTISIGVERIFY operation"; - case SCRIPT_ERR_CHECKSIGVERIFY: + case ScriptError::CHECKSIGVERIFY: return "Script failed an OP_CHECKSIGVERIFY operation"; - case SCRIPT_ERR_CHECKDATASIGVERIFY: + case ScriptError::CHECKDATASIGVERIFY: return "Script failed an OP_CHECKDATASIGVERIFY operation"; - case SCRIPT_ERR_NUMEQUALVERIFY: + case ScriptError::NUMEQUALVERIFY: return "Script failed an OP_NUMEQUALVERIFY operation"; - case SCRIPT_ERR_SCRIPT_SIZE: + case ScriptError::SCRIPT_SIZE: return "Script is too big"; - case SCRIPT_ERR_PUSH_SIZE: + case ScriptError::PUSH_SIZE: return "Push value size limit exceeded"; - case SCRIPT_ERR_OP_COUNT: + case ScriptError::OP_COUNT: return "Operation limit exceeded"; - case SCRIPT_ERR_STACK_SIZE: + case ScriptError::STACK_SIZE: return "Stack size limit exceeded"; - case SCRIPT_ERR_SIG_COUNT: + case ScriptError::SIG_COUNT: return "Signature count negative or greater than pubkey count"; - case SCRIPT_ERR_PUBKEY_COUNT: + case ScriptError::PUBKEY_COUNT: return "Pubkey count negative or limit exceeded"; - case SCRIPT_ERR_INVALID_OPERAND_SIZE: + case ScriptError::INVALID_OPERAND_SIZE: return "Invalid operand size"; - case SCRIPT_ERR_INVALID_NUMBER_RANGE: + case ScriptError::INVALID_NUMBER_RANGE: return "Given operand is not a number within the valid range " "[-2^31...2^31]"; - case SCRIPT_ERR_IMPOSSIBLE_ENCODING: + case ScriptError::IMPOSSIBLE_ENCODING: return "The requested encoding is impossible to satisfy"; - case SCRIPT_ERR_INVALID_SPLIT_RANGE: + case ScriptError::INVALID_SPLIT_RANGE: return "Invalid OP_SPLIT range"; - case SCRIPT_ERR_BAD_OPCODE: + case ScriptError::BAD_OPCODE: return "Opcode missing or not understood"; - case SCRIPT_ERR_DISABLED_OPCODE: + case ScriptError::DISABLED_OPCODE: return "Attempted to use a disabled opcode"; - case SCRIPT_ERR_INVALID_STACK_OPERATION: + case ScriptError::INVALID_STACK_OPERATION: return "Operation not valid with the current stack size"; - case SCRIPT_ERR_INVALID_ALTSTACK_OPERATION: + case ScriptError::INVALID_ALTSTACK_OPERATION: return "Operation not valid with the current altstack size"; - case SCRIPT_ERR_OP_RETURN: + case ScriptError::OP_RETURN: return "OP_RETURN was encountered"; - case SCRIPT_ERR_UNBALANCED_CONDITIONAL: + case ScriptError::UNBALANCED_CONDITIONAL: return "Invalid OP_IF construction"; - case SCRIPT_ERR_DIV_BY_ZERO: + case ScriptError::DIV_BY_ZERO: return "Division by zero error"; - case SCRIPT_ERR_MOD_BY_ZERO: + case ScriptError::MOD_BY_ZERO: return "Modulo by zero error"; - case SCRIPT_ERR_NEGATIVE_LOCKTIME: + case ScriptError::NEGATIVE_LOCKTIME: return "Negative locktime"; - case SCRIPT_ERR_UNSATISFIED_LOCKTIME: + case ScriptError::UNSATISFIED_LOCKTIME: return "Locktime requirement not satisfied"; - case SCRIPT_ERR_SIG_HASHTYPE: + case ScriptError::SIG_HASHTYPE: return "Signature hash type missing or not understood"; - case SCRIPT_ERR_SIG_DER: + case ScriptError::SIG_DER: return "Non-canonical DER signature"; - case SCRIPT_ERR_MINIMALDATA: + case ScriptError::MINIMALDATA: return "Data push larger than necessary"; - case SCRIPT_ERR_SIG_PUSHONLY: + case ScriptError::SIG_PUSHONLY: return "Only push operators allowed in signature scripts"; - case SCRIPT_ERR_SIG_HIGH_S: + case ScriptError::SIG_HIGH_S: return "Non-canonical signature: S value is unnecessarily high"; - case SCRIPT_ERR_SIG_NULLDUMMY: + case ScriptError::SIG_NULLDUMMY: return "Dummy CHECKMULTISIG argument must be zero"; - case SCRIPT_ERR_MINIMALIF: + case ScriptError::MINIMALIF: return "OP_IF/NOTIF argument must be minimal"; - case SCRIPT_ERR_SIG_NULLFAIL: + case ScriptError::SIG_NULLFAIL: return "Signature must be zero for failed CHECK(MULTI)SIG " "operation"; - case SCRIPT_ERR_SIG_BADLENGTH: + case ScriptError::SIG_BADLENGTH: return "Signature cannot be 65 bytes in CHECKMULTISIG"; - case SCRIPT_ERR_SIG_NONSCHNORR: + case ScriptError::SIG_NONSCHNORR: return "Only Schnorr signatures allowed in this operation"; - case SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS: + case ScriptError::DISCOURAGE_UPGRADABLE_NOPS: return "NOPx reserved for soft-fork upgrades"; - case SCRIPT_ERR_PUBKEYTYPE: + case ScriptError::PUBKEYTYPE: return "Public key is neither compressed or uncompressed"; - case SCRIPT_ERR_CLEANSTACK: + case ScriptError::CLEANSTACK: return "Script did not clean its stack"; - case SCRIPT_ERR_NONCOMPRESSED_PUBKEY: + case ScriptError::NONCOMPRESSED_PUBKEY: return "Using non-compressed public key"; - case SCRIPT_ERR_ILLEGAL_FORKID: + case ScriptError::ILLEGAL_FORKID: return "Illegal use of SIGHASH_FORKID"; - case SCRIPT_ERR_MUST_USE_FORKID: + case ScriptError::MUST_USE_FORKID: return "Signature must use SIGHASH_FORKID"; - case SCRIPT_ERR_UNKNOWN_ERROR: - case SCRIPT_ERR_ERROR_COUNT: + case ScriptError::UNKNOWN: + case ScriptError::ERROR_COUNT: default: break; } diff --git a/src/script/sigencoding.cpp b/src/script/sigencoding.cpp --- a/src/script/sigencoding.cpp +++ b/src/script/sigencoding.cpp @@ -162,16 +162,16 @@ ScriptError *serror) { if (IsSchnorrSig(sig)) { // In an ECDSA-only context, 64-byte signatures are forbidden. - return set_error(serror, SCRIPT_ERR_SIG_BADLENGTH); + return set_error(serror, ScriptError::SIG_BADLENGTH); } if ((flags & (SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_LOW_S | SCRIPT_VERIFY_STRICTENC)) && !IsValidDERSignatureEncoding(sig)) { - return set_error(serror, SCRIPT_ERR_SIG_DER); + return set_error(serror, ScriptError::SIG_DER); } if ((flags & SCRIPT_VERIFY_LOW_S) && !CPubKey::CheckLowS(sig)) { - return set_error(serror, SCRIPT_ERR_SIG_HIGH_S); + return set_error(serror, ScriptError::SIG_HIGH_S); } return true; @@ -183,7 +183,7 @@ if (IsSchnorrSig(sig)) { return true; } - return set_error(serror, SCRIPT_ERR_SIG_NONSCHNORR); + return set_error(serror, ScriptError::SIG_NONSCHNORR); } static bool CheckRawSignatureEncoding(const slicedvaltype &sig, uint32_t flags, @@ -212,17 +212,17 @@ ScriptError *serror) { if (flags & SCRIPT_VERIFY_STRICTENC) { if (!GetHashType(vchSig).isDefined()) { - return set_error(serror, SCRIPT_ERR_SIG_HASHTYPE); + return set_error(serror, ScriptError::SIG_HASHTYPE); } bool usesForkId = GetHashType(vchSig).hasForkId(); bool forkIdEnabled = flags & SCRIPT_ENABLE_SIGHASH_FORKID; if (!forkIdEnabled && usesForkId) { - return set_error(serror, SCRIPT_ERR_ILLEGAL_FORKID); + return set_error(serror, ScriptError::ILLEGAL_FORKID); } if (forkIdEnabled && !usesForkId) { - return set_error(serror, SCRIPT_ERR_MUST_USE_FORKID); + return set_error(serror, ScriptError::MUST_USE_FORKID); } } @@ -315,13 +315,13 @@ ScriptError *serror) { if ((flags & SCRIPT_VERIFY_STRICTENC) && !IsCompressedOrUncompressedPubKey(vchPubKey)) { - return set_error(serror, SCRIPT_ERR_PUBKEYTYPE); + return set_error(serror, ScriptError::PUBKEYTYPE); } // Only compressed keys are accepted when // SCRIPT_VERIFY_COMPRESSED_PUBKEYTYPE is enabled. if ((flags & SCRIPT_VERIFY_COMPRESSED_PUBKEYTYPE) && !IsCompressedPubKey(vchPubKey)) { - return set_error(serror, SCRIPT_ERR_NONCOMPRESSED_PUBKEY); + return set_error(serror, ScriptError::NONCOMPRESSED_PUBKEY); } return true; } diff --git a/src/test/checkdatasig_tests.cpp b/src/test/checkdatasig_tests.cpp --- a/src/test/checkdatasig_tests.cpp +++ b/src/test/checkdatasig_tests.cpp @@ -41,21 +41,21 @@ static void CheckError(uint32_t flags, const stacktype &original_stack, const CScript &script, ScriptError expected) { BaseSignatureChecker sigchecker; - ScriptError err = SCRIPT_ERR_OK; + ScriptError err = ScriptError::OK; stacktype stack{original_stack}; bool r = EvalScript(stack, script, flags, sigchecker, &err); BOOST_CHECK(!r); - BOOST_CHECK_EQUAL(err, expected); + BOOST_CHECK(err == expected); } static void CheckPass(uint32_t flags, const stacktype &original_stack, const CScript &script, const stacktype &expected) { BaseSignatureChecker sigchecker; - ScriptError err = SCRIPT_ERR_OK; + ScriptError err = ScriptError::OK; stacktype stack{original_stack}; bool r = EvalScript(stack, script, flags, sigchecker, &err); BOOST_CHECK(r); - BOOST_CHECK_EQUAL(err, SCRIPT_ERR_OK); + BOOST_CHECK(err == ScriptError::OK); BOOST_CHECK(stack == expected); } @@ -90,17 +90,17 @@ BOOST_AUTO_TEST_CASE(checkdatasig_test) { // Empty stack. CheckErrorForAllFlags({}, CScript() << OP_CHECKDATASIG, - SCRIPT_ERR_INVALID_STACK_OPERATION); + ScriptError::INVALID_STACK_OPERATION); CheckErrorForAllFlags({{0x00}}, CScript() << OP_CHECKDATASIG, - SCRIPT_ERR_INVALID_STACK_OPERATION); + ScriptError::INVALID_STACK_OPERATION); CheckErrorForAllFlags({{0x00}, {0x00}}, CScript() << OP_CHECKDATASIG, - SCRIPT_ERR_INVALID_STACK_OPERATION); + ScriptError::INVALID_STACK_OPERATION); CheckErrorForAllFlags({}, CScript() << OP_CHECKDATASIGVERIFY, - SCRIPT_ERR_INVALID_STACK_OPERATION); + ScriptError::INVALID_STACK_OPERATION); CheckErrorForAllFlags({{0x00}}, CScript() << OP_CHECKDATASIGVERIFY, - SCRIPT_ERR_INVALID_STACK_OPERATION); + ScriptError::INVALID_STACK_OPERATION); CheckErrorForAllFlags({{0x00}, {0x00}}, CScript() << OP_CHECKDATASIGVERIFY, - SCRIPT_ERR_INVALID_STACK_OPERATION); + ScriptError::INVALID_STACK_OPERATION); // Check various pubkey encoding. const valtype message{}; @@ -119,10 +119,10 @@ CScript() << OP_CHECKDATASIG, {{}}); CheckErrorForAllFlags({{}, message, pubkey}, CScript() << OP_CHECKDATASIGVERIFY, - SCRIPT_ERR_CHECKDATASIGVERIFY); + ScriptError::CHECKDATASIGVERIFY); CheckErrorForAllFlags({{}, message, pubkeyC}, CScript() << OP_CHECKDATASIGVERIFY, - SCRIPT_ERR_CHECKDATASIGVERIFY); + ScriptError::CHECKDATASIGVERIFY); // Flags dependent checks. const CScript script = CScript() << OP_CHECKDATASIG << OP_NOT << OP_VERIFY; @@ -155,76 +155,76 @@ if (flags & SCRIPT_VERIFY_STRICTENC) { // When strict encoding is enforced, hybrid keys are invalid. CheckError(flags, {{}, message, pubkeyH}, script, - SCRIPT_ERR_PUBKEYTYPE); + ScriptError::PUBKEYTYPE); CheckError(flags, {{}, message, pubkeyH}, scriptverify, - SCRIPT_ERR_PUBKEYTYPE); + ScriptError::PUBKEYTYPE); } else if (flags & SCRIPT_VERIFY_COMPRESSED_PUBKEYTYPE) { // When compressed-only is enforced, hybrid keys are invalid. CheckError(flags, {{}, message, pubkeyH}, script, - SCRIPT_ERR_NONCOMPRESSED_PUBKEY); + ScriptError::NONCOMPRESSED_PUBKEY); CheckError(flags, {{}, message, pubkeyH}, scriptverify, - SCRIPT_ERR_NONCOMPRESSED_PUBKEY); + ScriptError::NONCOMPRESSED_PUBKEY); } else { // Otherwise, hybrid keys are valid. CheckPass(flags, {{}, message, pubkeyH}, script, {}); CheckError(flags, {{}, message, pubkeyH}, scriptverify, - SCRIPT_ERR_CHECKDATASIGVERIFY); + ScriptError::CHECKDATASIGVERIFY); } if (flags & SCRIPT_VERIFY_COMPRESSED_PUBKEYTYPE) { // When compressed-only is enforced, uncompressed keys are invalid. CheckError(flags, {{}, message, pubkey}, script, - SCRIPT_ERR_NONCOMPRESSED_PUBKEY); + ScriptError::NONCOMPRESSED_PUBKEY); CheckError(flags, {{}, message, pubkey}, scriptverify, - SCRIPT_ERR_NONCOMPRESSED_PUBKEY); + ScriptError::NONCOMPRESSED_PUBKEY); } else { // Otherwise, uncompressed keys are valid. CheckPass(flags, {{}, message, pubkey}, script, {}); CheckError(flags, {{}, message, pubkey}, scriptverify, - SCRIPT_ERR_CHECKDATASIGVERIFY); + ScriptError::CHECKDATASIGVERIFY); } if (flags & SCRIPT_VERIFY_NULLFAIL) { // Invalid signature causes checkdatasig to fail. CheckError(flags, {minimalsig, message, pubkeyC}, script, - SCRIPT_ERR_SIG_NULLFAIL); + ScriptError::SIG_NULLFAIL); CheckError(flags, {minimalsig, message, pubkeyC}, scriptverify, - SCRIPT_ERR_SIG_NULLFAIL); + ScriptError::SIG_NULLFAIL); // Invalid message causes checkdatasig to fail. CheckError(flags, {validsig, {0x01}, pubkeyC}, script, - SCRIPT_ERR_SIG_NULLFAIL); + ScriptError::SIG_NULLFAIL); CheckError(flags, {validsig, {0x01}, pubkeyC}, scriptverify, - SCRIPT_ERR_SIG_NULLFAIL); + ScriptError::SIG_NULLFAIL); } else { // When nullfail is not enforced, invalid signature are just false. CheckPass(flags, {minimalsig, message, pubkeyC}, script, {}); CheckError(flags, {minimalsig, message, pubkeyC}, scriptverify, - SCRIPT_ERR_CHECKDATASIGVERIFY); + ScriptError::CHECKDATASIGVERIFY); // Invalid message cause checkdatasig to fail. CheckPass(flags, {validsig, {0x01}, pubkeyC}, script, {}); CheckError(flags, {validsig, {0x01}, pubkeyC}, scriptverify, - SCRIPT_ERR_CHECKDATASIGVERIFY); + ScriptError::CHECKDATASIGVERIFY); } if (flags & SCRIPT_VERIFY_LOW_S) { // If we do enforce low S, then high S sigs are rejected. CheckError(flags, {highSSig, message, pubkeyC}, script, - SCRIPT_ERR_SIG_HIGH_S); + ScriptError::SIG_HIGH_S); CheckError(flags, {highSSig, message, pubkeyC}, scriptverify, - SCRIPT_ERR_SIG_HIGH_S); + ScriptError::SIG_HIGH_S); } else if (flags & SCRIPT_VERIFY_NULLFAIL) { // If we do enforce nullfail, these invalid sigs hit this. CheckError(flags, {highSSig, message, pubkeyC}, script, - SCRIPT_ERR_SIG_NULLFAIL); + ScriptError::SIG_NULLFAIL); CheckError(flags, {highSSig, message, pubkeyC}, scriptverify, - SCRIPT_ERR_SIG_NULLFAIL); + ScriptError::SIG_NULLFAIL); } else { // If we do not enforce low S, then high S sigs are accepted. CheckPass(flags, {highSSig, message, pubkeyC}, script, {}); CheckError(flags, {highSSig, message, pubkeyC}, scriptverify, - SCRIPT_ERR_CHECKDATASIGVERIFY); + ScriptError::CHECKDATASIGVERIFY); } if (flags & (SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_LOW_S | @@ -232,20 +232,20 @@ // If we get any of the dersig flags, the non canonical dersig // signature fails. CheckError(flags, {nondersig, message, pubkeyC}, script, - SCRIPT_ERR_SIG_DER); + ScriptError::SIG_DER); CheckError(flags, {nondersig, message, pubkeyC}, scriptverify, - SCRIPT_ERR_SIG_DER); + ScriptError::SIG_DER); } else if (flags & SCRIPT_VERIFY_NULLFAIL) { // If we do enforce nullfail, these invalid sigs hit this. CheckError(flags, {nondersig, message, pubkeyC}, script, - SCRIPT_ERR_SIG_NULLFAIL); + ScriptError::SIG_NULLFAIL); CheckError(flags, {nondersig, message, pubkeyC}, scriptverify, - SCRIPT_ERR_SIG_NULLFAIL); + ScriptError::SIG_NULLFAIL); } else { // If we do not check, then it is accepted. CheckPass(flags, {nondersig, message, pubkeyC}, script, {}); CheckError(flags, {nondersig, message, pubkeyC}, scriptverify, - SCRIPT_ERR_CHECKDATASIGVERIFY); + ScriptError::CHECKDATASIGVERIFY); } } } diff --git a/src/test/monolith_opcodes_tests.cpp b/src/test/monolith_opcodes_tests.cpp --- a/src/test/monolith_opcodes_tests.cpp +++ b/src/test/monolith_opcodes_tests.cpp @@ -28,7 +28,7 @@ BaseSignatureChecker sigchecker; for (uint32_t flags : flagset) { - ScriptError err = SCRIPT_ERR_OK; + ScriptError err = ScriptError::OK; stacktype stack{original_stack}; bool r = EvalScript(stack, script, flags, sigchecker, &err); BOOST_CHECK(r); @@ -39,11 +39,11 @@ static void CheckError(uint32_t flags, const stacktype &original_stack, const CScript &script, ScriptError expected_error) { BaseSignatureChecker sigchecker; - ScriptError err = SCRIPT_ERR_OK; + ScriptError err = ScriptError::OK; stacktype stack{original_stack}; bool r = EvalScript(stack, script, flags, sigchecker, &err); BOOST_CHECK(!r); - BOOST_CHECK_EQUAL(err, expected_error); + BOOST_CHECK(err == expected_error); } static void CheckErrorForAllFlags(const stacktype &original_stack, @@ -373,23 +373,23 @@ // Check errors conditions. // 1. Less than 2 elements on stack. - CheckAllBitwiseOpErrors({}, SCRIPT_ERR_INVALID_STACK_OPERATION); - CheckAllBitwiseOpErrors({{}}, SCRIPT_ERR_INVALID_STACK_OPERATION); - CheckAllBitwiseOpErrors({{0x00}}, SCRIPT_ERR_INVALID_STACK_OPERATION); + CheckAllBitwiseOpErrors({}, ScriptError::INVALID_STACK_OPERATION); + CheckAllBitwiseOpErrors({{}}, ScriptError::INVALID_STACK_OPERATION); + CheckAllBitwiseOpErrors({{0x00}}, ScriptError::INVALID_STACK_OPERATION); CheckAllBitwiseOpErrors({{0xab, 0xcd, 0xef}}, - SCRIPT_ERR_INVALID_STACK_OPERATION); - CheckAllBitwiseOpErrors({a}, SCRIPT_ERR_INVALID_STACK_OPERATION); - CheckAllBitwiseOpErrors({b}, SCRIPT_ERR_INVALID_STACK_OPERATION); + ScriptError::INVALID_STACK_OPERATION); + CheckAllBitwiseOpErrors({a}, ScriptError::INVALID_STACK_OPERATION); + CheckAllBitwiseOpErrors({b}, ScriptError::INVALID_STACK_OPERATION); // 2. Operand of mismatching length - CheckAllBitwiseOpErrors({{}, {0x00}}, SCRIPT_ERR_INVALID_OPERAND_SIZE); - CheckAllBitwiseOpErrors({{0x00}, {}}, SCRIPT_ERR_INVALID_OPERAND_SIZE); + CheckAllBitwiseOpErrors({{}, {0x00}}, ScriptError::INVALID_OPERAND_SIZE); + CheckAllBitwiseOpErrors({{0x00}, {}}, ScriptError::INVALID_OPERAND_SIZE); CheckAllBitwiseOpErrors({{0x00}, {0xab, 0xcd, 0xef}}, - SCRIPT_ERR_INVALID_OPERAND_SIZE); + ScriptError::INVALID_OPERAND_SIZE); CheckAllBitwiseOpErrors({{0xab, 0xcd, 0xef}, {0x00}}, - SCRIPT_ERR_INVALID_OPERAND_SIZE); - CheckAllBitwiseOpErrors({{}, a}, SCRIPT_ERR_INVALID_OPERAND_SIZE); - CheckAllBitwiseOpErrors({b, {}}, SCRIPT_ERR_INVALID_OPERAND_SIZE); + ScriptError::INVALID_OPERAND_SIZE); + CheckAllBitwiseOpErrors({{}, a}, ScriptError::INVALID_OPERAND_SIZE); + CheckAllBitwiseOpErrors({b, {}}, ScriptError::INVALID_OPERAND_SIZE); } /** @@ -422,13 +422,13 @@ // Out of bound split. CheckErrorForAllFlags({a}, CScript() << (a.size() + 1) << OP_SPLIT, - SCRIPT_ERR_INVALID_SPLIT_RANGE); + ScriptError::INVALID_SPLIT_RANGE); CheckErrorForAllFlags({b}, CScript() << (b.size() + 1) << OP_SPLIT, - SCRIPT_ERR_INVALID_SPLIT_RANGE); + ScriptError::INVALID_SPLIT_RANGE); CheckErrorForAllFlags({n}, CScript() << (n.size() + 1) << OP_SPLIT, - SCRIPT_ERR_INVALID_SPLIT_RANGE); + ScriptError::INVALID_SPLIT_RANGE); CheckErrorForAllFlags({a}, CScript() << (-1) << OP_SPLIT, - SCRIPT_ERR_INVALID_SPLIT_RANGE); + ScriptError::INVALID_SPLIT_RANGE); } BOOST_AUTO_TEST_CASE(string_opcodes_test) { @@ -502,22 +502,22 @@ valtype extraB = b; extraB.push_back(0xad); - CheckOpError({extraA, b}, OP_CAT, SCRIPT_ERR_PUSH_SIZE); - CheckOpError({a, extraB}, OP_CAT, SCRIPT_ERR_PUSH_SIZE); - CheckOpError({extraA, extraB}, OP_CAT, SCRIPT_ERR_PUSH_SIZE); + CheckOpError({extraA, b}, OP_CAT, ScriptError::PUSH_SIZE); + CheckOpError({a, extraB}, OP_CAT, ScriptError::PUSH_SIZE); + CheckOpError({extraA, extraB}, OP_CAT, ScriptError::PUSH_SIZE); } // Check error conditions. - CheckOpError({}, OP_CAT, SCRIPT_ERR_INVALID_STACK_OPERATION); - CheckOpError({}, OP_SPLIT, SCRIPT_ERR_INVALID_STACK_OPERATION); - CheckOpError({{}}, OP_CAT, SCRIPT_ERR_INVALID_STACK_OPERATION); - CheckOpError({{}}, OP_SPLIT, SCRIPT_ERR_INVALID_STACK_OPERATION); - CheckOpError({{0x00}}, OP_CAT, SCRIPT_ERR_INVALID_STACK_OPERATION); - CheckOpError({{0x00}}, OP_SPLIT, SCRIPT_ERR_INVALID_STACK_OPERATION); + CheckOpError({}, OP_CAT, ScriptError::INVALID_STACK_OPERATION); + CheckOpError({}, OP_SPLIT, ScriptError::INVALID_STACK_OPERATION); + CheckOpError({{}}, OP_CAT, ScriptError::INVALID_STACK_OPERATION); + CheckOpError({{}}, OP_SPLIT, ScriptError::INVALID_STACK_OPERATION); + CheckOpError({{0x00}}, OP_CAT, ScriptError::INVALID_STACK_OPERATION); + CheckOpError({{0x00}}, OP_SPLIT, ScriptError::INVALID_STACK_OPERATION); CheckOpError({{0xab, 0xcd, 0xef}}, OP_CAT, - SCRIPT_ERR_INVALID_STACK_OPERATION); + ScriptError::INVALID_STACK_OPERATION); CheckOpError({{0xab, 0xcd, 0xef}}, OP_SPLIT, - SCRIPT_ERR_INVALID_STACK_OPERATION); + ScriptError::INVALID_STACK_OPERATION); } /** @@ -607,29 +607,29 @@ {0xab, 0xcd, 0x7f, 0x42}); // Empty stack is an error. - CheckBin2NumError({}, SCRIPT_ERR_INVALID_STACK_OPERATION); - CheckNum2BinError({}, SCRIPT_ERR_INVALID_STACK_OPERATION); + CheckBin2NumError({}, ScriptError::INVALID_STACK_OPERATION); + CheckNum2BinError({}, ScriptError::INVALID_STACK_OPERATION); // NUM2BIN require 2 elements on the stack. - CheckNum2BinError({{0x00}}, SCRIPT_ERR_INVALID_STACK_OPERATION); + CheckNum2BinError({{0x00}}, ScriptError::INVALID_STACK_OPERATION); // Values that do not fit in 4 bytes are considered out of range for // BIN2NUM. CheckBin2NumError({{0xab, 0xcd, 0xef, 0xc2, 0x80}}, - SCRIPT_ERR_INVALID_NUMBER_RANGE); + ScriptError::INVALID_NUMBER_RANGE); CheckBin2NumError({{0x00, 0x00, 0x00, 0x80, 0x80}}, - SCRIPT_ERR_INVALID_NUMBER_RANGE); + ScriptError::INVALID_NUMBER_RANGE); // NUM2BIN must not generate oversized push. valtype largezero(MAX_SCRIPT_ELEMENT_SIZE, 0); BOOST_CHECK_EQUAL(largezero.size(), MAX_SCRIPT_ELEMENT_SIZE); CheckTypeConversionOp(largezero, {}); - CheckNum2BinError({{}, {0x09, 0x02}}, SCRIPT_ERR_PUSH_SIZE); + CheckNum2BinError({{}, {0x09, 0x02}}, ScriptError::PUSH_SIZE); // Check that the requested encoding is possible. CheckNum2BinError({{0xab, 0xcd, 0xef, 0x80}, {0x03}}, - SCRIPT_ERR_IMPOSSIBLE_ENCODING); + ScriptError::IMPOSSIBLE_ENCODING); } /** @@ -653,45 +653,47 @@ // Div/Mod by zero for (uint32_t flags : flagset) { - CheckError(flags, {a, {}}, CScript() << OP_DIV, SCRIPT_ERR_DIV_BY_ZERO); - CheckError(flags, {b, {}}, CScript() << OP_DIV, SCRIPT_ERR_DIV_BY_ZERO); + CheckError(flags, {a, {}}, CScript() << OP_DIV, + ScriptError::DIV_BY_ZERO); + CheckError(flags, {b, {}}, CScript() << OP_DIV, + ScriptError::DIV_BY_ZERO); if (flags & SCRIPT_VERIFY_MINIMALDATA) { CheckError(flags, {a, {0x00}}, CScript() << OP_DIV, - SCRIPT_ERR_UNKNOWN_ERROR); + ScriptError::UNKNOWN); CheckError(flags, {a, {0x80}}, CScript() << OP_DIV, - SCRIPT_ERR_UNKNOWN_ERROR); + ScriptError::UNKNOWN); CheckError(flags, {a, {0x00, 0x00}}, CScript() << OP_DIV, - SCRIPT_ERR_UNKNOWN_ERROR); + ScriptError::UNKNOWN); CheckError(flags, {a, {0x00, 0x80}}, CScript() << OP_DIV, - SCRIPT_ERR_UNKNOWN_ERROR); + ScriptError::UNKNOWN); CheckError(flags, {b, {0x00}}, CScript() << OP_DIV, - SCRIPT_ERR_UNKNOWN_ERROR); + ScriptError::UNKNOWN); CheckError(flags, {b, {0x80}}, CScript() << OP_DIV, - SCRIPT_ERR_UNKNOWN_ERROR); + ScriptError::UNKNOWN); CheckError(flags, {b, {0x00, 0x00}}, CScript() << OP_DIV, - SCRIPT_ERR_UNKNOWN_ERROR); + ScriptError::UNKNOWN); CheckError(flags, {b, {0x00, 0x80}}, CScript() << OP_DIV, - SCRIPT_ERR_UNKNOWN_ERROR); + ScriptError::UNKNOWN); } else { CheckError(flags, {a, {0x00}}, CScript() << OP_DIV, - SCRIPT_ERR_DIV_BY_ZERO); + ScriptError::DIV_BY_ZERO); CheckError(flags, {a, {0x80}}, CScript() << OP_DIV, - SCRIPT_ERR_DIV_BY_ZERO); + ScriptError::DIV_BY_ZERO); CheckError(flags, {a, {0x00, 0x00}}, CScript() << OP_DIV, - SCRIPT_ERR_DIV_BY_ZERO); + ScriptError::DIV_BY_ZERO); CheckError(flags, {a, {0x00, 0x80}}, CScript() << OP_DIV, - SCRIPT_ERR_DIV_BY_ZERO); + ScriptError::DIV_BY_ZERO); CheckError(flags, {b, {0x00}}, CScript() << OP_DIV, - SCRIPT_ERR_DIV_BY_ZERO); + ScriptError::DIV_BY_ZERO); CheckError(flags, {b, {0x80}}, CScript() << OP_DIV, - SCRIPT_ERR_DIV_BY_ZERO); + ScriptError::DIV_BY_ZERO); CheckError(flags, {b, {0x00, 0x00}}, CScript() << OP_DIV, - SCRIPT_ERR_DIV_BY_ZERO); + ScriptError::DIV_BY_ZERO); CheckError(flags, {b, {0x00, 0x80}}, CScript() << OP_DIV, - SCRIPT_ERR_DIV_BY_ZERO); + ScriptError::DIV_BY_ZERO); } } @@ -722,17 +724,17 @@ } BOOST_AUTO_TEST_CASE(div_and_mod_opcode_tests) { - CheckDivModError({}, SCRIPT_ERR_INVALID_STACK_OPERATION); - CheckDivModError({{}}, SCRIPT_ERR_INVALID_STACK_OPERATION); + CheckDivModError({}, ScriptError::INVALID_STACK_OPERATION); + CheckDivModError({{}}, ScriptError::INVALID_STACK_OPERATION); // CheckOps not valid numbers CheckDivModError( {{0x01, 0x02, 0x03, 0x04, 0x05}, {0x01, 0x02, 0x03, 0x04, 0x05}}, - SCRIPT_ERR_UNKNOWN_ERROR); + ScriptError::UNKNOWN); CheckDivModError({{0x01, 0x02, 0x03, 0x04, 0x05}, {0x01}}, - SCRIPT_ERR_UNKNOWN_ERROR); + ScriptError::UNKNOWN); CheckDivModError({{0x01, 0x05}, {0x01, 0x02, 0x03, 0x04, 0x05}}, - SCRIPT_ERR_UNKNOWN_ERROR); + ScriptError::UNKNOWN); // 0x185377af / 0x85f41b01 = -4 // 0x185377af % 0x85f41b01 = 0x00830bab diff --git a/src/test/multisig_tests.cpp b/src/test/multisig_tests.cpp --- a/src/test/multisig_tests.cpp +++ b/src/test/multisig_tests.cpp @@ -87,7 +87,7 @@ BOOST_CHECK(VerifyScript( s, a_and_b, flags, MutableTransactionSignatureChecker(&txTo[0], 0, amount), &err)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err)); for (int i = 0; i < 4; i++) { keys.assign(1, key[i]); @@ -97,7 +97,7 @@ s, a_and_b, flags, MutableTransactionSignatureChecker(&txTo[0], 0, amount), &err), strprintf("a&b 1: %d", i)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_INVALID_STACK_OPERATION, + BOOST_CHECK_MESSAGE(err == ScriptError::INVALID_STACK_OPERATION, ScriptErrorString(err)); keys.assign(1, key[1]); @@ -108,7 +108,7 @@ s, a_and_b, flags, MutableTransactionSignatureChecker(&txTo[0], 0, amount), &err), strprintf("a&b 2: %d", i)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, + BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err)); } @@ -122,7 +122,7 @@ &txTo[1], 0, amount), &err), strprintf("a|b: %d", i)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err)); } else { BOOST_CHECK_MESSAGE( !VerifyScript( @@ -130,7 +130,7 @@ MutableTransactionSignatureChecker(&txTo[1], 0, amount), &err), strprintf("a|b: %d", i)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, + BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err)); } } @@ -139,7 +139,7 @@ BOOST_CHECK(!VerifyScript( s, a_or_b, flags, MutableTransactionSignatureChecker(&txTo[1], 0, amount), &err)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_SIG_DER, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err == ScriptError::SIG_DER, ScriptErrorString(err)); for (int i = 0; i < 4; i++) { for (int j = 0; j < 4; j++) { @@ -153,7 +153,7 @@ MutableTransactionSignatureChecker(&txTo[2], 0, amount), &err), strprintf("escrow 1: %d %d", i, j)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, + BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err)); } else { BOOST_CHECK_MESSAGE( @@ -162,7 +162,7 @@ MutableTransactionSignatureChecker(&txTo[2], 0, amount), &err), strprintf("escrow 2: %d %d", i, j)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, + BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err)); } } diff --git a/src/test/schnorr_tests.cpp b/src/test/schnorr_tests.cpp --- a/src/test/schnorr_tests.cpp +++ b/src/test/schnorr_tests.cpp @@ -38,21 +38,21 @@ static void CheckError(uint32_t flags, const stacktype &original_stack, const CScript &script, ScriptError expected) { BaseSignatureChecker sigchecker; - ScriptError err = SCRIPT_ERR_OK; + ScriptError err = ScriptError::OK; stacktype stack{original_stack}; bool r = EvalScript(stack, script, flags, sigchecker, &err); BOOST_CHECK(!r); - BOOST_CHECK_EQUAL(err, expected); + BOOST_CHECK(err == expected); } static void CheckPass(uint32_t flags, const stacktype &original_stack, const CScript &script, const stacktype &expected) { BaseSignatureChecker sigchecker; - ScriptError err = SCRIPT_ERR_OK; + ScriptError err = ScriptError::OK; stacktype stack{original_stack}; bool r = EvalScript(stack, script, flags, sigchecker, &err); BOOST_CHECK(r); - BOOST_CHECK_EQUAL(err, SCRIPT_ERR_OK); + BOOST_CHECK(err == ScriptError::OK); BOOST_CHECK(stack == expected); } @@ -68,7 +68,7 @@ valtype pubkeyC = ToByteVector(kd.pubkeyC); // Script endings. The non-verify variants will complete OK and the verify - // variant will complete with SCRIPT_ERR_, that is, unless + // variant will complete with ScriptError::, that is, unless // there is a flag-dependent error which we will be testing for. const CScript scriptCHECKSIG = CScript() << OP_CHECKSIG << OP_NOT << OP_VERIFY; @@ -117,54 +117,54 @@ // encoding, otherwise upon verification. if (hasNullFail) { CheckError(flags, {Zero64_with_hashtype, pubkeyC}, scriptCHECKSIG, - SCRIPT_ERR_SIG_NULLFAIL); + ScriptError::SIG_NULLFAIL); CheckError(flags, {Zero64_with_hashtype, pubkeyC}, - scriptCHECKSIGVERIFY, SCRIPT_ERR_SIG_NULLFAIL); + scriptCHECKSIGVERIFY, ScriptError::SIG_NULLFAIL); CheckError(flags, {Zero64, {}, pubkeyC}, scriptCHECKDATASIG, - SCRIPT_ERR_SIG_NULLFAIL); + ScriptError::SIG_NULLFAIL); CheckError(flags, {Zero64, {}, pubkeyC}, scriptCHECKDATASIGVERIFY, - SCRIPT_ERR_SIG_NULLFAIL); + ScriptError::SIG_NULLFAIL); } else { CheckPass(flags, {Zero64_with_hashtype, pubkeyC}, scriptCHECKSIG, {}); CheckError(flags, {Zero64_with_hashtype, pubkeyC}, - scriptCHECKSIGVERIFY, SCRIPT_ERR_CHECKSIGVERIFY); + scriptCHECKSIGVERIFY, ScriptError::CHECKSIGVERIFY); CheckPass(flags, {Zero64, {}, pubkeyC}, scriptCHECKDATASIG, {}); CheckError(flags, {Zero64, {}, pubkeyC}, scriptCHECKDATASIGVERIFY, - SCRIPT_ERR_CHECKDATASIGVERIFY); + ScriptError::CHECKDATASIGVERIFY); } // Test CHECKSIG & CHECKDATASIG with DER sig, which fails upon // verification. if (hasNullFail) { CheckError(flags, {DER64_with_hashtype, pubkeyC}, scriptCHECKSIG, - SCRIPT_ERR_SIG_NULLFAIL); + ScriptError::SIG_NULLFAIL); CheckError(flags, {DER64_with_hashtype, pubkeyC}, - scriptCHECKSIGVERIFY, SCRIPT_ERR_SIG_NULLFAIL); + scriptCHECKSIGVERIFY, ScriptError::SIG_NULLFAIL); CheckError(flags, {DER64, {}, pubkeyC}, scriptCHECKDATASIG, - SCRIPT_ERR_SIG_NULLFAIL); + ScriptError::SIG_NULLFAIL); CheckError(flags, {DER64, {}, pubkeyC}, scriptCHECKDATASIGVERIFY, - SCRIPT_ERR_SIG_NULLFAIL); + ScriptError::SIG_NULLFAIL); } else { CheckPass(flags, {DER64_with_hashtype, pubkeyC}, scriptCHECKSIG, {}); CheckError(flags, {DER64_with_hashtype, pubkeyC}, - scriptCHECKSIGVERIFY, SCRIPT_ERR_CHECKSIGVERIFY); + scriptCHECKSIGVERIFY, ScriptError::CHECKSIGVERIFY); CheckPass(flags, {DER64, {}, pubkeyC}, scriptCHECKDATASIG, {}); CheckError(flags, {DER64, {}, pubkeyC}, scriptCHECKDATASIGVERIFY, - SCRIPT_ERR_CHECKDATASIGVERIFY); + ScriptError::CHECKDATASIGVERIFY); } // test OP_CHECKMULTISIG/VERIFY // We fail with BADLENGTH no matter what. CheckError(flags, {{}, Zero64_with_hashtype, {1}, pubkeyC, {1}}, - scriptCHECKMULTISIG, SCRIPT_ERR_SIG_BADLENGTH); + scriptCHECKMULTISIG, ScriptError::SIG_BADLENGTH); CheckError(flags, {{}, Zero64_with_hashtype, {1}, pubkeyC, {1}}, - scriptCHECKMULTISIGVERIFY, SCRIPT_ERR_SIG_BADLENGTH); + scriptCHECKMULTISIGVERIFY, ScriptError::SIG_BADLENGTH); CheckError(flags, {{}, DER64_with_hashtype, {1}, pubkeyC, {1}}, - scriptCHECKMULTISIG, SCRIPT_ERR_SIG_BADLENGTH); + scriptCHECKMULTISIG, ScriptError::SIG_BADLENGTH); CheckError(flags, {{}, DER64_with_hashtype, {1}, pubkeyC, {1}}, - scriptCHECKMULTISIGVERIFY, SCRIPT_ERR_SIG_BADLENGTH); + scriptCHECKMULTISIGVERIFY, ScriptError::SIG_BADLENGTH); } } diff --git a/src/test/script_p2sh_tests.cpp b/src/test/script_p2sh_tests.cpp --- a/src/test/script_p2sh_tests.cpp +++ b/src/test/script_p2sh_tests.cpp @@ -149,7 +149,7 @@ // Should not verify, because it will try to execute OP_INVALIDOPCODE BOOST_CHECK(!Verify(scriptSig, p2sh, true, err)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_BAD_OPCODE, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err == ScriptError::BAD_OPCODE, ScriptErrorString(err)); // Try to recur, and verification should succeed because // the inner HASH160 <> EQUAL should only check the hash: @@ -158,7 +158,7 @@ scriptSig2 << Serialize(invalidAsScript) << Serialize(p2sh); BOOST_CHECK(Verify(scriptSig2, p2sh2, true, err)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err)); } BOOST_AUTO_TEST_CASE(set) { @@ -307,10 +307,11 @@ // Validation should succeed under old rules (hash is correct): BOOST_CHECK(Verify(scriptSig, fund, false, err)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err)); // Fail under new: BOOST_CHECK(!Verify(scriptSig, fund, true, err)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EQUALVERIFY, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err == ScriptError::EQUALVERIFY, + ScriptErrorString(err)); } BOOST_AUTO_TEST_CASE(AreInputsStandard) { diff --git a/src/test/script_tests.cpp b/src/test/script_tests.cpp --- a/src/test/script_tests.cpp +++ b/src/test/script_tests.cpp @@ -41,59 +41,59 @@ static const uint32_t gFlags = SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC; struct ScriptErrorDesc { - ScriptError_t err; + ScriptError err; const char *name; }; static ScriptErrorDesc script_errors[] = { - {SCRIPT_ERR_OK, "OK"}, - {SCRIPT_ERR_UNKNOWN_ERROR, "UNKNOWN_ERROR"}, - {SCRIPT_ERR_EVAL_FALSE, "EVAL_FALSE"}, - {SCRIPT_ERR_OP_RETURN, "OP_RETURN"}, - {SCRIPT_ERR_SCRIPT_SIZE, "SCRIPT_SIZE"}, - {SCRIPT_ERR_PUSH_SIZE, "PUSH_SIZE"}, - {SCRIPT_ERR_OP_COUNT, "OP_COUNT"}, - {SCRIPT_ERR_STACK_SIZE, "STACK_SIZE"}, - {SCRIPT_ERR_SIG_COUNT, "SIG_COUNT"}, - {SCRIPT_ERR_PUBKEY_COUNT, "PUBKEY_COUNT"}, - {SCRIPT_ERR_INVALID_OPERAND_SIZE, "OPERAND_SIZE"}, - {SCRIPT_ERR_INVALID_NUMBER_RANGE, "INVALID_NUMBER_RANGE"}, - {SCRIPT_ERR_IMPOSSIBLE_ENCODING, "IMPOSSIBLE_ENCODING"}, - {SCRIPT_ERR_INVALID_SPLIT_RANGE, "SPLIT_RANGE"}, - {SCRIPT_ERR_VERIFY, "VERIFY"}, - {SCRIPT_ERR_EQUALVERIFY, "EQUALVERIFY"}, - {SCRIPT_ERR_CHECKMULTISIGVERIFY, "CHECKMULTISIGVERIFY"}, - {SCRIPT_ERR_CHECKSIGVERIFY, "CHECKSIGVERIFY"}, - {SCRIPT_ERR_CHECKDATASIGVERIFY, "CHECKDATASIGVERIFY"}, - {SCRIPT_ERR_NUMEQUALVERIFY, "NUMEQUALVERIFY"}, - {SCRIPT_ERR_BAD_OPCODE, "BAD_OPCODE"}, - {SCRIPT_ERR_DISABLED_OPCODE, "DISABLED_OPCODE"}, - {SCRIPT_ERR_INVALID_STACK_OPERATION, "INVALID_STACK_OPERATION"}, - {SCRIPT_ERR_INVALID_ALTSTACK_OPERATION, "INVALID_ALTSTACK_OPERATION"}, - {SCRIPT_ERR_UNBALANCED_CONDITIONAL, "UNBALANCED_CONDITIONAL"}, - {SCRIPT_ERR_NEGATIVE_LOCKTIME, "NEGATIVE_LOCKTIME"}, - {SCRIPT_ERR_UNSATISFIED_LOCKTIME, "UNSATISFIED_LOCKTIME"}, - {SCRIPT_ERR_SIG_HASHTYPE, "SIG_HASHTYPE"}, - {SCRIPT_ERR_SIG_DER, "SIG_DER"}, - {SCRIPT_ERR_MINIMALDATA, "MINIMALDATA"}, - {SCRIPT_ERR_SIG_PUSHONLY, "SIG_PUSHONLY"}, - {SCRIPT_ERR_SIG_HIGH_S, "SIG_HIGH_S"}, - {SCRIPT_ERR_SIG_NULLDUMMY, "SIG_NULLDUMMY"}, - {SCRIPT_ERR_PUBKEYTYPE, "PUBKEYTYPE"}, - {SCRIPT_ERR_CLEANSTACK, "CLEANSTACK"}, - {SCRIPT_ERR_MINIMALIF, "MINIMALIF"}, - {SCRIPT_ERR_SIG_NULLFAIL, "NULLFAIL"}, - {SCRIPT_ERR_SIG_BADLENGTH, "SIG_BADLENGTH"}, - {SCRIPT_ERR_SIG_NONSCHNORR, "SIG_NONSCHNORR"}, - {SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS, "DISCOURAGE_UPGRADABLE_NOPS"}, - {SCRIPT_ERR_NONCOMPRESSED_PUBKEY, "NONCOMPRESSED_PUBKEY"}, - {SCRIPT_ERR_ILLEGAL_FORKID, "ILLEGAL_FORKID"}, - {SCRIPT_ERR_MUST_USE_FORKID, "MISSING_FORKID"}, - {SCRIPT_ERR_DIV_BY_ZERO, "DIV_BY_ZERO"}, - {SCRIPT_ERR_MOD_BY_ZERO, "MOD_BY_ZERO"}, + {ScriptError::OK, "OK"}, + {ScriptError::UNKNOWN, "UNKNOWN_ERROR"}, + {ScriptError::EVAL_FALSE, "EVAL_FALSE"}, + {ScriptError::OP_RETURN, "OP_RETURN"}, + {ScriptError::SCRIPT_SIZE, "SCRIPT_SIZE"}, + {ScriptError::PUSH_SIZE, "PUSH_SIZE"}, + {ScriptError::OP_COUNT, "OP_COUNT"}, + {ScriptError::STACK_SIZE, "STACK_SIZE"}, + {ScriptError::SIG_COUNT, "SIG_COUNT"}, + {ScriptError::PUBKEY_COUNT, "PUBKEY_COUNT"}, + {ScriptError::INVALID_OPERAND_SIZE, "OPERAND_SIZE"}, + {ScriptError::INVALID_NUMBER_RANGE, "INVALID_NUMBER_RANGE"}, + {ScriptError::IMPOSSIBLE_ENCODING, "IMPOSSIBLE_ENCODING"}, + {ScriptError::INVALID_SPLIT_RANGE, "SPLIT_RANGE"}, + {ScriptError::VERIFY, "VERIFY"}, + {ScriptError::EQUALVERIFY, "EQUALVERIFY"}, + {ScriptError::CHECKMULTISIGVERIFY, "CHECKMULTISIGVERIFY"}, + {ScriptError::CHECKSIGVERIFY, "CHECKSIGVERIFY"}, + {ScriptError::CHECKDATASIGVERIFY, "CHECKDATASIGVERIFY"}, + {ScriptError::NUMEQUALVERIFY, "NUMEQUALVERIFY"}, + {ScriptError::BAD_OPCODE, "BAD_OPCODE"}, + {ScriptError::DISABLED_OPCODE, "DISABLED_OPCODE"}, + {ScriptError::INVALID_STACK_OPERATION, "INVALID_STACK_OPERATION"}, + {ScriptError::INVALID_ALTSTACK_OPERATION, "INVALID_ALTSTACK_OPERATION"}, + {ScriptError::UNBALANCED_CONDITIONAL, "UNBALANCED_CONDITIONAL"}, + {ScriptError::NEGATIVE_LOCKTIME, "NEGATIVE_LOCKTIME"}, + {ScriptError::UNSATISFIED_LOCKTIME, "UNSATISFIED_LOCKTIME"}, + {ScriptError::SIG_HASHTYPE, "SIG_HASHTYPE"}, + {ScriptError::SIG_DER, "SIG_DER"}, + {ScriptError::MINIMALDATA, "MINIMALDATA"}, + {ScriptError::SIG_PUSHONLY, "SIG_PUSHONLY"}, + {ScriptError::SIG_HIGH_S, "SIG_HIGH_S"}, + {ScriptError::SIG_NULLDUMMY, "SIG_NULLDUMMY"}, + {ScriptError::PUBKEYTYPE, "PUBKEYTYPE"}, + {ScriptError::CLEANSTACK, "CLEANSTACK"}, + {ScriptError::MINIMALIF, "MINIMALIF"}, + {ScriptError::SIG_NULLFAIL, "NULLFAIL"}, + {ScriptError::SIG_BADLENGTH, "SIG_BADLENGTH"}, + {ScriptError::SIG_NONSCHNORR, "SIG_NONSCHNORR"}, + {ScriptError::DISCOURAGE_UPGRADABLE_NOPS, "DISCOURAGE_UPGRADABLE_NOPS"}, + {ScriptError::NONCOMPRESSED_PUBKEY, "NONCOMPRESSED_PUBKEY"}, + {ScriptError::ILLEGAL_FORKID, "ILLEGAL_FORKID"}, + {ScriptError::MUST_USE_FORKID, "MISSING_FORKID"}, + {ScriptError::DIV_BY_ZERO, "DIV_BY_ZERO"}, + {ScriptError::MOD_BY_ZERO, "MOD_BY_ZERO"}, }; -static const char *FormatScriptError(ScriptError_t err) { +static const char *FormatScriptError(ScriptError err) { for (size_t i = 0; i < ARRAYLEN(script_errors); ++i) { if (script_errors[i].err == err) { return script_errors[i].name; @@ -105,7 +105,7 @@ return ""; } -static ScriptError_t ParseScriptError(const std::string &name) { +static ScriptError ParseScriptError(const std::string &name) { for (size_t i = 0; i < ARRAYLEN(script_errors); ++i) { if (script_errors[i].name == name) { return script_errors[i].err; @@ -113,7 +113,7 @@ } BOOST_ERROR("Unknown scripterror \"" << name << "\" in test description"); - return SCRIPT_ERR_UNKNOWN_ERROR; + return ScriptError::UNKNOWN; } BOOST_FIXTURE_TEST_SUITE(script_tests, BasicTestingSetup) @@ -152,9 +152,9 @@ } static void DoTest(const CScript &scriptPubKey, const CScript &scriptSig, - uint32_t flags, const std::string &message, int scriptError, - const Amount nValue) { - bool expect = (scriptError == SCRIPT_ERR_OK); + uint32_t flags, const std::string &message, + ScriptError scriptError, const Amount nValue) { + bool expect = (scriptError == ScriptError::OK); if (flags & SCRIPT_VERIFY_CLEANSTACK) { flags |= SCRIPT_VERIFY_P2SH; } @@ -169,11 +169,10 @@ &tx, 0, txCredit.vout[0].nValue), &err) == expect, message); - BOOST_CHECK_MESSAGE( - err == scriptError, - std::string(FormatScriptError(err)) + " where " + - std::string(FormatScriptError((ScriptError_t)scriptError)) + - " expected: " + message); + BOOST_CHECK_MESSAGE(err == scriptError, + std::string(FormatScriptError(err)) + " where " + + std::string(FormatScriptError(scriptError)) + + " expected: " + message); #if defined(HAVE_CONSENSUS_LIB) CDataStream stream(SER_NETWORK, PROTOCOL_VERSION); stream << tx2; @@ -249,7 +248,7 @@ std::vector push; std::string comment; uint32_t flags; - int scriptError; + ScriptError scriptError; Amount nValue; void DoPush() { @@ -301,7 +300,7 @@ uint32_t flags_, bool P2SH = false, Amount nValue_ = Amount::zero()) : script(script_), havePush(false), comment(comment_), flags(flags_), - scriptError(SCRIPT_ERR_OK), nValue(nValue_) { + scriptError(ScriptError::OK), nValue(nValue_) { CScript scriptPubKey = script; if (P2SH) { redeemscript = scriptPubKey; @@ -314,7 +313,7 @@ spendTx = BuildSpendingTransaction(CScript(), *creditTx); } - TestBuilder &ScriptError(ScriptError_t err) { + TestBuilder &SetScriptError(ScriptError err) { scriptError = err; return *this; } @@ -521,7 +520,7 @@ array.push_back(FormatScript(spendTx.vin[0].scriptSig)); array.push_back(FormatScript(creditTx->vout[0].scriptPubKey)); array.push_back(FormatScriptFlags(flags)); - array.push_back(FormatScriptError((ScriptError_t)scriptError)); + array.push_back(FormatScriptError(scriptError)); array.push_back(comment); return array; } @@ -557,7 +556,7 @@ "P2PK, bad sig", 0) .PushSigECDSA(keys.key0) .DamagePush(10) - .ScriptError(SCRIPT_ERR_EVAL_FALSE)); + .SetScriptError(ScriptError::EVAL_FALSE)); tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey1C.GetID()) @@ -572,7 +571,7 @@ .PushSigECDSA(keys.key2) .Push(keys.pubkey2C) .DamagePush(5) - .ScriptError(SCRIPT_ERR_EQUALVERIFY)); + .SetScriptError(ScriptError::EQUALVERIFY)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG, @@ -583,7 +582,7 @@ "P2PK anyonecanpay marked with normal hashtype", 0) .PushSigECDSA(keys.key1, SigHashType().withAnyoneCanPay()) .EditPush(70, "81", "01") - .ScriptError(SCRIPT_ERR_EVAL_FALSE)); + .SetScriptError(ScriptError::EVAL_FALSE)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG, @@ -596,7 +595,7 @@ .PushSigECDSA(keys.key0) .PushRedeem() .DamagePush(10) - .ScriptError(SCRIPT_ERR_EVAL_FALSE)); + .SetScriptError(ScriptError::EVAL_FALSE)); tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey0.GetID()) @@ -621,7 +620,7 @@ .PushSigECDSA(keys.key0) .DamagePush(10) .PushRedeem() - .ScriptError(SCRIPT_ERR_EQUALVERIFY)); + .SetScriptError(ScriptError::EQUALVERIFY)); tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) @@ -641,7 +640,7 @@ .PushSigECDSA(keys.key0) .PushSigECDSA(keys.key1) .Num(0) - .ScriptError(SCRIPT_ERR_EVAL_FALSE)); + .SetScriptError(ScriptError::EVAL_FALSE)); tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) @@ -661,7 +660,7 @@ .PushSigECDSA(keys.key1) .Num(0) .PushRedeem() - .ScriptError(SCRIPT_ERR_EVAL_FALSE)); + .SetScriptError(ScriptError::EVAL_FALSE)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, @@ -673,7 +672,7 @@ "P2PK with too much R padding", SCRIPT_VERIFY_DERSIG) .PushSigECDSA(keys.key1, SigHashType(), 31, 32) .EditPush(1, "43021F", "44022000") - .ScriptError(SCRIPT_ERR_SIG_DER)); + .SetScriptError(ScriptError::SIG_DER)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, "P2PK with too much S padding but no DERSIG", 0) @@ -686,7 +685,7 @@ .PushSigECDSA(keys.key1) .EditPush(1, "44", "45") .EditPush(37, "20", "2100") - .ScriptError(SCRIPT_ERR_SIG_DER)); + .SetScriptError(ScriptError::SIG_DER)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, "P2PK with too little R padding but no DERSIG", 0) @@ -697,7 +696,7 @@ "P2PK with too little R padding", SCRIPT_VERIFY_DERSIG) .PushSigECDSA(keys.key1, SigHashType(), 33, 32) .EditPush(1, "45022100", "440220") - .ScriptError(SCRIPT_ERR_SIG_DER)); + .SetScriptError(ScriptError::SIG_DER)); tests.push_back( TestBuilder( CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT, @@ -712,21 +711,21 @@ .PushSigECDSA(keys.key2, SigHashType(), 31, 32) .EditPush(1, "43021F", "44022000") .DamagePush(10) - .ScriptError(SCRIPT_ERR_SIG_DER)); + .SetScriptError(ScriptError::SIG_DER)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT, "P2PK NOT with too much R padding but no DERSIG", 0) .PushSigECDSA(keys.key2, SigHashType(), 31, 32) .EditPush(1, "43021F", "44022000") - .ScriptError(SCRIPT_ERR_EVAL_FALSE)); + .SetScriptError(ScriptError::EVAL_FALSE)); tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT, "P2PK NOT with too much R padding", SCRIPT_VERIFY_DERSIG) .PushSigECDSA(keys.key2, SigHashType(), 31, 32) .EditPush(1, "43021F", "44022000") - .ScriptError(SCRIPT_ERR_SIG_DER)); + .SetScriptError(ScriptError::SIG_DER)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, @@ -738,30 +737,30 @@ "BIP66 example 1, with DERSIG", SCRIPT_VERIFY_DERSIG) .PushSigECDSA(keys.key1, SigHashType(), 33, 32) .EditPush(1, "45022100", "440220") - .ScriptError(SCRIPT_ERR_SIG_DER)); + .SetScriptError(ScriptError::SIG_DER)); tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT, "BIP66 example 2, without DERSIG", 0) .PushSigECDSA(keys.key1, SigHashType(), 33, 32) .EditPush(1, "45022100", "440220") - .ScriptError(SCRIPT_ERR_EVAL_FALSE)); + .SetScriptError(ScriptError::EVAL_FALSE)); tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT, "BIP66 example 2, with DERSIG", SCRIPT_VERIFY_DERSIG) .PushSigECDSA(keys.key1, SigHashType(), 33, 32) .EditPush(1, "45022100", "440220") - .ScriptError(SCRIPT_ERR_SIG_DER)); + .SetScriptError(ScriptError::SIG_DER)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, "BIP66 example 3, without DERSIG", 0) .Num(0) - .ScriptError(SCRIPT_ERR_EVAL_FALSE)); + .SetScriptError(ScriptError::EVAL_FALSE)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, "BIP66 example 3, with DERSIG", SCRIPT_VERIFY_DERSIG) .Num(0) - .ScriptError(SCRIPT_ERR_EVAL_FALSE)); + .SetScriptError(ScriptError::EVAL_FALSE)); tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT, "BIP66 example 4, without DERSIG", 0) @@ -788,17 +787,17 @@ "non-null DER-compliant signature", SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_NULLFAIL) .Push("300602010102010101") - .ScriptError(SCRIPT_ERR_SIG_NULLFAIL)); + .SetScriptError(ScriptError::SIG_NULLFAIL)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, "BIP66 example 5, without DERSIG", 0) .Num(1) - .ScriptError(SCRIPT_ERR_EVAL_FALSE)); + .SetScriptError(ScriptError::EVAL_FALSE)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG, "BIP66 example 5, with DERSIG", SCRIPT_VERIFY_DERSIG) .Num(1) - .ScriptError(SCRIPT_ERR_SIG_DER)); + .SetScriptError(ScriptError::SIG_DER)); tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT, "BIP66 example 6, without DERSIG", 0) @@ -808,7 +807,7 @@ "BIP66 example 6, with DERSIG", SCRIPT_VERIFY_DERSIG) .Num(1) - .ScriptError(SCRIPT_ERR_SIG_DER)); + .SetScriptError(ScriptError::SIG_DER)); tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG, @@ -826,7 +825,7 @@ .PushSigECDSA(keys.key1, SigHashType(), 33, 32) .EditPush(1, "45022100", "440220") .PushSigECDSA(keys.key2) - .ScriptError(SCRIPT_ERR_SIG_DER)); + .SetScriptError(ScriptError::SIG_DER)); tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG << OP_NOT, @@ -835,7 +834,7 @@ .PushSigECDSA(keys.key1, SigHashType(), 33, 32) .EditPush(1, "45022100", "440220") .PushSigECDSA(keys.key2) - .ScriptError(SCRIPT_ERR_EVAL_FALSE)); + .SetScriptError(ScriptError::EVAL_FALSE)); tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG << OP_NOT, @@ -845,7 +844,7 @@ .PushSigECDSA(keys.key1, SigHashType(), 33, 32) .EditPush(1, "45022100", "440220") .PushSigECDSA(keys.key2) - .ScriptError(SCRIPT_ERR_SIG_DER)); + .SetScriptError(ScriptError::SIG_DER)); tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG, @@ -854,7 +853,7 @@ .Num(0) .PushSigECDSA(keys.key2, SigHashType(), 33, 32) .EditPush(1, "45022100", "440220") - .ScriptError(SCRIPT_ERR_EVAL_FALSE)); + .SetScriptError(ScriptError::EVAL_FALSE)); tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG, @@ -864,7 +863,7 @@ .Num(0) .PushSigECDSA(keys.key2, SigHashType(), 33, 32) .EditPush(1, "45022100", "440220") - .ScriptError(SCRIPT_ERR_SIG_DER)); + .SetScriptError(ScriptError::SIG_DER)); tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG << OP_NOT, @@ -882,7 +881,7 @@ .Num(0) .PushSigECDSA(keys.key2, SigHashType(), 33, 32) .EditPush(1, "45022100", "440220") - .ScriptError(SCRIPT_ERR_SIG_DER)); + .SetScriptError(ScriptError::SIG_DER)); tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG, @@ -891,7 +890,7 @@ .PushSigECDSA(keys.key1, SigHashType(), 33, 32) .EditPush(1, "45022100", "440220") .Num(0) - .ScriptError(SCRIPT_ERR_EVAL_FALSE)); + .SetScriptError(ScriptError::EVAL_FALSE)); tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG, @@ -901,7 +900,7 @@ .PushSigECDSA(keys.key1, SigHashType(), 33, 32) .EditPush(1, "45022100", "440220") .Num(0) - .ScriptError(SCRIPT_ERR_EVAL_FALSE)); + .SetScriptError(ScriptError::EVAL_FALSE)); tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_2 << OP_CHECKMULTISIG << OP_NOT, @@ -930,7 +929,7 @@ SCRIPT_VERIFY_DERSIG) .PushSigECDSA(keys.key2) .EditPush(70, "01", "0101") - .ScriptError(SCRIPT_ERR_SIG_DER)); + .SetScriptError(ScriptError::SIG_DER)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG, @@ -940,7 +939,7 @@ TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG, "P2PK with high S", SCRIPT_VERIFY_LOW_S) .PushSigECDSA(keys.key2, SigHashType(), 32, 33) - .ScriptError(SCRIPT_ERR_SIG_HIGH_S)); + .SetScriptError(ScriptError::SIG_HIGH_S)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG, @@ -950,19 +949,19 @@ TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG, "P2PK with hybrid pubkey", SCRIPT_VERIFY_STRICTENC) .PushSigECDSA(keys.key0, SigHashType()) - .ScriptError(SCRIPT_ERR_PUBKEYTYPE)); + .SetScriptError(ScriptError::PUBKEYTYPE)); tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT, "P2PK NOT with hybrid pubkey but no STRICTENC", 0) .PushSigECDSA(keys.key0) - .ScriptError(SCRIPT_ERR_EVAL_FALSE)); + .SetScriptError(ScriptError::EVAL_FALSE)); tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT, "P2PK NOT with hybrid pubkey", SCRIPT_VERIFY_STRICTENC) .PushSigECDSA(keys.key0) - .ScriptError(SCRIPT_ERR_PUBKEYTYPE)); + .SetScriptError(ScriptError::PUBKEYTYPE)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT, @@ -975,7 +974,7 @@ SCRIPT_VERIFY_STRICTENC) .PushSigECDSA(keys.key0) .DamagePush(10) - .ScriptError(SCRIPT_ERR_PUBKEYTYPE)); + .SetScriptError(ScriptError::PUBKEYTYPE)); tests.push_back( TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0H) << ToByteVector(keys.pubkey1C) << OP_2 @@ -998,7 +997,7 @@ SCRIPT_VERIFY_STRICTENC) .Num(0) .PushSigECDSA(keys.key1) - .ScriptError(SCRIPT_ERR_PUBKEYTYPE)); + .SetScriptError(ScriptError::PUBKEYTYPE)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG, @@ -1008,7 +1007,7 @@ TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG, "P2PK with undefined hashtype", SCRIPT_VERIFY_STRICTENC) .PushSigECDSA(keys.key1, SigHashType(5)) - .ScriptError(SCRIPT_ERR_SIG_HASHTYPE)); + .SetScriptError(ScriptError::SIG_HASHTYPE)); // Generate P2PKH tests for invalid SigHashType tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 @@ -1027,7 +1026,7 @@ Amount::zero(), SCRIPT_VERIFY_STRICTENC) .Push(keys.pubkey0) // Should fail for STRICTENC - .ScriptError(SCRIPT_ERR_SIG_HASHTYPE)); + .SetScriptError(ScriptError::SIG_HASHTYPE)); // Generate P2SH tests for invalid SigHashType tests.push_back( @@ -1043,7 +1042,7 @@ .PushSigECDSA(keys.key1, SigHashType(0x21)) .PushRedeem() // Should fail for STRICTENC - .ScriptError(SCRIPT_ERR_SIG_HASHTYPE)); + .SetScriptError(ScriptError::SIG_HASHTYPE)); tests.push_back( TestBuilder( @@ -1059,7 +1058,7 @@ SCRIPT_VERIFY_STRICTENC) .PushSigECDSA(keys.key1, SigHashType(5)) .DamagePush(10) - .ScriptError(SCRIPT_ERR_SIG_HASHTYPE)); + .SetScriptError(ScriptError::SIG_HASHTYPE)); tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) @@ -1080,7 +1079,7 @@ .PushSigECDSA(keys.key0) .PushSigECDSA(keys.key1) .PushSigECDSA(keys.key2) - .ScriptError(SCRIPT_ERR_SIG_NULLDUMMY)); + .SetScriptError(ScriptError::SIG_NULLDUMMY)); tests.push_back( TestBuilder( CScript() << OP_3 << ToByteVector(keys.pubkey0C) @@ -1105,7 +1104,7 @@ .PushSigECDSA(keys.key1) .PushSigECDSA(keys.key2) .DamagePush(10) - .ScriptError(SCRIPT_ERR_SIG_NULLDUMMY)); + .SetScriptError(ScriptError::SIG_NULLDUMMY)); tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C) << OP_2 @@ -1126,7 +1125,7 @@ .Num(0) .PushSigECDSA(keys.key1) .Add(CScript() << OP_DUP) - .ScriptError(SCRIPT_ERR_SIG_PUSHONLY)); + .SetScriptError(ScriptError::SIG_PUSHONLY)); tests.push_back( TestBuilder( CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG, @@ -1147,7 +1146,7 @@ .PushSigECDSA(keys.key2) .Add(CScript() << OP_NOP8) .PushRedeem() - .ScriptError(SCRIPT_ERR_SIG_PUSHONLY)); + .SetScriptError(ScriptError::SIG_PUSHONLY)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG, "P2SH(P2PK) with non-push scriptSig but not P2SH", @@ -1155,7 +1154,7 @@ .PushSigECDSA(keys.key2) .Add(CScript() << OP_NOP8) .PushRedeem() - .ScriptError(SCRIPT_ERR_SIG_PUSHONLY)); + .SetScriptError(ScriptError::SIG_PUSHONLY)); tests.push_back( TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey1C) << OP_2 @@ -1177,7 +1176,7 @@ SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH) .Num(11) .PushSigECDSA(keys.key0) - .ScriptError(SCRIPT_ERR_CLEANSTACK)); + .SetScriptError(ScriptError::CLEANSTACK)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, "P2SH with unnecessary input but no CLEANSTACK", @@ -1192,7 +1191,7 @@ .Num(11) .PushSigECDSA(keys.key0) .PushRedeem() - .ScriptError(SCRIPT_ERR_CLEANSTACK)); + .SetScriptError(ScriptError::CLEANSTACK)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, "P2SH with CLEANSTACK", @@ -1214,14 +1213,14 @@ TEST_AMOUNT) .PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32, TEST_AMOUNT + SATOSHI) - .ScriptError(SCRIPT_ERR_EVAL_FALSE)); + .SetScriptError(ScriptError::EVAL_FALSE)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG, "P2PK INVALID FORKID", SCRIPT_VERIFY_STRICTENC, false, TEST_AMOUNT) .PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32, TEST_AMOUNT) - .ScriptError(SCRIPT_ERR_ILLEGAL_FORKID)); + .SetScriptError(ScriptError::ILLEGAL_FORKID)); // Test replay protection tests.push_back( @@ -1243,7 +1242,7 @@ false, TEST_AMOUNT) .PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32, TEST_AMOUNT, SCRIPT_ENABLE_SIGHASH_FORKID) - .ScriptError(SCRIPT_ERR_EVAL_FALSE)); + .SetScriptError(ScriptError::EVAL_FALSE)); // Test OP_CHECKDATASIG const uint32_t checkdatasigflags = @@ -1260,7 +1259,7 @@ checkdatasigflags) .PushDataSigECDSA(keys.key1, {}) .Num(1) - .ScriptError(SCRIPT_ERR_SIG_NULLFAIL)); + .SetScriptError(ScriptError::SIG_NULLFAIL)); tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG << OP_NOT, "CHECKDATASIG without NULLFAIL flags", @@ -1284,7 +1283,7 @@ checkdatasigflags | SCRIPT_VERIFY_LOW_S) .PushDataSigECDSA(keys.key1, {}, 32, 33) .Num(0) - .ScriptError(SCRIPT_ERR_SIG_HIGH_S)); + .SetScriptError(ScriptError::SIG_HIGH_S)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG, "CHECKDATASIG with too little R padding but no DERSIG", @@ -1298,7 +1297,7 @@ .PushDataSigECDSA(keys.key1, {}, 33, 32) .EditPush(1, "45022100", "440220") .Num(0) - .ScriptError(SCRIPT_ERR_SIG_DER)); + .SetScriptError(ScriptError::SIG_DER)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG, "CHECKDATASIG with hybrid pubkey but no STRICTENC", @@ -1310,7 +1309,7 @@ "CHECKDATASIG with hybrid pubkey", checkdatasigflags) .PushDataSigECDSA(keys.key0, {}) .Num(0) - .ScriptError(SCRIPT_ERR_PUBKEYTYPE)); + .SetScriptError(ScriptError::PUBKEYTYPE)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG << OP_NOT, @@ -1326,7 +1325,7 @@ .PushDataSigECDSA(keys.key0, {}) .DamagePush(10) .Num(0) - .ScriptError(SCRIPT_ERR_PUBKEYTYPE)); + .SetScriptError(ScriptError::PUBKEYTYPE)); // Test OP_CHECKDATASIGVERIFY tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) @@ -1341,21 +1340,21 @@ checkdatasigflags) .PushDataSigECDSA(keys.key1, {}) .Num(1) - .ScriptError(SCRIPT_ERR_SIG_NULLFAIL)); + .SetScriptError(ScriptError::SIG_NULLFAIL)); tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIGVERIFY << OP_TRUE, "CHECKDATASIGVERIFY without NULLFAIL flags", checkdatasigflags & ~SCRIPT_VERIFY_NULLFAIL) .PushDataSigECDSA(keys.key1, {}) .Num(1) - .ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY)); + .SetScriptError(ScriptError::CHECKDATASIGVERIFY)); tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIGVERIFY << OP_TRUE, "CHECKDATASIGVERIFY empty signature", checkdatasigflags) .Num(0) .Num(0) - .ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY)); + .SetScriptError(ScriptError::CHECKDATASIGVERIFY)); tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIGVERIFY << OP_TRUE, "CHECKDATASIG with High S but no Low S", @@ -1368,7 +1367,7 @@ checkdatasigflags | SCRIPT_VERIFY_LOW_S) .PushDataSigECDSA(keys.key1, {}, 32, 33) .Num(0) - .ScriptError(SCRIPT_ERR_SIG_HIGH_S)); + .SetScriptError(ScriptError::SIG_HIGH_S)); tests.push_back( TestBuilder( CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIGVERIFY @@ -1385,7 +1384,7 @@ .PushDataSigECDSA(keys.key1, {}, 33, 32) .EditPush(1, "45022100", "440220") .Num(0) - .ScriptError(SCRIPT_ERR_SIG_DER)); + .SetScriptError(ScriptError::SIG_DER)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIGVERIFY << OP_TRUE, @@ -1399,7 +1398,7 @@ checkdatasigflags) .PushDataSigECDSA(keys.key0, {}) .Num(0) - .ScriptError(SCRIPT_ERR_PUBKEYTYPE)); + .SetScriptError(ScriptError::PUBKEYTYPE)); tests.push_back( TestBuilder( CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIGVERIFY @@ -1408,7 +1407,7 @@ .PushDataSigECDSA(keys.key0, {}) .DamagePush(10) .Num(0) - .ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY)); + .SetScriptError(ScriptError::CHECKDATASIGVERIFY)); tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIGVERIFY << OP_TRUE, "CHECKDATASIGVERIFY with invalid hybrid pubkey", @@ -1416,7 +1415,7 @@ .PushDataSigECDSA(keys.key0, {}) .DamagePush(10) .Num(0) - .ScriptError(SCRIPT_ERR_PUBKEYTYPE)); + .SetScriptError(ScriptError::PUBKEYTYPE)); // Test all six CHECK*SIG* opcodes with Schnorr signatures. // - STRICTENC flag on/off. @@ -1461,7 +1460,7 @@ "CHECKSIGVERIFY Schnorr mismatched key", SCRIPT_VERIFY_STRICTENC) .PushSigSchnorr(keys.key1) - .ScriptError(SCRIPT_ERR_CHECKSIGVERIFY)); + .SetScriptError(ScriptError::CHECKSIGVERIFY)); // CHECKDATASIG and Schnorr tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0) @@ -1514,7 +1513,7 @@ "CHECKDATASIGVERIFY Schnorr mismatched key", SCRIPT_VERIFY_STRICTENC) .PushDataSigSchnorr(keys.key1, {}) - .ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY)); + .SetScriptError(ScriptError::CHECKDATASIGVERIFY)); tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1) << OP_CHECKDATASIGVERIFY << OP_1, "CHECKDATASIGVERIFY Schnorr other message", @@ -1525,7 +1524,7 @@ "CHECKDATASIGVERIFY Schnorr wrong message", SCRIPT_VERIFY_STRICTENC) .PushDataSigSchnorr(keys.key1, {1}) - .ScriptError(SCRIPT_ERR_CHECKDATASIGVERIFY)); + .SetScriptError(ScriptError::CHECKDATASIGVERIFY)); // CHECKMULTISIG 1-of-1 and Schnorr tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) @@ -1533,14 +1532,14 @@ "CHECKMULTISIG Schnorr w/ no STRICTENC", 0) .Num(0) .PushSigSchnorr(keys.key0) - .ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); + .SetScriptError(ScriptError::SIG_BADLENGTH)); tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1 << OP_CHECKMULTISIG, "CHECKMULTISIG Schnorr w/ STRICTENC", SCRIPT_VERIFY_STRICTENC) .Num(0) .PushSigSchnorr(keys.key0) - .ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); + .SetScriptError(ScriptError::SIG_BADLENGTH)); // Test multisig with multiple Schnorr signatures tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) @@ -1552,7 +1551,7 @@ .PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key1) .PushSigSchnorr(keys.key2) - .ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); + .SetScriptError(ScriptError::SIG_BADLENGTH)); tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 @@ -1562,7 +1561,7 @@ .PushSigECDSA(keys.key0) .PushSigECDSA(keys.key1) .PushSigSchnorr(keys.key2) - .ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); + .SetScriptError(ScriptError::SIG_BADLENGTH)); // CHECKMULTISIGVERIFY 1-of-1 and Schnorr tests.push_back( @@ -1571,7 +1570,7 @@ "CHECKMULTISIGVERIFY Schnorr w/ no STRICTENC", 0) .Num(0) .PushSigSchnorr(keys.key0) - .ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); + .SetScriptError(ScriptError::SIG_BADLENGTH)); tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1 << OP_CHECKMULTISIGVERIFY << OP_1, @@ -1579,7 +1578,7 @@ SCRIPT_VERIFY_STRICTENC) .Num(0) .PushSigSchnorr(keys.key0) - .ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); + .SetScriptError(ScriptError::SIG_BADLENGTH)); // Test damaged Schnorr signatures tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0) @@ -1599,7 +1598,7 @@ SCRIPT_VERIFY_NULLFAIL) .PushSigSchnorr(keys.key0) .DamagePush(10) - .ScriptError(SCRIPT_ERR_SIG_NULLFAIL)); + .SetScriptError(ScriptError::SIG_NULLFAIL)); // Make sure P2PKH works with Schnorr tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160 @@ -1627,12 +1626,12 @@ SCRIPT_VERIFY_STRICTENC | SCRIPT_VERIFY_COMPRESSED_PUBKEYTYPE) .PushSigSchnorr(keys.key0, SigHashType()) - .ScriptError(SCRIPT_ERR_NONCOMPRESSED_PUBKEY)); + .SetScriptError(ScriptError::NONCOMPRESSED_PUBKEY)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG, "Schnorr P2PK with hybrid pubkey", SCRIPT_VERIFY_STRICTENC) .PushSigSchnorr(keys.key0, SigHashType()) - .ScriptError(SCRIPT_ERR_PUBKEYTYPE)); + .SetScriptError(ScriptError::PUBKEYTYPE)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG, "Schnorr P2PK with hybrid pubkey but no STRICTENC", 0) @@ -1650,7 +1649,7 @@ "Schnorr P2PK with undefined basehashtype and STRICTENC", SCRIPT_VERIFY_STRICTENC) .PushSigSchnorr(keys.key1, SigHashType(5)) - .ScriptError(SCRIPT_ERR_SIG_HASHTYPE)); + .SetScriptError(ScriptError::SIG_HASHTYPE)); tests.push_back( TestBuilder(CScript() << OP_DUP << OP_HASH160 << ToByteVector(keys.pubkey0.GetID()) @@ -1668,7 +1667,7 @@ .PushSigSchnorr(keys.key0, SigHashType(0x21), Amount::zero(), SCRIPT_VERIFY_STRICTENC) .Push(keys.pubkey0) - .ScriptError(SCRIPT_ERR_SIG_HASHTYPE)); + .SetScriptError(ScriptError::SIG_HASHTYPE)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG, "Schnorr P2PK anyonecanpay", 0) @@ -1678,7 +1677,7 @@ "Schnorr P2PK anyonecanpay marked with normal hashtype", 0) .PushSigSchnorr(keys.key1, SigHashType().withAnyoneCanPay()) .EditPush(64, "81", "01") - .ScriptError(SCRIPT_ERR_EVAL_FALSE)); + .SetScriptError(ScriptError::EVAL_FALSE)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG, "Schnorr P2PK with forkID", @@ -1689,14 +1688,14 @@ "Schnorr P2PK with non-forkID sig", SCRIPT_VERIFY_STRICTENC | SCRIPT_ENABLE_SIGHASH_FORKID) .PushSigSchnorr(keys.key1) - .ScriptError(SCRIPT_ERR_MUST_USE_FORKID)); + .SetScriptError(ScriptError::MUST_USE_FORKID)); tests.push_back( TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG, "Schnorr P2PK with cheater forkID bit", SCRIPT_VERIFY_STRICTENC | SCRIPT_ENABLE_SIGHASH_FORKID) .PushSigSchnorr(keys.key1) .EditPush(64, "01", "41") - .ScriptError(SCRIPT_ERR_EVAL_FALSE)); + .SetScriptError(ScriptError::EVAL_FALSE)); { // There is a point with x = 7 + order but not x = 7. @@ -1734,7 +1733,7 @@ SCRIPT_VERIFY_STRICTENC) .PushECDSASigFromParts(rdata, sdata) .PushECDSARecoveredPubKey(rdata, sdata) - .ScriptError(SCRIPT_ERR_EVAL_FALSE)); + .SetScriptError(ScriptError::EVAL_FALSE)); } { std::vector rdata = ParseHex( @@ -1760,7 +1759,7 @@ .Num(0) .PushECDSASigFromParts(rdata, sdata) .PushECDSARecoveredPubKey(rdata, sdata) - .ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); + .SetScriptError(ScriptError::SIG_BADLENGTH)); } // New-multisig tests follow. New multisig will activate with a bunch of @@ -1789,7 +1788,7 @@ newmultisigflags) .Num(0) .PushSigECDSA(keys.key1) - .ScriptError(SCRIPT_ERR_PUBKEYTYPE)); + .SetScriptError(ScriptError::PUBKEYTYPE)); tests.push_back( TestBuilder( CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1 @@ -1798,14 +1797,14 @@ newmultisigflags & ~SCRIPT_VERIFY_STRICTENC) .Num(0) .PushSigSchnorr(keys.key0) - .ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); + .SetScriptError(ScriptError::SIG_BADLENGTH)); tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1 << OP_CHECKMULTISIG, "Legacy 1-of-1 Schnorr w/ SCHNORR_MULTISIG", newmultisigflags) .Num(0) .PushSigSchnorr(keys.key0) - .ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); + .SetScriptError(ScriptError::SIG_BADLENGTH)); tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C) << OP_3 @@ -1816,7 +1815,7 @@ .PushSigSchnorr(keys.key0) .PushSigSchnorr(keys.key1) .PushSigSchnorr(keys.key2) - .ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); + .SetScriptError(ScriptError::SIG_BADLENGTH)); tests.push_back( TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C) << ToByteVector(keys.pubkey1C) @@ -1828,7 +1827,7 @@ .PushSigECDSA(keys.key0) .PushSigECDSA(keys.key1) .PushSigSchnorr(keys.key2) - .ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); + .SetScriptError(ScriptError::SIG_BADLENGTH)); { // Try valid 64-byte ECDSA sig in multisig. std::vector rdata = ParseHex( @@ -1842,7 +1841,7 @@ .Num(0) .PushECDSASigFromParts(rdata, sdata) .PushECDSARecoveredPubKey(rdata, sdata) - .ScriptError(SCRIPT_ERR_SIG_BADLENGTH)); + .SetScriptError(ScriptError::SIG_BADLENGTH)); } std::set tests_set; @@ -1914,7 +1913,7 @@ CScript scriptSig = ParseScript(scriptSigString); CScript scriptPubKey = ParseScript(scriptPubKeyString); unsigned int scriptflags = ParseScriptFlags(test[pos++].get_str()); - int scriptError = ParseScriptError(test[pos++].get_str()); + ScriptError scriptError = ParseScriptError(test[pos++].get_str()); DoTest(scriptPubKey, scriptSig, scriptflags, strTest, scriptError, nValue); @@ -1941,28 +1940,28 @@ BOOST_CHECK(EvalScript(directStack, CScript(&direct[0], &direct[sizeof(direct)]), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err)); std::vector> pushdata1Stack; BOOST_CHECK(EvalScript( pushdata1Stack, CScript(&pushdata1[0], &pushdata1[sizeof(pushdata1)]), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err)); BOOST_CHECK(pushdata1Stack == directStack); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err)); std::vector> pushdata2Stack; BOOST_CHECK(EvalScript( pushdata2Stack, CScript(&pushdata2[0], &pushdata2[sizeof(pushdata2)]), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err)); BOOST_CHECK(pushdata2Stack == directStack); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err)); std::vector> pushdata4Stack; BOOST_CHECK(EvalScript( pushdata4Stack, CScript(&pushdata4[0], &pushdata4[sizeof(pushdata4)]), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err)); BOOST_CHECK(pushdata4Stack == directStack); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err)); } static CScript sign_multisig(const CScript &scriptPubKey, @@ -2018,13 +2017,13 @@ goodsig1, scriptPubKey12, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue), &err)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err)); txTo12.vout[0].nValue = 2 * SATOSHI; BOOST_CHECK(!VerifyScript( goodsig1, scriptPubKey12, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue), &err)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err)); CScript goodsig2 = sign_multisig(scriptPubKey12, key2, CTransaction(txTo12)); @@ -2032,14 +2031,14 @@ goodsig2, scriptPubKey12, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue), &err)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err)); CScript badsig1 = sign_multisig(scriptPubKey12, key3, CTransaction(txTo12)); BOOST_CHECK(!VerifyScript( badsig1, scriptPubKey12, gFlags, MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue), &err)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err)); } BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG23) { @@ -2074,7 +2073,7 @@ goodsig1, scriptPubKey23, gFlags, TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err)); keys.clear(); keys.push_back(key1); @@ -2084,7 +2083,7 @@ goodsig2, scriptPubKey23, gFlags, TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err)); keys.clear(); keys.push_back(key2); @@ -2094,7 +2093,7 @@ goodsig3, scriptPubKey23, gFlags, TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err)); keys.clear(); keys.push_back(key2); @@ -2104,7 +2103,7 @@ badsig1, scriptPubKey23, gFlags, TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err)); keys.clear(); keys.push_back(key2); @@ -2114,7 +2113,7 @@ badsig2, scriptPubKey23, gFlags, TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err)); keys.clear(); keys.push_back(key3); @@ -2124,7 +2123,7 @@ badsig3, scriptPubKey23, gFlags, TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err)); keys.clear(); keys.push_back(key4); @@ -2134,7 +2133,7 @@ badsig4, scriptPubKey23, gFlags, TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err)); keys.clear(); keys.push_back(key1); @@ -2144,7 +2143,7 @@ badsig5, scriptPubKey23, gFlags, TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EVAL_FALSE, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err)); keys.clear(); // Must have signatures CScript badsig6 = sign_multisig(scriptPubKey23, keys, txTo23); @@ -2152,7 +2151,7 @@ badsig6, scriptPubKey23, gFlags, TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue), &err)); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_INVALID_STACK_OPERATION, + BOOST_CHECK_MESSAGE(err == ScriptError::INVALID_STACK_OPERATION, ScriptErrorString(err)); } @@ -2326,7 +2325,7 @@ SCRIPT_VERIFY_MINIMALDATA, BaseSignatureChecker(), &err), "Number " << i << " push is not minimal data."); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err)); } for (unsigned int i = 0; i <= MAX_SCRIPT_ELEMENT_SIZE; i++) { @@ -2339,7 +2338,7 @@ SCRIPT_VERIFY_MINIMALDATA, BaseSignatureChecker(), &err), "Length " << i << " push is not minimal data."); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err)); } } diff --git a/src/test/sigencoding_tests.cpp b/src/test/sigencoding_tests.cpp --- a/src/test/sigencoding_tests.cpp +++ b/src/test/sigencoding_tests.cpp @@ -20,7 +20,7 @@ static void CheckSignatureEncodingWithSigHashType(const valtype &vchSig, uint32_t flags) { - ScriptError err = SCRIPT_ERR_OK; + ScriptError err = ScriptError::OK; BOOST_CHECK(CheckDataSignatureEncoding(vchSig, flags, &err)); const bool hasForkId = (flags & SCRIPT_ENABLE_SIGHASH_FORKID) != 0; @@ -58,21 +58,21 @@ CheckTransactionSignatureEncoding(undefSighash, flags, &err), !hasStrictEnc); if (hasStrictEnc) { - BOOST_CHECK_EQUAL(err, SCRIPT_ERR_SIG_HASHTYPE); + BOOST_CHECK(err == ScriptError::SIG_HASHTYPE); } BOOST_CHECK_EQUAL(CheckTransactionECDSASignatureEncoding( undefSighash, flags, &err), !(hasStrictEnc || is64)); if (is64 || hasStrictEnc) { - BOOST_CHECK_EQUAL(err, is64 ? SCRIPT_ERR_SIG_BADLENGTH - : SCRIPT_ERR_SIG_HASHTYPE); + BOOST_CHECK(err == (is64 ? ScriptError::SIG_BADLENGTH + : ScriptError::SIG_HASHTYPE)); } BOOST_CHECK_EQUAL(CheckTransactionSchnorrSignatureEncoding( undefSighash, flags, &err), !(hasStrictEnc || !is64)); if (!is64 || hasStrictEnc) { - BOOST_CHECK_EQUAL(err, !is64 ? SCRIPT_ERR_SIG_NONSCHNORR - : SCRIPT_ERR_SIG_HASHTYPE); + BOOST_CHECK(err == (!is64 ? ScriptError::SIG_NONSCHNORR + : ScriptError::SIG_HASHTYPE)); } } @@ -84,26 +84,26 @@ CheckTransactionSignatureEncoding(invalidSig, flags, &err), !hasStrictEnc); if (hasStrictEnc) { - BOOST_CHECK_EQUAL(err, hasForkId ? SCRIPT_ERR_MUST_USE_FORKID - : SCRIPT_ERR_ILLEGAL_FORKID); + BOOST_CHECK(err == (hasForkId ? ScriptError::MUST_USE_FORKID + : ScriptError::ILLEGAL_FORKID)); } BOOST_CHECK_EQUAL( CheckTransactionECDSASignatureEncoding(invalidSig, flags, &err), !(hasStrictEnc || is64)); if (is64 || hasStrictEnc) { - BOOST_CHECK_EQUAL(err, is64 - ? SCRIPT_ERR_SIG_BADLENGTH - : hasForkId ? SCRIPT_ERR_MUST_USE_FORKID - : SCRIPT_ERR_ILLEGAL_FORKID); + BOOST_CHECK(err == (is64 + ? ScriptError::SIG_BADLENGTH + : hasForkId ? ScriptError::MUST_USE_FORKID + : ScriptError::ILLEGAL_FORKID)); } BOOST_CHECK_EQUAL( CheckTransactionSchnorrSignatureEncoding(invalidSig, flags, &err), !(hasStrictEnc || !is64)); if (!is64 || hasStrictEnc) { - BOOST_CHECK_EQUAL(err, !is64 - ? SCRIPT_ERR_SIG_NONSCHNORR - : hasForkId ? SCRIPT_ERR_MUST_USE_FORKID - : SCRIPT_ERR_ILLEGAL_FORKID); + BOOST_CHECK(err == (!is64 + ? ScriptError::SIG_NONSCHNORR + : hasForkId ? ScriptError::MUST_USE_FORKID + : ScriptError::ILLEGAL_FORKID)); } } } @@ -200,7 +200,7 @@ for (int i = 0; i < 4096; i++) { uint32_t flags = lcg.next(); - ScriptError err = SCRIPT_ERR_OK; + ScriptError err = ScriptError::OK; // Empty sig is always validly encoded. BOOST_CHECK(CheckDataSignatureEncoding({}, flags, &err)); @@ -217,7 +217,7 @@ if (flags & SCRIPT_VERIFY_LOW_S) { // If we do enforce low S, then high S sigs are rejected. BOOST_CHECK(!CheckDataSignatureEncoding(highSSig, flags, &err)); - BOOST_CHECK_EQUAL(err, SCRIPT_ERR_SIG_HIGH_S); + BOOST_CHECK(err == ScriptError::SIG_HIGH_S); } else { // If we do not enforce low S, then high S sigs are accepted. CheckSignatureEncodingWithSigHashType(highSSig, flags); @@ -230,7 +230,7 @@ // signature fails. BOOST_CHECK( !CheckDataSignatureEncoding(nonDERSig, flags, &err)); - BOOST_CHECK_EQUAL(err, SCRIPT_ERR_SIG_DER); + BOOST_CHECK(err == ScriptError::SIG_DER); } else { // If we do not check, then it is accepted. BOOST_CHECK(CheckDataSignatureEncoding(nonDERSig, flags, &err)); @@ -244,7 +244,7 @@ // signature fails. BOOST_CHECK( !CheckDataSignatureEncoding(nonDERSig, flags, &err)); - BOOST_CHECK_EQUAL(err, SCRIPT_ERR_SIG_DER); + BOOST_CHECK(err == ScriptError::SIG_DER); } else { // If we do not check, then it is accepted. BOOST_CHECK(CheckDataSignatureEncoding(nonDERSig, flags, &err)); @@ -372,7 +372,7 @@ for (int i = 0; i < 4096; i++) { uint32_t flags = lcg.next(); - ScriptError err = SCRIPT_ERR_OK; + ScriptError err = ScriptError::OK; // Compressed pubkeys are always valid. BOOST_CHECK(CheckPubKeyEncoding(compressedKey0, flags, &err)); @@ -385,7 +385,7 @@ BOOST_CHECK_EQUAL(CheckPubKeyEncoding(fullKey, flags, &err), allowFullKey); if (!allowFullKey) { - BOOST_CHECK_EQUAL(err, SCRIPT_ERR_NONCOMPRESSED_PUBKEY); + BOOST_CHECK(err == ScriptError::NONCOMPRESSED_PUBKEY); } // If SCRIPT_VERIFY_STRICTENC or SCRIPT_VERIFY_COMPRESSED_PUBKEYTYPE is @@ -396,9 +396,9 @@ BOOST_CHECK_EQUAL(CheckPubKeyEncoding(key, flags, &err), allowInvalidKeys); if (!allowInvalidKeys) { - BOOST_CHECK_EQUAL(err, hasStrictEnc - ? SCRIPT_ERR_PUBKEYTYPE - : SCRIPT_ERR_NONCOMPRESSED_PUBKEY); + BOOST_CHECK(err == (hasStrictEnc + ? ScriptError::PUBKEYTYPE + : ScriptError::NONCOMPRESSED_PUBKEY)); } } } @@ -424,7 +424,7 @@ const bool hasForkId = (flags & SCRIPT_ENABLE_SIGHASH_FORKID) != 0; - ScriptError err = SCRIPT_ERR_OK; + ScriptError err = ScriptError::OK; valtype DER65_hb = SignatureWithHashType(DER64, SigHashType().withForkId(hasForkId)); valtype Zero65_hb = @@ -434,7 +434,7 @@ BOOST_CHECK(CheckTransactionSignatureEncoding(DER65_hb, flags, &err)); BOOST_CHECK( !CheckTransactionECDSASignatureEncoding(DER65_hb, flags, &err)); - BOOST_CHECK_EQUAL(err, SCRIPT_ERR_SIG_BADLENGTH); + BOOST_CHECK(err == ScriptError::SIG_BADLENGTH); BOOST_CHECK( CheckTransactionSchnorrSignatureEncoding(DER65_hb, flags, &err)); @@ -442,7 +442,7 @@ BOOST_CHECK(CheckTransactionSignatureEncoding(Zero65_hb, flags, &err)); BOOST_CHECK( !CheckTransactionECDSASignatureEncoding(Zero65_hb, flags, &err)); - BOOST_CHECK_EQUAL(err, SCRIPT_ERR_SIG_BADLENGTH); + BOOST_CHECK(err == ScriptError::SIG_BADLENGTH); BOOST_CHECK( CheckTransactionSchnorrSignatureEncoding(Zero65_hb, flags, &err)); } diff --git a/src/test/sigopcount_tests.cpp b/src/test/sigopcount_tests.cpp --- a/src/test/sigopcount_tests.cpp +++ b/src/test/sigopcount_tests.cpp @@ -121,7 +121,7 @@ bool ret = VerifyScript( inputi.vin[0].scriptSig, output.vout[0].scriptPubKey, flags, TransactionSignatureChecker(&inputi, 0, output.vout[0].nValue), &error); - BOOST_CHECK_EQUAL((ret == true), (error == SCRIPT_ERR_OK)); + BOOST_CHECK_EQUAL((ret == true), (error == ScriptError::OK)); return error; } @@ -194,9 +194,8 @@ MAX_PUBKEYS_PER_MULTISIG); // Sanity check: script verification fails because of an invalid // signature. - BOOST_CHECK_EQUAL( - VerifyWithFlag(CTransaction(creationTx), spendingTx, flags), - SCRIPT_ERR_CHECKMULTISIGVERIFY); + BOOST_CHECK(VerifyWithFlag(CTransaction(creationTx), spendingTx, + flags) == ScriptError::CHECKMULTISIGVERIFY); // Make sure non P2SH sigops are counted even if the flag for P2SH is // not passed in. @@ -221,9 +220,8 @@ BOOST_CHECK_EQUAL( GetTransactionSigOpCount(CTransaction(spendingTx), coins, flags), 2); - BOOST_CHECK_EQUAL( - VerifyWithFlag(CTransaction(creationTx), spendingTx, flags), - SCRIPT_ERR_CHECKMULTISIGVERIFY); + BOOST_CHECK(VerifyWithFlag(CTransaction(creationTx), spendingTx, + flags) == ScriptError::CHECKMULTISIGVERIFY); // Make sure P2SH sigops are not counted if the flag for P2SH is not // passed in. diff --git a/src/test/transaction_tests.cpp b/src/test/transaction_tests.cpp --- a/src/test/transaction_tests.cpp +++ b/src/test/transaction_tests.cpp @@ -138,7 +138,7 @@ TransactionSignatureChecker(&tx, i, amount, txdata), &err), strTest); - BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, + BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err)); } } @@ -159,9 +159,9 @@ std::string(json_tests::tx_invalid, json_tests::tx_invalid + sizeof(json_tests::tx_invalid))); - // Initialize to SCRIPT_ERR_OK. The tests expect err to be changed to a - // value other than SCRIPT_ERR_OK. - ScriptError err = SCRIPT_ERR_OK; + // Initialize to ScriptError::OK. The tests expect err to be changed to a + // value other than ScriptError::OK. + ScriptError err = ScriptError::OK; for (size_t idx = 0; idx < tests.size(); idx++) { UniValue test = tests[idx]; std::string strTest = test.write(); @@ -226,7 +226,7 @@ TransactionSignatureChecker(&tx, i, amount, txdata), &err); } BOOST_CHECK_MESSAGE(!fValid, strTest); - BOOST_CHECK_MESSAGE(err != SCRIPT_ERR_OK, ScriptErrorString(err)); + BOOST_CHECK_MESSAGE(err != ScriptError::OK, ScriptErrorString(err)); } } } diff --git a/src/validation.h b/src/validation.h --- a/src/validation.h +++ b/src/validation.h @@ -530,7 +530,7 @@ public: CScriptCheck() : amount(), ptxTo(nullptr), nIn(0), nFlags(0), cacheStore(false), - error(SCRIPT_ERR_UNKNOWN_ERROR), txdata() {} + error(ScriptError::UNKNOWN), txdata() {} CScriptCheck(const CScript &scriptPubKeyIn, const Amount amountIn, const CTransaction &txToIn, unsigned int nInIn, @@ -538,7 +538,7 @@ const PrecomputedTransactionData &txdataIn) : scriptPubKey(scriptPubKeyIn), amount(amountIn), ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), cacheStore(cacheIn), - error(SCRIPT_ERR_UNKNOWN_ERROR), txdata(txdataIn) {} + error(ScriptError::UNKNOWN), txdata(txdataIn) {} bool operator()();