diff --git a/src/script/interpreter.cpp b/src/script/interpreter.cpp index b553cc69323..2f9555b62b7 100644 --- a/src/script/interpreter.cpp +++ b/src/script/interpreter.cpp @@ -293,7 +293,7 @@ bool EvalScript(std::vector >& stack, const CScript& // static const CScriptNum bnFalse(0); // static const CScriptNum bnTrue(1); static const valtype vchFalse(0); - // static const valtype vchZero(0); + static const valtype vchZero(0); static const valtype vchTrue(1, 1); CScript::const_iterator pc = script.begin(); @@ -327,22 +327,26 @@ bool EvalScript(std::vector >& stack, const CScript& if (opcode > OP_16 && ++nOpCount > MAX_OPS_PER_SCRIPT) return set_error(serror, SCRIPT_ERR_OP_COUNT); - if (opcode == OP_CAT || - opcode == OP_SUBSTR || - opcode == OP_LEFT || - opcode == OP_RIGHT || - opcode == OP_INVERT || - opcode == OP_AND || - opcode == OP_OR || - opcode == OP_XOR || + // ELEMENTS: + // commented out opcodes are re-enabled in Elements + if (//opcode == OP_CAT || + //opcode == OP_SUBSTR || + //opcode == OP_LEFT || + //opcode == OP_RIGHT || + //opcode == OP_INVERT || + //opcode == OP_AND || + //opcode == OP_OR || + //opcode == OP_XOR || + //opcode == OP_LSHIFT || + //opcode == OP_RSHIFT || opcode == OP_2MUL || opcode == OP_2DIV || opcode == OP_MUL || opcode == OP_DIV || - opcode == OP_MOD || - opcode == OP_LSHIFT || - opcode == OP_RSHIFT) + opcode == OP_MOD + ) { return set_error(serror, SCRIPT_ERR_DISABLED_OPCODE); // Disabled opcodes. + } // With SCRIPT_VERIFY_CONST_SCRIPTCODE, OP_CODESEPARATOR in non-segwit script is rejected even in an unexecuted branch if (opcode == OP_CODESEPARATOR && sigversion == SigVersion::BASE && (flags & SCRIPT_VERIFY_CONST_SCRIPTCODE)) @@ -733,6 +737,26 @@ bool EvalScript(std::vector >& stack, const CScript& } break; + case OP_CAT: + { + if (stack.size() < 2) + return set_error(serror, SCRIPT_ERR_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_INVALID_STACK_OPERATION); + + valtype vch3; + vch3.reserve(vch1.size() + vch2.size()); + vch3.insert(vch3.end(), vch1.begin(), vch1.end()); + vch3.insert(vch3.end(), vch2.begin(), vch2.end()); + + popstack(stack); + popstack(stack); + stack.push_back(vch3); + } + break; case OP_SIZE: { @@ -745,9 +769,255 @@ bool EvalScript(std::vector >& stack, const CScript& break; + // + // String operators + // + case OP_LEFT: + case OP_RIGHT: + { + if (stack.size() < 2) + return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + + valtype vch1 = stacktop(-2); + CScriptNum start(stacktop(-1), fRequireMinimal); + + if (start < 0) + return set_error(serror, SCRIPT_ERR_UNKNOWN_ERROR); + + valtype vch2; + switch (opcode) { + case OP_RIGHT: + { + if (start >= vch1.size()) + vch2 = vchZero; + else + vch2.insert(vch2.begin(), vch1.begin() + start.getint(), vch1.end()); + break; + } + case OP_LEFT: + { + if (start >= vch1.size()) + vch2 = vch1; + else + vch2.insert(vch2.begin(), vch1.begin(), vch1.begin() + start.getint()); + break; + } + default: + { + assert(!"invalid opcode"); + break; + } + } + popstack(stack); + popstack(stack); + stack.push_back(vch2); + } + break; + + case OP_SUBSTR: + case OP_SUBSTR_LAZY: + { + if (stack.size() < 3) + return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + + valtype vch1 = stacktop(-3); + CScriptNum start(stacktop(-2), fRequireMinimal); + CScriptNum length(stacktop(-1), fRequireMinimal); + + if (opcode == OP_SUBSTR_LAZY) { + if (start < 0) + start = 0; + + if (length < 0) + length = 0; + + if (start >= vch1.size()) { + popstack(stack); + popstack(stack); + popstack(stack); + stack.push_back(vchZero); + break; + } + + if (length > MAX_SCRIPT_ELEMENT_SIZE) + length = MAX_SCRIPT_ELEMENT_SIZE; + + // start + length cannot overflow because of the restrictions immediately above + if (start + length > vch1.size()) { + length = CScriptNum(vch1.size()) - start; + } + } + + if (length < 0 || start < 0) + return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + + if (start >= vch1.size()) + return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + + if (length > vch1.size()) + return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + + if ((start + length) > vch1.size()) + return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + + valtype vch2; + vch2.insert(vch2.begin(), vch1.begin() + start.getint(), vch1.begin() + (start + length).getint()); + + popstack(stack); + popstack(stack); + popstack(stack); + stack.push_back(vch2); + } + break; + + // // Bitwise logic // + case OP_RSHIFT: + { + if (stack.size() < 2) + return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + valtype vch1 = stacktop(-2); + CScriptNum bn(stacktop(-1), fRequireMinimal); + + if (bn < 0) + return set_error(serror, SCRIPT_ERR_UNKNOWN_ERROR); + + unsigned int full_bytes = bn.getint() / 8; + unsigned int bits = bn.getint() % 8; + + if (full_bytes >= vch1.size()) { + popstack(stack); + popstack(stack); + stack.push_back(vchZero); + break; + } + + valtype vch2; + vch2.insert(vch2.begin(), vch1.begin() + full_bytes, vch1.end()); + + uint16_t temp = 0; + for (int i=(vch2.size()-1);i>=0;--i) { + temp = (vch2[i] << (8 - bits)) | ((temp << 8) & 0xff00); + vch2[i] = (temp & 0xff00) >> 8; + } + + // 0x0fff >> 4 == 0x00ff or 0xff, reduce to minimal representation + while (!vch2.empty() && vch2.back() == 0) + vch2.pop_back(); + + popstack(stack); + popstack(stack); + stack.push_back(vch2); + } + break; + + case OP_LSHIFT: + { + if (stack.size() < 2) + return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + valtype vch1 = stacktop(-2); + CScriptNum bn(stacktop(-1), fRequireMinimal); + + if (bn < 0) + return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + + unsigned int full_bytes = bn.getint() / 8; + unsigned int bits = bn.getint() % 8; + + if (vch1.size() + full_bytes + (bits ? 1 : 0) > MAX_SCRIPT_ELEMENT_SIZE) + return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + + valtype vch2; + vch2.reserve(vch1.size() + full_bytes + 1); + vch2.insert(vch2.end(), full_bytes, 0); + vch2.insert(vch2.end(), vch1.begin(), vch1.end()); + vch2.insert(vch2.end(), 1, 0); + + uint16_t temp = 0; + for (size_t i=0;i> 8); + vch2[i] = temp & 0xff; + } + + // reduce to minimal representation + while (!vch2.empty() && vch2.back() == 0) + vch2.pop_back(); + + popstack(stack); + popstack(stack); + stack.push_back(vch2); + } + break; + + case OP_INVERT: + { + if (stack.size() < 1) + return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + valtype& vch1 = stacktop(-1); + for (size_t i = 0; i < vch1.size(); ++i) + vch1[i] = ~vch1[i]; + } + break; + + case OP_AND: + { + // (x1 x2 -- x1 & x2) + if (stack.size() < 2) + return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + valtype& vch1 = stacktop(-1); + valtype& vch2 = stacktop(-2); + if (vch1.size() != vch2.size()) + return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + + valtype vch3(vch1); + for (size_t i = 0; i < vch1.size(); i++) + vch3[i] &= vch2[i]; + popstack(stack); + popstack(stack); + stack.push_back(vch3); + } + break; + + case OP_OR: + { + // (x1 x2 -- x1 | x2) + if (stack.size() < 2) + return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + valtype& vch1 = stacktop(-1); + valtype& vch2 = stacktop(-2); + if (vch1.size() != vch2.size()) + return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + + valtype vch3(vch1); + for (size_t i = 0; i < vch1.size(); i++) + vch3[i] |= vch2[i]; + popstack(stack); + popstack(stack); + stack.push_back(vch3); + } + break; + + case OP_XOR: + { + // (x1 x2 -- x1 ^ x2) + if (stack.size() < 2) + return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + valtype& vch1 = stacktop(-1); + valtype& vch2 = stacktop(-2); + if (vch1.size() != vch2.size()) + return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + + valtype vch3(vch1); + for (size_t i = 0; i < vch1.size(); i++) + vch3[i] ^= vch2[i]; + popstack(stack); + popstack(stack); + stack.push_back(vch3); + } + break; + case OP_EQUAL: case OP_EQUALVERIFY: //case OP_NOTEQUAL: // use OP_NUMNOTEQUAL @@ -1071,6 +1341,97 @@ bool EvalScript(std::vector >& stack, const CScript& } break; + case OP_DETERMINISTICRANDOM: + { + if (stack.size() < 3) + return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + + valtype vchSeed = stacktop(-3); + CScriptNum bnMin(stacktop(-2), fRequireMinimal); + CScriptNum bnMax(stacktop(-1), fRequireMinimal); + + if (bnMin > bnMax) + return set_error(serror, SCRIPT_ERR_UNKNOWN_ERROR); + + if (bnMin == bnMax) { + popstack(stack); + popstack(stack); + popstack(stack); + stack.push_back(bnMin.getvch()); + break; + } + + // The range of the random source must be a multiple of the modulus + // to give every possible output value an equal possibility + uint64_t nMax = (bnMax-bnMin).getint(); + uint64_t nRange = (std::numeric_limits::max() / nMax) * nMax; + uint64_t nRand; + + valtype vchHash(32, 0); + uint64_t nCounter = 0; + int nHashIndex = 3; + CSHA256 hasher; + hasher.Write(vchSeed.data(), vchSeed.size()); + do { + if (nHashIndex >= 3) { + uint64_t le_counter = htole64(nCounter); + CSHA256(hasher).Write((const unsigned char*)&le_counter, sizeof(nCounter)).Finalize(vchHash.data()); + nHashIndex = 0; + nCounter++; + } + + nRand = 0; + for (size_t i=0; i<8; ++i) + nRand |= ((uint64_t)vchHash[(nHashIndex*8) + i]) << (8*i); + + nHashIndex++; + } while (nRand > nRange); + CScriptNum result(nRand % nMax); + result += bnMin.getint(); + + popstack(stack); + popstack(stack); + popstack(stack); + stack.push_back(result.getvch()); + } + break; + + case OP_CHECKSIGFROMSTACK: + case OP_CHECKSIGFROMSTACKVERIFY: + { + // (sig data pubkey -- bool) + if (stack.size() < 3) + return set_error(serror, SCRIPT_ERR_INVALID_STACK_OPERATION); + + valtype& vchSig = stacktop(-3); + valtype& vchData = stacktop(-2); + valtype& vchPubKey = stacktop(-1); + + // Sigs from stack have no hash byte ever + if (!CheckSignatureEncoding(vchSig, (flags | SCRIPT_NO_SIGHASH_BYTE), serror) || !CheckPubKeyEncoding(vchPubKey, flags, sigversion, serror)) { + //serror is set + return false; + } + + valtype vchHash(32); + CSHA256().Write(vchData.data(), vchData.size()).Finalize(vchHash.data()); + uint256 hash(vchHash); + + CPubKey pubkey(vchPubKey); + bool fSuccess = pubkey.Verify(hash, vchSig); + + popstack(stack); + popstack(stack); + popstack(stack); + stack.push_back(fSuccess ? vchTrue : vchFalse); + if (opcode == OP_CHECKSIGFROMSTACKVERIFY) + popstack(stack); + + if (!fSuccess) + return set_error(serror, SCRIPT_ERR_CHECKSIGVERIFY); + } + break; + default: return set_error(serror, SCRIPT_ERR_BAD_OPCODE); } diff --git a/src/script/script.cpp b/src/script/script.cpp index fba7745983f..b27f4eaa89b 100644 --- a/src/script/script.cpp +++ b/src/script/script.cpp @@ -72,6 +72,7 @@ const char* GetOpName(opcodetype opcode) // splice ops case OP_CAT : return "OP_CAT"; case OP_SUBSTR : return "OP_SUBSTR"; + case OP_SUBSTR_LAZY : return "OP_SUBSTR_LAZY"; case OP_LEFT : return "OP_LEFT"; case OP_RIGHT : return "OP_RIGHT"; case OP_SIZE : return "OP_SIZE"; @@ -126,6 +127,9 @@ const char* GetOpName(opcodetype opcode) case OP_CHECKSIGVERIFY : return "OP_CHECKSIGVERIFY"; case OP_CHECKMULTISIG : return "OP_CHECKMULTISIG"; case OP_CHECKMULTISIGVERIFY : return "OP_CHECKMULTISIGVERIFY"; + case OP_DETERMINISTICRANDOM : return "OP_DETERMINISTICRANDOM"; + case OP_CHECKSIGFROMSTACK : return "OP_CHECKSIGFROMSTACK"; + case OP_CHECKSIGFROMSTACKVERIFY: return "OP_CHECKSIGFROMSTACKVERIFY"; // expansion case OP_NOP1 : return "OP_NOP1"; @@ -156,7 +160,8 @@ unsigned int CScript::GetSigOpCount(bool fAccurate) const opcodetype opcode; if (!GetOp(pc, opcode)) break; - if (opcode == OP_CHECKSIG || opcode == OP_CHECKSIGVERIFY) + if (opcode == OP_CHECKSIG || opcode == OP_CHECKSIGVERIFY || + opcode == OP_CHECKSIGFROMSTACK || opcode == OP_CHECKSIGFROMSTACKVERIFY) n++; else if (opcode == OP_CHECKMULTISIG || opcode == OP_CHECKMULTISIGVERIFY) { diff --git a/src/script/script.h b/src/script/script.h index a66dbc9353f..5fbbb891b6c 100644 --- a/src/script/script.h +++ b/src/script/script.h @@ -116,6 +116,7 @@ enum opcodetype // splice ops OP_CAT = 0x7e, OP_SUBSTR = 0x7f, + OP_SUBSTR_LAZY = 0xc3, OP_LEFT = 0x80, OP_RIGHT = 0x81, OP_SIZE = 0x82, @@ -173,6 +174,9 @@ enum opcodetype OP_CHECKSIGVERIFY = 0xad, OP_CHECKMULTISIG = 0xae, OP_CHECKMULTISIGVERIFY = 0xaf, + OP_DETERMINISTICRANDOM = 0xc0, + OP_CHECKSIGFROMSTACK = 0xc1, + OP_CHECKSIGFROMSTACKVERIFY = 0xc2, // expansion OP_NOP1 = 0xb0, @@ -192,7 +196,7 @@ enum opcodetype }; // Maximum value that an opcode can be -static const unsigned int MAX_OPCODE = OP_NOP10; +static const unsigned int MAX_OPCODE = OP_SUBSTR_LAZY; // 0xc3 const char* GetOpName(opcodetype opcode); diff --git a/src/test/data/script_tests.json b/src/test/data/script_tests.json index 9b320b6943c..ded29bbf512 100644 --- a/src/test/data/script_tests.json +++ b/src/test/data/script_tests.json @@ -258,9 +258,6 @@ ["0", "IF 0xbd ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"], ["0", "IF 0xbe ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"], ["0", "IF 0xbf ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"], -["0", "IF 0xc0 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"], -["0", "IF 0xc1 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"], -["0", "IF 0xc2 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"], ["0", "IF 0xc3 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"], ["0", "IF 0xc4 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"], ["0", "IF 0xc5 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"], @@ -829,26 +826,13 @@ ["NOP", "2SWAP 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"], ["1", "2 3 2SWAP 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"], -["'a' 'b'", "CAT", "P2SH,STRICTENC", "DISABLED_OPCODE", "CAT disabled"], -["'a' 'b' 0", "IF CAT ELSE 1 ENDIF", "P2SH,STRICTENC", "DISABLED_OPCODE", "CAT disabled"], -["'abc' 1 1", "SUBSTR", "P2SH,STRICTENC", "DISABLED_OPCODE", "SUBSTR disabled"], -["'abc' 1 1 0", "IF SUBSTR ELSE 1 ENDIF", "P2SH,STRICTENC", "DISABLED_OPCODE", "SUBSTR disabled"], -["'abc' 2 0", "IF LEFT ELSE 1 ENDIF", "P2SH,STRICTENC", "DISABLED_OPCODE", "LEFT disabled"], -["'abc' 2 0", "IF RIGHT ELSE 1 ENDIF", "P2SH,STRICTENC", "DISABLED_OPCODE", "RIGHT disabled"], - ["NOP", "SIZE 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"], -["'abc'", "IF INVERT ELSE 1 ENDIF", "P2SH,STRICTENC", "DISABLED_OPCODE", "INVERT disabled"], -["1 2 0 IF AND ELSE 1 ENDIF", "NOP", "P2SH,STRICTENC", "DISABLED_OPCODE", "AND disabled"], -["1 2 0 IF OR ELSE 1 ENDIF", "NOP", "P2SH,STRICTENC", "DISABLED_OPCODE", "OR disabled"], -["1 2 0 IF XOR ELSE 1 ENDIF", "NOP", "P2SH,STRICTENC", "DISABLED_OPCODE", "XOR disabled"], ["2 0 IF 2MUL ELSE 1 ENDIF", "NOP", "P2SH,STRICTENC", "DISABLED_OPCODE", "2MUL disabled"], ["2 0 IF 2DIV ELSE 1 ENDIF", "NOP", "P2SH,STRICTENC", "DISABLED_OPCODE", "2DIV disabled"], ["2 2 0 IF MUL ELSE 1 ENDIF", "NOP", "P2SH,STRICTENC", "DISABLED_OPCODE", "MUL disabled"], ["2 2 0 IF DIV ELSE 1 ENDIF", "NOP", "P2SH,STRICTENC", "DISABLED_OPCODE", "DIV disabled"], ["2 2 0 IF MOD ELSE 1 ENDIF", "NOP", "P2SH,STRICTENC", "DISABLED_OPCODE", "MOD disabled"], -["2 2 0 IF LSHIFT ELSE 1 ENDIF", "NOP", "P2SH,STRICTENC", "DISABLED_OPCODE", "LSHIFT disabled"], -["2 2 0 IF RSHIFT ELSE 1 ENDIF", "NOP", "P2SH,STRICTENC", "DISABLED_OPCODE", "RSHIFT disabled"], ["", "EQUAL NOT", "P2SH,STRICTENC", "INVALID_STACK_OPERATION", "EQUAL must error when there are no stack items"], ["0", "EQUAL NOT", "P2SH,STRICTENC", "INVALID_STACK_OPERATION", "EQUAL must error when there are not 2 stack items"], @@ -866,8 +850,6 @@ ["2 2MUL", "4 EQUAL", "P2SH,STRICTENC", "DISABLED_OPCODE", "disabled"], ["2 2DIV", "1 EQUAL", "P2SH,STRICTENC", "DISABLED_OPCODE", "disabled"], ["7 3 MOD", "1 EQUAL", "P2SH,STRICTENC", "DISABLED_OPCODE", "disabled"], -["2 2 LSHIFT", "8 EQUAL", "P2SH,STRICTENC", "DISABLED_OPCODE", "disabled"], -["2 1 RSHIFT", "1 EQUAL", "P2SH,STRICTENC", "DISABLED_OPCODE", "disabled"], ["1", "NOP1 CHECKLOCKTIMEVERIFY CHECKSEQUENCEVERIFY NOP4 NOP5 NOP6 NOP7 NOP8 NOP9 NOP10 2 EQUAL", "P2SH,STRICTENC", "EVAL_FALSE"], ["'NOP_1_to_10' NOP1 CHECKLOCKTIMEVERIFY CHECKSEQUENCEVERIFY NOP4 NOP5 NOP6 NOP7 NOP8 NOP9 NOP10","'NOP_1_to_11' EQUAL", "P2SH,STRICTENC", "EVAL_FALSE"], @@ -894,10 +876,6 @@ ["1", "IF 0xbd ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"], ["1", "IF 0xbe ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"], ["1", "IF 0xbf ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"], -["1", "IF 0xc0 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"], -["1", "IF 0xc1 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"], -["1", "IF 0xc2 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"], -["1", "IF 0xc3 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"], ["1", "IF 0xc4 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"], ["1", "IF 0xc5 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"], ["1", "IF 0xc6 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"], @@ -2615,5 +2593,146 @@ ["0 0x09 0x300602010102010101 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0", "0x01 0x14 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0x01 0x14 CHECKMULTISIG NOT", "DERSIG", "OK", "BIP66-compliant but not NULLFAIL-compliant"], ["0 0x09 0x300602010102010101 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0", "0x01 0x14 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0x01 0x14 CHECKMULTISIG NOT", "DERSIG,NULLFAIL", "NULLFAIL", "BIP66-compliant but not NULLFAIL-compliant"], + +["ELEMENTS:"], + + +["re-enabled opcodes:"], + +["0x08 0x0102030405060708", "-1 RIGHT 0x00 EQUAL", "", "UNKNOWN_ERROR", "-1 is not allowed"], +["0x08 0x0102030405060708", "-1 LEFT 0x00 EQUAL", "", "UNKNOWN_ERROR", "-1 is not allowed"], + +["0x08 0xffffffffffffffff 0x07 0x00000000000000", "AND 0x08 0x0000000000000001 EQUAL", "", "INVALID_STACK_OPERATION", "unequal length"], +["0x08 0xffffffffffffffff 0x06 0x020000000000", "AND 0x08 0x0200000000000002 EQUAL", "", "INVALID_STACK_OPERATION", "unequal length"], + +["0x08 0x0f0f0f0f0f0f0f0f 0x07 0xf0f0f0f0f0f0f0", "OR 0x08 0xffffffffffffffff EQUAL", "", "INVALID_STACK_OPERATION", "unequal length"], +["0x08 0xffffffffffffffff 0x06 0x000000000000", "OR 0x08 0xffffffffffffffff EQUAL", "", "INVALID_STACK_OPERATION", "unequal length"], + +["0x08 0x01ffffffffffffff", "-1 7 SUBSTR 0x07 0xffffffffffffff EQUAL", "", "INVALID_STACK_OPERATION", "-1 is not allowed"], +["0x08 0x01ffffffffffffff", "1 -7 SUBSTR 0x07 0xffffffffffffff EQUAL", "", "INVALID_STACK_OPERATION", "-1 is not allowed"], +["0x08 0x01ffffffffffffff", "9 1 SUBSTR 0x07 0xffffffffffffff EQUAL", "", "INVALID_STACK_OPERATION", "range exceeds length"], +["0x08 0x01ffffffffffffff", "0 9 SUBSTR 0x07 0xffffffffffffff EQUAL", "", "INVALID_STACK_OPERATION", "range exceeds length"], + +["0x08 0x0000000000000000", "INVERT 0x08 0x0000000000000000 EQUAL", "", "EVAL_FALSE", "not equal"], +["", "INVERT 0x08 0x0000000000000000 EQUAL", "", "INVALID_STACK_OPERATION", "nothing on stack"], + +["0x08 0x0000000000000000 0x08 0xffffffffffffffff", "CAT DEPTH 1 EQUALVERIFY 0x10 0xffffffffffffffff0000000000000000 EQUAL", "STRICTENC", "EVAL_FALSE", "wrong CAT order", "size > MAX_SCRIPT_ELEMENT_SIZE"], +["0x08 0xffffffffffffffff", "DUP CAT DUP CAT DUP CAT DUP CAT DUP CAT DUP CAT DUP CAT", "STRICTENC", "INVALID_STACK_OPERATION", "size > MAX_SCRIPT_ELEMENT_SIZE"], +["0x08 0xffffffffffffffff 0x08 0xffffffffffffffff", "DUP CAT DUP CAT DUP CAT DUP CAT DUP CAT DUP CAT CAT DEPTH 1 EQUALVERIFY 0x4d 0x0802 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff EQUAL", "STRICTENC", "OK"], +[""], + +["1", "4 LSHIFT 16 EQUAL", "", "OK"], + +["0x08 0x0102030405060708", "0 LSHIFT 0x08 0x0102030405060708 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "4 LSHIFT 0x09 0x1020304050607080 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "8 LSHIFT 0x09 0x000102030405060708 EQUAL", "", "OK"], + +["0x08 0x0102030405060708", "0 RSHIFT 0x08 0x0102030405060708 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "8 RSHIFT 0x07 0x02030405060708 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "16 RSHIFT 0x06 0x030405060708 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "24 RSHIFT 0x05 0x0405060708 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "32 RSHIFT 0x04 0x05060708 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "40 RSHIFT 0x03 0x060708 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "48 RSHIFT 0x02 0x0708 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "56 RSHIFT 0x01 0x08 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "64 RSHIFT 0x00 EQUAL", "", "OK"], + +["0x08 0xffffffffffffffff", "0 RSHIFT 0x08 0xffffffffffffffff EQUAL", "", "OK"], +["0x08 0xffffffffffffffff", "4 RSHIFT 0x08 0xffffffffffffff0f EQUAL", "", "OK"], +["0x08 0xffffffffffffffff", "8 RSHIFT 0x07 0xffffffffffffff EQUAL", "", "OK"], +["0x08 0xffffffffffffffff", "12 RSHIFT 0x07 0xffffffffffff0f EQUAL", "", "OK"], +["0x08 0xffffffffffffffff", "16 RSHIFT 0x06 0xffffffffffff EQUAL", "", "OK"], +["0x08 0xffffffffffffffff", "20 RSHIFT 0x06 0xffffffffff0f EQUAL", "", "OK"], +["0x08 0xffffffffffffffff", "24 RSHIFT 0x05 0xffffffffff EQUAL", "", "OK"], +["0x08 0xffffffffffffffff", "28 RSHIFT 0x05 0xffffffff0f EQUAL", "", "OK"], +["0x08 0xffffffffffffffff", "32 RSHIFT 0x04 0xffffffff EQUAL", "", "OK"], +["0x08 0xffffffffffffffff", "36 RSHIFT 0x04 0xffffff0f EQUAL", "", "OK"], +["0x08 0xffffffffffffffff", "40 RSHIFT 0x03 0xffffff EQUAL", "", "OK"], +["0x08 0xffffffffffffffff", "44 RSHIFT 0x03 0xffff0f EQUAL", "", "OK"], +["0x08 0xffffffffffffffff", "48 RSHIFT 0x02 0xffff EQUAL", "", "OK"], +["0x08 0xffffffffffffffff", "52 RSHIFT 0x02 0xff0f EQUAL", "", "OK"], +["0x08 0xffffffffffffffff", "56 RSHIFT 0x01 0xff EQUAL", "", "OK"], +["0x08 0xffffffffffffffff", "60 RSHIFT 0x01 0x0f EQUAL", "", "OK"], +["0x08 0xffffffffffffffff", "64 RSHIFT 0x00 EQUAL", "", "OK"], + +["0x08 0xffffffffffffff0f", "4 RSHIFT 0x08 0xffffffffffffff EQUAL", "", "OK"], +["0x01 0x0f", "4 RSHIFT 0x00 EQUAL", "", "OK"], + +["0x08 0x0102030405060708", "0 RIGHT 0x08 0x0102030405060708 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "1 RIGHT 0x07 0x02030405060708 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "2 RIGHT 0x06 0x030405060708 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "3 RIGHT 0x05 0x0405060708 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "4 RIGHT 0x04 0x05060708 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "5 RIGHT 0x03 0x060708 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "6 RIGHT 0x02 0x0708 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "7 RIGHT 0x01 0x08 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "8 RIGHT 0x00 EQUAL", "", "OK"], + +["0x08 0x0102030405060708", "8 LEFT 0x08 0x0102030405060708 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "7 LEFT 0x07 0x01020304050607 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "6 LEFT 0x06 0x010203040506 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "5 LEFT 0x05 0x0102030405 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "4 LEFT 0x04 0x01020304 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "3 LEFT 0x03 0x010203 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "2 LEFT 0x02 0x0102 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "1 LEFT 0x01 0x01 EQUAL", "", "OK"], +["0x08 0x0102030405060708", "0 LEFT 0x00 EQUAL", "", "OK"], + +["0x08 0xffffffffffffffff 0x08 0x0000000000000001", "AND 0x08 0x0000000000000001 EQUAL", "", "OK"], +["0x08 0xffffffffffffffff 0x08 0x0200000000000002", "AND 0x08 0x0200000000000002 EQUAL", "", "OK"], + +["0x08 0x0f0f0f0f0f0f0f0f 0x08 0xf0f0f0f0f0f0f0f0", "OR 0x08 0xffffffffffffffff EQUAL", "", "OK"], +["0x08 0xffffffffffffffff 0x08 0x0000000000000000", "OR 0x08 0xffffffffffffffff EQUAL", "", "OK"], + +["0x08 0x01ffffffffffffff", "0 8 SUBSTR 0x08 0x01ffffffffffffff EQUAL", "", "OK"], +["0x08 0x01ffffffffffffff", "1 7 SUBSTR 0x07 0xffffffffffffff EQUAL", "", "OK"], + +["0x08 0x0000000000000000", "INVERT 0x08 0xffffffffffffff EQUAL", "", "OK"], + +["0x08 0xffffffffffffffff 0x08 0x0000000000000000", "CAT DEPTH 1 EQUALVERIFY 0x10 0xffffffffffffffff0000000000000000 EQUAL", "STRICTENC", "OK"], +["0x08 0xffffffffffffffff", "DUP CAT DEPTH 1 EQUALVERIFY 0x10 0xffffffffffffffffffffffffffffffff EQUAL", "STRICTENC", "OK"], +["0x08 0xffffffffffffffff", "DUP CAT DUP CAT DEPTH 1 EQUALVERIFY 0x20 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff EQUAL", "STRICTENC", "OK"], +["0x08 0xffffffffffffffff", "DUP CAT DUP CAT DUP CAT DEPTH 1 EQUALVERIFY 0x40 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff EQUAL", "STRICTENC", "OK"], +["0x08 0xffffffffffffffff", "DUP CAT DUP CAT DUP CAT DUP CAT DEPTH 1 EQUALVERIFY 0x4c 0x80 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff EQUAL", "STRICTENC", "OK"], +["0x08 0xffffffffffffffff", "DUP CAT DUP CAT DUP CAT DUP CAT DUP CAT DEPTH 1 EQUALVERIFY 0x4d 0x0001 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff EQUAL", "STRICTENC", "OK"], + +["0x08 0xffffffffffffffff", "DUP CAT DUP CAT DUP CAT DUP CAT DUP CAT DUP CAT DEPTH 1 EQUALVERIFY 0x4d 0x0002 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff EQUAL", "STRICTENC", "OK"], +["0x08 0xffffffffffffffff", "DUP DUP CAT DEPTH 2 EQUALVERIFY 0x10 0xffffffffffffffffffffffffffffffff EQUAL", "STRICTENC", "OK"], +["0x08 0xffffffffffffffff", "DUP DUP CAT DUP CAT DEPTH 2 EQUALVERIFY 0x20 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff EQUAL", "STRICTENC", "OK"], +["0x08 0xffffffffffffffff", "DUP DUP CAT DUP CAT DUP CAT DEPTH 2 EQUALVERIFY 0x40 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff EQUAL", "STRICTENC", "OK"], +["0x08 0xffffffffffffffff", "DUP DUP CAT DUP CAT DUP CAT DUP CAT DEPTH 2 EQUALVERIFY 0x4c 0x80 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff EQUAL", "STRICTENC", "OK"], +["0x08 0xffffffffffffffff", "DUP DUP CAT DUP CAT DUP CAT DUP CAT DUP CAT DEPTH 2 EQUALVERIFY 0x4d 0x0001 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff EQUAL", "STRICTENC", "OK"], +["0x08 0xffffffffffffffff", "DUP DUP CAT DUP CAT DUP CAT DUP CAT DUP CAT DUP CAT DEPTH 2 EQUALVERIFY 0x4d 0x0002 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff EQUAL", "STRICTENC", "OK"], +["0x08 0xffffffffffffffff", "DUP DUP CAT DUP CAT DUP CAT DUP CAT DUP CAT DUP CAT CAT DEPTH 1 EQUALVERIFY 0x4d 0x0802 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff EQUAL", "STRICTENC", "OK"], +["0x08 0xffffffffffffffff 0x08 0xffffffffffffffff", "DUP CAT DUP CAT DUP CAT DUP CAT DUP CAT DUP CAT CAT DEPTH 1 EQUALVERIFY 0x4d 0x0802 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff EQUAL", "STRICTENC", "OK"], + +["0 0","XOR 0 EQUAL", "STRICTENC", "OK"], +["0x51 0x51","XOR 0x01 0x00 EQUAL", "STRICTENC", "OK"], +["0x01 0x00 0x51","XOR 0x51 EQUAL", "STRICTENC", "OK"], +["0x14 0x2595860bbba83109178f70419941302a3c2bf6eb 0x14 0x517051988cbe5bbcc1348b835694117138517800","XOR 0x14 0x74e5d79337166ab5d6bbfbc2cfd5215b047a8eeb EQUAL", "STRICTENC", "OK"], + + +["new Elements-only opcodes:"], + +["", "0x08 0xffffffffffffffff 0 0x01 0x00 DETERMINISTICRANDOM 0 EQUAL", "", "OK"], +["", "0x08 0xFFFFFFFFFFFFFFF0 0 0x01 0x02 DETERMINISTICRANDOM 0 EQUAL", "", "OK"], +["", "0x08 0xFFFFFFFFFFFFFFF0 0 0x01 0x03 DETERMINISTICRANDOM 0 EQUAL", "", "OK"], +["", "0x08 0xFFFFFFFFFFFFFFF0 0 0x01 0x05 DETERMINISTICRANDOM 0x01 0x03 EQUAL", "", "OK"], +["", "0x08 0xFFFFFFFFFFFFFFF0 0 0x01 0x07 DETERMINISTICRANDOM 0 EQUAL", "", "OK"], +["", "0x08 0xFFFFFFFFFFFFFFF0 0 0x01 0x0b DETERMINISTICRANDOM 0x01 0x02 EQUAL", "", "OK"], +["", "0x08 0xFFFFFFFFFFFFFFF0 0 0x01 0x0d DETERMINISTICRANDOM 0x01 0x01 EQUAL", "", "OK"], +["", "0x08 0xFFFFFFFFFFFFFFF0 0 0x01 0x11 DETERMINISTICRANDOM 0x01 0x0B EQUAL", "", "OK"], +["", "0x08 0xFFFFFFFFFFFFFFF0 0 0x01 0x13 DETERMINISTICRANDOM 0x01 0x0C EQUAL", "", "OK"], +["", "0x08 0xFFFFFFFFFFFFFFF0 0 0x01 0x17 DETERMINISTICRANDOM 0x01 0x04 EQUAL", "", "OK"], +["", "0x08 0xFFFFFFFFFFFFFFF0 0 0x01 0x1d DETERMINISTICRANDOM 0x01 0x0E EQUAL", "", "OK"], + +["0x46 0x304402206daa2cecefaa8930244efea8d8e6db945161a2040d48f67542b5f9cdc592110202204b83b83ad3d3a2359c36b6c4f57306de46246e5cd321c6bd5881df4ff319cda9", "0x03 0x776174 0x21 0x0292408c54f68eb7609ac8b1ac234192a1f5a5706b37854bcecf51ddd8b202885c CHECKSIGFROMSTACK", "", "OK"], + +["these arguments are not allowed in SUBSTR, but are in SUBSTR_LAZY:"], +["0x08 0x0102030405060708", "-1 7 SUBSTR_LAZY 0x07 0x01020304050607 EQUAL", "", "OK", "SUBSTR: -1 is not allowed"], +["0x08 0x0102030405060708", "1 -7 SUBSTR_LAZY 0x00 EQUAL", "", "OK", "SUBSTR: -1 is not allowed"], +["0x08 0x0102030405060708", "9 1 SUBSTR_LAZY 0x00 EQUAL", "", "OK", "SUBSTR: range exceeds length"], +["0x08 0x0102030405060708", "0 9 SUBSTR_LAZY 0x08 0x0102030405060708 EQUAL", "", "OK", "SUBSTR: ange exceeds length"], + ["The End"] ] diff --git a/src/test/script_tests.cpp b/src/test/script_tests.cpp index bc671394c0d..33dc6054ebd 100644 --- a/src/test/script_tests.cpp +++ b/src/test/script_tests.cpp @@ -1474,7 +1474,7 @@ BOOST_AUTO_TEST_CASE(script_HasValidOps) BOOST_CHECK(script.HasValidOps()); script = ScriptFromHex("ff88ac"); // Script with OP_INVALIDOPCODE explicit BOOST_CHECK(!script.HasValidOps()); - script = ScriptFromHex("88acc0"); // Script with undefined opcode + script = ScriptFromHex("88acc4"); // Script with undefined opcode: one higher then MAX_OPCODE BOOST_CHECK(!script.HasValidOps()); }