Coverage Report

Created: 2026-06-09 19:51

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/root/bitcoin/src/script/script.cpp
Line
Count
Source
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 <crypto/hex_base.h>
10
#include <hash.h>
11
#include <uint256.h>
12
#include <util/hash_type.h>
13
14
#include <compare>
15
#include <string>
16
17
0
CScriptID::CScriptID(const CScript& in) : BaseHash(Hash160(in)) {}
18
19
std::string GetOpName(opcodetype opcode)
20
0
{
21
0
    switch (opcode)
  Branch (21:13): [True: 0, False: 0]

22
0
    {
23
    // push value
24
0
    case OP_0                      : return "0";
  Branch (24:5): [True: 0, False: 0]

25
0
    case OP_PUSHDATA1              : return "OP_PUSHDATA1";
  Branch (25:5): [True: 0, False: 0]

26
0
    case OP_PUSHDATA2              : return "OP_PUSHDATA2";
  Branch (26:5): [True: 0, False: 0]

27
0
    case OP_PUSHDATA4              : return "OP_PUSHDATA4";
  Branch (27:5): [True: 0, False: 0]

28
0
    case OP_1NEGATE                : return "-1";
  Branch (28:5): [True: 0, False: 0]

29
0
    case OP_RESERVED               : return "OP_RESERVED";
  Branch (29:5): [True: 0, False: 0]

30
0
    case OP_1                      : return "1";
  Branch (30:5): [True: 0, False: 0]

31
0
    case OP_2                      : return "2";
  Branch (31:5): [True: 0, False: 0]

32
0
    case OP_3                      : return "3";
  Branch (32:5): [True: 0, False: 0]

33
0
    case OP_4                      : return "4";
  Branch (33:5): [True: 0, False: 0]

34
0
    case OP_5                      : return "5";
  Branch (34:5): [True: 0, False: 0]

35
0
    case OP_6                      : return "6";
  Branch (35:5): [True: 0, False: 0]

36
0
    case OP_7                      : return "7";
  Branch (36:5): [True: 0, False: 0]

37
0
    case OP_8                      : return "8";
  Branch (37:5): [True: 0, False: 0]

38
0
    case OP_9                      : return "9";
  Branch (38:5): [True: 0, False: 0]

39
0
    case OP_10                     : return "10";
  Branch (39:5): [True: 0, False: 0]

40
0
    case OP_11                     : return "11";
  Branch (40:5): [True: 0, False: 0]

41
0
    case OP_12                     : return "12";
  Branch (41:5): [True: 0, False: 0]

42
0
    case OP_13                     : return "13";
  Branch (42:5): [True: 0, False: 0]

43
0
    case OP_14                     : return "14";
  Branch (43:5): [True: 0, False: 0]

44
0
    case OP_15                     : return "15";
  Branch (44:5): [True: 0, False: 0]

45
0
    case OP_16                     : return "16";
  Branch (45:5): [True: 0, False: 0]

46
47
    // control
48
0
    case OP_NOP                    : return "OP_NOP";
  Branch (48:5): [True: 0, False: 0]

49
0
    case OP_VER                    : return "OP_VER";
  Branch (49:5): [True: 0, False: 0]

50
0
    case OP_IF                     : return "OP_IF";
  Branch (50:5): [True: 0, False: 0]

51
0
    case OP_NOTIF                  : return "OP_NOTIF";
  Branch (51:5): [True: 0, False: 0]

52
0
    case OP_VERIF                  : return "OP_VERIF";
  Branch (52:5): [True: 0, False: 0]

53
0
    case OP_VERNOTIF               : return "OP_VERNOTIF";
  Branch (53:5): [True: 0, False: 0]

54
0
    case OP_ELSE                   : return "OP_ELSE";
  Branch (54:5): [True: 0, False: 0]

55
0
    case OP_ENDIF                  : return "OP_ENDIF";
  Branch (55:5): [True: 0, False: 0]

56
0
    case OP_VERIFY                 : return "OP_VERIFY";
  Branch (56:5): [True: 0, False: 0]

57
0
    case OP_RETURN                 : return "OP_RETURN";
  Branch (57:5): [True: 0, False: 0]

58
59
    // stack ops
60
0
    case OP_TOALTSTACK             : return "OP_TOALTSTACK";
  Branch (60:5): [True: 0, False: 0]

61
0
    case OP_FROMALTSTACK           : return "OP_FROMALTSTACK";
  Branch (61:5): [True: 0, False: 0]

62
0
    case OP_2DROP                  : return "OP_2DROP";
  Branch (62:5): [True: 0, False: 0]

63
0
    case OP_2DUP                   : return "OP_2DUP";
  Branch (63:5): [True: 0, False: 0]

64
0
    case OP_3DUP                   : return "OP_3DUP";
  Branch (64:5): [True: 0, False: 0]

65
0
    case OP_2OVER                  : return "OP_2OVER";
  Branch (65:5): [True: 0, False: 0]

66
0
    case OP_2ROT                   : return "OP_2ROT";
  Branch (66:5): [True: 0, False: 0]

67
0
    case OP_2SWAP                  : return "OP_2SWAP";
  Branch (67:5): [True: 0, False: 0]

68
0
    case OP_IFDUP                  : return "OP_IFDUP";
  Branch (68:5): [True: 0, False: 0]

69
0
    case OP_DEPTH                  : return "OP_DEPTH";
  Branch (69:5): [True: 0, False: 0]

70
0
    case OP_DROP                   : return "OP_DROP";
  Branch (70:5): [True: 0, False: 0]

71
0
    case OP_DUP                    : return "OP_DUP";
  Branch (71:5): [True: 0, False: 0]

72
0
    case OP_NIP                    : return "OP_NIP";
  Branch (72:5): [True: 0, False: 0]

73
0
    case OP_OVER                   : return "OP_OVER";
  Branch (73:5): [True: 0, False: 0]

74
0
    case OP_PICK                   : return "OP_PICK";
  Branch (74:5): [True: 0, False: 0]

75
0
    case OP_ROLL                   : return "OP_ROLL";
  Branch (75:5): [True: 0, False: 0]

76
0
    case OP_ROT                    : return "OP_ROT";
  Branch (76:5): [True: 0, False: 0]

77
0
    case OP_SWAP                   : return "OP_SWAP";
  Branch (77:5): [True: 0, False: 0]

78
0
    case OP_TUCK                   : return "OP_TUCK";
  Branch (78:5): [True: 0, False: 0]

79
80
    // splice ops
81
0
    case OP_CAT                    : return "OP_CAT";
  Branch (81:5): [True: 0, False: 0]

82
0
    case OP_SUBSTR                 : return "OP_SUBSTR";
  Branch (82:5): [True: 0, False: 0]

83
0
    case OP_LEFT                   : return "OP_LEFT";
  Branch (83:5): [True: 0, False: 0]

84
0
    case OP_RIGHT                  : return "OP_RIGHT";
  Branch (84:5): [True: 0, False: 0]

85
0
    case OP_SIZE                   : return "OP_SIZE";
  Branch (85:5): [True: 0, False: 0]

86
87
    // bit logic
88
0
    case OP_INVERT                 : return "OP_INVERT";
  Branch (88:5): [True: 0, False: 0]

89
0
    case OP_AND                    : return "OP_AND";
  Branch (89:5): [True: 0, False: 0]

90
0
    case OP_OR                     : return "OP_OR";
  Branch (90:5): [True: 0, False: 0]

91
0
    case OP_XOR                    : return "OP_XOR";
  Branch (91:5): [True: 0, False: 0]

92
0
    case OP_EQUAL                  : return "OP_EQUAL";
  Branch (92:5): [True: 0, False: 0]

93
0
    case OP_EQUALVERIFY            : return "OP_EQUALVERIFY";
  Branch (93:5): [True: 0, False: 0]

94
0
    case OP_RESERVED1              : return "OP_RESERVED1";
  Branch (94:5): [True: 0, False: 0]

95
0
    case OP_RESERVED2              : return "OP_RESERVED2";
  Branch (95:5): [True: 0, False: 0]

96
97
    // numeric
98
0
    case OP_1ADD                   : return "OP_1ADD";
  Branch (98:5): [True: 0, False: 0]

99
0
    case OP_1SUB                   : return "OP_1SUB";
  Branch (99:5): [True: 0, False: 0]

100
0
    case OP_2MUL                   : return "OP_2MUL";
  Branch (100:5): [True: 0, False: 0]

101
0
    case OP_2DIV                   : return "OP_2DIV";
  Branch (101:5): [True: 0, False: 0]

102
0
    case OP_NEGATE                 : return "OP_NEGATE";
  Branch (102:5): [True: 0, False: 0]

103
0
    case OP_ABS                    : return "OP_ABS";
  Branch (103:5): [True: 0, False: 0]

104
0
    case OP_NOT                    : return "OP_NOT";
  Branch (104:5): [True: 0, False: 0]

105
0
    case OP_0NOTEQUAL              : return "OP_0NOTEQUAL";
  Branch (105:5): [True: 0, False: 0]

106
0
    case OP_ADD                    : return "OP_ADD";
  Branch (106:5): [True: 0, False: 0]

107
0
    case OP_SUB                    : return "OP_SUB";
  Branch (107:5): [True: 0, False: 0]

108
0
    case OP_MUL                    : return "OP_MUL";
  Branch (108:5): [True: 0, False: 0]

109
0
    case OP_DIV                    : return "OP_DIV";
  Branch (109:5): [True: 0, False: 0]

110
0
    case OP_MOD                    : return "OP_MOD";
  Branch (110:5): [True: 0, False: 0]

111
0
    case OP_LSHIFT                 : return "OP_LSHIFT";
  Branch (111:5): [True: 0, False: 0]

112
0
    case OP_RSHIFT                 : return "OP_RSHIFT";
  Branch (112:5): [True: 0, False: 0]

113
0
    case OP_BOOLAND                : return "OP_BOOLAND";
  Branch (113:5): [True: 0, False: 0]

114
0
    case OP_BOOLOR                 : return "OP_BOOLOR";
  Branch (114:5): [True: 0, False: 0]

115
0
    case OP_NUMEQUAL               : return "OP_NUMEQUAL";
  Branch (115:5): [True: 0, False: 0]

116
0
    case OP_NUMEQUALVERIFY         : return "OP_NUMEQUALVERIFY";
  Branch (116:5): [True: 0, False: 0]

117
0
    case OP_NUMNOTEQUAL            : return "OP_NUMNOTEQUAL";
  Branch (117:5): [True: 0, False: 0]

118
0
    case OP_LESSTHAN               : return "OP_LESSTHAN";
  Branch (118:5): [True: 0, False: 0]

119
0
    case OP_GREATERTHAN            : return "OP_GREATERTHAN";
  Branch (119:5): [True: 0, False: 0]

120
0
    case OP_LESSTHANOREQUAL        : return "OP_LESSTHANOREQUAL";
  Branch (120:5): [True: 0, False: 0]

121
0
    case OP_GREATERTHANOREQUAL     : return "OP_GREATERTHANOREQUAL";
  Branch (121:5): [True: 0, False: 0]

122
0
    case OP_MIN                    : return "OP_MIN";
  Branch (122:5): [True: 0, False: 0]

123
0
    case OP_MAX                    : return "OP_MAX";
  Branch (123:5): [True: 0, False: 0]

124
0
    case OP_WITHIN                 : return "OP_WITHIN";
  Branch (124:5): [True: 0, False: 0]

125
126
    // crypto
127
0
    case OP_RIPEMD160              : return "OP_RIPEMD160";
  Branch (127:5): [True: 0, False: 0]

128
0
    case OP_SHA1                   : return "OP_SHA1";
  Branch (128:5): [True: 0, False: 0]

129
0
    case OP_SHA256                 : return "OP_SHA256";
  Branch (129:5): [True: 0, False: 0]

130
0
    case OP_HASH160                : return "OP_HASH160";
  Branch (130:5): [True: 0, False: 0]

131
0
    case OP_HASH256                : return "OP_HASH256";
  Branch (131:5): [True: 0, False: 0]

132
0
    case OP_CODESEPARATOR          : return "OP_CODESEPARATOR";
  Branch (132:5): [True: 0, False: 0]

133
0
    case OP_CHECKSIG               : return "OP_CHECKSIG";
  Branch (133:5): [True: 0, False: 0]

134
0
    case OP_CHECKSIGVERIFY         : return "OP_CHECKSIGVERIFY";
  Branch (134:5): [True: 0, False: 0]

135
0
    case OP_CHECKMULTISIG          : return "OP_CHECKMULTISIG";
  Branch (135:5): [True: 0, False: 0]

136
0
    case OP_CHECKMULTISIGVERIFY    : return "OP_CHECKMULTISIGVERIFY";
  Branch (136:5): [True: 0, False: 0]

137
138
    // expansion
139
0
    case OP_NOP1                   : return "OP_NOP1";
  Branch (139:5): [True: 0, False: 0]

140
0
    case OP_CHECKLOCKTIMEVERIFY    : return "OP_CHECKLOCKTIMEVERIFY";
  Branch (140:5): [True: 0, False: 0]

141
0
    case OP_CHECKSEQUENCEVERIFY    : return "OP_CHECKSEQUENCEVERIFY";
  Branch (141:5): [True: 0, False: 0]

142
0
    case OP_NOP4                   : return "OP_NOP4";
  Branch (142:5): [True: 0, False: 0]

143
0
    case OP_NOP5                   : return "OP_NOP5";
  Branch (143:5): [True: 0, False: 0]

144
0
    case OP_NOP6                   : return "OP_NOP6";
  Branch (144:5): [True: 0, False: 0]

145
0
    case OP_NOP7                   : return "OP_NOP7";
  Branch (145:5): [True: 0, False: 0]

146
0
    case OP_NOP8                   : return "OP_NOP8";
  Branch (146:5): [True: 0, False: 0]

147
0
    case OP_NOP9                   : return "OP_NOP9";
  Branch (147:5): [True: 0, False: 0]

148
0
    case OP_NOP10                  : return "OP_NOP10";
  Branch (148:5): [True: 0, False: 0]

149
150
    // Opcode added by BIP 342 (Tapscript)
151
0
    case OP_CHECKSIGADD            : return "OP_CHECKSIGADD";
  Branch (151:5): [True: 0, False: 0]

152
153
0
    case OP_INVALIDOPCODE          : return "OP_INVALIDOPCODE";
  Branch (153:5): [True: 0, False: 0]

154
155
0
    } // no default case, so the compiler can warn about missing cases
156
0
    return "OP_UNKNOWN";
157
0
}
158
159
unsigned int CScript::GetSigOpCount(bool fAccurate) const
160
0
{
161
0
    unsigned int n = 0;
162
0
    const_iterator pc = begin();
163
0
    opcodetype lastOpcode = OP_INVALIDOPCODE;
164
0
    while (pc < end())
  Branch (164:12): [True: 0, False: 0]

165
0
    {
166
0
        opcodetype opcode;
167
0
        if (!GetOp(pc, opcode))
  Branch (167:13): [True: 0, False: 0]

168
0
            break;
169
0
        if (opcode == OP_CHECKSIG || opcode == OP_CHECKSIGVERIFY)
  Branch (169:13): [True: 0, False: 0]
  Branch (169:38): [True: 0, False: 0]

170
0
            n++;
171
0
        else if (opcode == OP_CHECKMULTISIG || opcode == OP_CHECKMULTISIGVERIFY)
  Branch (171:18): [True: 0, False: 0]
  Branch (171:48): [True: 0, False: 0]

172
0
        {
173
0
            if (fAccurate && lastOpcode >= OP_1 && lastOpcode <= OP_16)
  Branch (173:17): [True: 0, False: 0]
  Branch (173:30): [True: 0, False: 0]
  Branch (173:52): [True: 0, False: 0]

174
0
                n += DecodeOP_N(lastOpcode);
175
0
            else
176
0
                n += MAX_PUBKEYS_PER_MULTISIG;
177
0
        }
178
0
        lastOpcode = opcode;
179
0
    }
180
0
    return n;
181
0
}
182
183
unsigned int CScript::GetSigOpCount(const CScript& scriptSig) const
184
0
{
185
0
    if (!IsPayToScriptHash())
  Branch (185:9): [True: 0, False: 0]

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())
  Branch (193:12): [True: 0, False: 0]

194
0
    {
195
0
        opcodetype opcode;
196
0
        if (!scriptSig.GetOp(pc, opcode, vData))
  Branch (196:13): [True: 0, False: 0]

197
0
            return 0;
198
0
        if (opcode > OP_16)
  Branch (198:13): [True: 0, False: 0]

199
0
            return 0;
200
0
    }
201
202
    /// ... and return its opcount:
203
0
    CScript subscript(vData.begin(), vData.end());
204
0
    return subscript.GetSigOpCount(true);
205
0
}
206
207
bool CScript::IsPayToAnchor() const
208
0
{
209
0
    return (this->size() == 4 &&
  Branch (209:13): [True: 0, False: 0]

210
0
        (*this)[0] == OP_1 &&
  Branch (210:9): [True: 0, False: 0]

211
0
        (*this)[1] == 0x02 &&
  Branch (211:9): [True: 0, False: 0]

212
0
        (*this)[2] == 0x4e &&
  Branch (212:9): [True: 0, False: 0]

213
0
        (*this)[3] == 0x73);
  Branch (213:9): [True: 0, False: 0]

214
0
}
215
216
bool CScript::IsPayToAnchor(int version, const std::vector<unsigned char>& program)
217
0
{
218
0
    return version == 1 &&
  Branch (218:12): [True: 0, False: 0]

219
0
        program.size() == 2 &&
  Branch (219:9): [True: 0, False: 0]

220
0
        program[0] == 0x4e &&
  Branch (220:9): [True: 0, False: 0]

221
0
        program[1] == 0x73;
  Branch (221:9): [True: 0, False: 0]

222
0
}
223
224
bool CScript::IsPayToScriptHash() const
225
0
{
226
    // Extra-fast test for pay-to-script-hash CScripts:
227
0
    return (this->size() == 23 &&
  Branch (227:13): [True: 0, False: 0]

228
0
            (*this)[0] == OP_HASH160 &&
  Branch (228:13): [True: 0, False: 0]

229
0
            (*this)[1] == 0x14 &&
  Branch (229:13): [True: 0, False: 0]

230
0
            (*this)[22] == OP_EQUAL);
  Branch (230:13): [True: 0, False: 0]

231
0
}
232
233
bool CScript::IsPayToWitnessScriptHash() const
234
0
{
235
    // Extra-fast test for pay-to-witness-script-hash CScripts:
236
0
    return (this->size() == 34 &&
  Branch (236:13): [True: 0, False: 0]

237
0
            (*this)[0] == OP_0 &&
  Branch (237:13): [True: 0, False: 0]

238
0
            (*this)[1] == 0x20);
  Branch (238:13): [True: 0, False: 0]

239
0
}
240
241
bool CScript::IsPayToTaproot() const
242
0
{
243
0
    return (this->size() == 34 &&
  Branch (243:13): [True: 0, False: 0]

244
0
            (*this)[0] == OP_1 &&
  Branch (244:13): [True: 0, False: 0]

245
0
            (*this)[1] == 0x20);
  Branch (245:13): [True: 0, False: 0]

246
0
}
247
248
// A witness program is any valid CScript that consists of a 1-byte push opcode
249
// followed by a data push between 2 and 40 bytes.
250
bool CScript::IsWitnessProgram(int& version, std::vector<unsigned char>& program) const
251
0
{
252
0
    if (this->size() < 4 || this->size() > 42) {
  Branch (252:9): [True: 0, False: 0]
  Branch (252:29): [True: 0, False: 0]

253
0
        return false;
254
0
    }
255
0
    if ((*this)[0] != OP_0 && ((*this)[0] < OP_1 || (*this)[0] > OP_16)) {
  Branch (255:9): [True: 0, False: 0]
  Branch (255:32): [True: 0, False: 0]
  Branch (255:53): [True: 0, False: 0]

256
0
        return false;
257
0
    }
258
0
    if ((size_t)((*this)[1] + 2) == this->size()) {
  Branch (258:9): [True: 0, False: 0]

259
0
        version = DecodeOP_N((opcodetype)(*this)[0]);
260
0
        program = std::vector<unsigned char>(this->begin() + 2, this->end());
261
0
        return true;
262
0
    }
263
0
    return false;
264
0
}
265
266
bool CScript::IsPushOnly(const_iterator pc) const
267
0
{
268
0
    while (pc < end())
  Branch (268:12): [True: 0, False: 0]

269
0
    {
270
0
        opcodetype opcode;
271
0
        if (!GetOp(pc, opcode))
  Branch (271:13): [True: 0, False: 0]

272
0
            return false;
273
        // Note that IsPushOnly() *does* consider OP_RESERVED to be a
274
        // push-type opcode, however execution of OP_RESERVED fails, so
275
        // it's not relevant to P2SH/BIP62 as the scriptSig would fail prior to
276
        // the P2SH special validation code being executed.
277
0
        if (opcode > OP_16)
  Branch (277:13): [True: 0, False: 0]

278
0
            return false;
279
0
    }
280
0
    return true;
281
0
}
282
283
bool CScript::IsPushOnly() const
284
0
{
285
0
    return this->IsPushOnly(begin());
286
0
}
287
288
std::string CScriptWitness::ToString() const
289
0
{
290
0
    std::string ret = "CScriptWitness(";
291
0
    for (unsigned int i = 0; i < stack.size(); i++) {
  Branch (291:30): [True: 0, False: 0]

292
0
        if (i) {
  Branch (292:13): [True: 0, False: 0]

293
0
            ret += ", ";
294
0
        }
295
0
        ret += HexStr(stack[i]);
296
0
    }
297
0
    return ret + ")";
298
0
}
299
300
bool CScript::HasValidOps() const
301
0
{
302
0
    CScript::const_iterator it = begin();
303
0
    while (it < end()) {
  Branch (303:12): [True: 0, False: 0]

304
0
        opcodetype opcode;
305
0
        std::vector<unsigned char> item;
306
0
        if (!GetOp(it, opcode, item) || opcode > MAX_OPCODE || item.size() > MAX_SCRIPT_ELEMENT_SIZE) {
  Branch (306:13): [True: 0, False: 0]
  Branch (306:41): [True: 0, False: 0]
  Branch (306:64): [True: 0, False: 0]

307
0
            return false;
308
0
        }
309
0
    }
310
0
    return true;
311
0
}
312
313
bool GetScriptOp(CScriptBase::const_iterator& pc, CScriptBase::const_iterator end, opcodetype& opcodeRet, std::vector<unsigned char>* pvchRet)
314
0
{
315
0
    opcodeRet = OP_INVALIDOPCODE;
316
0
    if (pvchRet)
  Branch (316:9): [True: 0, False: 0]

317
0
        pvchRet->clear();
318
0
    if (pc >= end)
  Branch (318:9): [True: 0, False: 0]

319
0
        return false;
320
321
    // Read instruction
322
0
    if (end - pc < 1)
  Branch (322:9): [True: 0, False: 0]

323
0
        return false;
324
0
    unsigned int opcode = *pc++;
325
326
    // Immediate operand
327
0
    if (opcode <= OP_PUSHDATA4)
  Branch (327:9): [True: 0, False: 0]

328
0
    {
329
0
        unsigned int nSize = 0;
330
0
        if (opcode < OP_PUSHDATA1)
  Branch (330:13): [True: 0, False: 0]

331
0
        {
332
0
            nSize = opcode;
333
0
        }
334
0
        else if (opcode == OP_PUSHDATA1)
  Branch (334:18): [True: 0, False: 0]

335
0
        {
336
0
            if (end - pc < 1)
  Branch (336:17): [True: 0, False: 0]

337
0
                return false;
338
0
            nSize = *pc++;
339
0
        }
340
0
        else if (opcode == OP_PUSHDATA2)
  Branch (340:18): [True: 0, False: 0]

341
0
        {
342
0
            if (end - pc < 2)
  Branch (342:17): [True: 0, False: 0]

343
0
                return false;
344
0
            nSize = ReadLE16(&pc[0]);
345
0
            pc += 2;
346
0
        }
347
0
        else if (opcode == OP_PUSHDATA4)
  Branch (347:18): [True: 0, False: 0]

348
0
        {
349
0
            if (end - pc < 4)
  Branch (349:17): [True: 0, False: 0]

350
0
                return false;
351
0
            nSize = ReadLE32(&pc[0]);
352
0
            pc += 4;
353
0
        }
354
0
        if (end - pc < 0 || (unsigned int)(end - pc) < nSize)
  Branch (354:13): [True: 0, False: 0]
  Branch (354:29): [True: 0, False: 0]

355
0
            return false;
356
0
        if (pvchRet)
  Branch (356:13): [True: 0, False: 0]

357
0
            pvchRet->assign(pc, pc + nSize);
358
0
        pc += nSize;
359
0
    }
360
361
0
    opcodeRet = static_cast<opcodetype>(opcode);
362
0
    return true;
363
0
}
364
365
bool IsOpSuccess(const opcodetype& opcode)
366
0
{
367
0
    return opcode == 80 || opcode == 98 || (opcode >= 126 && opcode <= 129) ||
  Branch (367:12): [True: 0, False: 0]
  Branch (367:28): [True: 0, False: 0]
  Branch (367:45): [True: 0, False: 0]
  Branch (367:62): [True: 0, False: 0]

368
0
           (opcode >= 131 && opcode <= 134) || (opcode >= 137 && opcode <= 138) ||
  Branch (368:13): [True: 0, False: 0]
  Branch (368:30): [True: 0, False: 0]
  Branch (368:49): [True: 0, False: 0]
  Branch (368:66): [True: 0, False: 0]

369
0
           (opcode >= 141 && opcode <= 142) || (opcode >= 149 && opcode <= 153) ||
  Branch (369:13): [True: 0, False: 0]
  Branch (369:30): [True: 0, False: 0]
  Branch (369:49): [True: 0, False: 0]
  Branch (369:66): [True: 0, False: 0]

370
0
           (opcode >= 187 && opcode <= 254);
  Branch (370:13): [True: 0, False: 0]
  Branch (370:30): [True: 0, False: 0]

371
0
}
372
373
0
bool CheckMinimalPush(const std::vector<unsigned char>& data, opcodetype opcode) {
374
    // Excludes OP_1NEGATE, OP_1-16 since they are by definition minimal
375
0
    assert(0 <= opcode && opcode <= OP_PUSHDATA4);
  Branch (375:5): [True: 0, False: 0]
  Branch (375:5): [True: 0, False: 0]
  Branch (375:5): [True: 0, False: 0]

376
0
    if (data.size() == 0) {
  Branch (376:9): [True: 0, False: 0]

377
        // Should have used OP_0.
378
0
        return opcode == OP_0;
379
0
    } else if (data.size() == 1 && data[0] >= 1 && data[0] <= 16) {
  Branch (379:16): [True: 0, False: 0]
  Branch (379:36): [True: 0, False: 0]
  Branch (379:52): [True: 0, False: 0]

380
        // Should have used OP_1 .. OP_16.
381
0
        return false;
382
0
    } else if (data.size() == 1 && data[0] == 0x81) {
  Branch (382:16): [True: 0, False: 0]
  Branch (382:36): [True: 0, False: 0]

383
        // Should have used OP_1NEGATE.
384
0
        return false;
385
0
    } else if (data.size() <= 75) {
  Branch (385:16): [True: 0, False: 0]

386
        // Must have used a direct push (opcode indicating number of bytes pushed + those bytes).
387
0
        return opcode == data.size();
388
0
    } else if (data.size() <= 255) {
  Branch (388:16): [True: 0, False: 0]

389
        // Must have used OP_PUSHDATA.
390
0
        return opcode == OP_PUSHDATA1;
391
0
    } else if (data.size() <= 65535) {
  Branch (391:16): [True: 0, False: 0]

392
        // Must have used OP_PUSHDATA2.
393
0
        return opcode == OP_PUSHDATA2;
394
0
    }
395
0
    return true;
396
0
}