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_PRIMITIVES_TRANSACTION_H
7 : : #define BITCOIN_PRIMITIVES_TRANSACTION_H
8 : :
9 : : #include <consensus/amount.h>
10 : : #include <prevector.h>
11 : : #include <script/script.h>
12 : : #include <serialize.h>
13 : : #include <uint256.h>
14 : :
15 : : #include <cstddef>
16 : : #include <cstdint>
17 : : #include <ios>
18 : : #include <limits>
19 : : #include <memory>
20 : : #include <numeric>
21 : : #include <string>
22 : : #include <tuple>
23 : : #include <utility>
24 : : #include <vector>
25 : :
26 : : /**
27 : : * A flag that is ORed into the protocol version to designate that a transaction
28 : : * should be (un)serialized without witness data.
29 : : * Make sure that this does not collide with any of the values in `version.h`
30 : : * or with `ADDRV2_FORMAT`.
31 : : */
32 : : static const int SERIALIZE_TRANSACTION_NO_WITNESS = 0x40000000;
33 : :
34 : : /** An outpoint - a combination of a transaction hash and an index n into its vout */
35 : : class COutPoint
36 : : {
37 : : public:
38 : : uint256 hash;
39 : : uint32_t n;
40 : :
41 : : static constexpr uint32_t NULL_INDEX = std::numeric_limits<uint32_t>::max();
42 : :
43 : 15406175 : COutPoint(): n(NULL_INDEX) { }
44 : 21495515 : COutPoint(const uint256& hashIn, uint32_t nIn): hash(hashIn), n(nIn) { }
45 : :
46 : 362371092 : SERIALIZE_METHODS(COutPoint, obj) { READWRITE(obj.hash, obj.n); }
47 : :
48 : 54549 : void SetNull() { hash.SetNull(); n = NULL_INDEX; }
49 [ + + ]: 6424663 : bool IsNull() const { return (hash.IsNull() && n == NULL_INDEX); }
50 : :
51 : 428454946 : friend bool operator<(const COutPoint& a, const COutPoint& b)
52 : : {
53 : 428454946 : int cmp = a.hash.Compare(b.hash);
54 [ + + + + ]: 428454946 : return cmp < 0 || (cmp == 0 && a.n < b.n);
55 : : }
56 : :
57 : 30406726 : friend bool operator==(const COutPoint& a, const COutPoint& b)
58 : : {
59 [ + + ]: 30406726 : return (a.hash == b.hash && a.n == b.n);
60 : : }
61 : :
62 : : friend bool operator!=(const COutPoint& a, const COutPoint& b)
63 : : {
64 : : return !(a == b);
65 : : }
66 : :
67 : : std::string ToString() const;
68 : : };
69 : :
70 : : /** An input of a transaction. It contains the location of the previous
71 : : * transaction's output that it claims and a signature that matches the
72 : : * output's public key.
73 : : */
74 : 20647898 : class CTxIn
75 : : {
76 : : public:
77 : : COutPoint prevout;
78 : : CScript scriptSig;
79 : : uint32_t nSequence;
80 : : CScriptWitness scriptWitness; //!< Only serialized through CTransaction
81 : :
82 : : /**
83 : : * Setting nSequence to this value for every input in a transaction
84 : : * disables nLockTime/IsFinalTx().
85 : : * It fails OP_CHECKLOCKTIMEVERIFY/CheckLockTime() for any input that has
86 : : * it set (BIP 65).
87 : : * It has SEQUENCE_LOCKTIME_DISABLE_FLAG set (BIP 68/112).
88 : : */
89 : : static const uint32_t SEQUENCE_FINAL = 0xffffffff;
90 : : /**
91 : : * This is the maximum sequence number that enables both nLockTime and
92 : : * OP_CHECKLOCKTIMEVERIFY (BIP 65).
93 : : * It has SEQUENCE_LOCKTIME_DISABLE_FLAG set (BIP 68/112).
94 : : */
95 : : static const uint32_t MAX_SEQUENCE_NONFINAL{SEQUENCE_FINAL - 1};
96 : :
97 : : // Below flags apply in the context of BIP 68. BIP 68 requires the tx
98 : : // version to be set to 2, or higher.
99 : : /**
100 : : * If this flag is set, CTxIn::nSequence is NOT interpreted as a
101 : : * relative lock-time.
102 : : * It skips SequenceLocks() for any input that has it set (BIP 68).
103 : : * It fails OP_CHECKSEQUENCEVERIFY/CheckSequence() for any input that has
104 : : * it set (BIP 112).
105 : : */
106 : : static const uint32_t SEQUENCE_LOCKTIME_DISABLE_FLAG = (1U << 31);
107 : :
108 : : /**
109 : : * If CTxIn::nSequence encodes a relative lock-time and this flag
110 : : * is set, the relative lock-time has units of 512 seconds,
111 : : * otherwise it specifies blocks with a granularity of 1. */
112 : : static const uint32_t SEQUENCE_LOCKTIME_TYPE_FLAG = (1 << 22);
113 : :
114 : : /**
115 : : * If CTxIn::nSequence encodes a relative lock-time, this mask is
116 : : * applied to extract that lock-time from the sequence field. */
117 : : static const uint32_t SEQUENCE_LOCKTIME_MASK = 0x0000ffff;
118 : :
119 : : /**
120 : : * In order to use the same number of bits to encode roughly the
121 : : * same wall-clock duration, and because blocks are naturally
122 : : * limited to occur every 600s on average, the minimum granularity
123 : : * for time-based relative lock-time is fixed at 512 seconds.
124 : : * Converting from CTxIn::nSequence to seconds is performed by
125 : : * multiplying by 512 = 2^9, or equivalently shifting up by
126 : : * 9 bits. */
127 : : static const int SEQUENCE_LOCKTIME_GRANULARITY = 9;
128 : :
129 [ + - ]: 8234598 : CTxIn()
130 : : {
131 : 8234598 : nSequence = SEQUENCE_FINAL;
132 : 8234598 : }
133 : :
134 : : explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), uint32_t nSequenceIn=SEQUENCE_FINAL);
135 : : CTxIn(uint256 hashPrevTx, uint32_t nOut, CScript scriptSigIn=CScript(), uint32_t nSequenceIn=SEQUENCE_FINAL);
136 : :
137 : 297227427 : SERIALIZE_METHODS(CTxIn, obj) { READWRITE(obj.prevout, obj.scriptSig, obj.nSequence); }
138 : :
139 : 10536 : friend bool operator==(const CTxIn& a, const CTxIn& b)
140 : : {
141 [ + + ]: 14049 : return (a.prevout == b.prevout &&
142 [ - + ]: 3513 : a.scriptSig == b.scriptSig &&
143 : 3513 : a.nSequence == b.nSequence);
144 : : }
145 : :
146 : : friend bool operator!=(const CTxIn& a, const CTxIn& b)
147 : : {
148 : : return !(a == b);
149 : : }
150 : :
151 : : std::string ToString() const;
152 : : };
153 : :
154 : : /** An output of a transaction. It contains the public key that the next input
155 : : * must be able to sign with to claim it.
156 : : */
157 : : class CTxOut
158 : : {
159 : : public:
160 : : CAmount nValue;
161 : : CScript scriptPubKey;
162 : :
163 : 33263100 : CTxOut()
164 : : {
165 [ + - ]: 33263100 : SetNull();
166 : 33263100 : }
167 : :
168 : : CTxOut(const CAmount& nValueIn, CScript scriptPubKeyIn);
169 : :
170 : 605305299 : SERIALIZE_METHODS(CTxOut, obj) { READWRITE(obj.nValue, obj.scriptPubKey); }
171 : :
172 : 33410998 : void SetNull()
173 : : {
174 : 33410998 : nValue = -1;
175 : 33410998 : scriptPubKey.clear();
176 : 33410998 : }
177 : :
178 : 16635846 : bool IsNull() const
179 : : {
180 : 16635846 : return (nValue == -1);
181 : : }
182 : :
183 : 164143 : friend bool operator==(const CTxOut& a, const CTxOut& b)
184 : : {
185 [ + + ]: 327678 : return (a.nValue == b.nValue &&
186 : 163535 : a.scriptPubKey == b.scriptPubKey);
187 : : }
188 : :
189 : 378 : friend bool operator!=(const CTxOut& a, const CTxOut& b)
190 : : {
191 : 378 : return !(a == b);
192 : : }
193 : :
194 : : std::string ToString() const;
195 : : };
196 : :
197 : : struct CMutableTransaction;
198 : :
199 : : /**
200 : : * Basic transaction serialization format:
201 : : * - int32_t nVersion
202 : : * - std::vector<CTxIn> vin
203 : : * - std::vector<CTxOut> vout
204 : : * - uint32_t nLockTime
205 : : *
206 : : * Extended transaction serialization format:
207 : : * - int32_t nVersion
208 : : * - unsigned char dummy = 0x00
209 : : * - unsigned char flags (!= 0)
210 : : * - std::vector<CTxIn> vin
211 : : * - std::vector<CTxOut> vout
212 : : * - if (flags & 1):
213 : : * - CScriptWitness scriptWitness; (deserialized into CTxIn)
214 : : * - uint32_t nLockTime
215 : : */
216 : : template<typename Stream, typename TxType>
217 : 2017696 : inline void UnserializeTransaction(TxType& tx, Stream& s) {
218 : 2017696 : const bool fAllowWitness = !(s.GetVersion() & SERIALIZE_TRANSACTION_NO_WITNESS);
219 : :
220 : 2017696 : s >> tx.nVersion;
221 : 2017696 : unsigned char flags = 0;
222 : 2017696 : tx.vin.clear();
223 : 2017696 : tx.vout.clear();
224 : : /* Try to read the vin. In case the dummy is there, this will be read as an empty vector. */
225 : 2017696 : s >> tx.vin;
226 [ + + + + : 2017696 : if (tx.vin.size() == 0 && fAllowWitness) {
+ + + + ]
227 : : /* We read a dummy or an empty vin. */
228 : 1204701 : s >> flags;
229 [ + + + + ]: 1204701 : if (flags != 0) {
230 : 134224 : s >> tx.vin;
231 : 134224 : s >> tx.vout;
232 : 134224 : }
233 : 1204701 : } else {
234 : : /* We read a non-empty vin. Assume a normal vout follows. */
235 : 813021 : s >> tx.vout;
236 : : }
237 [ + + + + : 2017686 : if ((flags & 1) && fAllowWitness) {
+ + + + ]
238 : : /* The witness flag is present, and we support witnesses. */
239 : 90809 : flags ^= 1;
240 [ + + + + ]: 818803 : for (size_t i = 0; i < tx.vin.size(); i++) {
241 : 727994 : s >> tx.vin[i].scriptWitness.stack;
242 : 727994 : }
243 [ + + + + ]: 90809 : if (!tx.HasWitness()) {
244 : : /* It's illegal to encode witnesses when all witness stacks are empty. */
245 [ + - + - ]: 6884 : throw std::ios_base::failure("Superfluous witness record");
246 : : }
247 : 83925 : }
248 [ + + + + ]: 2010802 : if (flags) {
249 : : /* Unknown flag in the serialization */
250 [ + - + - ]: 4225 : throw std::ios_base::failure("Unknown transaction optional data");
251 : : }
252 : 2006577 : s >> tx.nLockTime;
253 : 2006577 : }
254 : :
255 : : template<typename Stream, typename TxType>
256 : 7265001 : inline void SerializeTransaction(const TxType& tx, Stream& s) {
257 : 7265001 : const bool fAllowWitness = !(s.GetVersion() & SERIALIZE_TRANSACTION_NO_WITNESS);
258 : :
259 : 7265001 : s << tx.nVersion;
260 : 7265001 : unsigned char flags = 0;
261 : : // Consistency check
262 [ + + + + : 7265001 : if (fAllowWitness) {
+ - # # +
- # # ]
263 : : /* Check whether witnesses need to be serialized. */
264 [ + + + + : 2139446 : if (tx.HasWitness()) {
# # # # #
# # # ]
265 : 1046390 : flags |= 1;
266 : 1046390 : }
267 : 2139446 : }
268 [ + + + + : 7265001 : if (flags) {
+ - # # +
- # # ]
269 : : /* Use extended format in case witnesses are to be serialized. */
270 : 1046390 : std::vector<CTxIn> vinDummy;
271 [ + - + - : 1046390 : s << vinDummy;
# # # # #
# # # ]
272 [ + - + - : 1046390 : s << flags;
# # # # #
# # # ]
273 : 1046390 : }
274 : 7265001 : s << tx.vin;
275 : 7265001 : s << tx.vout;
276 [ + + + + : 7265001 : if (flags & 1) {
+ - # # +
- # # ]
277 [ + + + + : 18363444 : for (size_t i = 0; i < tx.vin.size(); i++) {
# # # # #
# # # ]
278 : 17317054 : s << tx.vin[i].scriptWitness.stack;
279 : 17317054 : }
280 : 1046390 : }
281 : 7265001 : s << tx.nLockTime;
282 : 7265001 : }
283 : :
284 : : template<typename TxType>
285 : 0 : inline CAmount CalculateOutputValue(const TxType& tx)
286 : : {
287 : 0 : return std::accumulate(tx.vout.cbegin(), tx.vout.cend(), CAmount{0}, [](CAmount sum, const auto& txout) { return sum + txout.nValue; });
288 : : }
289 : :
290 : :
291 : : /** The basic transaction that is broadcasted on the network and contained in
292 : : * blocks. A transaction can contain multiple inputs and outputs.
293 : : */
294 : 223689 : class CTransaction
295 : : {
296 : : public:
297 : : // Default transaction version.
298 : : static const int32_t CURRENT_VERSION=2;
299 : :
300 : : // The local variables are made const to prevent unintended modification
301 : : // without updating the cached hash value. However, CTransaction is not
302 : : // actually immutable; deserialization and assignment are implemented,
303 : : // and bypass the constness. This is safe, as they update the entire
304 : : // structure, including the hash.
305 : : const std::vector<CTxIn> vin;
306 : : const std::vector<CTxOut> vout;
307 : : const int32_t nVersion;
308 : : const uint32_t nLockTime;
309 : :
310 : : private:
311 : : /** Memory only. */
312 : : const uint256 hash;
313 : : const uint256 m_witness_hash;
314 : :
315 : : uint256 ComputeHash() const;
316 : : uint256 ComputeWitnessHash() const;
317 : :
318 : : public:
319 : : /** Convert a CMutableTransaction into a CTransaction. */
320 : : explicit CTransaction(const CMutableTransaction& tx);
321 : : explicit CTransaction(CMutableTransaction&& tx);
322 : :
323 : : template <typename Stream>
324 : 7103213 : inline void Serialize(Stream& s) const {
325 : 7103213 : SerializeTransaction(*this, s);
326 : 7103213 : }
327 : :
328 : : /** This deserializing constructor is provided instead of an Unserialize method.
329 : : * Unserialize is not possible, since it would require overwriting const fields. */
330 : : template <typename Stream>
331 [ + - + - ]: 1791668 : CTransaction(deserialize_type, Stream& s) : CTransaction(CMutableTransaction(deserialize, s)) {}
332 : :
333 : 1097 : bool IsNull() const {
334 [ + + ]: 1097 : return vin.empty() && vout.empty();
335 : : }
336 : :
337 : 1179963348 : const uint256& GetHash() const { return hash; }
338 : 22365427 : const uint256& GetWitnessHash() const { return m_witness_hash; };
339 : :
340 : : // Return sum of txouts.
341 : : CAmount GetValueOut() const;
342 : :
343 : : /**
344 : : * Get the total transaction size in bytes, including witness data.
345 : : * "Total Size" defined in BIP141 and BIP144.
346 : : * @return Total transaction size in bytes
347 : : */
348 : : unsigned int GetTotalSize() const;
349 : :
350 : 2253117 : bool IsCoinBase() const
351 : : {
352 [ + + ]: 2253117 : return (vin.size() == 1 && vin[0].prevout.IsNull());
353 : : }
354 : :
355 : 127 : friend bool operator==(const CTransaction& a, const CTransaction& b)
356 : : {
357 : 127 : return a.hash == b.hash;
358 : : }
359 : :
360 : 127 : friend bool operator!=(const CTransaction& a, const CTransaction& b)
361 : : {
362 : 127 : return a.hash != b.hash;
363 : : }
364 : :
365 : : std::string ToString() const;
366 : :
367 : 5011577 : bool HasWitness() const
368 : : {
369 [ + + ]: 35155272 : for (size_t i = 0; i < vin.size(); i++) {
370 [ + + ]: 31782768 : if (!vin[i].scriptWitness.IsNull()) {
371 : 1639073 : return true;
372 : : }
373 : 30143695 : }
374 : 3372504 : return false;
375 : 5011577 : }
376 : : };
377 : :
378 : : /** A mutable version of CTransaction. */
379 : 35654 : struct CMutableTransaction
380 : : {
381 : : std::vector<CTxIn> vin;
382 : : std::vector<CTxOut> vout;
383 : : int32_t nVersion;
384 : : uint32_t nLockTime;
385 : :
386 : : explicit CMutableTransaction();
387 : : explicit CMutableTransaction(const CTransaction& tx);
388 : :
389 : : template <typename Stream>
390 : 161788 : inline void Serialize(Stream& s) const {
391 : 161788 : SerializeTransaction(*this, s);
392 : 161788 : }
393 : :
394 : :
395 : : template <typename Stream>
396 : 2307160 : inline void Unserialize(Stream& s) {
397 : 2307160 : UnserializeTransaction(*this, s);
398 : 2307160 : }
399 : :
400 : : template <typename Stream>
401 : 1791668 : CMutableTransaction(deserialize_type, Stream& s) {
402 [ + + + + ]: 1791668 : Unserialize(s);
403 : 1791668 : }
404 : :
405 : : /** Compute the hash of this CMutableTransaction. This is computed on the
406 : : * fly, as opposed to GetHash() in CTransaction, which uses a cached result.
407 : : */
408 : : uint256 GetHash() const;
409 : :
410 : 91724 : bool HasWitness() const
411 : : {
412 [ + + ]: 378196 : for (size_t i = 0; i < vin.size(); i++) {
413 [ + + ]: 370549 : if (!vin[i].scriptWitness.IsNull()) {
414 : 84077 : return true;
415 : : }
416 : 286472 : }
417 : 7647 : return false;
418 : 91724 : }
419 : : };
420 : :
421 : : typedef std::shared_ptr<const CTransaction> CTransactionRef;
422 : 857391 : template <typename Tx> static inline CTransactionRef MakeTransactionRef(Tx&& txIn) { return std::make_shared<const CTransaction>(std::forward<Tx>(txIn)); }
423 : :
424 : : /** A generic txid reference (txid or wtxid). */
425 : : class GenTxid
426 : : {
427 : : bool m_is_wtxid;
428 : : uint256 m_hash;
429 : 4301575 : GenTxid(bool is_wtxid, const uint256& hash) : m_is_wtxid(is_wtxid), m_hash(hash) {}
430 : :
431 : : public:
432 : 2588435 : static GenTxid Txid(const uint256& hash) { return GenTxid{false, hash}; }
433 : 1713140 : static GenTxid Wtxid(const uint256& hash) { return GenTxid{true, hash}; }
434 : 5768342 : bool IsWtxid() const { return m_is_wtxid; }
435 : 8927355 : const uint256& GetHash() const { return m_hash; }
436 [ - + ]: 67696 : friend bool operator==(const GenTxid& a, const GenTxid& b) { return a.m_is_wtxid == b.m_is_wtxid && a.m_hash == b.m_hash; }
437 : 25269 : friend bool operator<(const GenTxid& a, const GenTxid& b) { return std::tie(a.m_is_wtxid, a.m_hash) < std::tie(b.m_is_wtxid, b.m_hash); }
438 : : };
439 : :
440 : : #endif // BITCOIN_PRIMITIVES_TRANSACTION_H
|
