Skip to content

bitcoin / bitcoin
Sign up

case OP_LEFT : return "OP_LEFT";

case OP_RIGHT : return "OP_RIGHT";

case OP_SIZE : return "OP_SIZE";

// bit logic

case OP_INVERT : return "OP_INVERT";

case OP_AND : return "OP_AND";

case OP_OR : return "OP_OR";

case OP_XOR : return "OP_XOR";

case OP_EQUAL : return "OP_EQUAL";

case OP_EQUALVERIFY : return "OP_EQUALVERIFY";

case OP_RESERVED1 : return "OP_RESERVED1";

case OP_RESERVED2 : return "OP_RESERVED2";

// numeric

case OP_1ADD : return "OP_1ADD";

case OP_1SUB : return "OP_1SUB";

case OP_2MUL : return "OP_2MUL";

case OP_2DIV : return "OP_2DIV";

case OP_NEGATE : return "OP_NEGATE";

case OP_ABS : return "OP_ABS";

case OP_NOT : return "OP_NOT";

case OP_0NOTEQUAL : return "OP_0NOTEQUAL";

case OP_ADD : return "OP_ADD";

case OP_SUB : return "OP_SUB";

case OP_MUL : return "OP_MUL";

case OP_DIV : return "OP_DIV";

case OP_MOD : return "OP_MOD";

case OP_LSHIFT : return "OP_LSHIFT";

case OP_RSHIFT : return "OP_RSHIFT";

case OP_BOOLAND : return "OP_BOOLAND";

case OP_BOOLOR : return "OP_BOOLOR";

case OP_NUMEQUAL : return "OP_NUMEQUAL";

case OP_NUMEQUALVERIFY : return "OP_NUMEQUALVERIFY";

case OP_NUMNOTEQUAL : return "OP_NUMNOTEQUAL";

case OP_LESSTHAN : return "OP_LESSTHAN";

case OP_GREATERTHAN : return "OP_GREATERTHAN";

case OP_LESSTHANOREQUAL : return "OP_LESSTHANOREQUAL";

case OP_GREATERTHANOREQUAL : return "OP_GREATERTHANOREQUAL";

case OP_MIN : return "OP_MIN";

case OP_MAX : return "OP_MAX";

case OP_WITHIN : return "OP_WITHIN";

// crypto

case OP_RIPEMD160 : return "OP_RIPEMD160";

case OP_SHA1 : return "OP_SHA1";

case OP_SHA256 : return "OP_SHA256";

case OP_HASH160 : return "OP_HASH160";

case OP_HASH256 : return "OP_HASH256";

case OP_CODESEPARATOR : return "OP_CODESEPARATOR";

 case OP_CHECKSIG : return "OP_CHECKSIG";

case OP_CHECKSIGVERIFY : return "OP_CHECKSIGVERIFY";

case OP_CHECKMULTISIG : return "OP_CHECKMULTISIG";

case OP_CHECKMULTISIGVERIFY : return "OP_CHECKMULTISIGVERIFY";

// expansion

case OP_NOP1 : return "OP_NOP1";

case OP_CHECKLOCKTIMEVERIFY : return "OP_CHECKLOCKTIMEVERIFY";

case OP_CHECKSEQUENCEVERIFY : return "OP_CHECKSEQUENCEVERIFY";

case OP_NOP4 : return "OP_NOP4";

case OP_NOP5 : return "OP_NOP5";

case OP_NOP6 : return "OP_NOP6";

case OP_NOP7 : return "OP_NOP7";

case OP_NOP8 : return "OP_NOP8";

case OP_NOP9 : return "OP_NOP9";

case OP_NOP10 : return "OP_NOP10";

case OP_INVALIDOPCODE : return "OP_INVALIDOPCODE";

default:

return "OP_UNKNOWN";

}
unsigned int CScript::GetSigOpCount(bool fAccurate) const

unsigned int n = 0;

const_iterator pc = begin();

opcodetype lastOpcode = OP_INVALIDOPCODE;

while (pc < end())

opcodetype opcode;

if (!GetOp(pc, opcode))

break;

if (opcode == OP_CHECKSIG || opcode == OP_CHECKSIGVERIFY)

n++;

else if (opcode == OP_CHECKMULTISIG || opcode == OP_CHECKMULTISIGVERIFY)

if (fAccurate && lastOpcode >= OP_1 && lastOpcode <= OP_16)

n += DecodeOP_N(lastOpcode);

else

n += MAX_PUBKEYS_PER_MULTISIG;

lastOpcode = opcode;

return n;

unsigned int CScript::GetSigOpCount(const CScript& scriptSig) const

if (!IsPayToScriptHash())
 return GetSigOpCount(true);

// This is a pay-to-script-hash scriptPubKey;

// get the last item that the scriptSig

// pushes onto the stack:

const_iterator pc = scriptSig.begin();

std::vector<unsigned char> vData;

while (pc < scriptSig.end())

opcodetype opcode;

if (!scriptSig.GetOp(pc, opcode, vData))

return 0;

if (opcode > OP_16)

return 0;

/// ... and return its opcount:

CScript subscript(vData.begin(), vData.end());

return subscript.GetSigOpCount(true);

bool CScript::IsPayToScriptHash() const

// Extra-fast test for pay-to-script-hash CScripts:

return (this->size() == 23 &&

 (*this)[0] == OP_HASH160 &&

(*this)[1] == 0x14 &&

(*this)[22] == OP_EQUAL);

bool CScript::IsPayToWitnessScriptHash() const

// Extra-fast test for pay-to-witness-script-hash CScripts:

return (this->size() == 34 &&

(*this)[0] == OP_0 &&

(*this)[1] == 0x20);

// A witness program is any valid CScript that consists of a 1-byte push opcode

// followed by a data push between 2 and 40 bytes.

bool CScript::IsWitnessProgram(int& version, std::vector<unsigned char>& program)

const

if (this->size() < 4 || this->size() > 42) {

return false;

if ((*this)[0] != OP_0 && ((*this)[0] < OP_1 || (*this)[0] > OP_16)) {

return false;

if ((size_t)((*this)[1] + 2) == this->size()) {

version = DecodeOP_N((opcodetype)(*this)[0]);
 program = std::vector<unsigned char>(this->begin() + 2, this->end());

return true;

return false;

bool CScript::IsPushOnly(const_iterator pc) const

while (pc < end())

opcodetype opcode;

if (!GetOp(pc, opcode))

return false;

// Note that IsPushOnly() *does* consider OP_RESERVED to be a

// push-type opcode, however execution of OP_RESERVED fails, so

// it's not relevant to P2SH/BIP62 as the scriptSig would fail prior to

// the P2SH special validation code being executed.

if (opcode > OP_16)

return false;

return true;

bool CScript::IsPushOnly() const

return this->IsPushOnly(begin());
}

std::string CScriptWitness::ToString() const

std::string ret = "CScriptWitness(";

for (unsigned int i = 0; i < stack.size(); i++) {

if (i) {

ret += ", ";

ret += HexStr(stack[i]);

return ret + ")";

bool CScript::HasValidOps() const

CScript::const_iterator it = begin();

while (it < end()) {

opcodetype opcode;

std::vector<unsigned char> item;

if (!GetOp(it, opcode, item) || opcode > MAX_OPCODE || item.size() >

MAX_SCRIPT_ELEMENT_SIZE) {

return false;

return true;
}

bool GetScriptOp(CScriptBase::const_iterator& pc, CScriptBase::const_iterator end,

opcodetype& opcodeRet, std::vector<unsigned char>* pvchRet)

opcodeRet = OP_INVALIDOPCODE;

if (pvchRet)

pvchRet->clear();

if (pc >= end)

return false;

// Read instruction

if (end - pc < 1)

return false;

unsigned int opcode = *pc++;

// Immediate operand

if (opcode <= OP_PUSHDATA4)

unsigned int nSize = 0;

if (opcode < OP_PUSHDATA1)

nSize = opcode;

else if (opcode == OP_PUSHDATA1)

 {

if (end - pc < 1)

return false;

nSize = *pc++;

else if (opcode == OP_PUSHDATA2)

if (end - pc < 2)

return false;

nSize = ReadLE16(&pc[0]);

pc += 2;

else if (opcode == OP_PUSHDATA4)

if (end - pc < 4)

return false;

nSize = ReadLE32(&pc[0]);

pc += 4;

if (end - pc < 0 || (unsigned int)(end - pc) < nSize)

return false;

if (pvchRet)

pvchRet->assign(pc, pc + nSize);

pc += nSize;

opcodeRet = static_cast<opcodetype>(opcode);
 return true;

 © 2019 GitHub, Inc.

 Terms
 Privacy
 Security
 Status
 Help

 Contact GitHub
 Pricing
 API
 Training
 Blog
 About