Branch data     Line data    Source code

       1                 :            : // Copyright (c) 2009-2010 Satoshi Nakamoto
       2                 :            : // Copyright (c) 2009-2021 The Bitcoin Core developers
       3                 :            : // Distributed under the MIT software license, see the accompanying
       4                 :            : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       5                 :            : 
       6                 :            : #include <script/script.h>
       7                 :            : 
       8                 :            : #include <hash.h>
       9                 :            : #include <util/strencodings.h>
      10                 :            : 
      11                 :            : #include <string>
      12                 :            : 
      13                 :       9443 : CScriptID::CScriptID(const CScript& in) : BaseHash(Hash160(in)) {}
      14                 :            : 
      15                 :    5130001 : std::string GetOpName(opcodetype opcode)
      16                 :            : {
      17   [ +  +  +  +  :    5130001 :     switch (opcode)
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
             +  +  +  +  
                      + ]
      18                 :            :     {
      19                 :            :     // push value
      20         [ +  - ]:        324 :     case OP_0                      : return "0";
      21         [ +  - ]:          1 :     case OP_PUSHDATA1              : return "OP_PUSHDATA1";
      22         [ +  - ]:          1 :     case OP_PUSHDATA2              : return "OP_PUSHDATA2";
      23         [ +  - ]:          1 :     case OP_PUSHDATA4              : return "OP_PUSHDATA4";
      24         [ +  - ]:       2542 :     case OP_1NEGATE                : return "-1";
      25         [ +  - ]:      13297 :     case OP_RESERVED               : return "OP_RESERVED";
      26         [ +  - ]:      13440 :     case OP_1                      : return "1";
      27         [ +  - ]:      20846 :     case OP_2                      : return "2";
      28         [ +  - ]:      45581 :     case OP_3                      : return "3";
      29         [ +  - ]:       5914 :     case OP_4                      : return "4";
      30         [ +  - ]:       5826 :     case OP_5                      : return "5";
      31         [ +  - ]:       2720 :     case OP_6                      : return "6";
      32         [ +  - ]:       1991 :     case OP_7                      : return "7";
      33         [ +  - ]:     264456 :     case OP_8                      : return "8";
      34         [ +  - ]:       8248 :     case OP_9                      : return "9";
      35         [ +  - ]:       2173 :     case OP_10                     : return "10";
      36         [ +  - ]:      69250 :     case OP_11                     : return "11";
      37         [ +  - ]:       4349 :     case OP_12                     : return "12";
      38         [ +  - ]:      14648 :     case OP_13                     : return "13";
      39         [ +  - ]:       3718 :     case OP_14                     : return "14";
      40         [ +  - ]:       5376 :     case OP_15                     : return "15";
      41         [ +  - ]:       3916 :     case OP_16                     : return "16";
      42                 :            : 
      43                 :            :     // control
      44         [ +  - ]:     774823 :     case OP_NOP                    : return "OP_NOP";
      45         [ +  - ]:       5896 :     case OP_VER                    : return "OP_VER";
      46         [ +  - ]:       4238 :     case OP_IF                     : return "OP_IF";
      47         [ +  - ]:       2725 :     case OP_NOTIF                  : return "OP_NOTIF";
      48         [ +  - ]:       5337 :     case OP_VERIF                  : return "OP_VERIF";
      49         [ +  - ]:       5985 :     case OP_VERNOTIF               : return "OP_VERNOTIF";
      50         [ +  - ]:      60082 :     case OP_ELSE                   : return "OP_ELSE";
      51         [ +  - ]:       3962 :     case OP_ENDIF                  : return "OP_ENDIF";
      52         [ +  - ]:       3104 :     case OP_VERIFY                 : return "OP_VERIFY";
      53         [ +  - ]:      20142 :     case OP_RETURN                 : return "OP_RETURN";
      54                 :            : 
      55                 :            :     // stack ops
      56         [ +  - ]:       4305 :     case OP_TOALTSTACK             : return "OP_TOALTSTACK";
      57         [ +  - ]:       2195 :     case OP_FROMALTSTACK           : return "OP_FROMALTSTACK";
      58         [ +  - ]:       3827 :     case OP_2DROP                  : return "OP_2DROP";
      59         [ +  - ]:       2714 :     case OP_2DUP                   : return "OP_2DUP";
      60         [ +  - ]:      25264 :     case OP_3DUP                   : return "OP_3DUP";
      61         [ +  - ]:       2812 :     case OP_2OVER                  : return "OP_2OVER";
      62         [ +  - ]:       2391 :     case OP_2ROT                   : return "OP_2ROT";
      63         [ +  - ]:       4947 :     case OP_2SWAP                  : return "OP_2SWAP";
      64         [ +  - ]:       5623 :     case OP_IFDUP                  : return "OP_IFDUP";
      65         [ +  - ]:       3172 :     case OP_DEPTH                  : return "OP_DEPTH";
      66         [ +  - ]:       2442 :     case OP_DROP                   : return "OP_DROP";
      67         [ +  - ]:      13817 :     case OP_DUP                    : return "OP_DUP";
      68         [ +  - ]:       5754 :     case OP_NIP                    : return "OP_NIP";
      69         [ +  - ]:       3285 :     case OP_OVER                   : return "OP_OVER";
      70         [ +  - ]:       3122 :     case OP_PICK                   : return "OP_PICK";
      71         [ +  - ]:       5167 :     case OP_ROLL                   : return "OP_ROLL";
      72         [ +  - ]:       2219 :     case OP_ROT                    : return "OP_ROT";
      73         [ +  - ]:       3543 :     case OP_SWAP                   : return "OP_SWAP";
      74         [ +  - ]:       3311 :     case OP_TUCK                   : return "OP_TUCK";
      75                 :            : 
      76                 :            :     // splice ops
      77         [ +  - ]:       3041 :     case OP_CAT                    : return "OP_CAT";
      78         [ +  - ]:      24675 :     case OP_SUBSTR                 : return "OP_SUBSTR";
      79         [ +  - ]:      15367 :     case OP_LEFT                   : return "OP_LEFT";
      80         [ +  - ]:       3471 :     case OP_RIGHT                  : return "OP_RIGHT";
      81         [ +  - ]:       3300 :     case OP_SIZE                   : return "OP_SIZE";
      82                 :            : 
      83                 :            :     // bit logic
      84         [ +  - ]:       7924 :     case OP_INVERT                 : return "OP_INVERT";
      85         [ +  - ]:      12912 :     case OP_AND                    : return "OP_AND";
      86         [ +  - ]:       1733 :     case OP_OR                     : return "OP_OR";
      87         [ +  - ]:       2005 :     case OP_XOR                    : return "OP_XOR";
      88         [ +  - ]:      59936 :     case OP_EQUAL                  : return "OP_EQUAL";
      89         [ +  - ]:      14421 :     case OP_EQUALVERIFY            : return "OP_EQUALVERIFY";
      90         [ +  - ]:     313137 :     case OP_RESERVED1              : return "OP_RESERVED1";
      91         [ +  - ]:       4199 :     case OP_RESERVED2              : return "OP_RESERVED2";
      92                 :            : 
      93                 :            :     // numeric
      94         [ +  - ]:       2050 :     case OP_1ADD                   : return "OP_1ADD";
      95         [ +  - ]:       1636 :     case OP_1SUB                   : return "OP_1SUB";
      96         [ +  - ]:       1308 :     case OP_2MUL                   : return "OP_2MUL";
      97         [ +  - ]:       1501 :     case OP_2DIV                   : return "OP_2DIV";
      98         [ +  - ]:       2283 :     case OP_NEGATE                 : return "OP_NEGATE";
      99         [ +  - ]:       2841 :     case OP_ABS                    : return "OP_ABS";
     100         [ +  - ]:       2520 :     case OP_NOT                    : return "OP_NOT";
     101         [ +  - ]:       4547 :     case OP_0NOTEQUAL              : return "OP_0NOTEQUAL";
     102         [ +  - ]:       2536 :     case OP_ADD                    : return "OP_ADD";
     103         [ +  - ]:       2697 :     case OP_SUB                    : return "OP_SUB";
     104         [ +  - ]:       2984 :     case OP_MUL                    : return "OP_MUL";
     105         [ +  - ]:      19943 :     case OP_DIV                    : return "OP_DIV";
     106         [ +  - ]:       4059 :     case OP_MOD                    : return "OP_MOD";
     107         [ +  - ]:      15306 :     case OP_LSHIFT                 : return "OP_LSHIFT";
     108         [ +  - ]:       1300 :     case OP_RSHIFT                 : return "OP_RSHIFT";
     109         [ +  - ]:      11038 :     case OP_BOOLAND                : return "OP_BOOLAND";
     110         [ +  - ]:       2621 :     case OP_BOOLOR                 : return "OP_BOOLOR";
     111         [ +  - ]:     116241 :     case OP_NUMEQUAL               : return "OP_NUMEQUAL";
     112         [ +  - ]:       1819 :     case OP_NUMEQUALVERIFY         : return "OP_NUMEQUALVERIFY";
     113         [ +  - ]:       4222 :     case OP_NUMNOTEQUAL            : return "OP_NUMNOTEQUAL";
     114         [ +  - ]:       2647 :     case OP_LESSTHAN               : return "OP_LESSTHAN";
     115         [ +  - ]:       2209 :     case OP_GREATERTHAN            : return "OP_GREATERTHAN";
     116         [ +  - ]:       3507 :     case OP_LESSTHANOREQUAL        : return "OP_LESSTHANOREQUAL";
     117         [ +  - ]:       1657 :     case OP_GREATERTHANOREQUAL     : return "OP_GREATERTHANOREQUAL";
     118         [ +  - ]:      16052 :     case OP_MIN                    : return "OP_MIN";
     119         [ +  - ]:      24022 :     case OP_MAX                    : return "OP_MAX";
     120         [ +  - ]:       5201 :     case OP_WITHIN                 : return "OP_WITHIN";
     121                 :            : 
     122                 :            :     // crypto
     123         [ +  - ]:       1915 :     case OP_RIPEMD160              : return "OP_RIPEMD160";
     124         [ +  - ]:       3563 :     case OP_SHA1                   : return "OP_SHA1";
     125         [ +  - ]:       2241 :     case OP_SHA256                 : return "OP_SHA256";
     126         [ +  - ]:      64857 :     case OP_HASH160                : return "OP_HASH160";
     127         [ +  - ]:       2707 :     case OP_HASH256                : return "OP_HASH256";
     128         [ +  - ]:       2727 :     case OP_CODESEPARATOR          : return "OP_CODESEPARATOR";
     129         [ +  - ]:      50914 :     case OP_CHECKSIG               : return "OP_CHECKSIG";
     130         [ -  + ]:       6116 :     case OP_CHECKSIGVERIFY         : return "OP_CHECKSIGVERIFY";
     131         [ +  - ]:     334558 :     case OP_CHECKMULTISIG          : return "OP_CHECKMULTISIG";
     132         [ +  - ]:      17479 :     case OP_CHECKMULTISIGVERIFY    : return "OP_CHECKMULTISIGVERIFY";
     133                 :            : 
     134                 :            :     // expansion
     135         [ +  - ]:       6915 :     case OP_NOP1                   : return "OP_NOP1";
     136         [ +  - ]:       2289 :     case OP_CHECKLOCKTIMEVERIFY    : return "OP_CHECKLOCKTIMEVERIFY";
     137         [ +  - ]:       4326 :     case OP_CHECKSEQUENCEVERIFY    : return "OP_CHECKSEQUENCEVERIFY";
     138         [ +  - ]:       2811 :     case OP_NOP4                   : return "OP_NOP4";
     139         [ +  - ]:       6842 :     case OP_NOP5                   : return "OP_NOP5";
     140         [ +  - ]:       2608 :     case OP_NOP6                   : return "OP_NOP6";
     141         [ +  - ]:       2091 :     case OP_NOP7                   : return "OP_NOP7";
     142         [ +  - ]:       4990 :     case OP_NOP8                   : return "OP_NOP8";
     143         [ +  - ]:       3367 :     case OP_NOP9                   : return "OP_NOP9";
     144         [ +  - ]:       5141 :     case OP_NOP10                  : return "OP_NOP10";
     145                 :            : 
     146                 :            :     // Opcode added by BIP 342 (Tapscript)
     147         [ +  - ]:       3407 :     case OP_CHECKSIGADD            : return "OP_CHECKSIGADD";
     148                 :            : 
     149         [ +  - ]:      34188 :     case OP_INVALIDOPCODE          : return "OP_INVALIDOPCODE";
     150                 :            : 
     151                 :            :     default:
     152         [ +  - ]:    2364259 :         return "OP_UNKNOWN";
     153                 :            :     }
     154                 :    5130001 : }
     155                 :            : 
     156                 :    8688087 : unsigned int CScript::GetSigOpCount(bool fAccurate) const
     157                 :            : {
     158                 :    8688087 :     unsigned int n = 0;
     159                 :    8688087 :     const_iterator pc = begin();
     160                 :    8688087 :     opcodetype lastOpcode = OP_INVALIDOPCODE;
     161         [ +  + ]:  122135546 :     while (pc < end())
     162                 :            :     {
     163                 :            :         opcodetype opcode;
     164         [ +  + ]:  113677152 :         if (!GetOp(pc, opcode))
     165                 :     229693 :             break;
     166   [ +  +  +  + ]:  113447459 :         if (opcode == OP_CHECKSIG || opcode == OP_CHECKSIGVERIFY)
     167                 :     146705 :             n++;
     168   [ +  +  +  + ]:  113300754 :         else if (opcode == OP_CHECKMULTISIG || opcode == OP_CHECKMULTISIGVERIFY)
     169                 :            :         {
     170   [ +  +  +  +  :     755187 :             if (fAccurate && lastOpcode >= OP_1 && lastOpcode <= OP_16)
                   +  + ]
     171                 :      72764 :                 n += DecodeOP_N(lastOpcode);
     172                 :            :             else
     173                 :     682423 :                 n += MAX_PUBKEYS_PER_MULTISIG;
     174                 :     755187 :         }
     175                 :  113447459 :         lastOpcode = opcode;
     176                 :            :     }
     177                 :    8688087 :     return n;
     178                 :            : }
     179                 :            : 
     180                 :        528 : unsigned int CScript::GetSigOpCount(const CScript& scriptSig) const
     181                 :            : {
     182         [ +  + ]:        528 :     if (!IsPayToScriptHash())
     183                 :        253 :         return GetSigOpCount(true);
     184                 :            : 
     185                 :            :     // This is a pay-to-script-hash scriptPubKey;
     186                 :            :     // get the last item that the scriptSig
     187                 :            :     // pushes onto the stack:
     188                 :        275 :     const_iterator pc = scriptSig.begin();
     189                 :        275 :     std::vector<unsigned char> vData;
     190   [ +  -  +  -  :       3997 :     while (pc < scriptSig.end())
                   +  + ]
     191                 :            :     {
     192                 :            :         opcodetype opcode;
     193   [ +  -  +  + ]:       3846 :         if (!scriptSig.GetOp(pc, opcode, vData))
     194                 :         77 :             return 0;
     195         [ +  + ]:       3769 :         if (opcode > OP_16)
     196                 :         47 :             return 0;
     197                 :            :     }
     198                 :            : 
     199                 :            :     /// ... and return its opcount:
     200         [ +  - ]:        151 :     CScript subscript(vData.begin(), vData.end());
     201         [ -  + ]:        151 :     return subscript.GetSigOpCount(true);
     202                 :        528 : }
     203                 :            : 
     204                 :   12666506 : bool CScript::IsPayToScriptHash() const
     205                 :            : {
     206                 :            :     // Extra-fast test for pay-to-script-hash CScripts:
     207         [ +  + ]:   12900005 :     return (this->size() == 23 &&
     208         [ +  + ]:     233499 :             (*this)[0] == OP_HASH160 &&
     209         [ +  + ]:     229513 :             (*this)[1] == 0x14 &&
     210                 :     229034 :             (*this)[22] == OP_EQUAL);
     211                 :            : }
     212                 :            : 
     213                 :        906 : bool CScript::IsPayToWitnessScriptHash() const
     214                 :            : {
     215                 :            :     // Extra-fast test for pay-to-witness-script-hash CScripts:
     216         [ +  + ]:        914 :     return (this->size() == 34 &&
     217         [ +  + ]:          8 :             (*this)[0] == OP_0 &&
     218                 :          3 :             (*this)[1] == 0x20);
     219                 :            : }
     220                 :            : 
     221                 :            : // A witness program is any valid CScript that consists of a 1-byte push opcode
     222                 :            : // followed by a data push between 2 and 40 bytes.
     223                 :   21367245 : bool CScript::IsWitnessProgram(int& version, std::vector<unsigned char>& program) const
     224                 :            : {
     225   [ +  +  +  + ]:   21367245 :     if (this->size() < 4 || this->size() > 42) {
     226                 :    1703963 :         return false;
     227                 :            :     }
     228   [ +  +  +  +  :   19663282 :     if ((*this)[0] != OP_0 && ((*this)[0] < OP_1 || (*this)[0] > OP_16)) {
                   +  + ]
     229                 :     270476 :         return false;
     230                 :            :     }
     231         [ +  + ]:   19392806 :     if ((size_t)((*this)[1] + 2) == this->size()) {
     232                 :   19369014 :         version = DecodeOP_N((opcodetype)(*this)[0]);
     233         [ -  + ]:   19369014 :         program = std::vector<unsigned char>(this->begin() + 2, this->end());
     234                 :   19369014 :         return true;
     235                 :            :     }
     236                 :      23792 :     return false;
     237                 :   21367245 : }
     238                 :            : 
     239                 :    3236867 : bool CScript::IsPushOnly(const_iterator pc) const
     240                 :            : {
     241         [ +  + ]:    6207776 :     while (pc < end())
     242                 :            :     {
     243                 :            :         opcodetype opcode;
     244         [ +  + ]:    2989645 :         if (!GetOp(pc, opcode))
     245                 :       8028 :             return false;
     246                 :            :         // Note that IsPushOnly() *does* consider OP_RESERVED to be a
     247                 :            :         // push-type opcode, however execution of OP_RESERVED fails, so
     248                 :            :         // it's not relevant to P2SH/BIP62 as the scriptSig would fail prior to
     249                 :            :         // the P2SH special validation code being executed.
     250         [ +  + ]:    2981617 :         if (opcode > OP_16)
     251                 :      10708 :             return false;
     252                 :            :     }
     253                 :    3218131 :     return true;
     254                 :    3236867 : }
     255                 :            : 
     256                 :    3208953 : bool CScript::IsPushOnly() const
     257                 :            : {
     258                 :    3208953 :     return this->IsPushOnly(begin());
     259                 :            : }
     260                 :            : 
     261                 :     265864 : std::string CScriptWitness::ToString() const
     262                 :            : {
     263         [ +  - ]:     265864 :     std::string ret = "CScriptWitness(";
     264         [ +  + ]:    5035703 :     for (unsigned int i = 0; i < stack.size(); i++) {
     265         [ +  + ]:    4769839 :         if (i) {
     266         [ +  - ]:    4760291 :             ret += ", ";
     267                 :    4760291 :         }
     268   [ +  -  +  -  :    4769839 :         ret += HexStr(stack[i]);
                   +  - ]
     269                 :    4769839 :     }
     270         [ +  - ]:     265864 :     return ret + ")";
     271                 :     265864 : }
     272                 :            : 
     273                 :      18894 : bool CScript::HasValidOps() const
     274                 :            : {
     275                 :      18894 :     CScript::const_iterator it = begin();
     276         [ +  + ]:    3184573 :     while (it < end()) {
     277                 :            :         opcodetype opcode;
     278                 :    3167958 :         std::vector<unsigned char> item;
     279   [ +  -  +  +  :    3167958 :         if (!GetOp(it, opcode, item) || opcode > MAX_OPCODE || item.size() > MAX_SCRIPT_ELEMENT_SIZE) {
             +  +  +  + ]
     280                 :       2279 :             return false;
     281                 :            :         }
     282      [ -  +  + ]:    3167958 :     }
     283                 :      16615 :     return true;
     284                 :      18894 : }
     285                 :            : 
     286                 :  167797978 : bool GetScriptOp(CScriptBase::const_iterator& pc, CScriptBase::const_iterator end, opcodetype& opcodeRet, std::vector<unsigned char>* pvchRet)
     287                 :            : {
     288                 :  167797978 :     opcodeRet = OP_INVALIDOPCODE;
     289         [ +  + ]:  167797978 :     if (pvchRet)
     290                 :   18542861 :         pvchRet->clear();
     291         [ +  + ]:  167797978 :     if (pc >= end)
     292                 :      89124 :         return false;
     293                 :            : 
     294                 :            :     // Read instruction
     295         [ +  - ]:  167708854 :     if (end - pc < 1)
     296                 :          0 :         return false;
     297                 :  167708854 :     unsigned int opcode = *pc++;
     298                 :            : 
     299                 :            :     // Immediate operand
     300         [ +  + ]:  167708854 :     if (opcode <= OP_PUSHDATA4)
     301                 :            :     {
     302                 :   42833702 :         unsigned int nSize = 0;
     303         [ +  + ]:   42833702 :         if (opcode < OP_PUSHDATA1)
     304                 :            :         {
     305                 :   37749586 :             nSize = opcode;
     306                 :   37749586 :         }
     307         [ +  + ]:    5084116 :         else if (opcode == OP_PUSHDATA1)
     308                 :            :         {
     309         [ +  + ]:    4701590 :             if (end - pc < 1)
     310                 :       2452 :                 return false;
     311                 :    4699138 :             nSize = *pc++;
     312                 :    4699138 :         }
     313         [ +  + ]:     382526 :         else if (opcode == OP_PUSHDATA2)
     314                 :            :         {
     315         [ +  + ]:     130550 :             if (end - pc < 2)
     316                 :       5406 :                 return false;
     317                 :     125144 :             nSize = ReadLE16(&pc[0]);
     318                 :     125144 :             pc += 2;
     319                 :     125144 :         }
     320         [ -  + ]:     251976 :         else if (opcode == OP_PUSHDATA4)
     321                 :            :         {
     322         [ +  + ]:     251976 :             if (end - pc < 4)
     323                 :       2463 :                 return false;
     324                 :     249513 :             nSize = ReadLE32(&pc[0]);
     325                 :     249513 :             pc += 4;
     326                 :     249513 :         }
     327   [ +  -  +  + ]:   42823381 :         if (end - pc < 0 || (unsigned int)(end - pc) < nSize)
     328                 :     688036 :             return false;
     329         [ +  + ]:   42135345 :         if (pvchRet)
     330                 :    5118822 :             pvchRet->assign(pc, pc + nSize);
     331                 :   42135345 :         pc += nSize;
     332                 :   42135345 :     }
     333                 :            : 
     334                 :  167010497 :     opcodeRet = static_cast<opcodetype>(opcode);
     335                 :  167010497 :     return true;
     336                 :  167797978 : }
     337                 :            : 
     338                 :      65105 : bool IsOpSuccess(const opcodetype& opcode)
     339                 :            : {
     340   [ +  +  +  +  :     221295 :     return opcode == 80 || opcode == 98 || (opcode >= 126 && opcode <= 129) ||
             +  +  +  + ]
     341   [ +  +  +  + ]:     156190 :            (opcode >= 131 && opcode <= 134) || (opcode >= 137 && opcode <= 138) ||
     342   [ +  +  +  + ]:     173650 :            (opcode >= 141 && opcode <= 142) || (opcode >= 149 && opcode <= 153) ||
     343         [ +  + ]:      65038 :            (opcode >= 187 && opcode <= 254);
     344                 :            : }
     345                 :            : 
     346                 :     825744 : bool CheckMinimalPush(const std::vector<unsigned char>& data, opcodetype opcode) {
     347                 :            :     // Excludes OP_1NEGATE, OP_1-16 since they are by definition minimal
     348   [ -  +  +  - ]:     825744 :     assert(0 <= opcode && opcode <= OP_PUSHDATA4);
     349         [ +  + ]:     825744 :     if (data.size() == 0) {
     350                 :            :         // Should have used OP_0.
     351                 :     510620 :         return opcode == OP_0;
     352   [ +  +  +  +  :     315124 :     } else if (data.size() == 1 && data[0] >= 1 && data[0] <= 16) {
                   +  + ]
     353                 :            :         // Should have used OP_1 .. OP_16.
     354                 :       1351 :         return false;
     355   [ +  +  +  + ]:     313773 :     } else if (data.size() == 1 && data[0] == 0x81) {
     356                 :            :         // Should have used OP_1NEGATE.
     357                 :        395 :         return false;
     358         [ +  + ]:     313378 :     } else if (data.size() <= 75) {
     359                 :            :         // Must have used a direct push (opcode indicating number of bytes pushed + those bytes).
     360                 :     308892 :         return opcode == data.size();
     361         [ +  + ]:       4486 :     } else if (data.size() <= 255) {
     362                 :            :         // Must have used OP_PUSHDATA.
     363                 :       3610 :         return opcode == OP_PUSHDATA1;
     364         [ +  - ]:        876 :     } else if (data.size() <= 65535) {
     365                 :            :         // Must have used OP_PUSHDATA2.
     366                 :        876 :         return opcode == OP_PUSHDATA2;
     367                 :            :     }
     368                 :          0 :     return true;
     369                 :     825744 : }