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#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 <cassert>
17#include <cstddef>
18#include <cstdint>
19#include <iterator>
20#include <limits>
21#include <span>
22#include <stdexcept>
23#include <string>
24#include <type_traits>
25#include <utility>
26#include <vector>
27
28// Maximum number of bytes pushable to the stack
29inline constexpr unsigned int MAX_SCRIPT_ELEMENT_SIZE = 520;
30
31// Maximum number of non-push operations per script
32inline constexpr int MAX_OPS_PER_SCRIPT = 201;
33
34// Maximum number of public keys per multisig
35inline constexpr int MAX_PUBKEYS_PER_MULTISIG = 20;
36
37/** The limit of keys in OP_CHECKSIGADD-based scripts. It is due to the stack limit in BIP342. */
38inline constexpr unsigned int MAX_PUBKEYS_PER_MULTI_A = 999;
39
40// Maximum script length in bytes
41inline constexpr int MAX_SCRIPT_SIZE{10'000};
42
43// Maximum number of values on script interpreter stack
44inline constexpr int MAX_STACK_SIZE = 1000;
45
46// Threshold for nLockTime: below this value it is interpreted as block number,
47// otherwise as UNIX timestamp.
48inline constexpr unsigned int LOCKTIME_THRESHOLD{500'000'000}; // Tue Nov  5 00:53:20 1985 UTC
49
50// Maximum nLockTime. Since a lock time indicates the last invalid timestamp, a
51// transaction with this lock time will never be valid unless lock time
52// checking is disabled (by setting all input sequence numbers to
53// SEQUENCE_FINAL).
54inline constexpr uint32_t LOCKTIME_MAX = 0xFFFFFFFFU;
55
56// Tag for input annex. If there are at least two witness elements for a transaction input,
57// and the first byte of the last element is 0x50, this last element is called annex, and
58// has meanings independent of the script
59inline constexpr unsigned int ANNEX_TAG = 0x50;
60
61// Validation weight per passing signature (Tapscript only, see BIP 342).
62inline constexpr int64_t VALIDATION_WEIGHT_PER_SIGOP_PASSED{50};
63
64// How much weight budget is added to the witness size (Tapscript only, see BIP 342).
65inline constexpr int64_t VALIDATION_WEIGHT_OFFSET{50};
66
67template <typename T>
68std::vector<unsigned char> ToByteVector(const T& in)
69{
70    return std::vector<unsigned char>(in.begin(), in.end());
71}
72
73/** Script opcodes */
74enum opcodetype
75{
76    // push value
77    OP_0 = 0x00,
78    OP_FALSE = OP_0,
79    OP_PUSHDATA1 = 0x4c,
80    OP_PUSHDATA2 = 0x4d,
81    OP_PUSHDATA4 = 0x4e,
82    OP_1NEGATE = 0x4f,
83    OP_RESERVED = 0x50,
84    OP_1 = 0x51,
85    OP_TRUE=OP_1,
86    OP_2 = 0x52,
87    OP_3 = 0x53,
88    OP_4 = 0x54,
89    OP_5 = 0x55,
90    OP_6 = 0x56,
91    OP_7 = 0x57,
92    OP_8 = 0x58,
93    OP_9 = 0x59,
94    OP_10 = 0x5a,
95    OP_11 = 0x5b,
96    OP_12 = 0x5c,
97    OP_13 = 0x5d,
98    OP_14 = 0x5e,
99    OP_15 = 0x5f,
100    OP_16 = 0x60,
101
102    // control
103    OP_NOP = 0x61,
104    OP_VER = 0x62,
105    OP_IF = 0x63,
106    OP_NOTIF = 0x64,
107    OP_VERIF = 0x65,
108    OP_VERNOTIF = 0x66,
109    OP_ELSE = 0x67,
110    OP_ENDIF = 0x68,
111    OP_VERIFY = 0x69,
112    OP_RETURN = 0x6a,
113
114    // stack ops
115    OP_TOALTSTACK = 0x6b,
116    OP_FROMALTSTACK = 0x6c,
117    OP_2DROP = 0x6d,
118    OP_2DUP = 0x6e,
119    OP_3DUP = 0x6f,
120    OP_2OVER = 0x70,
121    OP_2ROT = 0x71,
122    OP_2SWAP = 0x72,
123    OP_IFDUP = 0x73,
124    OP_DEPTH = 0x74,
125    OP_DROP = 0x75,
126    OP_DUP = 0x76,
127    OP_NIP = 0x77,
128    OP_OVER = 0x78,
129    OP_PICK = 0x79,
130    OP_ROLL = 0x7a,
131    OP_ROT = 0x7b,
132    OP_SWAP = 0x7c,
133    OP_TUCK = 0x7d,
134
135    // splice ops
136    OP_CAT = 0x7e,
137    OP_SUBSTR = 0x7f,
138    OP_LEFT = 0x80,
139    OP_RIGHT = 0x81,
140    OP_SIZE = 0x82,
141
142    // bit logic
143    OP_INVERT = 0x83,
144    OP_AND = 0x84,
145    OP_OR = 0x85,
146    OP_XOR = 0x86,
147    OP_EQUAL = 0x87,
148    OP_EQUALVERIFY = 0x88,
149    OP_RESERVED1 = 0x89,
150    OP_RESERVED2 = 0x8a,
151
152    // numeric
153    OP_1ADD = 0x8b,
154    OP_1SUB = 0x8c,
155    OP_2MUL = 0x8d,
156    OP_2DIV = 0x8e,
157    OP_NEGATE = 0x8f,
158    OP_ABS = 0x90,
159    OP_NOT = 0x91,
160    OP_0NOTEQUAL = 0x92,
161
162    OP_ADD = 0x93,
163    OP_SUB = 0x94,
164    OP_MUL = 0x95,
165    OP_DIV = 0x96,
166    OP_MOD = 0x97,
167    OP_LSHIFT = 0x98,
168    OP_RSHIFT = 0x99,
169
170    OP_BOOLAND = 0x9a,
171    OP_BOOLOR = 0x9b,
172    OP_NUMEQUAL = 0x9c,
173    OP_NUMEQUALVERIFY = 0x9d,
174    OP_NUMNOTEQUAL = 0x9e,
175    OP_LESSTHAN = 0x9f,
176    OP_GREATERTHAN = 0xa0,
177    OP_LESSTHANOREQUAL = 0xa1,
178    OP_GREATERTHANOREQUAL = 0xa2,
179    OP_MIN = 0xa3,
180    OP_MAX = 0xa4,
181
182    OP_WITHIN = 0xa5,
183
184    // crypto
185    OP_RIPEMD160 = 0xa6,
186    OP_SHA1 = 0xa7,
187    OP_SHA256 = 0xa8,
188    OP_HASH160 = 0xa9,
189    OP_HASH256 = 0xaa,
190    OP_CODESEPARATOR = 0xab,
191    OP_CHECKSIG = 0xac,
192    OP_CHECKSIGVERIFY = 0xad,
193    OP_CHECKMULTISIG = 0xae,
194    OP_CHECKMULTISIGVERIFY = 0xaf,
195
196    // expansion
197    OP_NOP1 = 0xb0,
198    OP_CHECKLOCKTIMEVERIFY = 0xb1,
199    OP_NOP2 = OP_CHECKLOCKTIMEVERIFY,
200    OP_CHECKSEQUENCEVERIFY = 0xb2,
201    OP_NOP3 = OP_CHECKSEQUENCEVERIFY,
202    OP_NOP4 = 0xb3,
203    OP_NOP5 = 0xb4,
204    OP_NOP6 = 0xb5,
205    OP_NOP7 = 0xb6,
206    OP_NOP8 = 0xb7,
207    OP_NOP9 = 0xb8,
208    OP_NOP10 = 0xb9,
209
210    // Opcode added by BIP 342 (Tapscript)
211    OP_CHECKSIGADD = 0xba,
212
213    OP_INVALIDOPCODE = 0xff,
214};
215
216// Maximum value that an opcode can be
217inline constexpr unsigned int MAX_OPCODE = OP_NOP10;
218
219std::string GetOpName(opcodetype opcode);
220
221class scriptnum_error : public std::runtime_error
222{
223public:
224    explicit scriptnum_error(const std::string& str) : std::runtime_error(str) {}
225};
226
227class CScriptNum
228{
229/**
230 * Numeric opcodes (OP_1ADD, etc) are restricted to operating on 4-byte integers.
231 * The semantics are subtle, though: operands must be in the range [-2^31 +1...2^31 -1],
232 * but results may overflow (and are valid as long as they are not used in a subsequent
233 * numeric operation). CScriptNum enforces those semantics by storing results as
234 * an int64 and allowing out-of-range values to be returned as a vector of bytes but
235 * throwing an exception if arithmetic is done or the result is interpreted as an integer.
236 */
237public:
238
239    explicit CScriptNum(const int64_t& n)
240    {
241        m_value = n;
242    }
243
244    static constexpr size_t nDefaultMaxNumSize{4};
245
246    explicit CScriptNum(const std::vector<unsigned char>& vch, bool fRequireMinimal,
247                        const size_t nMaxNumSize = nDefaultMaxNumSize)
248    {
249        if (vch.size() > nMaxNumSize) {
250            throw scriptnum_error("script number overflow");