Coverage Report

Created: 2026-06-01 18:35

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/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 <string>
15
16
0
CScriptID::CScriptID(const CScript& in) : BaseHash(Hash160(in)) {}
17
18
std::string GetOpName(opcodetype opcode)
19
0
{
20
0
    switch (opcode)
  Branch (20:13): [True: 0, False: 0]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

185
0
        return GetSigOpCount(true);
186
187
    // This is a pay-to-script-hash scriptPubKey;
188
    // get the last item that the scriptSig
189
    // pushes onto the stack:
190
0
    const_iterator pc = scriptSig.begin();
191
0
    std::vector<unsigned char> vData;
192
0
    while (pc < scriptSig.end())
  Branch (192:12): [True: 0, False: 0]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

368
0
           (opcode >= 141 && opcode <= 142) || (opcode >= 149 && opcode <= 153) ||
  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 >= 187 && opcode <= 254);
  Branch (369:13): [True: 0, False: 0]
  Branch (369:30): [True: 0, False: 0]

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

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

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

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

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

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

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

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