251        if (tx.HasWitness()) {
252            flags |= 1;
253        }
254    }
255    if (flags) {
256        /* Use extended format in case witnesses are to be serialized. */
257        std::vector<CTxIn> vinDummy;
258        s << vinDummy;
259        s << flags;
260    }
261    s << tx.vin;
262    s << tx.vout;
263    if (flags & 1) {
264        for (size_t i = 0; i < tx.vin.size(); i++) {
265            s << tx.vin[i].scriptWitness.stack;
266        }
267    }
268    s << tx.nLockTime;
269}
270
271template<typename TxType>
272inline CAmount CalculateOutputValue(const TxType& tx)
273{
274    return std::accumulate(tx.vout.cbegin(), tx.vout.cend(), CAmount{0}, [](CAmount sum, const auto& txout) { return sum + txout.nValue; });
275}
276
277struct EqualsOptions {
278    bool include_script_sig{true};
279    bool include_witness_data{true};
280};
281
282
283/** The basic transaction that is broadcasted on the network and contained in
284 * blocks.  A transaction can contain multiple inputs and outputs.
285 */
286class CTransaction
287{
288public:
289    // Default transaction version.
290    static constexpr uint32_t CURRENT_VERSION{2};
291
292    // The local variables are made const to prevent unintended modification
293    // without updating the cached hash value. However, CTransaction is not
294    // actually immutable; deserialization and assignment are implemented,
295    // and bypass the constness. This is safe, as they update the entire
296    // structure, including the hash.
297    const std::vector<CTxIn> vin;
298    const std::vector<CTxOut> vout;
299    const uint32_t version;
300    const uint32_t nLockTime;
301
302private:
303    /** Memory only. */
304    const bool m_has_witness;
305    const Txid hash;
306    const Wtxid m_witness_hash;
307
308    Txid ComputeHash() const;
309    Wtxid ComputeWitnessHash() const;
310
311    bool ComputeHasWitness() const;
312
313public:
314    /** Convert a CMutableTransaction into a CTransaction. */
315    explicit CTransaction(const CMutableTransaction& tx);
316    explicit CTransaction(CMutableTransaction&& tx);
317
318    template <typename Stream>
319    inline void Serialize(Stream& s) const {
320        SerializeTransaction(*this, s, s.template GetParams<TransactionSerParams>());
321    }
322
323    /** This deserializing constructor is provided instead of an Unserialize method.
324     *  Unserialize is not possible, since it would require overwriting const fields. */
325    template <typename Stream>
326    CTransaction(deserialize_type, const TransactionSerParams& params, Stream& s) : CTransaction(CMutableTransaction(deserialize, params, s)) {}
327    template <typename Stream>
328    CTransaction(deserialize_type, Stream& s) : CTransaction(CMutableTransaction(deserialize, s)) {}
329
330    bool IsNull() const {
331        return vin.empty() && vout.empty();
332    }
333
334    const Txid& GetHash() const LIFETIMEBOUND { return hash; }
335    const Wtxid& GetWitnessHash() const LIFETIMEBOUND { return m_witness_hash; };
336
337    // Return sum of txouts.
338    CAmount GetValueOut() const;
339
340    /**
341     * Calculate the total transaction size in bytes, including witness data.
342     * "Total Size" defined in BIP141 and BIP144.
343     * @return Total transaction size in bytes
344     */
345    unsigned int ComputeTotalSize() const;
346
347    bool IsCoinBase() const
348    {
349        return (vin.size() == 1 && vin[0].prevout.IsNull());
350    }
351
352    bool Equals(const CTransaction& other, const EqualsOptions opts = {}) const
353    {
354        return nLockTime == other.nLockTime &&
355            version == other.version &&
356            vout == other.vout &&
357            std::ranges::equal(vin, other.vin, [&opts](const CTxIn& self, const CTxIn& other) {
358                return self.prevout == other.prevout &&
359                    self.nSequence == other.nSequence &&
360                    (opts.include_script_sig ? self.scriptSig == other.scriptSig : true) &&
361                    (opts.include_witness_data ? self.scriptWitness.stack == other.scriptWitness.stack : true);
362            });
363    }
364
365    std::string ToString() const;
366
367    bool HasWitness() const { return m_has_witness; }
368};
369
370/** A mutable version of CTransaction. */
371struct CMutableTransaction
372{
373    std::vector<CTxIn> vin;
374    std::vector<CTxOut> vout;
375    uint32_t version;
376    uint32_t nLockTime;
377
378    explicit CMutableTransaction();
379    explicit CMutableTransaction(const CTransaction& tx);
380
381    template <typename Stream>
382    inline void Serialize(Stream& s) const {
383        SerializeTransaction(*this, s, s.template GetParams<TransactionSerParams>());
384    }
385
386    template <typename Stream>
387    inline void Unserialize(Stream& s) {
388        UnserializeTransaction(*this, s, s.template GetParams<TransactionSerParams>());
389    }
390
391    template <typename Stream>
392    CMutableTransaction(deserialize_type, const TransactionSerParams& params, Stream& s) {
393        UnserializeTransaction(*this, s, params);
394    }
395
396    template <typename Stream>
397    CMutableTransaction(deserialize_type, Stream& s) {
398        Unserialize(s);
399    }
400
401    /** Compute the hash of this CMutableTransaction. This is computed on the
402     * fly, as opposed to GetHash() in CTransaction, which uses a cached result.
403     */
404    Txid GetHash() const;
405
406    bool HasWitness() const
407    {
408        for (size_t i = 0; i < vin.size(); i++) {
409            if (!vin[i].scriptWitness.IsNull()) {
410                return true;
411            }
412        }
413        return false;
414    }
415};
416
417typedef std::shared_ptr<const CTransaction> CTransactionRef;
418template <typename Tx> static inline CTransactionRef MakeTransactionRef(Tx&& txIn) { return std::make_shared<const CTransaction>(std::forward<Tx>(txIn)); }
419
420namespace std {
421/** Disable default std::hash for CTransactionRef to prevent accidentally
422 *  comparing by pointer. Use CTransactionRefHash or provide a custom
423 *  hasher. */
424template <>
425struct hash<CTransactionRef> {
426    hash() = delete;
427    // Belt-and-suspenders, already implied by the above.
428    size_t operator()(const CTransactionRef&) const = delete;
429};
430} // namespace std
431
432#endif // BITCOIN_PRIMITIVES_TRANSACTION_H
433