LCOV - code coverage report
Current view: top level - src/script - script.h (source / functions) Hit Total Coverage
Test: fuzz_coverage.info Lines: 48 176 27.3 %
Date: 2023-10-05 12:38:51 Functions: 30 222 13.5 %
Branches: 17 478 3.6 %

           Branch data     Line data    Source code
       1                 :            : // Copyright (c) 2009-2010 Satoshi Nakamoto
       2                 :            : // Copyright (c) 2009-2022 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                 :            : #ifndef BITCOIN_SCRIPT_SCRIPT_H
       7                 :            : #define BITCOIN_SCRIPT_SCRIPT_H
       8                 :            : 
       9                 :            : #include <attributes.h>
      10                 :            : #include <crypto/common.h>
      11                 :            : #include <prevector.h>
      12                 :            : #include <serialize.h>
      13                 :            : #include <uint256.h>
      14                 :            : #include <util/hash_type.h>
      15                 :            : 
      16                 :            : #include <assert.h>
      17                 :            : #include <climits>
      18                 :            : #include <limits>
      19                 :            : #include <stdexcept>
      20                 :            : #include <stdint.h>
      21                 :            : #include <string.h>
      22                 :            : #include <string>
      23                 :            : #include <vector>
      24                 :            : 
      25                 :            : // Maximum number of bytes pushable to the stack
      26                 :            : static const unsigned int MAX_SCRIPT_ELEMENT_SIZE = 520;
      27                 :            : 
      28                 :            : // Maximum number of non-push operations per script
      29                 :            : static const int MAX_OPS_PER_SCRIPT = 201;
      30                 :            : 
      31                 :            : // Maximum number of public keys per multisig
      32                 :            : static const int MAX_PUBKEYS_PER_MULTISIG = 20;
      33                 :            : 
      34                 :            : /** The limit of keys in OP_CHECKSIGADD-based scripts. It is due to the stack limit in BIP342. */
      35                 :            : static constexpr unsigned int MAX_PUBKEYS_PER_MULTI_A = 999;
      36                 :            : 
      37                 :            : // Maximum script length in bytes
      38                 :            : static const int MAX_SCRIPT_SIZE = 10000;
      39                 :            : 
      40                 :            : // Maximum number of values on script interpreter stack
      41                 :            : static const int MAX_STACK_SIZE = 1000;
      42                 :            : 
      43                 :            : // Threshold for nLockTime: below this value it is interpreted as block number,
      44                 :            : // otherwise as UNIX timestamp.
      45                 :            : static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov  5 00:53:20 1985 UTC
      46                 :            : 
      47                 :            : // Maximum nLockTime. Since a lock time indicates the last invalid timestamp, a
      48                 :            : // transaction with this lock time will never be valid unless lock time
      49                 :            : // checking is disabled (by setting all input sequence numbers to
      50                 :            : // SEQUENCE_FINAL).
      51                 :            : static const uint32_t LOCKTIME_MAX = 0xFFFFFFFFU;
      52                 :            : 
      53                 :            : // Tag for input annex. If there are at least two witness elements for a transaction input,
      54                 :            : // and the first byte of the last element is 0x50, this last element is called annex, and
      55                 :            : // has meanings independent of the script
      56                 :            : static constexpr unsigned int ANNEX_TAG = 0x50;
      57                 :            : 
      58                 :            : // Validation weight per passing signature (Tapscript only, see BIP 342).
      59                 :            : static constexpr int64_t VALIDATION_WEIGHT_PER_SIGOP_PASSED{50};
      60                 :            : 
      61                 :            : // How much weight budget is added to the witness size (Tapscript only, see BIP 342).
      62                 :            : static constexpr int64_t VALIDATION_WEIGHT_OFFSET{50};
      63                 :            : 
      64                 :            : template <typename T>
      65                 :         16 : std::vector<unsigned char> ToByteVector(const T& in)
      66                 :            : {
      67   [ +  -  #  #  :         16 :     return std::vector<unsigned char>(in.begin(), in.end());
          #  #  #  #  #  
                #  #  # ]
      68                 :          0 : }
      69                 :            : 
      70                 :            : /** Script opcodes */
      71                 :            : enum opcodetype
      72                 :            : {
      73                 :            :     // push value
      74                 :            :     OP_0 = 0x00,
      75                 :            :     OP_FALSE = OP_0,
      76                 :            :     OP_PUSHDATA1 = 0x4c,
      77                 :            :     OP_PUSHDATA2 = 0x4d,
      78                 :            :     OP_PUSHDATA4 = 0x4e,
      79                 :            :     OP_1NEGATE = 0x4f,
      80                 :            :     OP_RESERVED = 0x50,
      81                 :            :     OP_1 = 0x51,
      82                 :            :     OP_TRUE=OP_1,
      83                 :            :     OP_2 = 0x52,
      84                 :            :     OP_3 = 0x53,
      85                 :            :     OP_4 = 0x54,
      86                 :            :     OP_5 = 0x55,
      87                 :            :     OP_6 = 0x56,
      88                 :            :     OP_7 = 0x57,
      89                 :            :     OP_8 = 0x58,
      90                 :            :     OP_9 = 0x59,
      91                 :            :     OP_10 = 0x5a,
      92                 :            :     OP_11 = 0x5b,
      93                 :            :     OP_12 = 0x5c,
      94                 :            :     OP_13 = 0x5d,
      95                 :            :     OP_14 = 0x5e,
      96                 :            :     OP_15 = 0x5f,
      97                 :            :     OP_16 = 0x60,
      98                 :            : 
      99                 :            :     // control
     100                 :            :     OP_NOP = 0x61,
     101                 :            :     OP_VER = 0x62,
     102                 :            :     OP_IF = 0x63,
     103                 :            :     OP_NOTIF = 0x64,
     104                 :            :     OP_VERIF = 0x65,
     105                 :            :     OP_VERNOTIF = 0x66,
     106                 :            :     OP_ELSE = 0x67,
     107                 :            :     OP_ENDIF = 0x68,
     108                 :            :     OP_VERIFY = 0x69,
     109                 :            :     OP_RETURN = 0x6a,
     110                 :            : 
     111                 :            :     // stack ops
     112                 :            :     OP_TOALTSTACK = 0x6b,
     113                 :            :     OP_FROMALTSTACK = 0x6c,
     114                 :            :     OP_2DROP = 0x6d,
     115                 :            :     OP_2DUP = 0x6e,
     116                 :            :     OP_3DUP = 0x6f,
     117                 :            :     OP_2OVER = 0x70,
     118                 :            :     OP_2ROT = 0x71,
     119                 :            :     OP_2SWAP = 0x72,
     120                 :            :     OP_IFDUP = 0x73,
     121                 :            :     OP_DEPTH = 0x74,
     122                 :            :     OP_DROP = 0x75,
     123                 :            :     OP_DUP = 0x76,
     124                 :            :     OP_NIP = 0x77,
     125                 :            :     OP_OVER = 0x78,
     126                 :            :     OP_PICK = 0x79,
     127                 :            :     OP_ROLL = 0x7a,
     128                 :            :     OP_ROT = 0x7b,
     129                 :            :     OP_SWAP = 0x7c,
     130                 :            :     OP_TUCK = 0x7d,
     131                 :            : 
     132                 :            :     // splice ops
     133                 :            :     OP_CAT = 0x7e,
     134                 :            :     OP_SUBSTR = 0x7f,
     135                 :            :     OP_LEFT = 0x80,
     136                 :            :     OP_RIGHT = 0x81,
     137                 :            :     OP_SIZE = 0x82,
     138                 :            : 
     139                 :            :     // bit logic
     140                 :            :     OP_INVERT = 0x83,
     141                 :            :     OP_AND = 0x84,
     142                 :            :     OP_OR = 0x85,
     143                 :            :     OP_XOR = 0x86,
     144                 :            :     OP_EQUAL = 0x87,
     145                 :            :     OP_EQUALVERIFY = 0x88,
     146                 :            :     OP_RESERVED1 = 0x89,
     147                 :            :     OP_RESERVED2 = 0x8a,
     148                 :            : 
     149                 :            :     // numeric
     150                 :            :     OP_1ADD = 0x8b,
     151                 :            :     OP_1SUB = 0x8c,
     152                 :            :     OP_2MUL = 0x8d,
     153                 :            :     OP_2DIV = 0x8e,
     154                 :            :     OP_NEGATE = 0x8f,
     155                 :            :     OP_ABS = 0x90,
     156                 :            :     OP_NOT = 0x91,
     157                 :            :     OP_0NOTEQUAL = 0x92,
     158                 :            : 
     159                 :            :     OP_ADD = 0x93,
     160                 :            :     OP_SUB = 0x94,
     161                 :            :     OP_MUL = 0x95,
     162                 :            :     OP_DIV = 0x96,
     163                 :            :     OP_MOD = 0x97,
     164                 :            :     OP_LSHIFT = 0x98,
     165                 :            :     OP_RSHIFT = 0x99,
     166                 :            : 
     167                 :            :     OP_BOOLAND = 0x9a,
     168                 :            :     OP_BOOLOR = 0x9b,
     169                 :            :     OP_NUMEQUAL = 0x9c,
     170                 :            :     OP_NUMEQUALVERIFY = 0x9d,
     171                 :            :     OP_NUMNOTEQUAL = 0x9e,
     172                 :            :     OP_LESSTHAN = 0x9f,
     173                 :            :     OP_GREATERTHAN = 0xa0,
     174                 :            :     OP_LESSTHANOREQUAL = 0xa1,
     175                 :            :     OP_GREATERTHANOREQUAL = 0xa2,
     176                 :            :     OP_MIN = 0xa3,
     177                 :            :     OP_MAX = 0xa4,
     178                 :            : 
     179                 :            :     OP_WITHIN = 0xa5,
     180                 :            : 
     181                 :            :     // crypto
     182                 :            :     OP_RIPEMD160 = 0xa6,
     183                 :            :     OP_SHA1 = 0xa7,
     184                 :            :     OP_SHA256 = 0xa8,
     185                 :            :     OP_HASH160 = 0xa9,
     186                 :            :     OP_HASH256 = 0xaa,
     187                 :            :     OP_CODESEPARATOR = 0xab,
     188                 :            :     OP_CHECKSIG = 0xac,
     189                 :            :     OP_CHECKSIGVERIFY = 0xad,
     190                 :            :     OP_CHECKMULTISIG = 0xae,
     191                 :            :     OP_CHECKMULTISIGVERIFY = 0xaf,
     192                 :            : 
     193                 :            :     // expansion
     194                 :            :     OP_NOP1 = 0xb0,
     195                 :            :     OP_CHECKLOCKTIMEVERIFY = 0xb1,
     196                 :            :     OP_NOP2 = OP_CHECKLOCKTIMEVERIFY,
     197                 :            :     OP_CHECKSEQUENCEVERIFY = 0xb2,
     198                 :            :     OP_NOP3 = OP_CHECKSEQUENCEVERIFY,
     199                 :            :     OP_NOP4 = 0xb3,
     200                 :            :     OP_NOP5 = 0xb4,
     201                 :            :     OP_NOP6 = 0xb5,
     202                 :            :     OP_NOP7 = 0xb6,
     203                 :            :     OP_NOP8 = 0xb7,
     204                 :            :     OP_NOP9 = 0xb8,
     205                 :            :     OP_NOP10 = 0xb9,
     206                 :            : 
     207                 :            :     // Opcode added by BIP 342 (Tapscript)
     208                 :            :     OP_CHECKSIGADD = 0xba,
     209                 :            : 
     210                 :            :     OP_INVALIDOPCODE = 0xff,
     211                 :            : };
     212                 :            : 
     213                 :            : // Maximum value that an opcode can be
     214                 :            : static const unsigned int MAX_OPCODE = OP_NOP10;
     215                 :            : 
     216                 :            : std::string GetOpName(opcodetype opcode);
     217                 :            : 
     218                 :            : class scriptnum_error : public std::runtime_error
     219                 :            : {
     220                 :            : public:
     221                 :          0 :     explicit scriptnum_error(const std::string& str) : std::runtime_error(str) {}
     222                 :            : };
     223                 :            : 
     224                 :            : class CScriptNum
     225                 :            : {
     226                 :            : /**
     227                 :            :  * Numeric opcodes (OP_1ADD, etc) are restricted to operating on 4-byte integers.
     228                 :            :  * The semantics are subtle, though: operands must be in the range [-2^31 +1...2^31 -1],
     229                 :            :  * but results may overflow (and are valid as long as they are not used in a subsequent
     230                 :            :  * numeric operation). CScriptNum enforces those semantics by storing results as
     231                 :            :  * an int64 and allowing out-of-range values to be returned as a vector of bytes but
     232                 :            :  * throwing an exception if arithmetic is done or the result is interpreted as an integer.
     233                 :            :  */
     234                 :            : public:
     235                 :            : 
     236                 :          5 :     explicit CScriptNum(const int64_t& n)
     237                 :            :     {
     238                 :          5 :         m_value = n;
     239                 :          5 :     }
     240                 :            : 
     241                 :            :     static const size_t nDefaultMaxNumSize = 4;
     242                 :            : 
     243                 :          0 :     explicit CScriptNum(const std::vector<unsigned char>& vch, bool fRequireMinimal,
     244                 :            :                         const size_t nMaxNumSize = nDefaultMaxNumSize)
     245                 :            :     {
     246         [ #  # ]:          0 :         if (vch.size() > nMaxNumSize) {
     247   [ #  #  #  #  :          0 :             throw scriptnum_error("script number overflow");
                   #  # ]
     248                 :            :         }
     249   [ #  #  #  # ]:          0 :         if (fRequireMinimal && vch.size() > 0) {
     250                 :            :             // Check that the number is encoded with the minimum possible
     251                 :            :             // number of bytes.
     252                 :            :             //
     253                 :            :             // If the most-significant-byte - excluding the sign bit - is zero
     254                 :            :             // then we're not minimal. Note how this test also rejects the
     255                 :            :             // negative-zero encoding, 0x80.
     256         [ #  # ]:          0 :             if ((vch.back() & 0x7f) == 0) {
     257                 :            :                 // One exception: if there's more than one byte and the most
     258                 :            :                 // significant bit of the second-most-significant-byte is set
     259                 :            :                 // it would conflict with the sign bit. An example of this case
     260                 :            :                 // is +-255, which encode to 0xff00 and 0xff80 respectively.
     261                 :            :                 // (big-endian).
     262         [ #  # ]:          0 :                 if (vch.size() <= 1 || (vch[vch.size() - 2] & 0x80) == 0) {
     263   [ #  #  #  #  :          0 :                     throw scriptnum_error("non-minimally encoded script number");
                   #  # ]
     264                 :            :                 }
     265                 :          0 :             }
     266                 :          0 :         }
     267                 :          0 :         m_value = set_vch(vch);
     268                 :          0 :     }
     269                 :            : 
     270                 :          0 :     inline bool operator==(const int64_t& rhs) const    { return m_value == rhs; }
     271                 :          0 :     inline bool operator!=(const int64_t& rhs) const    { return m_value != rhs; }
     272                 :          0 :     inline bool operator<=(const int64_t& rhs) const    { return m_value <= rhs; }
     273                 :          0 :     inline bool operator< (const int64_t& rhs) const    { return m_value <  rhs; }
     274                 :          0 :     inline bool operator>=(const int64_t& rhs) const    { return m_value >= rhs; }
     275                 :          0 :     inline bool operator> (const int64_t& rhs) const    { return m_value >  rhs; }
     276                 :            : 
     277                 :          0 :     inline bool operator==(const CScriptNum& rhs) const { return operator==(rhs.m_value); }
     278                 :          0 :     inline bool operator!=(const CScriptNum& rhs) const { return operator!=(rhs.m_value); }
     279                 :          0 :     inline bool operator<=(const CScriptNum& rhs) const { return operator<=(rhs.m_value); }
     280                 :          0 :     inline bool operator< (const CScriptNum& rhs) const { return operator< (rhs.m_value); }
     281                 :          0 :     inline bool operator>=(const CScriptNum& rhs) const { return operator>=(rhs.m_value); }
     282                 :          0 :     inline bool operator> (const CScriptNum& rhs) const { return operator> (rhs.m_value); }
     283                 :            : 
     284                 :          0 :     inline CScriptNum operator+(   const int64_t& rhs)    const { return CScriptNum(m_value + rhs);}
     285                 :          0 :     inline CScriptNum operator-(   const int64_t& rhs)    const { return CScriptNum(m_value - rhs);}
     286                 :          0 :     inline CScriptNum operator+(   const CScriptNum& rhs) const { return operator+(rhs.m_value);   }
     287                 :          0 :     inline CScriptNum operator-(   const CScriptNum& rhs) const { return operator-(rhs.m_value);   }
     288                 :            : 
     289                 :          0 :     inline CScriptNum& operator+=( const CScriptNum& rhs)       { return operator+=(rhs.m_value);  }
     290                 :          0 :     inline CScriptNum& operator-=( const CScriptNum& rhs)       { return operator-=(rhs.m_value);  }
     291                 :            : 
     292                 :          0 :     inline CScriptNum operator&(   const int64_t& rhs)    const { return CScriptNum(m_value & rhs);}
     293                 :          0 :     inline CScriptNum operator&(   const CScriptNum& rhs) const { return operator&(rhs.m_value);   }
     294                 :            : 
     295                 :          0 :     inline CScriptNum& operator&=( const CScriptNum& rhs)       { return operator&=(rhs.m_value);  }
     296                 :            : 
     297                 :          0 :     inline CScriptNum operator-()                         const
     298                 :            :     {
     299         [ #  # ]:          0 :         assert(m_value != std::numeric_limits<int64_t>::min());
     300                 :          0 :         return CScriptNum(-m_value);
     301                 :            :     }
     302                 :            : 
     303                 :          0 :     inline CScriptNum& operator=( const int64_t& rhs)
     304                 :            :     {
     305                 :          0 :         m_value = rhs;
     306                 :          0 :         return *this;
     307                 :            :     }
     308                 :            : 
     309                 :          0 :     inline CScriptNum& operator+=( const int64_t& rhs)
     310                 :            :     {
     311   [ #  #  #  #  :          0 :         assert(rhs == 0 || (rhs > 0 && m_value <= std::numeric_limits<int64_t>::max() - rhs) ||
          #  #  #  #  #  
                      # ]
     312                 :            :                            (rhs < 0 && m_value >= std::numeric_limits<int64_t>::min() - rhs));
     313                 :          0 :         m_value += rhs;
     314                 :          0 :         return *this;
     315                 :            :     }
     316                 :            : 
     317                 :          0 :     inline CScriptNum& operator-=( const int64_t& rhs)
     318                 :            :     {
     319   [ #  #  #  #  :          0 :         assert(rhs == 0 || (rhs > 0 && m_value >= std::numeric_limits<int64_t>::min() + rhs) ||
          #  #  #  #  #  
                      # ]
     320                 :            :                            (rhs < 0 && m_value <= std::numeric_limits<int64_t>::max() + rhs));
     321                 :          0 :         m_value -= rhs;
     322                 :          0 :         return *this;
     323                 :            :     }
     324                 :            : 
     325                 :          0 :     inline CScriptNum& operator&=( const int64_t& rhs)
     326                 :            :     {
     327                 :          0 :         m_value &= rhs;
     328                 :          0 :         return *this;
     329                 :            :     }
     330                 :            : 
     331                 :          0 :     int getint() const
     332                 :            :     {
     333         [ #  # ]:          0 :         if (m_value > std::numeric_limits<int>::max())
     334                 :          0 :             return std::numeric_limits<int>::max();
     335         [ #  # ]:          0 :         else if (m_value < std::numeric_limits<int>::min())
     336                 :          0 :             return std::numeric_limits<int>::min();
     337                 :          0 :         return m_value;
     338                 :          0 :     }
     339                 :            : 
     340                 :          0 :     int64_t GetInt64() const { return m_value; }
     341                 :            : 
     342                 :          5 :     std::vector<unsigned char> getvch() const
     343                 :            :     {
     344                 :          5 :         return serialize(m_value);
     345                 :            :     }
     346                 :            : 
     347                 :         10 :     static std::vector<unsigned char> serialize(const int64_t& value)
     348                 :            :     {
     349         [ -  + ]:         10 :         if(value == 0)
     350                 :          0 :             return std::vector<unsigned char>();
     351                 :            : 
     352                 :         10 :         std::vector<unsigned char> result;
     353                 :         10 :         const bool neg = value < 0;
     354         [ -  + ]:         10 :         uint64_t absvalue = neg ? ~static_cast<uint64_t>(value) + 1 : static_cast<uint64_t>(value);
     355                 :            : 
     356         [ +  + ]:         35 :         while(absvalue)
     357                 :            :         {
     358         [ +  - ]:         25 :             result.push_back(absvalue & 0xff);
     359                 :         25 :             absvalue >>= 8;
     360                 :            :         }
     361                 :            : 
     362                 :            : //    - If the most significant byte is >= 0x80 and the value is positive, push a
     363                 :            : //    new zero-byte to make the significant byte < 0x80 again.
     364                 :            : 
     365                 :            : //    - If the most significant byte is >= 0x80 and the value is negative, push a
     366                 :            : //    new 0x80 byte that will be popped off when converting to an integral.
     367                 :            : 
     368                 :            : //    - If the most significant byte is < 0x80 and the value is negative, add
     369                 :            : //    0x80 to it, since it will be subtracted and interpreted as a negative when
     370                 :            : //    converting to an integral.
     371                 :            : 
     372         [ -  + ]:         10 :         if (result.back() & 0x80)
     373         [ #  # ]:          0 :             result.push_back(neg ? 0x80 : 0);
     374         [ +  - ]:         10 :         else if (neg)
     375                 :          0 :             result.back() |= 0x80;
     376                 :            : 
     377                 :         10 :         return result;
     378         [ +  - ]:         20 :     }
     379                 :            : 
     380                 :            : private:
     381                 :          0 :     static int64_t set_vch(const std::vector<unsigned char>& vch)
     382                 :            :     {
     383         [ #  # ]:          0 :       if (vch.empty())
     384                 :          0 :           return 0;
     385                 :            : 
     386                 :          0 :       int64_t result = 0;
     387         [ #  # ]:          0 :       for (size_t i = 0; i != vch.size(); ++i)
     388                 :          0 :           result |= static_cast<int64_t>(vch[i]) << 8*i;
     389                 :            : 
     390                 :            :       // If the input vector's most significant byte is 0x80, remove it from
     391                 :            :       // the result's msb and return a negative.
     392         [ #  # ]:          0 :       if (vch.back() & 0x80)
     393                 :          0 :           return -((int64_t)(result & ~(0x80ULL << (8 * (vch.size() - 1)))));
     394                 :            : 
     395                 :          0 :       return result;
     396                 :          0 :     }
     397                 :            : 
     398                 :            :     int64_t m_value;
     399                 :            : };
     400                 :            : 
     401                 :            : /**
     402                 :            :  * We use a prevector for the script to reduce the considerable memory overhead
     403                 :            :  *  of vectors in cases where they normally contain a small number of small elements.
     404                 :            :  * Tests in October 2015 showed use of this reduced dbcache memory usage by 23%
     405                 :            :  *  and made an initial sync 13% faster.
     406                 :            :  */
     407                 :            : typedef prevector<28, unsigned char> CScriptBase;
     408                 :            : 
     409                 :            : bool GetScriptOp(CScriptBase::const_iterator& pc, CScriptBase::const_iterator end, opcodetype& opcodeRet, std::vector<unsigned char>* pvchRet);
     410                 :            : 
     411                 :            : /** Serialized script, used inside transaction inputs and outputs */
     412                 :            : class CScript : public CScriptBase
     413                 :            : {
     414                 :            : protected:
     415                 :          5 :     CScript& push_int64(int64_t n)
     416                 :            :     {
     417   [ +  -  +  -  :          5 :         if (n == -1 || (n >= 1 && n <= 16))
                   -  + ]
     418                 :            :         {
     419                 :          0 :             push_back(n + (OP_1 - 1));
     420                 :          0 :         }
     421         [ +  - ]:          5 :         else if (n == 0)
     422                 :            :         {
     423                 :          0 :             push_back(OP_0);
     424                 :          0 :         }
     425                 :            :         else
     426                 :            :         {
     427         [ +  - ]:          5 :             *this << CScriptNum::serialize(n);
     428                 :            :         }
     429                 :          5 :         return *this;
     430                 :          0 :     }
     431                 :            : public:
     432                 :         46 :     CScript() { }
     433                 :          0 :     CScript(const_iterator pbegin, const_iterator pend) : CScriptBase(pbegin, pend) { }
     434                 :          0 :     CScript(std::vector<unsigned char>::const_iterator pbegin, std::vector<unsigned char>::const_iterator pend) : CScriptBase(pbegin, pend) { }
     435                 :          0 :     CScript(const unsigned char* pbegin, const unsigned char* pend) : CScriptBase(pbegin, pend) { }
     436                 :            : 
     437                 :         78 :     SERIALIZE_METHODS(CScript, obj) { READWRITE(AsBase<CScriptBase>(obj)); }
     438                 :            : 
     439                 :            :     explicit CScript(int64_t b) { operator<<(b); }
     440         [ #  # ]:          0 :     explicit CScript(opcodetype b)     { operator<<(b); }
     441                 :            :     explicit CScript(const CScriptNum& b) { operator<<(b); }
     442                 :            :     // delete non-existent constructor to defend against future introduction
     443                 :            :     // e.g. via prevector
     444                 :            :     explicit CScript(const std::vector<unsigned char>& b) = delete;
     445                 :            : 
     446                 :            :     /** Delete non-existent operator to defend against future introduction */
     447                 :            :     CScript& operator<<(const CScript& b) = delete;
     448                 :            : 
     449                 :          5 :     CScript& operator<<(int64_t b) LIFETIMEBOUND { return push_int64(b); }
     450                 :            : 
     451                 :         21 :     CScript& operator<<(opcodetype opcode) LIFETIMEBOUND
     452                 :            :     {
     453         [ +  - ]:         21 :         if (opcode < 0 || opcode > 0xff)
     454         [ #  # ]:          0 :             throw std::runtime_error("CScript::operator<<(): invalid opcode");
     455                 :         21 :         insert(end(), (unsigned char)opcode);
     456                 :         21 :         return *this;
     457                 :          0 :     }
     458                 :            : 
     459                 :          5 :     CScript& operator<<(const CScriptNum& b) LIFETIMEBOUND
     460                 :            :     {
     461         [ +  - ]:          5 :         *this << b.getvch();
     462                 :          5 :         return *this;
     463                 :          0 :     }
     464                 :            : 
     465                 :         36 :     CScript& operator<<(const std::vector<unsigned char>& b) LIFETIMEBOUND
     466                 :            :     {
     467         [ +  - ]:         36 :         if (b.size() < OP_PUSHDATA1)
     468                 :            :         {
     469                 :         36 :             insert(end(), (unsigned char)b.size());
     470                 :         36 :         }
     471         [ #  # ]:          0 :         else if (b.size() <= 0xff)
     472                 :            :         {
     473                 :          0 :             insert(end(), OP_PUSHDATA1);
     474                 :          0 :             insert(end(), (unsigned char)b.size());
     475                 :          0 :         }
     476         [ #  # ]:          0 :         else if (b.size() <= 0xffff)
     477                 :            :         {
     478                 :          0 :             insert(end(), OP_PUSHDATA2);
     479                 :            :             uint8_t _data[2];
     480                 :          0 :             WriteLE16(_data, b.size());
     481                 :          0 :             insert(end(), _data, _data + sizeof(_data));
     482                 :          0 :         }
     483                 :            :         else
     484                 :            :         {
     485                 :          0 :             insert(end(), OP_PUSHDATA4);
     486                 :            :             uint8_t _data[4];
     487                 :          0 :             WriteLE32(_data, b.size());
     488                 :          0 :             insert(end(), _data, _data + sizeof(_data));
     489                 :            :         }
     490                 :         36 :         insert(end(), b.begin(), b.end());
     491                 :         36 :         return *this;
     492                 :            :     }
     493                 :            : 
     494                 :          0 :     bool GetOp(const_iterator& pc, opcodetype& opcodeRet, std::vector<unsigned char>& vchRet) const
     495                 :            :     {
     496                 :          0 :         return GetScriptOp(pc, end(), opcodeRet, &vchRet);
     497                 :            :     }
     498                 :            : 
     499                 :          5 :     bool GetOp(const_iterator& pc, opcodetype& opcodeRet) const
     500                 :            :     {
     501                 :          5 :         return GetScriptOp(pc, end(), opcodeRet, nullptr);
     502                 :            :     }
     503                 :            : 
     504                 :            :     /** Encode/decode small integers: */
     505                 :          0 :     static int DecodeOP_N(opcodetype opcode)
     506                 :            :     {
     507         [ #  # ]:          0 :         if (opcode == OP_0)
     508                 :          0 :             return 0;
     509   [ #  #  #  # ]:          0 :         assert(opcode >= OP_1 && opcode <= OP_16);
     510                 :          0 :         return (int)opcode - (int)(OP_1 - 1);
     511                 :          0 :     }
     512                 :          0 :     static opcodetype EncodeOP_N(int n)
     513                 :            :     {
     514   [ #  #  #  # ]:          0 :         assert(n >= 0 && n <= 16);
     515         [ #  # ]:          0 :         if (n == 0)
     516                 :          0 :             return OP_0;
     517                 :          0 :         return (opcodetype)(OP_1+n-1);
     518                 :          0 :     }
     519                 :            : 
     520                 :            :     /**
     521                 :            :      * Pre-version-0.6, Bitcoin always counted CHECKMULTISIGs
     522                 :            :      * as 20 sigops. With pay-to-script-hash, that changed:
     523                 :            :      * CHECKMULTISIGs serialized in scriptSigs are
     524                 :            :      * counted more accurately, assuming they are of the form
     525                 :            :      *  ... OP_N CHECKMULTISIG ...
     526                 :            :      */
     527                 :            :     unsigned int GetSigOpCount(bool fAccurate) const;
     528                 :            : 
     529                 :            :     /**
     530                 :            :      * Accurately count sigOps, including sigOps in
     531                 :            :      * pay-to-script-hash transactions:
     532                 :            :      */
     533                 :            :     unsigned int GetSigOpCount(const CScript& scriptSig) const;
     534                 :            : 
     535                 :            :     bool IsPayToScriptHash() const;
     536                 :            :     bool IsPayToWitnessScriptHash() const;
     537                 :            :     bool IsWitnessProgram(int& version, std::vector<unsigned char>& program) const;
     538                 :            : 
     539                 :            :     /** Called by IsStandardTx and P2SH/BIP62 VerifyScript (which makes it consensus-critical). */
     540                 :            :     bool IsPushOnly(const_iterator pc) const;
     541                 :            :     bool IsPushOnly() const;
     542                 :            : 
     543                 :            :     /** Check if the script contains valid OP_CODES */
     544                 :            :     bool HasValidOps() const;
     545                 :            : 
     546                 :            :     /**
     547                 :            :      * Returns whether the script is guaranteed to fail at execution,
     548                 :            :      * regardless of the initial stack. This allows outputs to be pruned
     549                 :            :      * instantly when entering the UTXO set.
     550                 :            :      */
     551                 :          0 :     bool IsUnspendable() const
     552                 :            :     {
     553   [ #  #  #  # ]:          0 :         return (size() > 0 && *begin() == OP_RETURN) || (size() > MAX_SCRIPT_SIZE);
     554                 :            :     }
     555                 :            : 
     556                 :         12 :     void clear()
     557                 :            :     {
     558                 :            :         // The default prevector::clear() does not release memory
     559                 :         12 :         CScriptBase::clear();
     560                 :         12 :         shrink_to_fit();
     561                 :         12 :     }
     562                 :            : };
     563                 :            : 
     564                 :            : struct CScriptWitness
     565                 :            : {
     566                 :            :     // Note that this encodes the data elements being pushed, rather than
     567                 :            :     // encoding them as a CScript that pushes them.
     568                 :            :     std::vector<std::vector<unsigned char> > stack;
     569                 :            : 
     570                 :            :     // Some compilers complain without a default constructor
     571                 :          6 :     CScriptWitness() { }
     572                 :            : 
     573                 :          9 :     bool IsNull() const { return stack.empty(); }
     574                 :            : 
     575                 :          0 :     void SetNull() { stack.clear(); stack.shrink_to_fit(); }
     576                 :            : 
     577                 :            :     std::string ToString() const;
     578                 :            : };
     579                 :            : 
     580                 :            : /** A reference to a CScript: the Hash160 of its serialization */
     581                 :            : class CScriptID : public BaseHash<uint160>
     582                 :            : {
     583                 :            : public:
     584                 :          0 :     CScriptID() : BaseHash() {}
     585                 :            :     explicit CScriptID(const CScript& in);
     586                 :          0 :     explicit CScriptID(const uint160& in) : BaseHash(in) {}
     587                 :            : };
     588                 :            : 
     589                 :            : /** Test for OP_SUCCESSx opcodes as defined by BIP342. */
     590                 :            : bool IsOpSuccess(const opcodetype& opcode);
     591                 :            : 
     592                 :            : bool CheckMinimalPush(const std::vector<unsigned char>& data, opcodetype opcode);
     593                 :            : 
     594                 :            : /** Build a script by concatenating other scripts, or any argument accepted by CScript::operator<<. */
     595                 :            : template<typename... Ts>
     596                 :          0 : CScript BuildScript(Ts&&... inputs)
     597                 :            : {
     598                 :          0 :     CScript ret;
     599                 :          0 :     int cnt{0};
     600                 :            : 
     601   [ #  #  #  #  :          0 :     ([&ret, &cnt] (Ts&& input) {
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
     602                 :            :         if constexpr (std::is_same_v<std::remove_cv_t<std::remove_reference_t<Ts>>, CScript>) {
     603                 :            :             // If it is a CScript, extend ret with it. Move or copy the first element instead.
     604   [ #  #  #  #  :          0 :             if (cnt == 0) {
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
     605                 :          0 :                 ret = std::forward<Ts>(input);
     606                 :          0 :             } else {
     607                 :          0 :                 ret.insert(ret.end(), input.begin(), input.end());
     608                 :            :             }
     609                 :            :         } else {
     610                 :            :             // Otherwise invoke CScript::operator<<.
     611                 :          0 :             ret << input;
     612                 :            :         }
     613                 :          0 :         cnt++;
     614                 :          0 :     } (std::forward<Ts>(inputs)), ...);
     615                 :            : 
     616                 :          0 :     return ret;
     617   [ #  #  #  #  :          0 : }
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
     618                 :            : 
     619                 :            : #endif // BITCOIN_SCRIPT_SCRIPT_H

Generated by: LCOV version 1.14