Coverage Report

Created: 2025-03-18 19:28

/root/bitcoin/src/script/script.cpp
Line
Count
Source (jump to first uncovered line)
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)
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
    default:
  Branch (154:5): [True: 0, False: 0]

155
0
        return "OP_UNKNOWN";
156
0
    }
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
20
{
209
20
    return (this->size() == 4 &&
  Branch (209:13): [True: 0, False: 20]

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

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

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

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

214
20
}
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
50
{
226
    // Extra-fast test for pay-to-script-hash CScripts:
227
50
    return (this->size() == 23 &&
  Branch (227:13): [True: 0, False: 50]

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

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

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

231
50
}
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
// A witness program is any valid CScript that consists of a 1-byte push opcode
242
// followed by a data push between 2 and 40 bytes.
243
bool CScript::IsWitnessProgram(int& version, std::vector<unsigned char>& program) const
244
50
{
245
50
    if (this->size() < 4 || this->size() > 42) {
  Branch (245:9): [True: 50, False: 0]
  Branch (245:29): [True: 0, False: 0]

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

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

252
0
        version = DecodeOP_N((opcodetype)(*this)[0]);
253
0
        program = std::vector<unsigned char>(this->begin() + 2, this->end());
254
0
        return true;
255
0
    }
256
0
    return false;
257
0
}
258
259
bool CScript::IsPushOnly(const_iterator pc) const
260
0
{
261
0
    while (pc < end())
  Branch (261:12): [True: 0, False: 0]

262
0
    {
263
0
        opcodetype opcode;
264
0
        if (!GetOp(pc, opcode))
  Branch (264:13): [True: 0, False: 0]

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

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

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

286
0
            ret += ", ";
287
0
        }
288
0
        ret += HexStr(stack[i]);
289
0
    }
290
0
    return ret + ")";
291
0
}
292
293
bool CScript::HasValidOps() const
294
0
{
295
0
    CScript::const_iterator it = begin();
296
0
    while (it < end()) {
  Branch (296:12): [True: 0, False: 0]

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

300
0
            return false;
301
0
        }
302
0
    }
303
0
    return true;
304
0
}
305
306
bool GetScriptOp(CScriptBase::const_iterator& pc, CScriptBase::const_iterator end, opcodetype& opcodeRet, std::vector<unsigned char>* pvchRet)
307
0
{
308
0
    opcodeRet = OP_INVALIDOPCODE;
309
0
    if (pvchRet)
  Branch (309:9): [True: 0, False: 0]

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

312
0
        return false;
313
314
    // Read instruction
315
0
    if (end - pc < 1)
  Branch (315:9): [True: 0, False: 0]

316
0
        return false;
317
0
    unsigned int opcode = *pc++;
318
319
    // Immediate operand
320
0
    if (opcode <= OP_PUSHDATA4)
  Branch (320:9): [True: 0, False: 0]

321
0
    {
322
0
        unsigned int nSize = 0;
323
0
        if (opcode < OP_PUSHDATA1)
  Branch (323:13): [True: 0, False: 0]

324
0
        {
325
0
            nSize = opcode;
326
0
        }
327
0
        else if (opcode == OP_PUSHDATA1)
  Branch (327:18): [True: 0, False: 0]

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

330
0
                return false;
331
0
            nSize = *pc++;
332
0
        }
333
0
        else if (opcode == OP_PUSHDATA2)
  Branch (333:18): [True: 0, False: 0]

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

336
0
                return false;
337
0
            nSize = ReadLE16(&pc[0]);
338
0
            pc += 2;
339
0
        }
340
0
        else if (opcode == OP_PUSHDATA4)
  Branch (340:18): [True: 0, False: 0]

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

343
0
                return false;
344
0
            nSize = ReadLE32(&pc[0]);
345
0
            pc += 4;
346
0
        }
347
0
        if (end - pc < 0 || (unsigned int)(end - pc) < nSize)
  Branch (347:13): [True: 0, False: 0]
  Branch (347:29): [True: 0, False: 0]

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

350
0
            pvchRet->assign(pc, pc + nSize);
351
0
        pc += nSize;
352
0
    }
353
354
0
    opcodeRet = static_cast<opcodetype>(opcode);
355
0
    return true;
356
0
}
357
358
bool IsOpSuccess(const opcodetype& opcode)
359
0
{
360
0
    return opcode == 80 || opcode == 98 || (opcode >= 126 && opcode <= 129) ||
  Branch (360:12): [True: 0, False: 0]
  Branch (360:28): [True: 0, False: 0]
  Branch (360:45): [True: 0, False: 0]
  Branch (360:62): [True: 0, False: 0]

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

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

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

364
0
}
365
366
0
bool CheckMinimalPush(const std::vector<unsigned char>& data, opcodetype opcode) {
367
    // Excludes OP_1NEGATE, OP_1-16 since they are by definition minimal
368
0
    assert(0 <= opcode && opcode <= OP_PUSHDATA4);
369
0
    if (data.size() == 0) {
  Branch (369:9): [True: 0, False: 0]

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

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

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

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

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

385
        // Must have used OP_PUSHDATA2.
386
0
        return opcode == OP_PUSHDATA2;
387
0
    }
388
0
    return true;
389
0
}