foster/bitcoin-bitcoin-core
0
0
Fork 0
mirror of https://github.com/bitcoin/bitcoin.git synced 2025-02-09 10:43:19 -05:00
Code Issues Activity

Merge bitcoin/bitcoin#29325: consensus: Store transaction nVersion as uint32_t

Browse source 
429ec1aaaa refactor: Rename CTransaction::nVersion to version (Ava Chow)
27e70f1f5b consensus: Store transaction nVersion as uint32_t (Ava Chow)

Pull request description:

  Given that the use of a transaction's nVersion is always as an unsigned int, it doesn't make sense to store it as signed and then cast it to unsigned everywhere it is used and displayed.

  Since a few alternative implementations have recently been revealed to have made an error with this signedness that would have resulted in consensus failure, I think it makes sense for us to just make this always unsigned to make it clear that the version is treated as unsigned. This would also help us avoid future potential issues with signedness of this value.

  I believe that this is safe and does not actually change what transactions would or would not be considered both standard and consensus valid. Within consensus, the only use of the version in consensus is in BIP68 validation which was already casting it to uint32_t. Within policy, although it is used as a signed int for the transaction version number check, I do not think that this change would change standardness. Standard transactions are limited to the range [1, 2]. Negative numbers would have fallen under the < 1 condition, but by making it unsigned, they are still non-standard under the > 2 condition.

  Unsigned and signed ints are serialized and unserialized the same way so there is no change in serialization.

ACKs for top commit:
  maflcko:
    ACK 429ec1aaaa 🐿
  glozow:
    ACK 429ec1aaaa
  shaavan:
    ACK 429ec1aaaa 💯

Tree-SHA512: 0bcd92a245d7d16c3665d2d4e815a4ef28207ad4a1fb46c6f0203cdafeab1b82c4e95e4bdce7805d80a4f4a46074f6542abad708e970550d38a00d759e3dcef1
This commit is contained in:
merge-script 2024-06-12 10:32:31 +01:00
commit 5ee6b76c69
No known key found for this signature in database
GPG key ID: 2EEB9F5CC09526C1
45 changed files with 157 additions and 149 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
contrib/signet/miner
View file

@ -58,14 +58,14 @@ def signet_txs(block, challenge):
sd += block.nTime.to_bytes(4, "little") sd += block.nTime.to_bytes(4, "little")
to_spend = CTransaction() to_spend = CTransaction()
to_spend.nVersion = 0 to_spend.version = 0
to_spend.nLockTime = 0 to_spend.nLockTime = 0
to_spend.vin = [CTxIn(COutPoint(0, 0xFFFFFFFF), b"\x00" + CScriptOp.encode_op_pushdata(sd), 0)] to_spend.vin = [CTxIn(COutPoint(0, 0xFFFFFFFF), b"\x00" + CScriptOp.encode_op_pushdata(sd), 0)]
to_spend.vout = [CTxOut(0, challenge)] to_spend.vout = [CTxOut(0, challenge)]
to_spend.rehash() to_spend.rehash()
spend = CTransaction() spend = CTransaction()
spend.nVersion = 0 spend.version = 0
spend.nLockTime = 0 spend.nLockTime = 0
spend.vin = [CTxIn(COutPoint(to_spend.sha256, 0), b"", 0)] spend.vin = [CTxIn(COutPoint(to_spend.sha256, 0), b"", 0)]
spend.vout = [CTxOut(0, b"\x6a")] spend.vout = [CTxOut(0, b"\x6a")]

2
doc/policy/mempool-replacements.md
View file

@ -12,7 +12,7 @@ other consensus and policy rules, each of the following conditions are met:
1. The directly conflicting transactions all signal replaceability explicitly. A transaction is 1. The directly conflicting transactions all signal replaceability explicitly. A transaction is
signaling BIP125 replaceability if any of its inputs have an nSequence number less than (0xffffffff - 1). signaling BIP125 replaceability if any of its inputs have an nSequence number less than (0xffffffff - 1).
A transaction also signals replaceability if its nVersion field is set to 3. A transaction also signals replaceability if its version field is set to 3.
*Rationale*: See [BIP125 *Rationale*: See [BIP125
explanation](https://github.com/bitcoin/bips/blob/master/bip-0125.mediawiki#motivation). explanation](https://github.com/bitcoin/bips/blob/master/bip-0125.mediawiki#motivation).

6
src/bitcoin-tx.cpp
View file

@ -203,12 +203,12 @@ static CAmount ExtractAndValidateValue(const std::string& strValue)
static void MutateTxVersion(CMutableTransaction& tx, const std::string& cmdVal) static void MutateTxVersion(CMutableTransaction& tx, const std::string& cmdVal)
{ {
int64_t newVersion; uint32_t newVersion;
if (!ParseInt64(cmdVal, &newVersion) || newVersion < 1 || newVersion > TX_MAX_STANDARD_VERSION) { if (!ParseUInt32(cmdVal, &newVersion) || newVersion < 1 || newVersion > TX_MAX_STANDARD_VERSION) {
throw std::runtime_error("Invalid TX version requested: '" + cmdVal + "'"); throw std::runtime_error("Invalid TX version requested: '" + cmdVal + "'");
} }
tx.nVersion = (int) newVersion; tx.version = newVersion;
} }
static void MutateTxLocktime(CMutableTransaction& tx, const std::string& cmdVal) static void MutateTxLocktime(CMutableTransaction& tx, const std::string& cmdVal)

4
src/compressor.h
View file

@ -55,8 +55,8 @@ struct ScriptCompression
{ {
/** /**
* make this static for now (there are only 6 special scripts defined) * make this static for now (there are only 6 special scripts defined)
* this can potentially be extended together with a new nVersion for * this can potentially be extended together with a new version for
* transactions, in which case this value becomes dependent on nVersion * transactions, in which case this value becomes dependent on version
* and nHeight of the enclosing transaction. * and nHeight of the enclosing transaction.
*/ */
static const unsigned int nSpecialScripts = 6; static const unsigned int nSpecialScripts = 6;

6
src/consensus/tx_verify.cpp
View file

@ -48,11 +48,7 @@ std::pair<int, int64_t> CalculateSequenceLocks(const CTransaction &tx, int flags
int nMinHeight = -1; int nMinHeight = -1;
int64_t nMinTime = -1; int64_t nMinTime = -1;
// tx.nVersion is signed integer so requires cast to unsigned otherwise bool fEnforceBIP68 = tx.version >= 2 && flags & LOCKTIME_VERIFY_SEQUENCE;
// we would be doing a signed comparison and half the range of nVersion
// wouldn't support BIP 68.
bool fEnforceBIP68 = static_cast<uint32_t>(tx.nVersion) >= 2
&& flags & LOCKTIME_VERIFY_SEQUENCE;
// Do not enforce sequence numbers as a relative lock time // Do not enforce sequence numbers as a relative lock time
// unless we have been instructed to // unless we have been instructed to

4
src/core_write.cpp
View file

@ -174,9 +174,7 @@ void TxToUniv(const CTransaction& tx, const uint256& block_hash, UniValue& entry
entry.pushKV("txid", tx.GetHash().GetHex()); entry.pushKV("txid", tx.GetHash().GetHex());
entry.pushKV("hash", tx.GetWitnessHash().GetHex()); entry.pushKV("hash", tx.GetWitnessHash().GetHex());
// Transaction version is actually unsigned in consensus checks, just signed in memory, entry.pushKV("version", tx.version);
// so cast to unsigned before giving it to the user.
entry.pushKV("version", static_cast<int64_t>(static_cast<uint32_t>(tx.nVersion)));
entry.pushKV("size", tx.GetTotalSize()); entry.pushKV("size", tx.GetTotalSize());
entry.pushKV("vsize", (GetTransactionWeight(tx) + WITNESS_SCALE_FACTOR - 1) / WITNESS_SCALE_FACTOR); entry.pushKV("vsize", (GetTransactionWeight(tx) + WITNESS_SCALE_FACTOR - 1) / WITNESS_SCALE_FACTOR);
entry.pushKV("weight", GetTransactionWeight(tx)); entry.pushKV("weight", GetTransactionWeight(tx));

2
src/kernel/chainparams.cpp
View file

@ -29,7 +29,7 @@
static CBlock CreateGenesisBlock(const char* pszTimestamp, const CScript& genesisOutputScript, uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward) static CBlock CreateGenesisBlock(const char* pszTimestamp, const CScript& genesisOutputScript, uint32_t nTime, uint32_t nNonce, uint32_t nBits, int32_t nVersion, const CAmount& genesisReward)
{ {
CMutableTransaction txNew; CMutableTransaction txNew;
txNew.nVersion = 1; txNew.version = 1;
txNew.vin.resize(1); txNew.vin.resize(1);
txNew.vout.resize(1); txNew.vout.resize(1);
txNew.vin[0].scriptSig = CScript() << 486604799 << CScriptNum(4) << std::vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp)); txNew.vin[0].scriptSig = CScript() << 486604799 << CScriptNum(4) << std::vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));

2
src/policy/policy.cpp
View file

@ -93,7 +93,7 @@ bool IsStandard(const CScript& scriptPubKey, const std::optional<unsigned>& max_
bool IsStandardTx(const CTransaction& tx, const std::optional<unsigned>& max_datacarrier_bytes, bool permit_bare_multisig, const CFeeRate& dust_relay_fee, std::string& reason) bool IsStandardTx(const CTransaction& tx, const std::optional<unsigned>& max_datacarrier_bytes, bool permit_bare_multisig, const CFeeRate& dust_relay_fee, std::string& reason)
{ {
if (tx.nVersion > TX_MAX_STANDARD_VERSION || tx.nVersion < 1) { if (tx.version > TX_MAX_STANDARD_VERSION || tx.version < 1) {
reason = "version"; reason = "version";
return false; return false;
} }

2
src/policy/policy.h
View file

@ -131,7 +131,7 @@ bool IsStandard(const CScript& scriptPubKey, const std::optional<unsigned>& max_
// Changing the default transaction version requires a two step process: first // Changing the default transaction version requires a two step process: first
// adapting relay policy by bumping TX_MAX_STANDARD_VERSION, and then later // adapting relay policy by bumping TX_MAX_STANDARD_VERSION, and then later
// allowing the new transaction version in the wallet/RPC. // allowing the new transaction version in the wallet/RPC.
static constexpr decltype(CTransaction::nVersion) TX_MAX_STANDARD_VERSION{3}; static constexpr decltype(CTransaction::version) TX_MAX_STANDARD_VERSION{3};
/** /**
* Check for standard transaction types * Check for standard transaction types

24
src/policy/v3_policy.cpp
View file

@ -43,13 +43,13 @@ struct ParentInfo {
const Txid& m_txid; const Txid& m_txid;
/** Wtxid used for debug string */ /** Wtxid used for debug string */
const Wtxid& m_wtxid; const Wtxid& m_wtxid;
/** nVersion used to check inheritance of v3 and non-v3 */ /** version used to check inheritance of v3 and non-v3 */
decltype(CTransaction::nVersion) m_version; decltype(CTransaction::version) m_version;
/** If parent is in mempool, whether it has any descendants in mempool. */ /** If parent is in mempool, whether it has any descendants in mempool. */
bool m_has_mempool_descendant; bool m_has_mempool_descendant;
ParentInfo() = delete; ParentInfo() = delete;
ParentInfo(const Txid& txid, const Wtxid& wtxid, decltype(CTransaction::nVersion) version, bool has_mempool_descendant) : ParentInfo(const Txid& txid, const Wtxid& wtxid, decltype(CTransaction::version) version, bool has_mempool_descendant) :
m_txid{txid}, m_wtxid{wtxid}, m_version{version}, m_txid{txid}, m_wtxid{wtxid}, m_version{version},
m_has_mempool_descendant{has_mempool_descendant} m_has_mempool_descendant{has_mempool_descendant}
{} {}
@ -66,7 +66,7 @@ std::optional<std::string> PackageV3Checks(const CTransactionRef& ptx, int64_t v
const auto in_package_parents{FindInPackageParents(package, ptx)}; const auto in_package_parents{FindInPackageParents(package, ptx)};
// Now we have all ancestors, so we can start checking v3 rules. // Now we have all ancestors, so we can start checking v3 rules.
if (ptx->nVersion == TRUC_VERSION) { if (ptx->version == TRUC_VERSION) {
// SingleV3Checks should have checked this already. // SingleV3Checks should have checked this already.
if (!Assume(vsize <= V3_MAX_VSIZE)) { if (!Assume(vsize <= V3_MAX_VSIZE)) {
return strprintf("v3 tx %s (wtxid=%s) is too big: %u > %u virtual bytes", return strprintf("v3 tx %s (wtxid=%s) is too big: %u > %u virtual bytes",
@ -94,14 +94,14 @@ std::optional<std::string> PackageV3Checks(const CTransactionRef& ptx, int64_t v
Assume(mempool_parent->GetCountWithDescendants() == 1); Assume(mempool_parent->GetCountWithDescendants() == 1);
return ParentInfo{mempool_parent->GetTx().GetHash(), return ParentInfo{mempool_parent->GetTx().GetHash(),
mempool_parent->GetTx().GetWitnessHash(), mempool_parent->GetTx().GetWitnessHash(),
mempool_parent->GetTx().nVersion, mempool_parent->GetTx().version,
/*has_mempool_descendant=*/mempool_parent->GetCountWithDescendants() > 1}; /*has_mempool_descendant=*/mempool_parent->GetCountWithDescendants() > 1};
} else { } else {
auto& parent_index = in_package_parents.front(); auto& parent_index = in_package_parents.front();
auto& package_parent = package.at(parent_index); auto& package_parent = package.at(parent_index);
return ParentInfo{package_parent->GetHash(), return ParentInfo{package_parent->GetHash(),
package_parent->GetWitnessHash(), package_parent->GetWitnessHash(),
package_parent->nVersion, package_parent->version,
/*has_mempool_descendant=*/false}; /*has_mempool_descendant=*/false};
} }
}(); }();
@ -146,14 +146,14 @@ std::optional<std::string> PackageV3Checks(const CTransactionRef& ptx, int64_t v
} else { } else {
// Non-v3 transactions cannot have v3 parents. // Non-v3 transactions cannot have v3 parents.
for (auto it : mempool_ancestors) { for (auto it : mempool_ancestors) {
if (it->GetTx().nVersion == TRUC_VERSION) { if (it->GetTx().version == TRUC_VERSION) {
return strprintf("non-v3 tx %s (wtxid=%s) cannot spend from v3 tx %s (wtxid=%s)", return strprintf("non-v3 tx %s (wtxid=%s) cannot spend from v3 tx %s (wtxid=%s)",
ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(), ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(),
it->GetSharedTx()->GetHash().ToString(), it->GetSharedTx()->GetWitnessHash().ToString()); it->GetSharedTx()->GetHash().ToString(), it->GetSharedTx()->GetWitnessHash().ToString());
} }
} }
for (const auto& index: in_package_parents) { for (const auto& index: in_package_parents) {
if (package.at(index)->nVersion == TRUC_VERSION) { if (package.at(index)->version == TRUC_VERSION) {
return strprintf("non-v3 tx %s (wtxid=%s) cannot spend from v3 tx %s (wtxid=%s)", return strprintf("non-v3 tx %s (wtxid=%s) cannot spend from v3 tx %s (wtxid=%s)",
ptx->GetHash().ToString(), ptx->GetHash().ToString(),
ptx->GetWitnessHash().ToString(), ptx->GetWitnessHash().ToString(),
@ -172,12 +172,12 @@ std::optional<std::pair<std::string, CTransactionRef>> SingleV3Checks(const CTra
{ {
// Check v3 and non-v3 inheritance. // Check v3 and non-v3 inheritance.
for (const auto& entry : mempool_ancestors) { for (const auto& entry : mempool_ancestors) {
if (ptx->nVersion != TRUC_VERSION && entry->GetTx().nVersion == TRUC_VERSION) { if (ptx->version != TRUC_VERSION && entry->GetTx().version == TRUC_VERSION) {
return std::make_pair(strprintf("non-v3 tx %s (wtxid=%s) cannot spend from v3 tx %s (wtxid=%s)", return std::make_pair(strprintf("non-v3 tx %s (wtxid=%s) cannot spend from v3 tx %s (wtxid=%s)",
ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(), ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(),
entry->GetSharedTx()->GetHash().ToString(), entry->GetSharedTx()->GetWitnessHash().ToString()), entry->GetSharedTx()->GetHash().ToString(), entry->GetSharedTx()->GetWitnessHash().ToString()),
nullptr); nullptr);
} else if (ptx->nVersion == TRUC_VERSION && entry->GetTx().nVersion != TRUC_VERSION) { } else if (ptx->version == TRUC_VERSION && entry->GetTx().version != TRUC_VERSION) {
return std::make_pair(strprintf("v3 tx %s (wtxid=%s) cannot spend from non-v3 tx %s (wtxid=%s)", return std::make_pair(strprintf("v3 tx %s (wtxid=%s) cannot spend from non-v3 tx %s (wtxid=%s)",
ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(), ptx->GetHash().ToString(), ptx->GetWitnessHash().ToString(),
entry->GetSharedTx()->GetHash().ToString(), entry->GetSharedTx()->GetWitnessHash().ToString()), entry->GetSharedTx()->GetHash().ToString(), entry->GetSharedTx()->GetWitnessHash().ToString()),
@ -189,8 +189,8 @@ std::optional<std::pair<std::string, CTransactionRef>> SingleV3Checks(const CTra
static_assert(V3_ANCESTOR_LIMIT == 2); static_assert(V3_ANCESTOR_LIMIT == 2);
static_assert(V3_DESCENDANT_LIMIT == 2); static_assert(V3_DESCENDANT_LIMIT == 2);
// The rest of the rules only apply to transactions with nVersion=3. // The rest of the rules only apply to transactions with version=3.
if (ptx->nVersion != TRUC_VERSION) return std::nullopt; if (ptx->version != TRUC_VERSION) return std::nullopt;
if (vsize > V3_MAX_VSIZE) { if (vsize > V3_MAX_VSIZE) {
return std::make_pair(strprintf("v3 tx %s (wtxid=%s) is too big: %u > %u virtual bytes", return std::make_pair(strprintf("v3 tx %s (wtxid=%s) is too big: %u > %u virtual bytes",

4
src/policy/v3_policy.h
View file

@ -15,9 +15,9 @@
#include <set> #include <set>
#include <string> #include <string>
// This module enforces rules for BIP 431 TRUC transactions (with nVersion=3) which help make // This module enforces rules for BIP 431 TRUC transactions (with version=3) which help make
// RBF abilities more robust. // RBF abilities more robust.
static constexpr decltype(CTransaction::nVersion) TRUC_VERSION{3}; static constexpr decltype(CTransaction::version) TRUC_VERSION{3};
// v3 only allows 1 parent and 1 child when unconfirmed. // v3 only allows 1 parent and 1 child when unconfirmed.
/** Maximum number of transactions including an unconfirmed tx and its descendants. */ /** Maximum number of transactions including an unconfirmed tx and its descendants. */

12
src/primitives/transaction.cpp
View file

@ -63,8 +63,8 @@ std::string CTxOut::ToString() const
return strprintf("CTxOut(nValue=%d.%08d, scriptPubKey=%s)", nValue / COIN, nValue % COIN, HexStr(scriptPubKey).substr(0, 30)); return strprintf("CTxOut(nValue=%d.%08d, scriptPubKey=%s)", nValue / COIN, nValue % COIN, HexStr(scriptPubKey).substr(0, 30));
} }
CMutableTransaction::CMutableTransaction() : nVersion(CTransaction::CURRENT_VERSION), nLockTime(0) {} CMutableTransaction::CMutableTransaction() : version{CTransaction::CURRENT_VERSION}, nLockTime{0} {}
CMutableTransaction::CMutableTransaction(const CTransaction& tx) : vin(tx.vin), vout(tx.vout), nVersion(tx.nVersion), nLockTime(tx.nLockTime) {} CMutableTransaction::CMutableTransaction(const CTransaction& tx) : vin(tx.vin), vout(tx.vout), version{tx.version}, nLockTime{tx.nLockTime} {}
Txid CMutableTransaction::GetHash() const Txid CMutableTransaction::GetHash() const
{ {
@ -92,8 +92,8 @@ Wtxid CTransaction::ComputeWitnessHash() const
return Wtxid::FromUint256((HashWriter{} << TX_WITH_WITNESS(*this)).GetHash()); return Wtxid::FromUint256((HashWriter{} << TX_WITH_WITNESS(*this)).GetHash());
} }
CTransaction::CTransaction(const CMutableTransaction& tx) : vin(tx.vin), vout(tx.vout), nVersion(tx.nVersion), nLockTime(tx.nLockTime), m_has_witness{ComputeHasWitness()}, hash{ComputeHash()}, m_witness_hash{ComputeWitnessHash()} {} CTransaction::CTransaction(const CMutableTransaction& tx) : vin(tx.vin), vout(tx.vout), version{tx.version}, nLockTime{tx.nLockTime}, m_has_witness{ComputeHasWitness()}, hash{ComputeHash()}, m_witness_hash{ComputeWitnessHash()} {}
CTransaction::CTransaction(CMutableTransaction&& tx) : vin(std::move(tx.vin)), vout(std::move(tx.vout)), nVersion(tx.nVersion), nLockTime(tx.nLockTime), m_has_witness{ComputeHasWitness()}, hash{ComputeHash()}, m_witness_hash{ComputeWitnessHash()} {} CTransaction::CTransaction(CMutableTransaction&& tx) : vin(std::move(tx.vin)), vout(std::move(tx.vout)), version{tx.version}, nLockTime{tx.nLockTime}, m_has_witness{ComputeHasWitness()}, hash{ComputeHash()}, m_witness_hash{ComputeWitnessHash()} {}
CAmount CTransaction::GetValueOut() const CAmount CTransaction::GetValueOut() const
{ {
@ -115,9 +115,9 @@ unsigned int CTransaction::GetTotalSize() const
std::string CTransaction::ToString() const std::string CTransaction::ToString() const
{ {
std::string str; std::string str;
str += strprintf("CTransaction(hash=%s, ver=%d, vin.size=%u, vout.size=%u, nLockTime=%u)\n", str += strprintf("CTransaction(hash=%s, ver=%u, vin.size=%u, vout.size=%u, nLockTime=%u)\n",
GetHash().ToString().substr(0,10), GetHash().ToString().substr(0,10),
nVersion, version,
vin.size(), vin.size(),
vout.size(), vout.size(),
nLockTime); nLockTime);

14
src/primitives/transaction.h
View file

@ -197,13 +197,13 @@ static constexpr TransactionSerParams TX_NO_WITNESS{.allow_witness = false};
/** /**
* Basic transaction serialization format: * Basic transaction serialization format:
* - int32_t nVersion * - uint32_t version
* - std::vector<CTxIn> vin * - std::vector<CTxIn> vin
* - std::vector<CTxOut> vout * - std::vector<CTxOut> vout
* - uint32_t nLockTime * - uint32_t nLockTime
* *
* Extended transaction serialization format: * Extended transaction serialization format:
* - int32_t nVersion * - uint32_t version
* - unsigned char dummy = 0x00 * - unsigned char dummy = 0x00
* - unsigned char flags (!= 0) * - unsigned char flags (!= 0)
* - std::vector<CTxIn> vin * - std::vector<CTxIn> vin
@ -217,7 +217,7 @@ void UnserializeTransaction(TxType& tx, Stream& s, const TransactionSerParams& p
{ {
const bool fAllowWitness = params.allow_witness; const bool fAllowWitness = params.allow_witness;
s >> tx.nVersion; s >> tx.version;
unsigned char flags = 0; unsigned char flags = 0;
tx.vin.clear(); tx.vin.clear();
tx.vout.clear(); tx.vout.clear();
@ -257,7 +257,7 @@ void SerializeTransaction(const TxType& tx, Stream& s, const TransactionSerParam
{ {
const bool fAllowWitness = params.allow_witness; const bool fAllowWitness = params.allow_witness;
s << tx.nVersion; s << tx.version;
unsigned char flags = 0; unsigned char flags = 0;
// Consistency check // Consistency check
if (fAllowWitness) { if (fAllowWitness) {
@ -296,7 +296,7 @@ class CTransaction
{ {
public: public:
// Default transaction version. // Default transaction version.
static const int32_t CURRENT_VERSION=2; static const uint32_t CURRENT_VERSION{2};
// The local variables are made const to prevent unintended modification // The local variables are made const to prevent unintended modification
// without updating the cached hash value. However, CTransaction is not // without updating the cached hash value. However, CTransaction is not
@ -305,7 +305,7 @@ public:
// structure, including the hash. // structure, including the hash.
const std::vector<CTxIn> vin; const std::vector<CTxIn> vin;
const std::vector<CTxOut> vout; const std::vector<CTxOut> vout;
const int32_t nVersion; const uint32_t version;
const uint32_t nLockTime; const uint32_t nLockTime;
private: private:
@ -378,7 +378,7 @@ struct CMutableTransaction
{ {
std::vector<CTxIn> vin; std::vector<CTxIn> vin;
std::vector<CTxOut> vout; std::vector<CTxOut> vout;
int32_t nVersion; uint32_t version;
uint32_t nLockTime; uint32_t nLockTime;
explicit CMutableTransaction(); explicit CMutableTransaction();

8
src/rpc/rawtransaction.cpp
View file

@ -1748,8 +1748,8 @@ static RPCHelpMan joinpsbts()
} }
psbtxs.push_back(psbtx); psbtxs.push_back(psbtx);
// Choose the highest version number // Choose the highest version number
if (static_cast<uint32_t>(psbtx.tx->nVersion) > best_version) { if (psbtx.tx->version > best_version) {
best_version = static_cast<uint32_t>(psbtx.tx->nVersion); best_version = psbtx.tx->version;
} }
// Choose the lowest lock time // Choose the lowest lock time
if (psbtx.tx->nLockTime < best_locktime) { if (psbtx.tx->nLockTime < best_locktime) {
@ -1760,7 +1760,7 @@ static RPCHelpMan joinpsbts()
// Create a blank psbt where everything will be added // Create a blank psbt where everything will be added
PartiallySignedTransaction merged_psbt; PartiallySignedTransaction merged_psbt;
merged_psbt.tx = CMutableTransaction(); merged_psbt.tx = CMutableTransaction();
merged_psbt.tx->nVersion = static_cast<int32_t>(best_version); merged_psbt.tx->version = best_version;
merged_psbt.tx->nLockTime = best_locktime; merged_psbt.tx->nLockTime = best_locktime;
// Merge // Merge
@ -1795,7 +1795,7 @@ static RPCHelpMan joinpsbts()
PartiallySignedTransaction shuffled_psbt; PartiallySignedTransaction shuffled_psbt;
shuffled_psbt.tx = CMutableTransaction(); shuffled_psbt.tx = CMutableTransaction();
shuffled_psbt.tx->nVersion = merged_psbt.tx->nVersion; shuffled_psbt.tx->version = merged_psbt.tx->version;
shuffled_psbt.tx->nLockTime = merged_psbt.tx->nLockTime; shuffled_psbt.tx->nLockTime = merged_psbt.tx->nLockTime;
for (int i : input_indices) { for (int i : input_indices) {
shuffled_psbt.AddInput(merged_psbt.tx->vin[i], merged_psbt.inputs[i]); shuffled_psbt.AddInput(merged_psbt.tx->vin[i], merged_psbt.inputs[i]);

10
src/script/interpreter.cpp
View file

@ -1321,8 +1321,8 @@ public:
/** Serialize txTo */ /** Serialize txTo */
template<typename S> template<typename S>
void Serialize(S &s) const { void Serialize(S &s) const {
// Serialize nVersion // Serialize version
::Serialize(s, txTo.nVersion); ::Serialize(s, txTo.version);
// Serialize vin // Serialize vin
unsigned int nInputs = fAnyoneCanPay ? 1 : txTo.vin.size(); unsigned int nInputs = fAnyoneCanPay ? 1 : txTo.vin.size();
::WriteCompactSize(s, nInputs); ::WriteCompactSize(s, nInputs);
@ -1512,7 +1512,7 @@ bool SignatureHashSchnorr(uint256& hash_out, ScriptExecutionData& execdata, cons
ss << hash_type; ss << hash_type;
// Transaction level data // Transaction level data
ss << tx_to.nVersion; ss << tx_to.version;
ss << tx_to.nLockTime; ss << tx_to.nLockTime;
if (input_type != SIGHASH_ANYONECANPAY) { if (input_type != SIGHASH_ANYONECANPAY) {
ss << cache.m_prevouts_single_hash; ss << cache.m_prevouts_single_hash;
@ -1594,7 +1594,7 @@ uint256 SignatureHash(const CScript& scriptCode, const T& txTo, unsigned int nIn
HashWriter ss{}; HashWriter ss{};
// Version // Version
ss << txTo.nVersion; ss << txTo.version;
// Input prevouts/nSequence (none/all, depending on flags) // Input prevouts/nSequence (none/all, depending on flags)
ss << hashPrevouts; ss << hashPrevouts;
ss << hashSequence; ss << hashSequence;
@ -1743,7 +1743,7 @@ bool GenericTransactionSignatureChecker<T>::CheckSequence(const CScriptNum& nSeq
// Fail if the transaction's version number is not set high // Fail if the transaction's version number is not set high
// enough to trigger BIP 68 rules. // enough to trigger BIP 68 rules.
if (static_cast<uint32_t>(txTo->nVersion) < 2) if (txTo->version < 2)
return false; return false;
// Sequence numbers with their most significant bit set are not // Sequence numbers with their most significant bit set are not

2
src/script/miniscript.h
View file

@ -251,7 +251,7 @@ namespace internal {
//! The maximum size of a witness item for a Miniscript under Tapscript context. (A BIP340 signature with a sighash type byte.) //! The maximum size of a witness item for a Miniscript under Tapscript context. (A BIP340 signature with a sighash type byte.)
static constexpr uint32_t MAX_TAPMINISCRIPT_STACK_ELEM_SIZE{65}; static constexpr uint32_t MAX_TAPMINISCRIPT_STACK_ELEM_SIZE{65};
//! nVersion + nLockTime //! version + nLockTime
constexpr uint32_t TX_OVERHEAD{4 + 4}; constexpr uint32_t TX_OVERHEAD{4 + 4};
//! prevout + nSequence + scriptSig //! prevout + nSequence + scriptSig
constexpr uint32_t TXIN_BYTES_NO_WITNESS{36 + 4 + 1}; constexpr uint32_t TXIN_BYTES_NO_WITNESS{36 + 4 + 1};

4
src/signet.cpp
View file

@ -68,13 +68,13 @@ static uint256 ComputeModifiedMerkleRoot(const CMutableTransaction& cb, const CB
std::optional<SignetTxs> SignetTxs::Create(const CBlock& block, const CScript& challenge) std::optional<SignetTxs> SignetTxs::Create(const CBlock& block, const CScript& challenge)
{ {
CMutableTransaction tx_to_spend; CMutableTransaction tx_to_spend;
tx_to_spend.nVersion = 0; tx_to_spend.version = 0;
tx_to_spend.nLockTime = 0; tx_to_spend.nLockTime = 0;
tx_to_spend.vin.emplace_back(COutPoint(), CScript(OP_0), 0); tx_to_spend.vin.emplace_back(COutPoint(), CScript(OP_0), 0);
tx_to_spend.vout.emplace_back(0, challenge); tx_to_spend.vout.emplace_back(0, challenge);
CMutableTransaction tx_spending; CMutableTransaction tx_spending;
tx_spending.nVersion = 0; tx_spending.version = 0;
tx_spending.nLockTime = 0; tx_spending.nLockTime = 0;
tx_spending.vin.emplace_back(COutPoint(), CScript(), 0); tx_spending.vin.emplace_back(COutPoint(), CScript(), 0);
tx_spending.vout.emplace_back(0, CScript(OP_RETURN)); tx_spending.vout.emplace_back(0, CScript(OP_RETURN));

2
src/test/data/tx_invalid.json
View file

@ -246,7 +246,7 @@
[[["0000000000000000000000000000000000000000000000000000000000000100", 0, "HASH160 0x14 0x7c17aff532f22beb54069942f9bf567a66133eaf EQUAL"]], [[["0000000000000000000000000000000000000000000000000000000000000100", 0, "HASH160 0x14 0x7c17aff532f22beb54069942f9bf567a66133eaf EQUAL"]],
"0200000001000100000000000000000000000000000000000000000000000000000000000000000000030251b2000000000100000000000000000000000000", "P2SH,CHECKSEQUENCEVERIFY"], "0200000001000100000000000000000000000000000000000000000000000000000000000000000000030251b2000000000100000000000000000000000000", "P2SH,CHECKSEQUENCEVERIFY"],
["Failure due to insufficient tx.nVersion (<2)"], ["Failure due to insufficient tx.version (<2)"],
[[["0000000000000000000000000000000000000000000000000000000000000100", 0, "0 CHECKSEQUENCEVERIFY 1"]], [[["0000000000000000000000000000000000000000000000000000000000000100", 0, "0 CHECKSEQUENCEVERIFY 1"]],
"010000000100010000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000", "CHECKSEQUENCEVERIFY"], "010000000100010000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000", "CHECKSEQUENCEVERIFY"],
[[["0000000000000000000000000000000000000000000000000000000000000100", 0, "4194304 CHECKSEQUENCEVERIFY"]], [[["0000000000000000000000000000000000000000000000000000000000000100", 0, "4194304 CHECKSEQUENCEVERIFY"]],

2
src/test/fuzz/package_eval.cpp
View file

@ -180,7 +180,7 @@ FUZZ_TARGET(tx_package_eval, .init = initialize_tx_pool)
// Create transaction to add to the mempool // Create transaction to add to the mempool
const CTransactionRef tx = [&] { const CTransactionRef tx = [&] {
CMutableTransaction tx_mut; CMutableTransaction tx_mut;
tx_mut.nVersion = fuzzed_data_provider.ConsumeBool() ? TRUC_VERSION : CTransaction::CURRENT_VERSION; tx_mut.version = fuzzed_data_provider.ConsumeBool() ? TRUC_VERSION : CTransaction::CURRENT_VERSION;
tx_mut.nLockTime = fuzzed_data_provider.ConsumeBool() ? 0 : fuzzed_data_provider.ConsumeIntegral<uint32_t>(); tx_mut.nLockTime = fuzzed_data_provider.ConsumeBool() ? 0 : fuzzed_data_provider.ConsumeIntegral<uint32_t>();
// Last tx will sweep all outpoints in package // Last tx will sweep all outpoints in package
const auto num_in = last_tx ? package_outpoints.size() : fuzzed_data_provider.ConsumeIntegralInRange<int>(1, mempool_outpoints.size()); const auto num_in = last_tx ? package_outpoints.size() : fuzzed_data_provider.ConsumeIntegralInRange<int>(1, mempool_outpoints.size());

2
src/test/fuzz/tx_pool.cpp
View file

@ -233,7 +233,7 @@ FUZZ_TARGET(tx_pool_standard, .init = initialize_tx_pool)
// Create transaction to add to the mempool // Create transaction to add to the mempool
const CTransactionRef tx = [&] { const CTransactionRef tx = [&] {
CMutableTransaction tx_mut; CMutableTransaction tx_mut;
tx_mut.nVersion = fuzzed_data_provider.ConsumeBool() ? TRUC_VERSION : CTransaction::CURRENT_VERSION; tx_mut.version = fuzzed_data_provider.ConsumeBool() ? TRUC_VERSION : CTransaction::CURRENT_VERSION;
tx_mut.nLockTime = fuzzed_data_provider.ConsumeBool() ? 0 : fuzzed_data_provider.ConsumeIntegral<uint32_t>(); tx_mut.nLockTime = fuzzed_data_provider.ConsumeBool() ? 0 : fuzzed_data_provider.ConsumeIntegral<uint32_t>();
const auto num_in = fuzzed_data_provider.ConsumeIntegralInRange<int>(1, outpoints_rbf.size()); const auto num_in = fuzzed_data_provider.ConsumeIntegralInRange<int>(1, outpoints_rbf.size());
const auto num_out = fuzzed_data_provider.ConsumeIntegralInRange<int>(1, outpoints_rbf.size() * 2); const auto num_out = fuzzed_data_provider.ConsumeIntegralInRange<int>(1, outpoints_rbf.size() * 2);

4
src/test/fuzz/util.cpp
View file

@ -43,9 +43,9 @@ CMutableTransaction ConsumeTransaction(FuzzedDataProvider& fuzzed_data_provider,
{ {
CMutableTransaction tx_mut; CMutableTransaction tx_mut;
const auto p2wsh_op_true = fuzzed_data_provider.ConsumeBool(); const auto p2wsh_op_true = fuzzed_data_provider.ConsumeBool();
tx_mut.nVersion = fuzzed_data_provider.ConsumeBool() ? tx_mut.version = fuzzed_data_provider.ConsumeBool() ?
CTransaction::CURRENT_VERSION : CTransaction::CURRENT_VERSION :
fuzzed_data_provider.ConsumeIntegral<int32_t>(); fuzzed_data_provider.ConsumeIntegral<uint32_t>();
tx_mut.nLockTime = fuzzed_data_provider.ConsumeIntegral<uint32_t>(); tx_mut.nLockTime = fuzzed_data_provider.ConsumeIntegral<uint32_t>();
const auto num_in = fuzzed_data_provider.ConsumeIntegralInRange<int>(0, max_num_in); const auto num_in = fuzzed_data_provider.ConsumeIntegralInRange<int>(0, max_num_in);
const auto num_out = fuzzed_data_provider.ConsumeIntegralInRange<int>(0, max_num_out); const auto num_out = fuzzed_data_provider.ConsumeIntegralInRange<int>(0, max_num_out);

4
src/test/hash_tests.cpp
View file

@ -124,9 +124,9 @@ BOOST_AUTO_TEST_CASE(siphash)
HashWriter ss{}; HashWriter ss{};
CMutableTransaction tx; CMutableTransaction tx;
// Note these tests were originally written with tx.nVersion=1 // Note these tests were originally written with tx.version=1
// and the test would be affected by default tx version bumps if not fixed. // and the test would be affected by default tx version bumps if not fixed.
tx.nVersion = 1; tx.version = 1;
ss << TX_WITH_WITNESS(tx); ss << TX_WITH_WITNESS(tx);
BOOST_CHECK_EQUAL(SipHashUint256(1, 2, ss.GetHash()), 0x79751e980c2a0a35ULL); BOOST_CHECK_EQUAL(SipHashUint256(1, 2, ss.GetHash()), 0x79751e980c2a0a35ULL);

4
src/test/miner_tests.cpp
View file

@ -425,7 +425,7 @@ void MinerTestingSetup::TestBasicMining(const CScript& scriptPubKey, const std::
std::vector<int> prevheights; std::vector<int> prevheights;
// relative height locked // relative height locked
tx.nVersion = 2; tx.version = 2;
tx.vin.resize(1); tx.vin.resize(1);
prevheights.resize(1); prevheights.resize(1);
tx.vin[0].prevout.hash = txFirst[0]->GetHash(); // only 1 transaction tx.vin[0].prevout.hash = txFirst[0]->GetHash(); // only 1 transaction
@ -626,7 +626,7 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
pblock->nVersion = VERSIONBITS_TOP_BITS; pblock->nVersion = VERSIONBITS_TOP_BITS;
pblock->nTime = m_node.chainman->ActiveChain().Tip()->GetMedianTimePast()+1; pblock->nTime = m_node.chainman->ActiveChain().Tip()->GetMedianTimePast()+1;
CMutableTransaction txCoinbase(*pblock->vtx[0]); CMutableTransaction txCoinbase(*pblock->vtx[0]);
txCoinbase.nVersion = 1; txCoinbase.version = 1;
txCoinbase.vin[0].scriptSig = CScript{} << (m_node.chainman->ActiveChain().Height() + 1) << bi.extranonce; txCoinbase.vin[0].scriptSig = CScript{} << (m_node.chainman->ActiveChain().Height() + 1) << bi.extranonce;
txCoinbase.vout.resize(1); // Ignore the (optional) segwit commitment added by CreateNewBlock (as the hardcoded nonces don't account for this) txCoinbase.vout.resize(1); // Ignore the (optional) segwit commitment added by CreateNewBlock (as the hardcoded nonces don't account for this)
txCoinbase.vout[0].scriptPubKey = CScript(); txCoinbase.vout[0].scriptPubKey = CScript();

2
src/test/sighash_tests.cpp
View file

@ -92,7 +92,7 @@ void static RandomScript(CScript &script) {
void static RandomTransaction(CMutableTransaction& tx, bool fSingle) void static RandomTransaction(CMutableTransaction& tx, bool fSingle)
{ {
tx.nVersion = int(InsecureRand32()); tx.version = InsecureRand32();
tx.vin.clear(); tx.vin.clear();
tx.vout.clear(); tx.vout.clear();
tx.nLockTime = (InsecureRandBool()) ? InsecureRand32() : 0; tx.nLockTime = (InsecureRandBool()) ? InsecureRand32() : 0;

4
src/test/sigopcount_tests.cpp
View file

@ -86,7 +86,7 @@ static ScriptError VerifyWithFlag(const CTransaction& output, const CMutableTran
*/ */
static void BuildTxs(CMutableTransaction& spendingTx, CCoinsViewCache& coins, CMutableTransaction& creationTx, const CScript& scriptPubKey, const CScript& scriptSig, const CScriptWitness& witness) static void BuildTxs(CMutableTransaction& spendingTx, CCoinsViewCache& coins, CMutableTransaction& creationTx, const CScript& scriptPubKey, const CScript& scriptSig, const CScriptWitness& witness)
{ {
creationTx.nVersion = 1; creationTx.version = 1;
creationTx.vin.resize(1); creationTx.vin.resize(1);
creationTx.vin[0].prevout.SetNull(); creationTx.vin[0].prevout.SetNull();
creationTx.vin[0].scriptSig = CScript(); creationTx.vin[0].scriptSig = CScript();
@ -94,7 +94,7 @@ static void BuildTxs(CMutableTransaction& spendingTx, CCoinsViewCache& coins, CM
creationTx.vout[0].nValue = 1; creationTx.vout[0].nValue = 1;
creationTx.vout[0].scriptPubKey = scriptPubKey; creationTx.vout[0].scriptPubKey = scriptPubKey;
spendingTx.nVersion = 1; spendingTx.version = 1;
spendingTx.vin.resize(1); spendingTx.vin.resize(1);
spendingTx.vin[0].prevout.hash = creationTx.GetHash(); spendingTx.vin[0].prevout.hash = creationTx.GetHash();
spendingTx.vin[0].prevout.n = 0; spendingTx.vin[0].prevout.n = 0;

20
src/test/transaction_tests.cpp
View file

@ -412,7 +412,7 @@ BOOST_AUTO_TEST_CASE(test_Get)
static void CreateCreditAndSpend(const FillableSigningProvider& keystore, const CScript& outscript, CTransactionRef& output, CMutableTransaction& input, bool success = true) static void CreateCreditAndSpend(const FillableSigningProvider& keystore, const CScript& outscript, CTransactionRef& output, CMutableTransaction& input, bool success = true)
{ {
CMutableTransaction outputm; CMutableTransaction outputm;
outputm.nVersion = 1; outputm.version = 1;
outputm.vin.resize(1); outputm.vin.resize(1);
outputm.vin[0].prevout.SetNull(); outputm.vin[0].prevout.SetNull();
outputm.vin[0].scriptSig = CScript(); outputm.vin[0].scriptSig = CScript();
@ -428,7 +428,7 @@ static void CreateCreditAndSpend(const FillableSigningProvider& keystore, const
assert(output->vout[0] == outputm.vout[0]); assert(output->vout[0] == outputm.vout[0]);
CMutableTransaction inputm; CMutableTransaction inputm;
inputm.nVersion = 1; inputm.version = 1;
inputm.vin.resize(1); inputm.vin.resize(1);
inputm.vin[0].prevout.hash = output->GetHash(); inputm.vin[0].prevout.hash = output->GetHash();
inputm.vin[0].prevout.n = 0; inputm.vin[0].prevout.n = 0;
@ -485,7 +485,7 @@ static void ReplaceRedeemScript(CScript& script, const CScript& redeemScript)
BOOST_AUTO_TEST_CASE(test_big_witness_transaction) BOOST_AUTO_TEST_CASE(test_big_witness_transaction)
{ {
CMutableTransaction mtx; CMutableTransaction mtx;
mtx.nVersion = 1; mtx.version = 1;
CKey key = GenerateRandomKey(); // Need to use compressed keys in segwit or the signing will fail CKey key = GenerateRandomKey(); // Need to use compressed keys in segwit or the signing will fail
FillableSigningProvider keystore; FillableSigningProvider keystore;
@ -779,21 +779,21 @@ BOOST_AUTO_TEST_CASE(test_IsStandard)
t.vout[0].nValue = nDustThreshold; t.vout[0].nValue = nDustThreshold;
CheckIsStandard(t); CheckIsStandard(t);
// Disallowed nVersion // Disallowed version
t.nVersion = -1; t.version = std::numeric_limits<uint32_t>::max();
CheckIsNotStandard(t, "version"); CheckIsNotStandard(t, "version");
t.nVersion = 0; t.version = 0;
CheckIsNotStandard(t, "version"); CheckIsNotStandard(t, "version");
t.nVersion = TX_MAX_STANDARD_VERSION + 1; t.version = TX_MAX_STANDARD_VERSION + 1;
CheckIsNotStandard(t, "version"); CheckIsNotStandard(t, "version");
// Allowed nVersion // Allowed version
t.nVersion = 1; t.version = 1;
CheckIsStandard(t); CheckIsStandard(t);
t.nVersion = 2; t.version = 2;
CheckIsStandard(t); CheckIsStandard(t);
// Check dust with odd relay fee to verify rounding: // Check dust with odd relay fee to verify rounding:

4
src/test/txpackage_tests.cpp
View file

@ -523,7 +523,7 @@ BOOST_FIXTURE_TEST_CASE(package_witness_swap_tests, TestChain100Setup)
CKey child_key = GenerateRandomKey(); CKey child_key = GenerateRandomKey();
CScript child_locking_script = GetScriptForDestination(WitnessV0KeyHash(child_key.GetPubKey())); CScript child_locking_script = GetScriptForDestination(WitnessV0KeyHash(child_key.GetPubKey()));
CMutableTransaction mtx_child1; CMutableTransaction mtx_child1;
mtx_child1.nVersion = 1; mtx_child1.version = 1;
mtx_child1.vin.resize(1); mtx_child1.vin.resize(1);
mtx_child1.vin[0].prevout.hash = ptx_parent->GetHash(); mtx_child1.vin[0].prevout.hash = ptx_parent->GetHash();
mtx_child1.vin[0].prevout.n = 0; mtx_child1.vin[0].prevout.n = 0;
@ -651,7 +651,7 @@ BOOST_FIXTURE_TEST_CASE(package_witness_swap_tests, TestChain100Setup)
CTransactionRef ptx_grandparent2 = MakeTransactionRef(mtx_grandparent2); CTransactionRef ptx_grandparent2 = MakeTransactionRef(mtx_grandparent2);
CMutableTransaction mtx_parent2_v1; CMutableTransaction mtx_parent2_v1;
mtx_parent2_v1.nVersion = 1; mtx_parent2_v1.version = 1;
mtx_parent2_v1.vin.resize(1); mtx_parent2_v1.vin.resize(1);
mtx_parent2_v1.vin[0].prevout.hash = ptx_grandparent2->GetHash(); mtx_parent2_v1.vin[0].prevout.hash = ptx_grandparent2->GetHash();
mtx_parent2_v1.vin[0].prevout.n = 0; mtx_parent2_v1.vin[0].prevout.n = 0;

8
src/test/txvalidation_tests.cpp
View file

@ -27,7 +27,7 @@ BOOST_FIXTURE_TEST_CASE(tx_mempool_reject_coinbase, TestChain100Setup)
CScript scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG; CScript scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
CMutableTransaction coinbaseTx; CMutableTransaction coinbaseTx;
coinbaseTx.nVersion = 1; coinbaseTx.version = 1;
coinbaseTx.vin.resize(1); coinbaseTx.vin.resize(1);
coinbaseTx.vout.resize(1); coinbaseTx.vout.resize(1);
coinbaseTx.vin[0].scriptSig = CScript() << OP_11 << OP_EQUAL; coinbaseTx.vin[0].scriptSig = CScript() << OP_11 << OP_EQUAL;
@ -72,11 +72,11 @@ static inline std::vector<CPubKey> random_keys(size_t num_keys) {
return keys; return keys;
} }
// Creates a placeholder tx (not valid) with 25 outputs. Specify the nVersion and the inputs. // Creates a placeholder tx (not valid) with 25 outputs. Specify the version and the inputs.
static inline CTransactionRef make_tx(const std::vector<COutPoint>& inputs, int32_t version) static inline CTransactionRef make_tx(const std::vector<COutPoint>& inputs, int32_t version)
{ {
CMutableTransaction mtx = CMutableTransaction{}; CMutableTransaction mtx = CMutableTransaction{};
mtx.nVersion = version; mtx.version = version;
mtx.vin.resize(inputs.size()); mtx.vin.resize(inputs.size());
mtx.vout.resize(25); mtx.vout.resize(25);
for (size_t i{0}; i < inputs.size(); ++i) { for (size_t i{0}; i < inputs.size(); ++i) {
@ -286,7 +286,7 @@ BOOST_FIXTURE_TEST_CASE(version3_tests, RegTestingSetup)
script_multisig << OP_2 << OP_CHECKMULTISIG; script_multisig << OP_2 << OP_CHECKMULTISIG;
{ {
CMutableTransaction mtx_many_sigops = CMutableTransaction{}; CMutableTransaction mtx_many_sigops = CMutableTransaction{};
mtx_many_sigops.nVersion = TRUC_VERSION; mtx_many_sigops.version = TRUC_VERSION;
for (const auto& outpoint : multisig_outpoints) { for (const auto& outpoint : multisig_outpoints) {
mtx_many_sigops.vin.emplace_back(outpoint); mtx_many_sigops.vin.emplace_back(outpoint);
mtx_many_sigops.vin.back().scriptWitness.stack.emplace_back(script_multisig.begin(), script_multisig.end()); mtx_many_sigops.vin.back().scriptWitness.stack.emplace_back(script_multisig.begin(), script_multisig.end());

14
src/test/txvalidationcache_tests.cpp
View file

@ -46,7 +46,7 @@ BOOST_FIXTURE_TEST_CASE(tx_mempool_block_doublespend, Dersig100Setup)
spends.resize(2); spends.resize(2);
for (int i = 0; i < 2; i++) for (int i = 0; i < 2; i++)
{ {
spends[i].nVersion = 1; spends[i].version = 1;
spends[i].vin.resize(1); spends[i].vin.resize(1);
spends[i].vin[0].prevout.hash = m_coinbase_txns[0]->GetHash(); spends[i].vin[0].prevout.hash = m_coinbase_txns[0]->GetHash();
spends[i].vin[0].prevout.n = 0; spends[i].vin[0].prevout.n = 0;
@ -181,7 +181,7 @@ BOOST_FIXTURE_TEST_CASE(checkinputs_test, Dersig100Setup)
// coinbase tx. // coinbase tx.
CMutableTransaction spend_tx; CMutableTransaction spend_tx;
spend_tx.nVersion = 1; spend_tx.version = 1;
spend_tx.vin.resize(1); spend_tx.vin.resize(1);
spend_tx.vin[0].prevout.hash = m_coinbase_txns[0]->GetHash(); spend_tx.vin[0].prevout.hash = m_coinbase_txns[0]->GetHash();
spend_tx.vin[0].prevout.n = 0; spend_tx.vin[0].prevout.n = 0;
@ -243,7 +243,7 @@ BOOST_FIXTURE_TEST_CASE(checkinputs_test, Dersig100Setup)
// then test validity with P2SH. // then test validity with P2SH.
{ {
CMutableTransaction invalid_under_p2sh_tx; CMutableTransaction invalid_under_p2sh_tx;
invalid_under_p2sh_tx.nVersion = 1; invalid_under_p2sh_tx.version = 1;
invalid_under_p2sh_tx.vin.resize(1); invalid_under_p2sh_tx.vin.resize(1);
invalid_under_p2sh_tx.vin[0].prevout.hash = spend_tx.GetHash(); invalid_under_p2sh_tx.vin[0].prevout.hash = spend_tx.GetHash();
invalid_under_p2sh_tx.vin[0].prevout.n = 0; invalid_under_p2sh_tx.vin[0].prevout.n = 0;
@ -259,7 +259,7 @@ BOOST_FIXTURE_TEST_CASE(checkinputs_test, Dersig100Setup)
// Test CHECKLOCKTIMEVERIFY // Test CHECKLOCKTIMEVERIFY
{ {
CMutableTransaction invalid_with_cltv_tx; CMutableTransaction invalid_with_cltv_tx;
invalid_with_cltv_tx.nVersion = 1; invalid_with_cltv_tx.version = 1;
invalid_with_cltv_tx.nLockTime = 100; invalid_with_cltv_tx.nLockTime = 100;
invalid_with_cltv_tx.vin.resize(1); invalid_with_cltv_tx.vin.resize(1);
invalid_with_cltv_tx.vin[0].prevout.hash = spend_tx.GetHash(); invalid_with_cltv_tx.vin[0].prevout.hash = spend_tx.GetHash();
@ -288,7 +288,7 @@ BOOST_FIXTURE_TEST_CASE(checkinputs_test, Dersig100Setup)
// TEST CHECKSEQUENCEVERIFY // TEST CHECKSEQUENCEVERIFY
{ {
CMutableTransaction invalid_with_csv_tx; CMutableTransaction invalid_with_csv_tx;
invalid_with_csv_tx.nVersion = 2; invalid_with_csv_tx.version = 2;
invalid_with_csv_tx.vin.resize(1); invalid_with_csv_tx.vin.resize(1);
invalid_with_csv_tx.vin[0].prevout.hash = spend_tx.GetHash(); invalid_with_csv_tx.vin[0].prevout.hash = spend_tx.GetHash();
invalid_with_csv_tx.vin[0].prevout.n = 3; invalid_with_csv_tx.vin[0].prevout.n = 3;
@ -319,7 +319,7 @@ BOOST_FIXTURE_TEST_CASE(checkinputs_test, Dersig100Setup)
// for the same tx with a different witness. // for the same tx with a different witness.
{ {
CMutableTransaction valid_with_witness_tx; CMutableTransaction valid_with_witness_tx;
valid_with_witness_tx.nVersion = 1; valid_with_witness_tx.version = 1;
valid_with_witness_tx.vin.resize(1); valid_with_witness_tx.vin.resize(1);
valid_with_witness_tx.vin[0].prevout.hash = spend_tx.GetHash(); valid_with_witness_tx.vin[0].prevout.hash = spend_tx.GetHash();
valid_with_witness_tx.vin[0].prevout.n = 1; valid_with_witness_tx.vin[0].prevout.n = 1;
@ -344,7 +344,7 @@ BOOST_FIXTURE_TEST_CASE(checkinputs_test, Dersig100Setup)
// Test a transaction with multiple inputs. // Test a transaction with multiple inputs.
CMutableTransaction tx; CMutableTransaction tx;
tx.nVersion = 1; tx.version = 1;
tx.vin.resize(2); tx.vin.resize(2);
tx.vin[0].prevout.hash = spend_tx.GetHash(); tx.vin[0].prevout.hash = spend_tx.GetHash();
tx.vin[0].prevout.n = 0; tx.vin[0].prevout.n = 0;

4
src/test/util/transaction_utils.cpp
View file

@ -9,7 +9,7 @@
CMutableTransaction BuildCreditingTransaction(const CScript& scriptPubKey, int nValue) CMutableTransaction BuildCreditingTransaction(const CScript& scriptPubKey, int nValue)
{ {
CMutableTransaction txCredit; CMutableTransaction txCredit;
txCredit.nVersion = 1; txCredit.version = 1;
txCredit.nLockTime = 0; txCredit.nLockTime = 0;
txCredit.vin.resize(1); txCredit.vin.resize(1);
txCredit.vout.resize(1); txCredit.vout.resize(1);
@ -25,7 +25,7 @@ CMutableTransaction BuildCreditingTransaction(const CScript& scriptPubKey, int n
CMutableTransaction BuildSpendingTransaction(const CScript& scriptSig, const CScriptWitness& scriptWitness, const CTransaction& txCredit) CMutableTransaction BuildSpendingTransaction(const CScript& scriptSig, const CScriptWitness& scriptWitness, const CTransaction& txCredit)
{ {
CMutableTransaction txSpend; CMutableTransaction txSpend;
txSpend.nVersion = 1; txSpend.version = 1;
txSpend.nLockTime = 0; txSpend.nLockTime = 0;
txSpend.vin.resize(1); txSpend.vin.resize(1);
txSpend.vout.resize(1); txSpend.vout.resize(1);

6
src/test/util/txmempool.cpp
View file

@ -118,7 +118,7 @@ void CheckMempoolV3Invariants(const CTxMemPool& tx_pool)
LOCK(tx_pool.cs); LOCK(tx_pool.cs);
for (const auto& tx_info : tx_pool.infoAll()) { for (const auto& tx_info : tx_pool.infoAll()) {
const auto& entry = *Assert(tx_pool.GetEntry(tx_info.tx->GetHash())); const auto& entry = *Assert(tx_pool.GetEntry(tx_info.tx->GetHash()));
if (tx_info.tx->nVersion == TRUC_VERSION) { if (tx_info.tx->version == TRUC_VERSION) {
// Check that special maximum virtual size is respected // Check that special maximum virtual size is respected
Assert(entry.GetTxSize() <= V3_MAX_VSIZE); Assert(entry.GetTxSize() <= V3_MAX_VSIZE);
@ -133,12 +133,12 @@ void CheckMempoolV3Invariants(const CTxMemPool& tx_pool)
Assert(entry.GetTxSize() <= V3_CHILD_MAX_VSIZE); Assert(entry.GetTxSize() <= V3_CHILD_MAX_VSIZE);
// All v3 transactions must only have v3 unconfirmed parents. // All v3 transactions must only have v3 unconfirmed parents.
const auto& parents = entry.GetMemPoolParentsConst(); const auto& parents = entry.GetMemPoolParentsConst();
Assert(parents.begin()->get().GetSharedTx()->nVersion == TRUC_VERSION); Assert(parents.begin()->get().GetSharedTx()->version == TRUC_VERSION);
} }
} else if (entry.GetCountWithAncestors() > 1) { } else if (entry.GetCountWithAncestors() > 1) {
// All non-v3 transactions must only have non-v3 unconfirmed parents. // All non-v3 transactions must only have non-v3 unconfirmed parents.
for (const auto& parent : entry.GetMemPoolParentsConst()) { for (const auto& parent : entry.GetMemPoolParentsConst()) {
Assert(parent.get().GetSharedTx()->nVersion != TRUC_VERSION); Assert(parent.get().GetSharedTx()->version != TRUC_VERSION);
} }
} }
} }

6
src/validation.cpp
View file

@ -831,7 +831,7 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
// //
// Replaceability signaling of the original transactions may be // Replaceability signaling of the original transactions may be
// ignored due to node setting. // ignored due to node setting.
const bool allow_rbf{m_pool.m_opts.full_rbf || SignalsOptInRBF(*ptxConflicting) || ptxConflicting->nVersion == TRUC_VERSION}; const bool allow_rbf{m_pool.m_opts.full_rbf || SignalsOptInRBF(*ptxConflicting) || ptxConflicting->version == TRUC_VERSION};
if (!allow_rbf) { if (!allow_rbf) {
return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "txn-mempool-conflict"); return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "txn-mempool-conflict");
} }
@ -935,7 +935,7 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
// method of ensuring the tx remains bumped. For example, the fee-bumping child could disappear // method of ensuring the tx remains bumped. For example, the fee-bumping child could disappear
// due to a replacement. // due to a replacement.
// The only exception is v3 transactions. // The only exception is v3 transactions.
if (!bypass_limits && ws.m_ptx->nVersion != TRUC_VERSION && ws.m_modified_fees < m_pool.m_opts.min_relay_feerate.GetFee(ws.m_vsize)) { if (!bypass_limits && ws.m_ptx->version != TRUC_VERSION && ws.m_modified_fees < m_pool.m_opts.min_relay_feerate.GetFee(ws.m_vsize)) {
// Even though this is a fee-related failure, this result is TX_MEMPOOL_POLICY, not // Even though this is a fee-related failure, this result is TX_MEMPOOL_POLICY, not
// TX_RECONSIDERABLE, because it cannot be bypassed using package validation. // TX_RECONSIDERABLE, because it cannot be bypassed using package validation.
return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "min relay fee not met", return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "min relay fee not met",
@ -1017,7 +1017,7 @@ bool MemPoolAccept::PreChecks(ATMPArgs& args, Workspace& ws)
.descendant_count = maybe_rbf_limits.descendant_count + 1, .descendant_count = maybe_rbf_limits.descendant_count + 1,
.descendant_size_vbytes = maybe_rbf_limits.descendant_size_vbytes + EXTRA_DESCENDANT_TX_SIZE_LIMIT, .descendant_size_vbytes = maybe_rbf_limits.descendant_size_vbytes + EXTRA_DESCENDANT_TX_SIZE_LIMIT,
}; };
if (ws.m_vsize > EXTRA_DESCENDANT_TX_SIZE_LIMIT || ws.m_ptx->nVersion == TRUC_VERSION) { if (ws.m_vsize > EXTRA_DESCENDANT_TX_SIZE_LIMIT || ws.m_ptx->version == TRUC_VERSION) {
return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "too-long-mempool-chain", error_message); return state.Invalid(TxValidationResult::TX_MEMPOOL_POLICY, "too-long-mempool-chain", error_message);
} }
if (auto ancestors_retry{m_pool.CalculateMemPoolAncestors(*entry, cpfp_carve_out_limits)}) { if (auto ancestors_retry{m_pool.CalculateMemPoolAncestors(*entry, cpfp_carve_out_limits)}) {

8
src/wallet/spend.cpp
View file

@ -132,7 +132,7 @@ static std::optional<int64_t> GetSignedTxinWeight(const CWallet* wallet, const C
// txouts needs to be in the order of tx.vin // txouts needs to be in the order of tx.vin
TxSize CalculateMaximumSignedTxSize(const CTransaction &tx, const CWallet *wallet, const std::vector<CTxOut>& txouts, const CCoinControl* coin_control) TxSize CalculateMaximumSignedTxSize(const CTransaction &tx, const CWallet *wallet, const std::vector<CTxOut>& txouts, const CCoinControl* coin_control)
{ {
// nVersion + nLockTime + input count + output count // version + nLockTime + input count + output count
int64_t weight = (4 + 4 + GetSizeOfCompactSize(tx.vin.size()) + GetSizeOfCompactSize(tx.vout.size())) * WITNESS_SCALE_FACTOR; int64_t weight = (4 + 4 + GetSizeOfCompactSize(tx.vin.size()) + GetSizeOfCompactSize(tx.vout.size())) * WITNESS_SCALE_FACTOR;
// Whether any input spends a witness program. Necessary to run before the next loop over the // Whether any input spends a witness program. Necessary to run before the next loop over the
// inputs in order to accurately compute the compactSize length for the witness data per input. // inputs in order to accurately compute the compactSize length for the witness data per input.
@ -985,7 +985,7 @@ static util::Result<CreatedTransactionResult> CreateTransactionInternal(
CMutableTransaction txNew; // The resulting transaction that we make CMutableTransaction txNew; // The resulting transaction that we make
if (coin_control.m_version) { if (coin_control.m_version) {
txNew.nVersion = coin_control.m_version.value(); txNew.version = coin_control.m_version.value();
} }
CoinSelectionParams coin_selection_params{rng_fast}; // Parameters for coin selection, init with dummy CoinSelectionParams coin_selection_params{rng_fast}; // Parameters for coin selection, init with dummy
@ -1084,7 +1084,7 @@ static util::Result<CreatedTransactionResult> CreateTransactionInternal(
const auto change_spend_fee = coin_selection_params.m_discard_feerate.GetFee(coin_selection_params.change_spend_size); const auto change_spend_fee = coin_selection_params.m_discard_feerate.GetFee(coin_selection_params.change_spend_size);
coin_selection_params.min_viable_change = std::max(change_spend_fee + 1, dust); coin_selection_params.min_viable_change = std::max(change_spend_fee + 1, dust);
// Static vsize overhead + outputs vsize. 4 nVersion, 4 nLocktime, 1 input count, 1 witness overhead (dummy, flag, stack size) // Static vsize overhead + outputs vsize. 4 version, 4 nLocktime, 1 input count, 1 witness overhead (dummy, flag, stack size)
coin_selection_params.tx_noinputs_size = 10 + GetSizeOfCompactSize(vecSend.size()); // bytes for output count coin_selection_params.tx_noinputs_size = 10 + GetSizeOfCompactSize(vecSend.size()); // bytes for output count
// vouts to the payees // vouts to the payees
@ -1394,7 +1394,7 @@ util::Result<CreatedTransactionResult> FundTransaction(CWallet& wallet, const CM
coinControl.m_locktime = tx.nLockTime; coinControl.m_locktime = tx.nLockTime;
// Set the user desired version // Set the user desired version
coinControl.m_version = tx.nVersion; coinControl.m_version = tx.version;
// Acquire the locks to prevent races to the new locked unspents between the // Acquire the locks to prevent races to the new locked unspents between the
// CreateTransaction call and LockCoin calls (when lockUnspents is true). // CreateTransaction call and LockCoin calls (when lockUnspents is true).

18
test/functional/feature_bip68_sequence.py
View file

@ -78,8 +78,8 @@ class BIP68Test(BitcoinTestFramework):
self.log.info("Activating BIP68 (and 112/113)") self.log.info("Activating BIP68 (and 112/113)")
self.activateCSV() self.activateCSV()
self.log.info("Verifying nVersion=2 transactions are standard.") self.log.info("Verifying version=2 transactions are standard.")
self.log.info("Note that nVersion=2 transactions are always standard (independent of BIP68 activation status).") self.log.info("Note that version=2 transactions are always standard (independent of BIP68 activation status).")
self.test_version2_relay() self.test_version2_relay()
self.log.info("Passed") self.log.info("Passed")
@ -107,7 +107,7 @@ class BIP68Test(BitcoinTestFramework):
# This transaction will enable sequence-locks, so this transaction should # This transaction will enable sequence-locks, so this transaction should
# fail # fail
tx2 = CTransaction() tx2 = CTransaction()
tx2.nVersion = 2 tx2.version = 2
sequence_value = sequence_value & 0x7fffffff sequence_value = sequence_value & 0x7fffffff
tx2.vin = [CTxIn(COutPoint(tx1_id, 0), nSequence=sequence_value)] tx2.vin = [CTxIn(COutPoint(tx1_id, 0), nSequence=sequence_value)]
tx2.wit.vtxinwit = [CTxInWitness()] tx2.wit.vtxinwit = [CTxInWitness()]
@ -119,7 +119,7 @@ class BIP68Test(BitcoinTestFramework):
# Setting the version back down to 1 should disable the sequence lock, # Setting the version back down to 1 should disable the sequence lock,
# so this should be accepted. # so this should be accepted.
tx2.nVersion = 1 tx2.version = 1
self.wallet.sendrawtransaction(from_node=self.nodes[0], tx_hex=tx2.serialize().hex()) self.wallet.sendrawtransaction(from_node=self.nodes[0], tx_hex=tx2.serialize().hex())
@ -159,7 +159,7 @@ class BIP68Test(BitcoinTestFramework):
using_sequence_locks = False using_sequence_locks = False
tx = CTransaction() tx = CTransaction()
tx.nVersion = 2 tx.version = 2
value = 0 value = 0
for j in range(num_inputs): for j in range(num_inputs):
sequence_value = 0xfffffffe # this disables sequence locks sequence_value = 0xfffffffe # this disables sequence locks
@ -228,7 +228,7 @@ class BIP68Test(BitcoinTestFramework):
# Anyone-can-spend mempool tx. # Anyone-can-spend mempool tx.
# Sequence lock of 0 should pass. # Sequence lock of 0 should pass.
tx2 = CTransaction() tx2 = CTransaction()
tx2.nVersion = 2 tx2.version = 2
tx2.vin = [CTxIn(COutPoint(tx1.sha256, 0), nSequence=0)] tx2.vin = [CTxIn(COutPoint(tx1.sha256, 0), nSequence=0)]
tx2.vout = [CTxOut(int(tx1.vout[0].nValue - self.relayfee * COIN), SCRIPT_W0_SH_OP_TRUE)] tx2.vout = [CTxOut(int(tx1.vout[0].nValue - self.relayfee * COIN), SCRIPT_W0_SH_OP_TRUE)]
self.wallet.sign_tx(tx=tx2) self.wallet.sign_tx(tx=tx2)
@ -246,7 +246,7 @@ class BIP68Test(BitcoinTestFramework):
sequence_value |= SEQUENCE_LOCKTIME_TYPE_FLAG sequence_value |= SEQUENCE_LOCKTIME_TYPE_FLAG
tx = CTransaction() tx = CTransaction()
tx.nVersion = 2 tx.version = 2
tx.vin = [CTxIn(COutPoint(orig_tx.sha256, 0), nSequence=sequence_value)] tx.vin = [CTxIn(COutPoint(orig_tx.sha256, 0), nSequence=sequence_value)]
tx.wit.vtxinwit = [CTxInWitness()] tx.wit.vtxinwit = [CTxInWitness()]
tx.wit.vtxinwit[0].scriptWitness.stack = [CScript([OP_TRUE])] tx.wit.vtxinwit[0].scriptWitness.stack = [CScript([OP_TRUE])]
@ -360,7 +360,7 @@ class BIP68Test(BitcoinTestFramework):
# Make an anyone-can-spend transaction # Make an anyone-can-spend transaction
tx2 = CTransaction() tx2 = CTransaction()
tx2.nVersion = 1 tx2.version = 1
tx2.vin = [CTxIn(COutPoint(tx1.sha256, 0), nSequence=0)] tx2.vin = [CTxIn(COutPoint(tx1.sha256, 0), nSequence=0)]
tx2.vout = [CTxOut(int(tx1.vout[0].nValue - self.relayfee * COIN), SCRIPT_W0_SH_OP_TRUE)] tx2.vout = [CTxOut(int(tx1.vout[0].nValue - self.relayfee * COIN), SCRIPT_W0_SH_OP_TRUE)]
@ -376,7 +376,7 @@ class BIP68Test(BitcoinTestFramework):
sequence_value = 100 # 100 block relative locktime sequence_value = 100 # 100 block relative locktime
tx3 = CTransaction() tx3 = CTransaction()
tx3.nVersion = 2 tx3.version = 2
tx3.vin = [CTxIn(COutPoint(tx2.sha256, 0), nSequence=sequence_value)] tx3.vin = [CTxIn(COutPoint(tx2.sha256, 0), nSequence=sequence_value)]
tx3.wit.vtxinwit = [CTxInWitness()] tx3.wit.vtxinwit = [CTxInWitness()]
tx3.wit.vtxinwit[0].scriptWitness.stack = [CScript([OP_TRUE])] tx3.wit.vtxinwit[0].scriptWitness.stack = [CScript([OP_TRUE])]

12
test/functional/feature_csv_activation.py
View file

@ -110,7 +110,7 @@ class BIP68_112_113Test(BitcoinTestFramework):
def create_bip112special(self, input, txversion): def create_bip112special(self, input, txversion):
tx = self.create_self_transfer_from_utxo(input) tx = self.create_self_transfer_from_utxo(input)
tx.nVersion = txversion tx.version = txversion
self.miniwallet.sign_tx(tx) self.miniwallet.sign_tx(tx)
tx.vin[0].scriptSig = CScript([-1, OP_CHECKSEQUENCEVERIFY, OP_DROP] + list(CScript(tx.vin[0].scriptSig))) tx.vin[0].scriptSig = CScript([-1, OP_CHECKSEQUENCEVERIFY, OP_DROP] + list(CScript(tx.vin[0].scriptSig)))
tx.rehash() tx.rehash()
@ -118,7 +118,7 @@ class BIP68_112_113Test(BitcoinTestFramework):
def create_bip112emptystack(self, input, txversion): def create_bip112emptystack(self, input, txversion):
tx = self.create_self_transfer_from_utxo(input) tx = self.create_self_transfer_from_utxo(input)
tx.nVersion = txversion tx.version = txversion
self.miniwallet.sign_tx(tx) self.miniwallet.sign_tx(tx)
tx.vin[0].scriptSig = CScript([OP_CHECKSEQUENCEVERIFY] + list(CScript(tx.vin[0].scriptSig))) tx.vin[0].scriptSig = CScript([OP_CHECKSEQUENCEVERIFY] + list(CScript(tx.vin[0].scriptSig)))
tx.rehash() tx.rehash()
@ -136,7 +136,7 @@ class BIP68_112_113Test(BitcoinTestFramework):
for i, (sdf, srhb, stf, srlb) in enumerate(product(*[[True, False]] * 4)): for i, (sdf, srhb, stf, srlb) in enumerate(product(*[[True, False]] * 4)):
locktime = relative_locktime(sdf, srhb, stf, srlb) locktime = relative_locktime(sdf, srhb, stf, srlb)
tx = self.create_self_transfer_from_utxo(bip68inputs[i]) tx = self.create_self_transfer_from_utxo(bip68inputs[i])
tx.nVersion = txversion tx.version = txversion
tx.vin[0].nSequence = locktime + locktime_delta tx.vin[0].nSequence = locktime + locktime_delta
self.miniwallet.sign_tx(tx) self.miniwallet.sign_tx(tx)
txs.append({'tx': tx, 'sdf': sdf, 'stf': stf}) txs.append({'tx': tx, 'sdf': sdf, 'stf': stf})
@ -154,7 +154,7 @@ class BIP68_112_113Test(BitcoinTestFramework):
tx.vin[0].nSequence = BASE_RELATIVE_LOCKTIME + locktime_delta tx.vin[0].nSequence = BASE_RELATIVE_LOCKTIME + locktime_delta
else: # vary nSequence instead, OP_CSV is fixed else: # vary nSequence instead, OP_CSV is fixed
tx.vin[0].nSequence = locktime + locktime_delta tx.vin[0].nSequence = locktime + locktime_delta
tx.nVersion = txversion tx.version = txversion
self.miniwallet.sign_tx(tx) self.miniwallet.sign_tx(tx)
if varyOP_CSV: if varyOP_CSV:
tx.vin[0].scriptSig = CScript([locktime, OP_CHECKSEQUENCEVERIFY, OP_DROP] + list(CScript(tx.vin[0].scriptSig))) tx.vin[0].scriptSig = CScript([locktime, OP_CHECKSEQUENCEVERIFY, OP_DROP] + list(CScript(tx.vin[0].scriptSig)))
@ -257,10 +257,10 @@ class BIP68_112_113Test(BitcoinTestFramework):
# BIP113 test transaction will be modified before each use to put in appropriate block time # BIP113 test transaction will be modified before each use to put in appropriate block time
bip113tx_v1 = self.create_self_transfer_from_utxo(bip113input) bip113tx_v1 = self.create_self_transfer_from_utxo(bip113input)
bip113tx_v1.vin[0].nSequence = 0xFFFFFFFE bip113tx_v1.vin[0].nSequence = 0xFFFFFFFE
bip113tx_v1.nVersion = 1 bip113tx_v1.version = 1
bip113tx_v2 = self.create_self_transfer_from_utxo(bip113input) bip113tx_v2 = self.create_self_transfer_from_utxo(bip113input)
bip113tx_v2.vin[0].nSequence = 0xFFFFFFFE bip113tx_v2.vin[0].nSequence = 0xFFFFFFFE
bip113tx_v2.nVersion = 2 bip113tx_v2.version = 2
# For BIP68 test all 16 relative sequence locktimes # For BIP68 test all 16 relative sequence locktimes
bip68txs_v1 = self.create_bip68txs(bip68inputs, 1) bip68txs_v1 = self.create_bip68txs(bip68inputs, 1)

16
test/functional/feature_taproot.py
View file

@ -1408,10 +1408,10 @@ class TaprootTest(BitcoinTestFramework):
left = done left = done
while left: while left:
# Construct CTransaction with random nVersion, nLocktime # Construct CTransaction with random version, nLocktime
tx = CTransaction() tx = CTransaction()
tx.nVersion = random.choice([1, 2, random.randint(-0x80000000, 0x7fffffff)]) tx.version = random.choice([1, 2, random.getrandbits(32)])
min_sequence = (tx.nVersion != 1 and tx.nVersion != 0) * 0x80000000 # The minimum sequence number to disable relative locktime min_sequence = (tx.version != 1 and tx.version != 0) * 0x80000000 # The minimum sequence number to disable relative locktime
if random.choice([True, False]): if random.choice([True, False]):
tx.nLockTime = random.randrange(LOCKTIME_THRESHOLD, self.lastblocktime - 7200) # all absolute locktimes in the past tx.nLockTime = random.randrange(LOCKTIME_THRESHOLD, self.lastblocktime - 7200) # all absolute locktimes in the past
else: else:
@ -1502,8 +1502,8 @@ class TaprootTest(BitcoinTestFramework):
is_standard_tx = ( is_standard_tx = (
fail_input is None # Must be valid to be standard fail_input is None # Must be valid to be standard
and (all(utxo.spender.is_standard for utxo in input_utxos)) # All inputs must be standard and (all(utxo.spender.is_standard for utxo in input_utxos)) # All inputs must be standard
and tx.nVersion >= 1 # The tx version must be standard and tx.version >= 1 # The tx version must be standard
and tx.nVersion <= 2) and tx.version <= 2)
tx.rehash() tx.rehash()
msg = ','.join(utxo.spender.comment + ("*" if n == fail_input else "") for n, utxo in enumerate(input_utxos)) msg = ','.join(utxo.spender.comment + ("*" if n == fail_input else "") for n, utxo in enumerate(input_utxos))
if is_standard_tx: if is_standard_tx:
@ -1530,7 +1530,7 @@ class TaprootTest(BitcoinTestFramework):
# Deterministically mine coins to OP_TRUE in block 1 # Deterministically mine coins to OP_TRUE in block 1
assert_equal(self.nodes[0].getblockcount(), 0) assert_equal(self.nodes[0].getblockcount(), 0)
coinbase = CTransaction() coinbase = CTransaction()
coinbase.nVersion = 1 coinbase.version = 1
coinbase.vin = [CTxIn(COutPoint(0, 0xffffffff), CScript([OP_1, OP_1]), SEQUENCE_FINAL)] coinbase.vin = [CTxIn(COutPoint(0, 0xffffffff), CScript([OP_1, OP_1]), SEQUENCE_FINAL)]
coinbase.vout = [CTxOut(5000000000, CScript([OP_1]))] coinbase.vout = [CTxOut(5000000000, CScript([OP_1]))]
coinbase.nLockTime = 0 coinbase.nLockTime = 0
@ -1622,7 +1622,7 @@ class TaprootTest(BitcoinTestFramework):
for i, spk in enumerate(old_spks + tap_spks): for i, spk in enumerate(old_spks + tap_spks):
val = 42000000 * (i + 7) val = 42000000 * (i + 7)
tx = CTransaction() tx = CTransaction()
tx.nVersion = 1 tx.version = 1
tx.vin = [CTxIn(COutPoint(lasttxid, i & 1), CScript([]), SEQUENCE_FINAL)] tx.vin = [CTxIn(COutPoint(lasttxid, i & 1), CScript([]), SEQUENCE_FINAL)]
tx.vout = [CTxOut(val, spk), CTxOut(amount - val, CScript([OP_1]))] tx.vout = [CTxOut(val, spk), CTxOut(amount - val, CScript([OP_1]))]
if i & 1: if i & 1:
@ -1679,7 +1679,7 @@ class TaprootTest(BitcoinTestFramework):
# Construct a deterministic transaction spending all outputs created above. # Construct a deterministic transaction spending all outputs created above.
tx = CTransaction() tx = CTransaction()
tx.nVersion = 2 tx.version = 2
tx.vin = [] tx.vin = []
inputs = [] inputs = []
input_spks = [tap_spks[0], tap_spks[1], old_spks[0], tap_spks[2], tap_spks[5], old_spks[2], tap_spks[6], tap_spks[3], tap_spks[4]] input_spks = [tap_spks[0], tap_spks[1], old_spks[0], tap_spks[2], tap_spks[5], old_spks[2], tap_spks[6], tap_spks[3], tap_spks[4]]

2
test/functional/mempool_accept.py
View file

@ -287,7 +287,7 @@ class MempoolAcceptanceTest(BitcoinTestFramework):
self.log.info('Some nonstandard transactions') self.log.info('Some nonstandard transactions')
tx = tx_from_hex(raw_tx_reference) tx = tx_from_hex(raw_tx_reference)
tx.nVersion = 4 # A version currently non-standard tx.version = 4 # A version currently non-standard
self.check_mempool_result( self.check_mempool_result(
result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': 'version'}], result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': 'version'}],
rawtxs=[tx.serialize().hex()], rawtxs=[tx.serialize().hex()],

2
test/functional/p2p_mutated_blocks.py
View file

@ -55,7 +55,7 @@ class MutatedBlocksTest(BitcoinTestFramework):
# Create mutated version of the block by changing the transaction # Create mutated version of the block by changing the transaction
# version on the self-transfer. # version on the self-transfer.
mutated_block = copy.deepcopy(block) mutated_block = copy.deepcopy(block)
mutated_block.vtx[1].nVersion = 4 mutated_block.vtx[1].version = 4
# Announce the new block via a compact block through the honest relayer # Announce the new block via a compact block through the honest relayer
cmpctblock = HeaderAndShortIDs() cmpctblock = HeaderAndShortIDs()

4
test/functional/p2p_segwit.py
View file

@ -1164,7 +1164,7 @@ class SegWitTest(BitcoinTestFramework):
if not self.wit.is_null(): if not self.wit.is_null():
flags |= 1 flags |= 1
r = b"" r = b""
r += self.nVersion.to_bytes(4, "little", signed=True) r += self.version.to_bytes(4, "little")
if flags: if flags:
dummy = [] dummy = []
r += ser_vector(dummy) r += ser_vector(dummy)
@ -1975,7 +1975,7 @@ class SegWitTest(BitcoinTestFramework):
def serialize_with_bogus_witness(tx): def serialize_with_bogus_witness(tx):
flags = 3 flags = 3
r = b"" r = b""
r += tx.nVersion.to_bytes(4, "little", signed=True) r += tx.version.to_bytes(4, "little")
if flags: if flags:
dummy = [] dummy = []
r += ser_vector(dummy) r += ser_vector(dummy)

2
test/functional/rpc_packages.py
View file

@ -394,7 +394,7 @@ class RPCPackagesTest(BitcoinTestFramework):
peer = node.add_p2p_connection(P2PTxInvStore()) peer = node.add_p2p_connection(P2PTxInvStore())
txs = self.wallet.create_self_transfer_chain(chain_length=2) txs = self.wallet.create_self_transfer_chain(chain_length=2)
bad_child = tx_from_hex(txs[1]["hex"]) bad_child = tx_from_hex(txs[1]["hex"])
bad_child.nVersion = -1 bad_child.version = 0xffffffff
hex_partial_acceptance = [txs[0]["hex"], bad_child.serialize().hex()] hex_partial_acceptance = [txs[0]["hex"], bad_child.serialize().hex()]
res = node.submitpackage(hex_partial_acceptance) res = node.submitpackage(hex_partial_acceptance)
assert_equal(res["package_msg"], "transaction failed") assert_equal(res["package_msg"], "transaction failed")

20
test/functional/rpc_rawtransaction.py
View file

@ -463,20 +463,34 @@ class RawTransactionsTest(BitcoinTestFramework):
self.log.info("Test transaction version numbers") self.log.info("Test transaction version numbers")
# Test the minimum transaction version number that fits in a signed 32-bit integer. # Test the minimum transaction version number that fits in a signed 32-bit integer.
# As transaction version is unsigned, this should convert to its unsigned equivalent. # As transaction version is serialized unsigned, this should convert to its unsigned equivalent.
tx = CTransaction() tx = CTransaction()
tx.nVersion = -0x80000000 tx.version = 0x80000000
rawtx = tx.serialize().hex() rawtx = tx.serialize().hex()
decrawtx = self.nodes[0].decoderawtransaction(rawtx) decrawtx = self.nodes[0].decoderawtransaction(rawtx)
assert_equal(decrawtx['version'], 0x80000000) assert_equal(decrawtx['version'], 0x80000000)
# Test the maximum transaction version number that fits in a signed 32-bit integer. # Test the maximum transaction version number that fits in a signed 32-bit integer.
tx = CTransaction() tx = CTransaction()
tx.nVersion = 0x7fffffff tx.version = 0x7fffffff
rawtx = tx.serialize().hex() rawtx = tx.serialize().hex()
decrawtx = self.nodes[0].decoderawtransaction(rawtx) decrawtx = self.nodes[0].decoderawtransaction(rawtx)
assert_equal(decrawtx['version'], 0x7fffffff) assert_equal(decrawtx['version'], 0x7fffffff)
# Test the minimum transaction version number that fits in an unsigned 32-bit integer.
tx = CTransaction()
tx.version = 0
rawtx = tx.serialize().hex()
decrawtx = self.nodes[0].decoderawtransaction(rawtx)
assert_equal(decrawtx['version'], 0)
# Test the maximum transaction version number that fits in an unsigned 32-bit integer.
tx = CTransaction()
tx.version = 0xffffffff
rawtx = tx.serialize().hex()
decrawtx = self.nodes[0].decoderawtransaction(rawtx)
assert_equal(decrawtx['version'], 0xffffffff)
def raw_multisig_transaction_legacy_tests(self): def raw_multisig_transaction_legacy_tests(self):
self.log.info("Test raw multisig transactions (legacy)") self.log.info("Test raw multisig transactions (legacy)")
# The traditional multisig workflow does not work with descriptor wallets so these are legacy only. # The traditional multisig workflow does not work with descriptor wallets so these are legacy only.

16
test/functional/test_framework/messages.py
View file

@ -560,12 +560,12 @@ class CTxWitness:
class CTransaction: class CTransaction:
__slots__ = ("hash", "nLockTime", "nVersion", "sha256", "vin", "vout", __slots__ = ("hash", "nLockTime", "version", "sha256", "vin", "vout",
"wit") "wit")
def __init__(self, tx=None): def __init__(self, tx=None):
if tx is None: if tx is None:
self.nVersion = 2 self.version = 2
self.vin = [] self.vin = []
self.vout = [] self.vout = []
self.wit = CTxWitness() self.wit = CTxWitness()
@ -573,7 +573,7 @@ class CTransaction:
self.sha256 = None self.sha256 = None
self.hash = None self.hash = None
else: else:
self.nVersion = tx.nVersion self.version = tx.version
self.vin = copy.deepcopy(tx.vin) self.vin = copy.deepcopy(tx.vin)
self.vout = copy.deepcopy(tx.vout) self.vout = copy.deepcopy(tx.vout)
self.nLockTime = tx.nLockTime self.nLockTime = tx.nLockTime
@ -582,7 +582,7 @@ class CTransaction:
self.wit = copy.deepcopy(tx.wit) self.wit = copy.deepcopy(tx.wit)
def deserialize(self, f): def deserialize(self, f):
self.nVersion = int.from_bytes(f.read(4), "little", signed=True) self.version = int.from_bytes(f.read(4), "little")
self.vin = deser_vector(f, CTxIn) self.vin = deser_vector(f, CTxIn)
flags = 0 flags = 0
if len(self.vin) == 0: if len(self.vin) == 0:
@ -605,7 +605,7 @@ class CTransaction:
def serialize_without_witness(self): def serialize_without_witness(self):
r = b"" r = b""
r += self.nVersion.to_bytes(4, "little", signed=True) r += self.version.to_bytes(4, "little")
r += ser_vector(self.vin) r += ser_vector(self.vin)
r += ser_vector(self.vout) r += ser_vector(self.vout)
r += self.nLockTime.to_bytes(4, "little") r += self.nLockTime.to_bytes(4, "little")
@ -617,7 +617,7 @@ class CTransaction:
if not self.wit.is_null(): if not self.wit.is_null():
flags |= 1 flags |= 1
r = b"" r = b""
r += self.nVersion.to_bytes(4, "little", signed=True) r += self.version.to_bytes(4, "little")
if flags: if flags:
dummy = [] dummy = []
r += ser_vector(dummy) r += ser_vector(dummy)
@ -677,8 +677,8 @@ class CTransaction:
return math.ceil(self.get_weight() / WITNESS_SCALE_FACTOR) return math.ceil(self.get_weight() / WITNESS_SCALE_FACTOR)
def __repr__(self): def __repr__(self):
return "CTransaction(nVersion=%i vin=%s vout=%s wit=%s nLockTime=%i)" \ return "CTransaction(version=%i vin=%s vout=%s wit=%s nLockTime=%i)" \
% (self.nVersion, repr(self.vin), repr(self.vout), repr(self.wit), self.nLockTime) % (self.version, repr(self.vin), repr(self.vout), repr(self.wit), self.nLockTime)
class CBlockHeader: class CBlockHeader:

4
test/functional/test_framework/script.py
View file

@ -738,7 +738,7 @@ def SegwitV0SignatureMsg(script, txTo, inIdx, hashtype, amount):
hashOutputs = uint256_from_str(hash256(serialize_outputs)) hashOutputs = uint256_from_str(hash256(serialize_outputs))
ss = bytes() ss = bytes()
ss += txTo.nVersion.to_bytes(4, "little", signed=True) ss += txTo.version.to_bytes(4, "little")
ss += ser_uint256(hashPrevouts) ss += ser_uint256(hashPrevouts)
ss += ser_uint256(hashSequence) ss += ser_uint256(hashSequence)
ss += txTo.vin[inIdx].prevout.serialize() ss += txTo.vin[inIdx].prevout.serialize()
@ -817,7 +817,7 @@ def TaprootSignatureMsg(txTo, spent_utxos, hash_type, input_index = 0, scriptpat
in_type = hash_type & SIGHASH_ANYONECANPAY in_type = hash_type & SIGHASH_ANYONECANPAY
spk = spent_utxos[input_index].scriptPubKey spk = spent_utxos[input_index].scriptPubKey
ss = bytes([0, hash_type]) # epoch, hash_type ss = bytes([0, hash_type]) # epoch, hash_type
ss += txTo.nVersion.to_bytes(4, "little", signed=True) ss += txTo.version.to_bytes(4, "little")
ss += txTo.nLockTime.to_bytes(4, "little") ss += txTo.nLockTime.to_bytes(4, "little")
if in_type != SIGHASH_ANYONECANPAY: if in_type != SIGHASH_ANYONECANPAY:
ss += BIP341_sha_prevouts(txTo) ss += BIP341_sha_prevouts(txTo)

2
test/functional/test_framework/wallet.py
View file

@ -329,7 +329,7 @@ class MiniWallet:
tx = CTransaction() tx = CTransaction()
tx.vin = [CTxIn(COutPoint(int(utxo_to_spend['txid'], 16), utxo_to_spend['vout']), nSequence=seq) for utxo_to_spend, seq in zip(utxos_to_spend, sequence)] tx.vin = [CTxIn(COutPoint(int(utxo_to_spend['txid'], 16), utxo_to_spend['vout']), nSequence=seq) for utxo_to_spend, seq in zip(utxos_to_spend, sequence)]
tx.vout = [CTxOut(amount_per_output, bytearray(self._scriptPubKey)) for _ in range(num_outputs)] tx.vout = [CTxOut(amount_per_output, bytearray(self._scriptPubKey)) for _ in range(num_outputs)]
tx.nVersion = version tx.version = version
tx.nLockTime = locktime tx.nLockTime = locktime
self.sign_tx(tx) self.sign_tx(tx)

4
test/functional/wallet_create_tx.py
View file

@ -111,7 +111,7 @@ class CreateTxWalletTest(BitcoinTestFramework):
test_wallet.unloadwallet() test_wallet.unloadwallet()
def test_version3(self): def test_version3(self):
self.log.info('Check wallet does not create transactions with nVersion=3 yet') self.log.info('Check wallet does not create transactions with version=3 yet')
wallet_rpc = self.nodes[0].get_wallet_rpc(self.default_wallet_name) wallet_rpc = self.nodes[0].get_wallet_rpc(self.default_wallet_name)
self.nodes[0].createwallet("v3") self.nodes[0].createwallet("v3")
@ -124,7 +124,7 @@ class CreateTxWalletTest(BitcoinTestFramework):
# While v3 transactions are standard, the CURRENT_VERSION is 2. # While v3 transactions are standard, the CURRENT_VERSION is 2.
# This test can be removed if CURRENT_VERSION is changed, and replaced with tests that the # This test can be removed if CURRENT_VERSION is changed, and replaced with tests that the
# wallet handles v3 rules properly. # wallet handles v3 rules properly.
assert_equal(tx_current_version.nVersion, 2) assert_equal(tx_current_version.version, 2)
wallet_v3.unloadwallet() wallet_v3.unloadwallet()