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