比特币源码解析(5)

0x00 摘要

交易(transaction)是比特币甚至所有区块链中最核心的数据结构之一，可以说其他所有的模块都是为交易服务的，包括交易的产生、广播、共识、存储等等，所以我们首先从交易出发，然后逐步延伸到其他的部分。

0x01 COutPoint

/** An outpoint - a combination of a transaction hash and an index n into its vout. * COutPoint主要用在交易的输入CTxIn中，用来确定当前输出的来源，* 包括前一笔交易的hash，以及对应前一笔交易中的第几个输出的序列号。*/class COutPoint{public:    uint256 hash; // 交易的哈希    uint32_t n;  // 对应的序列号    COutPoint() { SetNull(); }    COutPoint(uint256 hashIn, uint32_t nIn) { hash = hashIn; n = nIn; }    ADD_SERIALIZE_METHODS;  // 用来序列化数据结构，方便存储和传输    template <typename Stream, typename Operation>    inline void SerializationOp(Stream& s, Operation ser_action) {        READWRITE(hash);        READWRITE(n);    }    void SetNull() { hash.SetNull(); n = (uint32_t) -1; }    bool IsNull() const { return (hash.IsNull() && n == (uint32_t) -1); }    //重载小于号    friend bool operator<(const COutPoint& a, const COutPoint& b)    {        int cmp = a.hash.Compare(b.hash);        return cmp < 0 || (cmp == 0 && a.n < b.n);    }    friend bool operator==(const COutPoint& a, const COutPoint& b)    {        return (a.hash == b.hash && a.n == b.n);    }    friend bool operator!=(const COutPoint& a, const COutPoint& b)    {        return !(a == b);    }    std::string ToString() const;};

0x02 CTxIn

/** An input of a transaction.  It contains the location of the previous * transaction's output that it claims and a signature that matches the * output's public key. * 交易的输入，包括当前输入对应前一笔交易的输出的位置，以及花费前一笔输出需要的签名脚本 * CScriptWitness是用来支持隔离见证时使用的。 */class CTxIn{public:    COutPoint prevout;  // 前一笔交易输出的位置    CScript scriptSig;  // 解锁脚本    uint32_t nSequence;  // 序列号    CScriptWitness scriptWitness; //! Only serialized through CTransaction    /* Setting nSequence to this value for every input in a transaction     * disables nLockTime.      * 规则1：如果一笔交易中所有的SEQUENCE_FINAL都被赋值了相应的nSequence，那么nLockTime就会被禁用*/    static const uint32_t SEQUENCE_FINAL = 0xffffffff;    /* Below flags apply in the context of BIP 68*/    /* If this flag set, CTxIn::nSequence is NOT interpreted as a     * relative lock-time.      * 规则2：如果设置了这个变量，那么规则1就失效了*/    static const uint32_t SEQUENCE_LOCKTIME_DISABLE_FLAG = (1 << 31);    /* If CTxIn::nSequence encodes a relative lock-time and this flag     * is set, the relative lock-time has units of 512 seconds,     * otherwise it specifies blocks with a granularity of 1.      * 规则3：如果规则1有效并且设置了此变量，那么相对锁定时间就为512秒，否则锁定时间就为1个区块*/    static const uint32_t SEQUENCE_LOCKTIME_TYPE_FLAG = (1 << 22);    /* If CTxIn::nSequence encodes a relative lock-time, this mask is     * applied to extract that lock-time from the sequence field.      * 规则4：如果规则1有效，那么这个变量就用来从nSequence计算对应的锁定时间*/    static const uint32_t SEQUENCE_LOCKTIME_MASK = 0x0000ffff;    /* In order to use the same number of bits to encode roughly the     * same wall-clock duration, and because blocks are naturally     * limited to occur every 600s on average, the minimum granularity     * for time-based relative lock-time is fixed at 512 seconds.     * Converting from CTxIn::nSequence to seconds is performed by     * multiplying by 512 = 2^9, or equivalently shifting up by     * 9 bits. */    static const int SEQUENCE_LOCKTIME_GRANULARITY = 9;    CTxIn()    {        nSequence = SEQUENCE_FINAL;    }    // 禁用隐式转换，构造函数必须明确使用当前形式    explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), uint32_t nSequenceIn=SEQUENCE_FINAL);    CTxIn(uint256 hashPrevTx, uint32_t nOut, CScript scriptSigIn=CScript(), uint32_t nSequenceIn=SEQUENCE_FINAL);    ADD_SERIALIZE_METHODS;    template <typename Stream, typename Operation>    inline void SerializationOp(Stream& s, Operation ser_action) {        READWRITE(prevout);        READWRITE(*(CScriptBase*)(&scriptSig));        READWRITE(nSequence);    }    friend bool operator==(const CTxIn& a, const CTxIn& b)    {        return (a.prevout   == b.prevout &&                a.scriptSig == b.scriptSig &&                a.nSequence == b.nSequence);    }    friend bool operator!=(const CTxIn& a, const CTxIn& b)    {        return !(a == b);    }    std::string ToString() const;};

0x03 CTxOut

/** An output of a transaction.  It contains the public key that the next input must be able to sign with to claim it. * 交易的输出，包含金额和锁定脚本 */class CTxOut{public:    CAmount nValue;  // 输出金额    CScript scriptPubKey;  // 锁定脚本    CTxOut()    {        SetNull();    }    CTxOut(const CAmount& nValueIn, CScript scriptPubKeyIn);    ADD_SERIALIZE_METHODS;    template <typename Stream, typename Operation>    inline void SerializationOp(Stream& s, Operation ser_action) {        READWRITE(nValue);        READWRITE(*(CScriptBase*)(&scriptPubKey));    }    void SetNull()    {        nValue = -1;        scriptPubKey.clear();    }    bool IsNull() const    {        return (nValue == -1);    }    // 获取dust阈值，一笔交易如果交易费小于dust阈值，就会被认为是dust tx，     // 此函数在最新版本中已转移到src/policy/policy.h中    CAmount GetDustThreshold(const CFeeRate &minRelayTxFee) const    {        // "Dust" is defined in terms of CTransaction::minRelayTxFee,        // which has units satoshis-per-kilobyte.        // If you'd pay more than 1/3 in fees        // to spend something, then we consider it dust.        // A typical spendable non-segwit txout is 34 bytes big, and will        // need a CTxIn of at least 148 bytes to spend:        // so dust is a spendable txout less than        // 546*minRelayTxFee/1000 (in satoshis).        // A typical spendable segwit txout is 31 bytes big, and will        // need a CTxIn of at least 67 bytes to spend:        // so dust is a spendable txout less than        // 294*minRelayTxFee/1000 (in satoshis).        /**  "Dust"是根据CTransaction中的minRelayTxFee来定义的，单位是satoshis/千字节，        * 如果在一笔交易中交易费占了1/3以上，那么我们就认为该交易是"Dust"交易。        * 因此dust交易的金额小于 546*minRelayTxFee/1000;         * 而在支持隔离见证的交易中，txout通常大小为31字节，CTxIn大小至少为67字节，        * 此时dust交易的金额则一般小于 294*minRelayTxFee/1000.        */        if (scriptPubKey.IsUnspendable())  // 判断脚本格式是否正确            return 0;        size_t nSize = GetSerializeSize(*this, SER_DISK, 0);        int witnessversion = 0;        std::vector<unsigned char> witnessprogram;        // 判断是否支持隔离见证        if (scriptPubKey.IsWitnessProgram(witnessversion, witnessprogram)) {            // sum the sizes of the parts of a transaction input            // with 75% segwit discount applied to the script size.            nSize += (32 + 4 + 1 + (107 / WITNESS_SCALE_FACTOR) + 4);        } else {            nSize += (32 + 4 + 1 + 107 + 4); // the 148 mentioned above        }        return 3 * minRelayTxFee.GetFee(nSize);    }    bool IsDust(const CFeeRate &minRelayTxFee) const    {        return (nValue < GetDustThreshold(minRelayTxFee));    }    friend bool operator==(const CTxOut& a, const CTxOut& b)    {        return (a.nValue       == b.nValue &&                a.scriptPubKey == b.scriptPubKey);    }    friend bool operator!=(const CTxOut& a, const CTxOut& b)    {        return !(a == b);    }    std::string ToString() const;};

0x04 CTransaction

/** The basic transaction that is broadcasted on the network and contained in blocks.   * A transaction can contain multiple inputs and outputs. * 下面就是在网络中广播然后被打包进区块的最基本的交易的结构，一个交易可能包含多个交易输入和输出。 */class CTransaction{public:    // Default transaction version. 默认交易版本    static const int32_t CURRENT_VERSION=2;    // Changing the default transaction version requires a two step process: first    // adapting relay policy by bumping MAX_STANDARD_VERSION, and then later date    // bumping the default CURRENT_VERSION at which point both CURRENT_VERSION and    // MAX_STANDARD_VERSION will be equal.    static const int32_t MAX_STANDARD_VERSION=2;    // The local variables are made const to prevent unintended modification    // without updating the cached hash value. However, CTransaction is not    // actually immutable; deserialization and assignment are implemented,    // and bypass the constness. This is safe, as they update the entire    // structure, including the hash.    /** 下面这些变量都被定义为常量类型，从而避免无意识的修改了交易而没有更新缓存的hash值；    * 但还是可以通过重新构造一个交易然后赋值给当前交易来进行修改，这样就更新了交易的所有内容    */    const int32_t nVersion;  // 版本    const std::vector<CTxIn> vin; // 交易输入    const std::vector<CTxOut> vout; // 交易输出    const uint32_t nLockTime; // 锁定时间private:    /** Memory only. */    const uint256 hash;    uint256 ComputeHash() const;public:    /** Construct a CTransaction that qualifies as IsNull() */    CTransaction();    /** Convert a CMutableTransaction into a CTransaction. */    CTransaction(const CMutableTransaction &tx);    CTransaction(CMutableTransaction &&tx);    template <typename Stream>    inline void Serialize(Stream& s) const {        SerializeTransaction(*this, s);    }    /** This deserializing constructor is provided instead of an Unserialize method.     *  Unserialize is not possible, since it would require overwriting const fields. */    template <typename Stream>    CTransaction(deserialize_type, Stream& s) : CTransaction(CMutableTransaction(deserialize, s)) {}    bool IsNull() const {        return vin.empty() && vout.empty();    }    const uint256& GetHash() const {        return hash;    }    // Compute a hash that includes both transaction and witness data    uint256 GetWitnessHash() const;    // Return sum of txouts.    CAmount GetValueOut() const; // 返回交易输出金额之和    // GetValueIn() is a method on CCoinsViewCache, because    // inputs must be known to compute value in.    /**     * Get the total transaction size in bytes, including witness data.     * "Total Size" defined in BIP141 and BIP144.     * @return Total transaction size in bytes     */    unsigned int GetTotalSize() const; // 返回交易大小    bool IsCoinBase() const  // 判断是否是coinbase交易    {        return (vin.size() == 1 && vin[0].prevout.IsNull());    }    friend bool operator==(const CTransaction& a, const CTransaction& b)    {        return a.hash == b.hash;    }    friend bool operator!=(const CTransaction& a, const CTransaction& b)    {        return a.hash != b.hash;    }    std::string ToString() const;    bool HasWitness() const    {        for (size_t i = 0; i < vin.size(); i++) {            if (!vin[i].scriptWitness.IsNull()) {                return true;            }        }        return false;    }};

除了这个结构以外，还定义了一个CMutableTransaction其中的变量内容和CTransaction相同，但是都是可以直接修改的，但是最后广播和网络中传输的类型都是CTransaction。