Branch data     Line data    Source code

       1                 :            : // Copyright (c) 2009-2010 Satoshi Nakamoto
       2                 :            : // Copyright (c) 2009-present 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 <crypto/common.h>
       9                 :            : #include <hash.h>
      10                 :            : #include <uint256.h>
      11                 :            : #include <util/hash_type.h>
      12                 :            : #include <util/strencodings.h>
      13                 :            : 
      14                 :            : #include <string>
      15                 :            : 
      16                 :       2379 : CScriptID::CScriptID(const CScript& in) : BaseHash(Hash160(in)) {}
      17                 :            : 
      18                 :          0 : std::string GetOpName(opcodetype opcode)
      19                 :            : {
      20   [ #  #  #  #  :          0 :     switch (opcode)
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
      21                 :            :     {
      22                 :            :     // push value
      23         [ #  # ]:          0 :     case OP_0                      : return "0";
      24         [ #  # ]:          0 :     case OP_PUSHDATA1              : return "OP_PUSHDATA1";
      25         [ #  # ]:          0 :     case OP_PUSHDATA2              : return "OP_PUSHDATA2";
      26         [ #  # ]:          0 :     case OP_PUSHDATA4              : return "OP_PUSHDATA4";
      27         [ #  # ]:          0 :     case OP_1NEGATE                : return "-1";
      28         [ #  # ]:          0 :     case OP_RESERVED               : return "OP_RESERVED";
      29         [ #  # ]:          0 :     case OP_1                      : return "1";
      30         [ #  # ]:          0 :     case OP_2                      : return "2";
      31         [ #  # ]:          0 :     case OP_3                      : return "3";
      32         [ #  # ]:          0 :     case OP_4                      : return "4";
      33         [ #  # ]:          0 :     case OP_5                      : return "5";
      34         [ #  # ]:          0 :     case OP_6                      : return "6";
      35         [ #  # ]:          0 :     case OP_7                      : return "7";
      36         [ #  # ]:          0 :     case OP_8                      : return "8";
      37         [ #  # ]:          0 :     case OP_9                      : return "9";
      38         [ #  # ]:          0 :     case OP_10                     : return "10";
      39         [ #  # ]:          0 :     case OP_11                     : return "11";
      40         [ #  # ]:          0 :     case OP_12                     : return "12";
      41         [ #  # ]:          0 :     case OP_13                     : return "13";
      42         [ #  # ]:          0 :     case OP_14                     : return "14";
      43         [ #  # ]:          0 :     case OP_15                     : return "15";
      44         [ #  # ]:          0 :     case OP_16                     : return "16";
      45                 :            : 
      46                 :            :     // control
      47         [ #  # ]:          0 :     case OP_NOP                    : return "OP_NOP";
      48         [ #  # ]:          0 :     case OP_VER                    : return "OP_VER";
      49         [ #  # ]:          0 :     case OP_IF                     : return "OP_IF";
      50         [ #  # ]:          0 :     case OP_NOTIF                  : return "OP_NOTIF";
      51         [ #  # ]:          0 :     case OP_VERIF                  : return "OP_VERIF";
      52         [ #  # ]:          0 :     case OP_VERNOTIF               : return "OP_VERNOTIF";
      53         [ #  # ]:          0 :     case OP_ELSE                   : return "OP_ELSE";
      54         [ #  # ]:          0 :     case OP_ENDIF                  : return "OP_ENDIF";
      55         [ #  # ]:          0 :     case OP_VERIFY                 : return "OP_VERIFY";
      56         [ #  # ]:          0 :     case OP_RETURN                 : return "OP_RETURN";
      57                 :            : 
      58                 :            :     // stack ops
      59         [ #  # ]:          0 :     case OP_TOALTSTACK             : return "OP_TOALTSTACK";
      60         [ #  # ]:          0 :     case OP_FROMALTSTACK           : return "OP_FROMALTSTACK";
      61         [ #  # ]:          0 :     case OP_2DROP                  : return "OP_2DROP";
      62         [ #  # ]:          0 :     case OP_2DUP                   : return "OP_2DUP";
      63         [ #  # ]:          0 :     case OP_3DUP                   : return "OP_3DUP";
      64         [ #  # ]:          0 :     case OP_2OVER                  : return "OP_2OVER";
      65         [ #  # ]:          0 :     case OP_2ROT                   : return "OP_2ROT";
      66         [ #  # ]:          0 :     case OP_2SWAP                  : return "OP_2SWAP";
      67         [ #  # ]:          0 :     case OP_IFDUP                  : return "OP_IFDUP";
      68         [ #  # ]:          0 :     case OP_DEPTH                  : return "OP_DEPTH";
      69         [ #  # ]:          0 :     case OP_DROP                   : return "OP_DROP";
      70         [ #  # ]:          0 :     case OP_DUP                    : return "OP_DUP";
      71         [ #  # ]:          0 :     case OP_NIP                    : return "OP_NIP";
      72         [ #  # ]:          0 :     case OP_OVER                   : return "OP_OVER";
      73         [ #  # ]:          0 :     case OP_PICK                   : return "OP_PICK";
      74         [ #  # ]:          0 :     case OP_ROLL                   : return "OP_ROLL";
      75         [ #  # ]:          0 :     case OP_ROT                    : return "OP_ROT";
      76         [ #  # ]:          0 :     case OP_SWAP                   : return "OP_SWAP";
      77         [ #  # ]:          0 :     case OP_TUCK                   : return "OP_TUCK";
      78                 :            : 
      79                 :            :     // splice ops
      80         [ #  # ]:          0 :     case OP_CAT                    : return "OP_CAT";
      81         [ #  # ]:          0 :     case OP_SUBSTR                 : return "OP_SUBSTR";
      82         [ #  # ]:          0 :     case OP_LEFT                   : return "OP_LEFT";
      83         [ #  # ]:          0 :     case OP_RIGHT                  : return "OP_RIGHT";
      84         [ #  # ]:          0 :     case OP_SIZE                   : return "OP_SIZE";
      85                 :            : 
      86                 :            :     // bit logic
      87         [ #  # ]:          0 :     case OP_INVERT                 : return "OP_INVERT";
      88         [ #  # ]:          0 :     case OP_AND                    : return "OP_AND";
      89         [ #  # ]:          0 :     case OP_OR                     : return "OP_OR";
      90         [ #  # ]:          0 :     case OP_XOR                    : return "OP_XOR";
      91         [ #  # ]:          0 :     case OP_EQUAL                  : return "OP_EQUAL";
      92         [ #  # ]:          0 :     case OP_EQUALVERIFY            : return "OP_EQUALVERIFY";
      93         [ #  # ]:          0 :     case OP_RESERVED1              : return "OP_RESERVED1";
      94         [ #  # ]:          0 :     case OP_RESERVED2              : return "OP_RESERVED2";
      95                 :            : 
      96                 :            :     // numeric
      97         [ #  # ]:          0 :     case OP_1ADD                   : return "OP_1ADD";
      98         [ #  # ]:          0 :     case OP_1SUB                   : return "OP_1SUB";
      99         [ #  # ]:          0 :     case OP_2MUL                   : return "OP_2MUL";
     100         [ #  # ]:          0 :     case OP_2DIV                   : return "OP_2DIV";
     101         [ #  # ]:          0 :     case OP_NEGATE                 : return "OP_NEGATE";
     102         [ #  # ]:          0 :     case OP_ABS                    : return "OP_ABS";
     103         [ #  # ]:          0 :     case OP_NOT                    : return "OP_NOT";
     104         [ #  # ]:          0 :     case OP_0NOTEQUAL              : return "OP_0NOTEQUAL";
     105         [ #  # ]:          0 :     case OP_ADD                    : return "OP_ADD";
     106         [ #  # ]:          0 :     case OP_SUB                    : return "OP_SUB";
     107         [ #  # ]:          0 :     case OP_MUL                    : return "OP_MUL";
     108         [ #  # ]:          0 :     case OP_DIV                    : return "OP_DIV";
     109         [ #  # ]:          0 :     case OP_MOD                    : return "OP_MOD";
     110         [ #  # ]:          0 :     case OP_LSHIFT                 : return "OP_LSHIFT";
     111         [ #  # ]:          0 :     case OP_RSHIFT                 : return "OP_RSHIFT";
     112         [ #  # ]:          0 :     case OP_BOOLAND                : return "OP_BOOLAND";
     113         [ #  # ]:          0 :     case OP_BOOLOR                 : return "OP_BOOLOR";
     114         [ #  # ]:          0 :     case OP_NUMEQUAL               : return "OP_NUMEQUAL";
     115         [ #  # ]:          0 :     case OP_NUMEQUALVERIFY         : return "OP_NUMEQUALVERIFY";
     116         [ #  # ]:          0 :     case OP_NUMNOTEQUAL            : return "OP_NUMNOTEQUAL";
     117         [ #  # ]:          0 :     case OP_LESSTHAN               : return "OP_LESSTHAN";
     118         [ #  # ]:          0 :     case OP_GREATERTHAN            : return "OP_GREATERTHAN";
     119         [ #  # ]:          0 :     case OP_LESSTHANOREQUAL        : return "OP_LESSTHANOREQUAL";
     120         [ #  # ]:          0 :     case OP_GREATERTHANOREQUAL     : return "OP_GREATERTHANOREQUAL";
     121         [ #  # ]:          0 :     case OP_MIN                    : return "OP_MIN";
     122         [ #  # ]:          0 :     case OP_MAX                    : return "OP_MAX";
     123         [ #  # ]:          0 :     case OP_WITHIN                 : return "OP_WITHIN";
     124                 :            : 
     125                 :            :     // crypto
     126         [ #  # ]:          0 :     case OP_RIPEMD160              : return "OP_RIPEMD160";
     127         [ #  # ]:          0 :     case OP_SHA1                   : return "OP_SHA1";
     128         [ #  # ]:          0 :     case OP_SHA256                 : return "OP_SHA256";
     129         [ #  # ]:          0 :     case OP_HASH160                : return "OP_HASH160";
     130         [ #  # ]:          0 :     case OP_HASH256                : return "OP_HASH256";
     131         [ #  # ]:          0 :     case OP_CODESEPARATOR          : return "OP_CODESEPARATOR";
     132         [ #  # ]:          0 :     case OP_CHECKSIG               : return "OP_CHECKSIG";
     133         [ #  # ]:          0 :     case OP_CHECKSIGVERIFY         : return "OP_CHECKSIGVERIFY";
     134         [ #  # ]:          0 :     case OP_CHECKMULTISIG          : return "OP_CHECKMULTISIG";
     135         [ #  # ]:          0 :     case OP_CHECKMULTISIGVERIFY    : return "OP_CHECKMULTISIGVERIFY";
     136                 :            : 
     137                 :            :     // expansion
     138         [ #  # ]:          0 :     case OP_NOP1                   : return "OP_NOP1";
     139         [ #  # ]:          0 :     case OP_CHECKLOCKTIMEVERIFY    : return "OP_CHECKLOCKTIMEVERIFY";
     140         [ #  # ]:          0 :     case OP_CHECKSEQUENCEVERIFY    : return "OP_CHECKSEQUENCEVERIFY";
     141         [ #  # ]:          0 :     case OP_NOP4                   : return "OP_NOP4";
     142         [ #  # ]:          0 :     case OP_NOP5                   : return "OP_NOP5";
     143         [ #  # ]:          0 :     case OP_NOP6                   : return "OP_NOP6";
     144         [ #  # ]:          0 :     case OP_NOP7                   : return "OP_NOP7";
     145         [ #  # ]:          0 :     case OP_NOP8                   : return "OP_NOP8";
     146         [ #  # ]:          0 :     case OP_NOP9                   : return "OP_NOP9";
     147         [ #  # ]:          0 :     case OP_NOP10                  : return "OP_NOP10";
     148                 :            : 
     149                 :            :     // Opcode added by BIP 342 (Tapscript)
     150         [ #  # ]:          0 :     case OP_CHECKSIGADD            : return "OP_CHECKSIGADD";
     151                 :            : 
     152         [ #  # ]:          0 :     case OP_INVALIDOPCODE          : return "OP_INVALIDOPCODE";
     153                 :            : 
     154                 :            :     default:
     155         [ #  # ]:          0 :         return "OP_UNKNOWN";
     156                 :            :     }
     157                 :          0 : }
     158                 :            : 
     159                 :       2702 : unsigned int CScript::GetSigOpCount(bool fAccurate) const
     160                 :            : {
     161                 :       2702 :     unsigned int n = 0;
     162                 :       2702 :     const_iterator pc = begin();
     163                 :       2702 :     opcodetype lastOpcode = OP_INVALIDOPCODE;
     164         [ +  + ]:       8107 :     while (pc < end())
     165                 :            :     {
     166                 :            :         opcodetype opcode;
     167         [ +  - ]:       5405 :         if (!GetOp(pc, opcode))
     168                 :          0 :             break;
     169 [ +  + ][ -  + ]:       5405 :         if (opcode == OP_CHECKSIG || opcode == OP_CHECKSIGVERIFY)
     170                 :        901 :             n++;
     171 [ +  - ][ -  + ]:       4504 :         else if (opcode == OP_CHECKMULTISIG || opcode == OP_CHECKMULTISIGVERIFY)
     172                 :            :         {
     173 [ #  # ][ #  # ]:          0 :             if (fAccurate && lastOpcode >= OP_1 && lastOpcode <= OP_16)
                 [ #  # ]
     174                 :          0 :                 n += DecodeOP_N(lastOpcode);
     175                 :            :             else
     176                 :          0 :                 n += MAX_PUBKEYS_PER_MULTISIG;
     177                 :          0 :         }
     178                 :       5405 :         lastOpcode = opcode;
     179                 :            :     }
     180                 :       2702 :     return n;
     181                 :            : }
     182                 :            : 
     183                 :          0 : unsigned int CScript::GetSigOpCount(const CScript& scriptSig) const
     184                 :            : {
     185         [ #  # ]:          0 :     if (!IsPayToScriptHash())
     186                 :          0 :         return GetSigOpCount(true);
     187                 :            : 
     188                 :            :     // This is a pay-to-script-hash scriptPubKey;
     189                 :            :     // get the last item that the scriptSig
     190                 :            :     // pushes onto the stack:
     191                 :          0 :     const_iterator pc = scriptSig.begin();
     192                 :          0 :     std::vector<unsigned char> vData;
     193 [ #  # ][ #  # ]:          0 :     while (pc < scriptSig.end())
                 [ #  # ]
     194                 :            :     {
     195                 :            :         opcodetype opcode;
     196 [ #  # ][ #  # ]:          0 :         if (!scriptSig.GetOp(pc, opcode, vData))
     197                 :          0 :             return 0;
     198         [ #  # ]:          0 :         if (opcode > OP_16)
     199                 :          0 :             return 0;
     200                 :            :     }
     201                 :            : 
     202                 :            :     /// ... and return its opcount:
     203         [ #  # ]:          0 :     CScript subscript(vData.begin(), vData.end());
     204         [ #  # ]:          0 :     return subscript.GetSigOpCount(true);
     205                 :          0 : }
     206                 :            : 
     207                 :     794453 : bool CScript::IsPayToScriptHash() const
     208                 :            : {
     209                 :            :     // Extra-fast test for pay-to-script-hash CScripts:
     210         [ +  + ]:     808620 :     return (this->size() == 23 &&
     211         [ +  + ]:      14167 :             (*this)[0] == OP_HASH160 &&
     212         [ -  + ]:       1384 :             (*this)[1] == 0x14 &&
     213                 :       1384 :             (*this)[22] == OP_EQUAL);
     214                 :            : }
     215                 :            : 
     216                 :          0 : bool CScript::IsPayToWitnessScriptHash() const
     217                 :            : {
     218                 :            :     // Extra-fast test for pay-to-witness-script-hash CScripts:
     219         [ #  # ]:          0 :     return (this->size() == 34 &&
     220         [ #  # ]:          0 :             (*this)[0] == OP_0 &&
     221                 :          0 :             (*this)[1] == 0x20);
     222                 :            : }
     223                 :            : 
     224                 :            : // A witness program is any valid CScript that consists of a 1-byte push opcode
     225                 :            : // followed by a data push between 2 and 40 bytes.
     226                 :     832074 : bool CScript::IsWitnessProgram(int& version, std::vector<unsigned char>& program) const
     227                 :            : {
     228 [ +  + ][ +  + ]:     832074 :     if (this->size() < 4 || this->size() > 42) {
     229                 :      10101 :         return false;
     230                 :            :     }
     231 [ +  + ][ +  + ]:     821973 :     if ((*this)[0] != OP_0 && ((*this)[0] < OP_1 || (*this)[0] > OP_16)) {
                 [ +  + ]
     232                 :     776063 :         return false;
     233                 :            :     }
     234         [ +  + ]:      45910 :     if ((size_t)((*this)[1] + 2) == this->size()) {
     235                 :      44798 :         version = DecodeOP_N((opcodetype)(*this)[0]);
     236         [ -  + ]:      44798 :         program = std::vector<unsigned char>(this->begin() + 2, this->end());
     237                 :      44798 :         return true;
     238                 :            :     }
     239                 :       1112 :     return false;
     240                 :     832074 : }
     241                 :            : 
     242                 :       1084 : bool CScript::IsPushOnly(const_iterator pc) const
     243                 :            : {
     244         [ +  + ]:       1607 :     while (pc < end())
     245                 :            :     {
     246                 :            :         opcodetype opcode;
     247         [ +  + ]:       1398 :         if (!GetOp(pc, opcode))
     248                 :        598 :             return false;
     249                 :            :         // Note that IsPushOnly() *does* consider OP_RESERVED to be a
     250                 :            :         // push-type opcode, however execution of OP_RESERVED fails, so
     251                 :            :         // it's not relevant to P2SH/BIP62 as the scriptSig would fail prior to
     252                 :            :         // the P2SH special validation code being executed.
     253         [ +  + ]:        800 :         if (opcode > OP_16)
     254                 :        277 :             return false;
     255                 :            :     }
     256                 :        209 :     return true;
     257                 :       1084 : }
     258                 :            : 
     259                 :          0 : bool CScript::IsPushOnly() const
     260                 :            : {
     261                 :          0 :     return this->IsPushOnly(begin());
     262                 :            : }
     263                 :            : 
     264                 :          0 : std::string CScriptWitness::ToString() const
     265                 :            : {
     266         [ #  # ]:          0 :     std::string ret = "CScriptWitness(";
     267         [ #  # ]:          0 :     for (unsigned int i = 0; i < stack.size(); i++) {
     268         [ #  # ]:          0 :         if (i) {
     269         [ #  # ]:          0 :             ret += ", ";
     270                 :          0 :         }
     271 [ #  # ][ #  # ]:          0 :         ret += HexStr(stack[i]);
                 [ #  # ]
     272                 :          0 :     }
     273         [ #  # ]:          0 :     return ret + ")";
     274                 :          0 : }
     275                 :            : 
     276                 :          0 : bool CScript::HasValidOps() const
     277                 :            : {
     278                 :          0 :     CScript::const_iterator it = begin();
     279         [ #  # ]:          0 :     while (it < end()) {
     280                 :            :         opcodetype opcode;
     281                 :          0 :         std::vector<unsigned char> item;
     282 [ #  # ][ #  # ]:          0 :         if (!GetOp(it, opcode, item) || opcode > MAX_OPCODE || item.size() > MAX_SCRIPT_ELEMENT_SIZE) {
         [ #  # ][ #  # ]
     283                 :          0 :             return false;
     284                 :            :         }
     285      [ #  #  # ]:          0 :     }
     286                 :          0 :     return true;
     287                 :          0 : }
     288                 :            : 
     289                 :     396778 : bool GetScriptOp(CScriptBase::const_iterator& pc, CScriptBase::const_iterator end, opcodetype& opcodeRet, std::vector<unsigned char>* pvchRet)
     290                 :            : {
     291                 :     396778 :     opcodeRet = OP_INVALIDOPCODE;
     292         [ +  + ]:     396778 :     if (pvchRet)
     293                 :     245303 :         pvchRet->clear();
     294         [ +  + ]:     396778 :     if (pc >= end)
     295                 :      48224 :         return false;
     296                 :            : 
     297                 :            :     // Read instruction
     298         [ +  - ]:     348554 :     if (end - pc < 1)
     299                 :          0 :         return false;
     300                 :     348554 :     unsigned int opcode = *pc++;
     301                 :            : 
     302                 :            :     // Immediate operand
     303         [ +  + ]:     348554 :     if (opcode <= OP_PUSHDATA4)
     304                 :            :     {
     305                 :     182217 :         unsigned int nSize = 0;
     306         [ +  + ]:     182217 :         if (opcode < OP_PUSHDATA1)
     307                 :            :         {
     308                 :     181001 :             nSize = opcode;
     309                 :     181001 :         }
     310         [ +  + ]:       1216 :         else if (opcode == OP_PUSHDATA1)
     311                 :            :         {
     312         [ +  - ]:        486 :             if (end - pc < 1)
     313                 :          0 :                 return false;
     314                 :        486 :             nSize = *pc++;
     315                 :        486 :         }
     316         [ +  + ]:        730 :         else if (opcode == OP_PUSHDATA2)
     317                 :            :         {
     318         [ +  + ]:        361 :             if (end - pc < 2)
     319                 :         14 :                 return false;
     320                 :        347 :             nSize = ReadLE16(&pc[0]);
     321                 :        347 :             pc += 2;
     322                 :        347 :         }
     323         [ -  + ]:        369 :         else if (opcode == OP_PUSHDATA4)
     324                 :            :         {
     325         [ +  + ]:        369 :             if (end - pc < 4)
     326                 :          6 :                 return false;
     327                 :        363 :             nSize = ReadLE32(&pc[0]);
     328                 :        363 :             pc += 4;
     329                 :        363 :         }
     330 [ +  - ][ +  + ]:     182197 :         if (end - pc < 0 || (unsigned int)(end - pc) < nSize)
     331                 :       1783 :             return false;
     332         [ +  + ]:     180414 :         if (pvchRet)
     333                 :     128159 :             pvchRet->assign(pc, pc + nSize);
     334                 :     180414 :         pc += nSize;
     335                 :     180414 :     }
     336                 :            : 
     337                 :     346751 :     opcodeRet = static_cast<opcodetype>(opcode);
     338                 :     346751 :     return true;
     339                 :     396778 : }
     340                 :            : 
     341                 :          0 : bool IsOpSuccess(const opcodetype& opcode)
     342                 :            : {
     343 [ #  # ][ #  # ]:          0 :     return opcode == 80 || opcode == 98 || (opcode >= 126 && opcode <= 129) ||
         [ #  # ][ #  # ]
     344 [ #  # ][ #  # ]:          0 :            (opcode >= 131 && opcode <= 134) || (opcode >= 137 && opcode <= 138) ||
     345 [ #  # ][ #  # ]:          0 :            (opcode >= 141 && opcode <= 142) || (opcode >= 149 && opcode <= 153) ||
     346         [ #  # ]:          0 :            (opcode >= 187 && opcode <= 254);
     347                 :            : }
     348                 :            : 
     349                 :     128031 : bool CheckMinimalPush(const std::vector<unsigned char>& data, opcodetype opcode) {
     350                 :            :     // Excludes OP_1NEGATE, OP_1-16 since they are by definition minimal
     351 [ -  + ][ +  - ]:     128031 :     assert(0 <= opcode && opcode <= OP_PUSHDATA4);
     352         [ +  + ]:     128031 :     if (data.size() == 0) {
     353                 :            :         // Should have used OP_0.
     354                 :        158 :         return opcode == OP_0;
     355 [ +  + ][ +  + ]:     127873 :     } else if (data.size() == 1 && data[0] >= 1 && data[0] <= 16) {
                 [ +  + ]
     356                 :            :         // Should have used OP_1 .. OP_16.
     357                 :        107 :         return false;
     358 [ +  + ][ +  - ]:     127766 :     } else if (data.size() == 1 && data[0] == 0x81) {
     359                 :            :         // Should have used OP_1NEGATE.
     360                 :          0 :         return false;
     361         [ +  - ]:     127766 :     } else if (data.size() <= 75) {
     362                 :            :         // Must have used a direct push (opcode indicating number of bytes pushed + those bytes).
     363                 :     127766 :         return opcode == data.size();
     364         [ #  # ]:          0 :     } else if (data.size() <= 255) {
     365                 :            :         // Must have used OP_PUSHDATA.
     366                 :          0 :         return opcode == OP_PUSHDATA1;
     367         [ #  # ]:          0 :     } else if (data.size() <= 65535) {
     368                 :            :         // Must have used OP_PUSHDATA2.
     369                 :          0 :         return opcode == OP_PUSHDATA2;
     370                 :            :     }
     371                 :          0 :     return true;
     372                 :     128031 : }