diff --git a/src/blockfilter.cpp b/src/blockfilter.cpp index 985a81f522..dd3824fb1c 100644 --- a/src/blockfilter.cpp +++ b/src/blockfilter.cpp @@ -16,9 +16,6 @@ #include #include -/// SerType used to serialize parameters in GCS filter encoding. -static constexpr int GCS_SER_TYPE = SER_NETWORK; - /// Protocol version used to serialize parameters in GCS filter encoding. static constexpr int GCS_SER_VERSION = 0; @@ -52,7 +49,7 @@ GCSFilter::GCSFilter(const Params& params) GCSFilter::GCSFilter(const Params& params, std::vector encoded_filter, bool skip_decode_check) : m_params(params), m_encoded(std::move(encoded_filter)) { - SpanReader stream{GCS_SER_TYPE, GCS_SER_VERSION, m_encoded}; + SpanReader stream{GCS_SER_VERSION, m_encoded}; uint64_t N = ReadCompactSize(stream); m_N = static_cast(N); @@ -84,7 +81,7 @@ GCSFilter::GCSFilter(const Params& params, const ElementSet& elements) } m_F = static_cast(m_N) * static_cast(m_params.m_M); - CVectorWriter stream(GCS_SER_TYPE, GCS_SER_VERSION, m_encoded, 0); + CVectorWriter stream(GCS_SER_VERSION, m_encoded, 0); WriteCompactSize(stream, m_N); @@ -106,7 +103,7 @@ GCSFilter::GCSFilter(const Params& params, const ElementSet& elements) bool GCSFilter::MatchInternal(const uint64_t* element_hashes, size_t size) const { - SpanReader stream{GCS_SER_TYPE, GCS_SER_VERSION, m_encoded}; + SpanReader stream{GCS_SER_VERSION, m_encoded}; // Seek forward by size of N uint64_t N = ReadCompactSize(stream); diff --git a/src/hash.h b/src/hash.h index e41b16fd94..d355b703ff 100644 --- a/src/hash.h +++ b/src/hash.h @@ -149,13 +149,11 @@ public: class CHashWriter : public HashWriter { private: - const int nType; const int nVersion; public: - CHashWriter(int nTypeIn, int nVersionIn) : nType(nTypeIn), nVersion(nVersionIn) {} + CHashWriter(int nVersionIn) : nVersion{nVersionIn} {} - int GetType() const { return nType; } int GetVersion() const { return nVersion; } template @@ -223,15 +221,6 @@ public: } }; -/** Compute the 256-bit hash of an object's serialization, with optional sighash byte. */ -template -uint256 SerializeHash(const T& obj, int nType=SER_GETHASH, int nVersion=PROTOCOL_VERSION) -{ - CHashWriter ss(nType, nVersion); - ss << obj; - return ss.GetHash(); -} - /** Single-SHA256 a 32-byte input (represented as uint256). */ [[nodiscard]] uint256 SHA256Uint256(const uint256& input); diff --git a/src/issuance.cpp b/src/issuance.cpp index 5ecb31c883..711eeaa5e1 100644 --- a/src/issuance.cpp +++ b/src/issuance.cpp @@ -28,7 +28,7 @@ void GenerateAssetEntropy(uint256& entropy, const COutPoint& prevout, const uint // E = H( H(I) || H(C) ) std::vector leaves; leaves.reserve(2); - leaves.push_back(SerializeHash(prevout, SER_GETHASH, 0)); + leaves.push_back((CHashWriter{0} << prevout).GetHash()); leaves.push_back(contracthash); entropy = ComputeFastMerkleRoot(leaves); } diff --git a/src/net.cpp b/src/net.cpp index c540b2f7ae..df8f3acfd1 100644 --- a/src/net.cpp +++ b/src/net.cpp @@ -855,7 +855,7 @@ bool V1Transport::SetMessageToSend(CSerializedNetMsg& msg) noexcept // serialize header m_header_to_send.clear(); - CVectorWriter{SER_NETWORK, INIT_PROTO_VERSION, m_header_to_send, 0, hdr}; + CVectorWriter{INIT_PROTO_VERSION, m_header_to_send, 0, hdr}; // update state m_message_to_send = std::move(msg); diff --git a/src/netmessagemaker.h b/src/netmessagemaker.h index 89fb4758f9..a121183aab 100644 --- a/src/netmessagemaker.h +++ b/src/netmessagemaker.h @@ -19,7 +19,7 @@ public: { CSerializedNetMsg msg; msg.m_type = std::move(msg_type); - CVectorWriter{ SER_NETWORK, nFlags | nVersion, msg.data, 0, std::forward(args)... }; + CVectorWriter{nFlags | nVersion, msg.data, 0, std::forward(args)...}; return msg; } diff --git a/src/pegins.cpp b/src/pegins.cpp index 7b8566bcd6..b5fbf59b92 100644 --- a/src/pegins.cpp +++ b/src/pegins.cpp @@ -506,7 +506,7 @@ template CScriptWitness CreatePeginWitnessInner(const CAmount& value, const CAsset& asset, const uint256& genesis_hash, const CScript& claim_script, const T_tx_ref& tx_ref, const T_merkle_block& merkle_block) { std::vector value_bytes; - CVectorWriter ss_val(0, 0, value_bytes, 0); + CVectorWriter ss_val(0, value_bytes, 0); try { ss_val << value; } catch (...) { diff --git a/src/primitives/bitcoin/block.cpp b/src/primitives/bitcoin/block.cpp index 6c29860648..0175dccecc 100644 --- a/src/primitives/bitcoin/block.cpp +++ b/src/primitives/bitcoin/block.cpp @@ -15,7 +15,7 @@ namespace Bitcoin { uint256 CBlockHeader::GetHash() const { - return SerializeHash(*this); + return (CHashWriter{PROTOCOL_VERSION} << *this).GetHash(); } std::string CBlock::ToString() const diff --git a/src/primitives/bitcoin/block.h b/src/primitives/bitcoin/block.h index d11fe84d66..7d5df7d6d0 100644 --- a/src/primitives/bitcoin/block.h +++ b/src/primitives/bitcoin/block.h @@ -124,8 +124,7 @@ struct CBlockLocator SERIALIZE_METHODS(CBlockLocator, obj) { int nVersion = s.GetVersion(); - if (!(s.GetType() & SER_GETHASH)) - READWRITE(nVersion); + READWRITE(nVersion); READWRITE(obj.vHave); } diff --git a/src/primitives/bitcoin/transaction.cpp b/src/primitives/bitcoin/transaction.cpp index 654bc3c21b..4f6a37b520 100644 --- a/src/primitives/bitcoin/transaction.cpp +++ b/src/primitives/bitcoin/transaction.cpp @@ -64,12 +64,12 @@ CMutableTransaction::CMutableTransaction(const CTransaction& tx) : vin(tx.vin), uint256 CMutableTransaction::GetHash() const { - return SerializeHash(*this, SER_GETHASH, SERIALIZE_TRANSACTION_NO_WITNESS); + return (CHashWriter{SERIALIZE_TRANSACTION_NO_WITNESS} << *this).GetHash(); } uint256 CTransaction::ComputeHash() const { - return SerializeHash(*this, SER_GETHASH, SERIALIZE_TRANSACTION_NO_WITNESS); + return (CHashWriter{SERIALIZE_TRANSACTION_NO_WITNESS} << *this).GetHash(); } uint256 CTransaction::ComputeWitnessHash() const @@ -77,7 +77,7 @@ uint256 CTransaction::ComputeWitnessHash() const if (!HasWitness()) { return hash; } - return SerializeHash(*this, SER_GETHASH, 0); + return (CHashWriter{0} << *this).GetHash(); } /* For backward compatibility, the hash is initialized to 0. TODO: remove the need for this default constructor entirely. */ diff --git a/src/primitives/block.cpp b/src/primitives/block.cpp index fa00aed0ce..f768f35014 100644 --- a/src/primitives/block.cpp +++ b/src/primitives/block.cpp @@ -18,9 +18,40 @@ std::string CProof::ToString() const HexStr(challenge), HexStr(solution)); } +// ELEMENTS: GetHash manually implemented for CBlockHeader. +// SER_GETHASH removed in #28508 so CProof now always serializes `solution`. +// Only include `challenge` of CProof here, and no signblock witness uint256 CBlockHeader::GetHash() const { - return SerializeHash(*this); + CHashWriter s{PROTOCOL_VERSION}; + // Detect dynamic federation block serialization using "HF bit", + // or the signed bit which is invalid in Bitcoin + bool is_dyna = false; + int32_t nVersion = this->nVersion; + if (!m_dynafed_params.IsNull()) { + nVersion |= DYNAFED_HF_MASK; + is_dyna = true; + } + s << (nVersion); + s << hashPrevBlock; + s << hashMerkleRoot; + s << nTime; + + if (is_dyna) { + s << block_height; + s << m_dynafed_params; + } else { + if (g_con_blockheightinheader) { + s << block_height; + } + if (g_signed_blocks) { + s << proof.challenge; + } else { + s << nBits; + s << nNonce; + } + } + return s.GetHash(); } std::string CBlock::ToString() const @@ -46,8 +77,8 @@ uint256 DynaFedParamEntry::CalculateRoot() const } std::vector compact_leaves; - compact_leaves.push_back(SerializeHash(m_signblockscript, SER_GETHASH, 0)); - compact_leaves.push_back(SerializeHash(m_signblock_witness_limit, SER_GETHASH, 0)); + compact_leaves.push_back((CHashWriter{0} << m_signblockscript).GetHash()); + compact_leaves.push_back((CHashWriter{0} << m_signblock_witness_limit).GetHash()); uint256 compact_root(ComputeFastMerkleRoot(compact_leaves)); uint256 extra_root; @@ -68,9 +99,9 @@ uint256 DynaFedParamEntry::CalculateRoot() const uint256 DynaFedParamEntry::CalculateExtraRoot() const { std::vector extra_leaves; - extra_leaves.push_back(SerializeHash(m_fedpeg_program, SER_GETHASH, 0)); - extra_leaves.push_back(SerializeHash(m_fedpegscript, SER_GETHASH, 0)); - extra_leaves.push_back(SerializeHash(m_extension_space, SER_GETHASH, 0)); + extra_leaves.push_back((CHashWriter{0} << m_fedpeg_program).GetHash()); + extra_leaves.push_back((CHashWriter{0} << m_fedpegscript).GetHash()); + extra_leaves.push_back((CHashWriter{0} << m_extension_space).GetHash()); return ComputeFastMerkleRoot(extra_leaves); } diff --git a/src/primitives/block.h b/src/primitives/block.h index 2ca98da9e5..2dc3a1264b 100644 --- a/src/primitives/block.h +++ b/src/primitives/block.h @@ -29,15 +29,13 @@ public: template inline void Serialize(Stream& s) const { s << *(CScriptBase*)(&challenge); - if (!(s.GetType() & SER_GETHASH)) - s << *(CScriptBase*)(&solution); + s << *(CScriptBase*)(&solution); } template inline void Unserialize(Stream& s) const { s >> *(CScriptBase*)(&challenge); - if (!(s.GetType() & SER_GETHASH)) - s >> *(CScriptBase*)(&solution); + s >> *(CScriptBase*)(&solution); } void SetNull() @@ -258,7 +256,7 @@ public: s << block_height; s << m_dynafed_params; // We do not serialize witness for hashes, or weight calculation - if (!(s.GetType() & SER_GETHASH) && fAllowWitness) { + if (fAllowWitness) { s << m_signblock_witness.stack; } } else { @@ -296,7 +294,7 @@ public: s >> block_height; s >> m_dynafed_params; // We do not serialize witness for hashes, or weight calculation - if (!(s.GetType() & SER_GETHASH) && fAllowWitness) { + if (fAllowWitness) { s >> m_signblock_witness.stack; } } else { diff --git a/src/primitives/transaction.cpp b/src/primitives/transaction.cpp index 3707d422c6..b5a180e735 100644 --- a/src/primitives/transaction.cpp +++ b/src/primitives/transaction.cpp @@ -78,12 +78,12 @@ CMutableTransaction::CMutableTransaction(const CTransaction& tx) : uint256 CMutableTransaction::GetHash() const { - return SerializeHash(*this, SER_GETHASH, SERIALIZE_TRANSACTION_NO_WITNESS); + return (CHashWriter{SERIALIZE_TRANSACTION_NO_WITNESS} << *this).GetHash(); } uint256 CTransaction::ComputeHash() const { - return SerializeHash(*this, SER_GETHASH, SERIALIZE_TRANSACTION_NO_WITNESS); + return (CHashWriter{SERIALIZE_TRANSACTION_NO_WITNESS} << *this).GetHash(); } uint256 CTransaction::ComputeWitnessHash() const @@ -91,7 +91,7 @@ uint256 CTransaction::ComputeWitnessHash() const if (!HasWitness()) { return hash; } - return SerializeHash(*this, SER_GETHASH, 0); + return (CHashWriter{0} << *this).GetHash(); } // ELEMENTS ONLY diff --git a/src/primitives/txwitness.cpp b/src/primitives/txwitness.cpp index 6a0a99c40b..d3447b0318 100644 --- a/src/primitives/txwitness.cpp +++ b/src/primitives/txwitness.cpp @@ -16,10 +16,10 @@ uint256 CTxInWitness::GetHash() const { std::vector leaves; - leaves.push_back(SerializeHash(vchIssuanceAmountRangeproof, SER_GETHASH, 0)); - leaves.push_back(SerializeHash(vchInflationKeysRangeproof, SER_GETHASH, 0)); - leaves.push_back(SerializeHash(scriptWitness.stack, SER_GETHASH, 0)); - leaves.push_back(SerializeHash(m_pegin_witness.stack, SER_GETHASH, 0)); + leaves.push_back((CHashWriter{0} << vchIssuanceAmountRangeproof).GetHash()); + leaves.push_back((CHashWriter{0} << vchInflationKeysRangeproof).GetHash()); + leaves.push_back((CHashWriter{0} << scriptWitness.stack).GetHash()); + leaves.push_back((CHashWriter{0} << m_pegin_witness.stack).GetHash()); return ComputeFastMerkleRoot(leaves); } @@ -37,8 +37,8 @@ uint256 CTxInWitness::GetHash() const uint256 CTxOutWitness::GetHash() const { std::vector leaves; - leaves.push_back(SerializeHash(vchSurjectionproof, SER_GETHASH, 0)); - leaves.push_back(SerializeHash(vchRangeproof, SER_GETHASH, 0)); + leaves.push_back((CHashWriter{0} << vchSurjectionproof).GetHash()); + leaves.push_back((CHashWriter{0} << vchRangeproof).GetHash()); return ComputeFastMerkleRoot(leaves); } diff --git a/src/psbt.h b/src/psbt.h index 123b3d7321..cb3f5dd9c6 100644 --- a/src/psbt.h +++ b/src/psbt.h @@ -326,7 +326,7 @@ struct PSBTInput // Write the utxo if (non_witness_utxo) { SerializeToVector(s, CompactSizeWriter(PSBT_IN_NON_WITNESS_UTXO)); - OverrideStream os(&s, s.GetType(), s.GetVersion() | SERIALIZE_TRANSACTION_NO_WITNESS); + OverrideStream os{&s, s.GetVersion() | SERIALIZE_TRANSACTION_NO_WITNESS}; SerializeToVector(os, non_witness_utxo); } if (!witness_utxo.IsNull()) { @@ -415,7 +415,7 @@ struct PSBTInput const auto& [leaf_hashes, origin] = leaf_origin; SerializeToVector(s, PSBT_IN_TAP_BIP32_DERIVATION, xonly); std::vector value; - CVectorWriter s_value(s.GetType(), s.GetVersion(), value, 0); + CVectorWriter s_value{s.GetVersion(), value, 0}; s_value << leaf_hashes; SerializeKeyOrigin(s_value, origin); s << value; @@ -498,7 +498,7 @@ struct PSBTInput const auto peg_in_tx = std::get_if(&m_peg_in_tx); if (peg_in_tx) { SerializeToVector(s, CompactSizeWriter(PSBT_IN_PROPRIETARY), PSBT_ELEMENTS_ID, CompactSizeWriter(PSBT_ELEMENTS_IN_PEG_IN_TX)); - OverrideStream os(&s, s.GetType(), s.GetVersion() | SERIALIZE_TRANSACTION_NO_WITNESS); + OverrideStream os(&s, s.GetVersion() | SERIALIZE_TRANSACTION_NO_WITNESS); SerializeToVector(os, *peg_in_tx); } } @@ -517,7 +517,7 @@ struct PSBTInput const auto peg_in_tx = std::get_if(&m_peg_in_tx); if (peg_in_tx) { SerializeToVector(s, CompactSizeWriter(PSBT_IN_PROPRIETARY), PSBT_ELEMENTS_ID, CompactSizeWriter(PSBT_ELEMENTS_IN_PEG_IN_TX)); - OverrideStream os(&s, s.GetType(), s.GetVersion() | SERIALIZE_TRANSACTION_NO_WITNESS); + OverrideStream os(&s, s.GetVersion() | SERIALIZE_TRANSACTION_NO_WITNESS); SerializeToVector(os, *peg_in_tx); } } @@ -660,7 +660,7 @@ struct PSBTInput } // Type is compact size uint at beginning of key - SpanReader skey(s.GetType(), s.GetVersion(), key); + SpanReader skey{s.GetVersion(), key}; uint64_t type = ReadCompactSize(skey); // Do stuff based on type @@ -673,7 +673,7 @@ struct PSBTInput throw std::ios_base::failure("Non-witness utxo key is more than one byte type"); } // Set the stream to unserialize with witness since this is always a valid network transaction - OverrideStream os(&s, s.GetType(), s.GetVersion() & ~SERIALIZE_TRANSACTION_NO_WITNESS); + OverrideStream os{&s, s.GetVersion() & ~SERIALIZE_TRANSACTION_NO_WITNESS}; UnserializeFromVector(os, non_witness_utxo); break; } @@ -937,7 +937,7 @@ struct PSBTInput } else if (key.size() != 65) { throw std::ios_base::failure("Input Taproot script signature key is not 65 bytes"); } - SpanReader s_key(s.GetType(), s.GetVersion(), Span{key}.subspan(1)); + SpanReader s_key{s.GetVersion(), Span{key}.subspan(1)}; XOnlyPubKey xonly; uint256 hash; s_key >> xonly; @@ -979,7 +979,7 @@ struct PSBTInput } else if (key.size() != 33) { throw std::ios_base::failure("Input Taproot BIP32 keypath key is not at 33 bytes"); } - SpanReader s_key(s.GetType(), s.GetVersion(), Span{key}.subspan(1)); + SpanReader s_key{s.GetVersion(), Span{key}.subspan(1)}; XOnlyPubKey xonly; s_key >> xonly; std::set leaf_hashes; @@ -1078,14 +1078,14 @@ struct PSBTInput } if (Params().GetConsensus().ParentChainHasPow()) { Sidechain::Bitcoin::CTransactionRef tx; - OverrideStream os(&s, s.GetType(), s.GetVersion()); + OverrideStream os(&s, s.GetVersion()); UnserializeFromVector(os, tx); if (tx) { m_peg_in_tx = tx; } } else { CTransactionRef tx; - OverrideStream os(&s, s.GetType(), s.GetVersion()); + OverrideStream os(&s, s.GetVersion()); UnserializeFromVector(os, tx); if (tx) { m_peg_in_tx = tx; @@ -1486,7 +1486,7 @@ struct PSBTOutput if (!m_tap_tree.empty()) { SerializeToVector(s, PSBT_OUT_TAP_TREE); std::vector value; - CVectorWriter s_value(s.GetType(), s.GetVersion(), value, 0); + CVectorWriter s_value{s.GetVersion(), value, 0}; for (const auto& [depth, leaf_ver, script] : m_tap_tree) { s_value << depth; s_value << leaf_ver; @@ -1500,7 +1500,7 @@ struct PSBTOutput const auto& [leaf_hashes, origin] = leaf; SerializeToVector(s, PSBT_OUT_TAP_BIP32_DERIVATION, xonly); std::vector value; - CVectorWriter s_value(s.GetType(), s.GetVersion(), value, 0); + CVectorWriter s_value{s.GetVersion(), value, 0}; s_value << leaf_hashes; SerializeKeyOrigin(s_value, origin); s << value; @@ -1536,7 +1536,7 @@ struct PSBTOutput } // Type is compact size uint at beginning of key - SpanReader skey(s.GetType(), s.GetVersion(), key); + SpanReader skey{s.GetVersion(), key}; uint64_t type = ReadCompactSize(skey); // Do stuff based on type @@ -1609,7 +1609,7 @@ struct PSBTOutput } std::vector tree_v; s >> tree_v; - SpanReader s_tree(s.GetType(), s.GetVersion(), tree_v); + SpanReader s_tree{s.GetVersion(), tree_v}; if (s_tree.empty()) { throw std::ios_base::failure("Output Taproot tree must not be empty"); } @@ -1884,8 +1884,8 @@ struct PartiallySignedTransaction SerializeToVector(s, CompactSizeWriter(PSBT_GLOBAL_UNSIGNED_TX)); // Write serialized tx to a stream - OverrideStream os(&s, s.GetType(), s.GetVersion() | SERIALIZE_TRANSACTION_NO_WITNESS); - SerializeToVector(os, GetUnsignedTx()); + OverrideStream os{&s, s.GetVersion() | SERIALIZE_TRANSACTION_NO_WITNESS}; + SerializeToVector(os, *tx); } // Write xpubs @@ -1994,7 +1994,7 @@ struct PartiallySignedTransaction } // Type is compact size uint at beginning of key - SpanReader skey(s.GetType(), s.GetVersion(), key); + SpanReader skey{s.GetVersion(), key}; uint64_t type = ReadCompactSize(skey); // Do stuff based on type @@ -2011,7 +2011,7 @@ struct PartiallySignedTransaction } CMutableTransaction mtx; // Set the stream to serialize with non-witness since this should always be non-witness - OverrideStream os(&s, s.GetType(), s.GetVersion() | SERIALIZE_TRANSACTION_NO_WITNESS); + OverrideStream os{&s, s.GetVersion() | SERIALIZE_TRANSACTION_NO_WITNESS}; UnserializeFromVector(os, mtx); tx = std::move(mtx); // Make sure that all scriptSigs and scriptWitnesses are empty diff --git a/src/script/generic.hpp b/src/script/generic.hpp index 8d63d88dfb..80b2779f3e 100644 --- a/src/script/generic.hpp +++ b/src/script/generic.hpp @@ -74,7 +74,7 @@ bool GenericVerifyScript(const CScript& scriptSig, const CScriptWitness& witness { bool sighash_byte = (flags & SCRIPT_NO_SIGHASH_BYTE) ? false : true; // Note: Our hash doesn't commit to the sighash byte - return VerifyScript(scriptSig, scriptPubKey, &witness, flags, SimpleSignatureChecker(SerializeHash(data), sighash_byte)); + return VerifyScript(scriptSig, scriptPubKey, &witness, flags, SimpleSignatureChecker(data.GetHash(), sighash_byte)); } template @@ -82,7 +82,7 @@ bool GenericSignScript(const FillableSigningProvider& keystore, const T& data, c { bool sighash_byte = (additional_flags & SCRIPT_NO_SIGHASH_BYTE) ? false : true; // Note: Our hash doesn't commit to the sighash byte - return ProduceSignature(keystore, SimpleSignatureCreator(SerializeHash(data), sighash_byte), fromPubKey, scriptSig, additional_flags); + return ProduceSignature(keystore, SimpleSignatureCreator(data.GetHash(), sighash_byte), fromPubKey, scriptSig, additional_flags); } #endif // H_BITCOIN_SCRIPT_GENERIC diff --git a/src/script/interpreter.cpp b/src/script/interpreter.cpp index 5611510896..1e67305287 100644 --- a/src/script/interpreter.cpp +++ b/src/script/interpreter.cpp @@ -2366,7 +2366,7 @@ public: template uint256 GetOutpointFlagsSHA256(const T& txTo) { - CHashWriter ss(SER_GETHASH, 0); + CHashWriter ss(0); for (const auto& txin : txTo.vin) { ss << GetOutpointFlag(txin); } @@ -2400,7 +2400,7 @@ uint256 GetSequencesSHA256(const T& txTo) template uint256 GetIssuanceSHA256(const T& txTo) { - CHashWriter ss(SER_GETHASH, 0); + CHashWriter ss(0); for (const auto& txin : txTo.vin) { if (txin.assetIssuance.IsNull()) ss << (unsigned char)0; @@ -2416,7 +2416,7 @@ uint256 GetIssuanceSHA256(const T& txTo) template uint256 GetOutputWitnessesSHA256(const T& txTo) { - CHashWriter ss(SER_GETHASH, 0); + CHashWriter ss(0); for (const auto& outwit : txTo.witness.vtxoutwit) { ss << outwit; } @@ -2429,7 +2429,7 @@ uint256 GetOutputWitnessesSHA256(const T& txTo) template uint256 GetIssuanceRangeproofsSHA256(const T& txTo) { - CHashWriter ss(SER_GETHASH, 0); + CHashWriter ss(0); for (const auto& inwit : txTo.witness.vtxinwit) { ss << inwit.vchIssuanceAmountRangeproof; ss << inwit.vchInflationKeysRangeproof; @@ -2501,7 +2501,7 @@ std::vector GetOutputScriptPubKeysSHA256(const T& txTo) template uint256 GetRangeproofsHash(const T& txTo) { - CHashWriter ss(SER_GETHASH, 0); + CHashWriter ss(0); for (size_t i = 0; i < txTo.vout.size(); i++) { if (i < txTo.witness.vtxoutwit.size()) { ss << txTo.witness.vtxoutwit[i].vchRangeproof; @@ -2754,7 +2754,7 @@ bool SignatureHashSchnorr(uint256& hash_out, ScriptExecutionData& execdata, cons } else { ss << tx_to.vin[in_pos].assetIssuance; - CHashWriter sha_single_input_issuance_witness(SER_GETHASH, 0); + CHashWriter sha_single_input_issuance_witness(0); sha_single_input_issuance_witness << tx_to.witness.vtxinwit[in_pos].vchIssuanceAmountRangeproof; sha_single_input_issuance_witness << tx_to.witness.vtxinwit[in_pos].vchInflationKeysRangeproof; ss << sha_single_input_issuance_witness.GetSHA256(); @@ -2777,7 +2777,7 @@ bool SignatureHashSchnorr(uint256& hash_out, ScriptExecutionData& execdata, cons // ELEMENTS if (!execdata.m_output_witness_hash) { - CHashWriter sha_single_output_witness(SER_GETHASH, 0); + CHashWriter sha_single_output_witness(0); sha_single_output_witness << tx_to.witness.vtxoutwit[in_pos]; execdata.m_output_witness_hash = sha_single_output_witness.GetSHA256(); } @@ -2835,7 +2835,7 @@ uint256 SignatureHash(const CScript& scriptCode, const T& txTo, unsigned int nIn hashOutputs = ss.GetHash(); if (fRangeproof) { - CHashWriter ss(SER_GETHASH, 0); + CHashWriter ss(0); if (nIn < txTo.witness.vtxoutwit.size()) { ss << txTo.witness.vtxoutwit[nIn].vchRangeproof; ss << txTo.witness.vtxoutwit[nIn].vchSurjectionproof; diff --git a/src/serialize.h b/src/serialize.h index 50965c2557..2013581085 100644 --- a/src/serialize.h +++ b/src/serialize.h @@ -131,7 +131,6 @@ enum // primary actions SER_NETWORK = (1 << 0), SER_DISK = (1 << 1), - SER_GETHASH = (1 << 2), }; /** @@ -1124,9 +1123,6 @@ public: } int GetVersion() const { return nVersion; } - - // ELEMENTS: Required for CProof size computation to deal with SER_GETHASH - int GetType() const { return 0; } }; template diff --git a/src/signet.cpp b/src/signet.cpp index 2bbc4791b8..ed19e127b6 100644 --- a/src/signet.cpp +++ b/src/signet.cpp @@ -99,7 +99,7 @@ std::optional SignetTxs::Create(const CBlock& block, const CScript& c // no signet solution -- allow this to support OP_TRUE as trivial block challenge } else { try { - SpanReader v{SER_NETWORK, INIT_PROTO_VERSION, signet_solution}; + SpanReader v{INIT_PROTO_VERSION, signet_solution}; v >> tx_spending.vin[0].scriptSig; v >> tx_spending.witness.vtxinwit[0].scriptWitness.stack; if (!v.empty()) return std::nullopt; // extraneous data encountered @@ -110,7 +110,7 @@ std::optional SignetTxs::Create(const CBlock& block, const CScript& c uint256 signet_merkle = ComputeModifiedMerkleRoot(modified_cb, block); std::vector block_data; - CVectorWriter writer(SER_NETWORK, INIT_PROTO_VERSION, block_data, 0); + CVectorWriter writer{INIT_PROTO_VERSION, block_data, 0}; writer << block.nVersion; writer << block.hashPrevBlock; writer << signet_merkle; diff --git a/src/streams.h b/src/streams.h index e432098665..d58de5233b 100644 --- a/src/streams.h +++ b/src/streams.h @@ -50,11 +50,10 @@ class OverrideStream { Stream* stream; - const int nType; const int nVersion; public: - OverrideStream(Stream* stream_, int nType_, int nVersion_) : stream(stream_), nType(nType_), nVersion(nVersion_) {} + OverrideStream(Stream* stream_, int nVersion_) : stream{stream_}, nVersion{nVersion_} {} template OverrideStream& operator<<(const T& obj) @@ -81,7 +80,6 @@ public: } int GetVersion() const { return nVersion; } - int GetType() const { return nType; } size_t size() const { return stream->size(); } void ignore(size_t size) { return stream->ignore(size); } }; @@ -95,13 +93,12 @@ class CVectorWriter public: /* - * @param[in] nTypeIn Serialization Type * @param[in] nVersionIn Serialization Version (including any flags) * @param[in] vchDataIn Referenced byte vector to overwrite/append * @param[in] nPosIn Starting position. Vector index where writes should start. The vector will initially * grow as necessary to max(nPosIn, vec.size()). So to append, use vec.size(). */ - CVectorWriter(int nTypeIn, int nVersionIn, std::vector& vchDataIn, size_t nPosIn) : nType(nTypeIn), nVersion(nVersionIn), vchData(vchDataIn), nPos(nPosIn) + CVectorWriter(int nVersionIn, std::vector& vchDataIn, size_t nPosIn) : nVersion{nVersionIn}, vchData{vchDataIn}, nPos{nPosIn} { if(nPos > vchData.size()) vchData.resize(nPos); @@ -111,7 +108,7 @@ class CVectorWriter * @param[in] args A list of items to serialize starting at nPosIn. */ template - CVectorWriter(int nTypeIn, int nVersionIn, std::vector& vchDataIn, size_t nPosIn, Args&&... args) : CVectorWriter(nTypeIn, nVersionIn, vchDataIn, nPosIn) + CVectorWriter(int nVersionIn, std::vector& vchDataIn, size_t nPosIn, Args&&... args) : CVectorWriter{nVersionIn, vchDataIn, nPosIn} { ::SerializeMany(*this, std::forward(args)...); } @@ -137,12 +134,8 @@ class CVectorWriter { return nVersion; } - int GetType() const - { - return nType; - } + private: - const int nType; const int nVersion; std::vector& vchData; size_t nPos; @@ -153,19 +146,16 @@ private: class SpanReader { private: - const int m_type; const int m_version; Span m_data; public: - /** - * @param[in] type Serialization Type * @param[in] version Serialization Version (including any flags) * @param[in] data Referenced byte vector to overwrite/append */ - SpanReader(int type, int version, Span data) - : m_type(type), m_version(version), m_data(data) {} + SpanReader(int version, Span data) + : m_version{version}, m_data{data} {} template SpanReader& operator>>(T&& obj) @@ -175,7 +165,6 @@ public: } int GetVersion() const { return m_version; } - int GetType() const { return m_type; } size_t size() const { return m_data.size(); } bool empty() const { return m_data.empty(); } @@ -334,9 +323,6 @@ public: { util::Xor(MakeWritableByteSpan(*this), MakeByteSpan(key)); } - - // ELEMENTS: Required for CProof serialization to deal with SER_GETHASH - int GetType() const { return 0; } }; class CDataStream : public DataStream @@ -572,9 +558,6 @@ public: ::Unserialize(*this, obj); return (*this); } - - // ELEMENTS: Required for CProof serialization to deal with SER_GETHASH - int GetType() const { return 0; } }; /** Wrapper around a CAutoFile& that implements a ring buffer to @@ -724,9 +707,6 @@ public: if (buf_offset >= vchBuf.size()) buf_offset = 0; } } - - // ELEMENTS: Required for CProof serialization to deal with SER_GETHASH - int GetType() const { return 0; } }; #endif // BITCOIN_STREAMS_H diff --git a/src/test/fuzz/golomb_rice.cpp b/src/test/fuzz/golomb_rice.cpp index e006653ca9..f3073c5c97 100644 --- a/src/test/fuzz/golomb_rice.cpp +++ b/src/test/fuzz/golomb_rice.cpp @@ -51,7 +51,7 @@ FUZZ_TARGET(golomb_rice) for (int i = 0; i < n; ++i) { elements.insert(ConsumeRandomLengthByteVector(fuzzed_data_provider, 16)); } - CVectorWriter stream(SER_NETWORK, 0, golomb_rice_data, 0); + CVectorWriter stream{0, golomb_rice_data, 0}; WriteCompactSize(stream, static_cast(elements.size())); BitStreamWriter bitwriter(stream); if (!elements.empty()) { @@ -68,7 +68,7 @@ FUZZ_TARGET(golomb_rice) std::vector decoded_deltas; { - SpanReader stream{SER_NETWORK, 0, golomb_rice_data}; + SpanReader stream{0, golomb_rice_data}; BitStreamReader bitreader{stream}; const uint32_t n = static_cast(ReadCompactSize(stream)); for (uint32_t i = 0; i < n; ++i) { @@ -80,7 +80,7 @@ FUZZ_TARGET(golomb_rice) { const std::vector random_bytes = ConsumeRandomLengthByteVector(fuzzed_data_provider, 1024); - SpanReader stream{SER_NETWORK, 0, random_bytes}; + SpanReader stream{0, random_bytes}; uint32_t n; try { n = static_cast(ReadCompactSize(stream)); diff --git a/src/test/fuzz/script_assets_test_minimizer.cpp b/src/test/fuzz/script_assets_test_minimizer.cpp index 5a09541b31..c1e7d77576 100644 --- a/src/test/fuzz/script_assets_test_minimizer.cpp +++ b/src/test/fuzz/script_assets_test_minimizer.cpp @@ -54,7 +54,7 @@ CMutableTransaction TxFromHex(const std::string& str) { CMutableTransaction tx; try { - SpanReader{SER_DISK, SERIALIZE_TRANSACTION_NO_WITNESS, CheckedParseHex(str)} >> tx; + SpanReader{SERIALIZE_TRANSACTION_NO_WITNESS, CheckedParseHex(str)} >> tx; } catch (const std::ios_base::failure&) { throw std::runtime_error("Tx deserialization failure"); } @@ -68,7 +68,7 @@ std::vector TxOutsFromJSON(const UniValue& univalue) for (size_t i = 0; i < univalue.size(); ++i) { CTxOut txout; try { - SpanReader{SER_DISK, 0, CheckedParseHex(univalue[i].get_str())} >> txout; + SpanReader{0, CheckedParseHex(univalue[i].get_str())} >> txout; } catch (const std::ios_base::failure&) { throw std::runtime_error("Prevout invalid format"); } diff --git a/src/test/hash_tests.cpp b/src/test/hash_tests.cpp index a990797ca7..54afcef989 100644 --- a/src/test/hash_tests.cpp +++ b/src/test/hash_tests.cpp @@ -122,7 +122,7 @@ BOOST_AUTO_TEST_CASE(siphash) (uint64_t(x+4)<<32)|(uint64_t(x+5)<<40)|(uint64_t(x+6)<<48)|(uint64_t(x+7)<<56)); } - CHashWriter ss(SER_DISK, CLIENT_VERSION); + CHashWriter ss{CLIENT_VERSION}; CMutableTransaction tx; // Note these tests were originally written with tx.nVersion=1 // and the test would be affected by default tx version bumps if not fixed. diff --git a/src/test/script_tests.cpp b/src/test/script_tests.cpp index 095308f2a4..0b48859b24 100644 --- a/src/test/script_tests.cpp +++ b/src/test/script_tests.cpp @@ -1512,7 +1512,7 @@ BOOST_AUTO_TEST_CASE(script_HasValidOps) static CMutableTransaction TxFromHex(const std::string& str) { CMutableTransaction tx; - SpanReader{SER_DISK, SERIALIZE_TRANSACTION_NO_WITNESS, ParseHex(str)} >> tx; + SpanReader{SERIALIZE_TRANSACTION_NO_WITNESS, ParseHex(str)} >> tx; return tx; } @@ -1522,7 +1522,7 @@ static std::vector TxOutsFromJSON(const UniValue& univalue) std::vector prevouts; for (size_t i = 0; i < univalue.size(); ++i) { CTxOut txout; - SpanReader{SER_DISK, 0, ParseHex(univalue[i].get_str())} >> txout; + SpanReader{0, ParseHex(univalue[i].get_str())} >> txout; prevouts.push_back(std::move(txout)); } return prevouts; @@ -1817,7 +1817,7 @@ BOOST_AUTO_TEST_CASE(bip341_keypath_test_vectors) for (const auto& vec : vectors.getValues()) { auto txhex = ParseHex(vec["given"]["rawUnsignedTx"].get_str()); CMutableTransaction tx; - SpanReader{SER_NETWORK, PROTOCOL_VERSION, txhex} >> tx; + SpanReader{PROTOCOL_VERSION, txhex} >> tx; std::vector utxos; for (const auto& utxo_spent : vec["given"]["utxosSpent"].getValues()) { auto script_bytes = ParseHex(utxo_spent["scriptPubKey"].get_str()); diff --git a/src/test/serialize_tests.cpp b/src/test/serialize_tests.cpp index 2f2bb6698c..d18d2623b1 100644 --- a/src/test/serialize_tests.cpp +++ b/src/test/serialize_tests.cpp @@ -176,7 +176,7 @@ BOOST_AUTO_TEST_CASE(vector_bool) std::vector vec2{1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1}; BOOST_CHECK(vec1 == std::vector(vec2.begin(), vec2.end())); - BOOST_CHECK(SerializeHash(vec1) == SerializeHash(vec2)); + BOOST_CHECK((HashWriter{} << vec1).GetHash() == (HashWriter{} << vec2).GetHash()); } BOOST_AUTO_TEST_CASE(noncanonical) diff --git a/src/test/sighash_tests.cpp b/src/test/sighash_tests.cpp index cca5325ff8..e770894244 100644 --- a/src/test/sighash_tests.cpp +++ b/src/test/sighash_tests.cpp @@ -78,7 +78,7 @@ uint256 static SignatureHashOld(CScript scriptCode, const CTransaction& txTo, un } // Serialize and hash - CHashWriter ss(SER_GETHASH, SERIALIZE_TRANSACTION_NO_WITNESS); + CHashWriter ss{SERIALIZE_TRANSACTION_NO_WITNESS}; ss << txTmp << nHashType; return ss.GetHash(); } diff --git a/src/test/streams_tests.cpp b/src/test/streams_tests.cpp index 8ff65b5377..f03f7c1da2 100644 --- a/src/test/streams_tests.cpp +++ b/src/test/streams_tests.cpp @@ -74,49 +74,49 @@ BOOST_AUTO_TEST_CASE(streams_vector_writer) // point should yield the same results, even if the first test grew the // vector. - CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 0, a, b); + CVectorWriter{INIT_PROTO_VERSION, vch, 0, a, b}; BOOST_CHECK((vch == std::vector{{1, 2}})); - CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 0, a, b); + CVectorWriter{INIT_PROTO_VERSION, vch, 0, a, b}; BOOST_CHECK((vch == std::vector{{1, 2}})); vch.clear(); - CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 2, a, b); + CVectorWriter{INIT_PROTO_VERSION, vch, 2, a, b}; BOOST_CHECK((vch == std::vector{{0, 0, 1, 2}})); - CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 2, a, b); + CVectorWriter{INIT_PROTO_VERSION, vch, 2, a, b}; BOOST_CHECK((vch == std::vector{{0, 0, 1, 2}})); vch.clear(); vch.resize(5, 0); - CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 2, a, b); + CVectorWriter{INIT_PROTO_VERSION, vch, 2, a, b}; BOOST_CHECK((vch == std::vector{{0, 0, 1, 2, 0}})); - CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 2, a, b); + CVectorWriter{INIT_PROTO_VERSION, vch, 2, a, b}; BOOST_CHECK((vch == std::vector{{0, 0, 1, 2, 0}})); vch.clear(); vch.resize(4, 0); - CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 3, a, b); + CVectorWriter{INIT_PROTO_VERSION, vch, 3, a, b}; BOOST_CHECK((vch == std::vector{{0, 0, 0, 1, 2}})); - CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 3, a, b); + CVectorWriter{INIT_PROTO_VERSION, vch, 3, a, b}; BOOST_CHECK((vch == std::vector{{0, 0, 0, 1, 2}})); vch.clear(); vch.resize(4, 0); - CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 4, a, b); + CVectorWriter{INIT_PROTO_VERSION, vch, 4, a, b}; BOOST_CHECK((vch == std::vector{{0, 0, 0, 0, 1, 2}})); - CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 4, a, b); + CVectorWriter{INIT_PROTO_VERSION, vch, 4, a, b}; BOOST_CHECK((vch == std::vector{{0, 0, 0, 0, 1, 2}})); vch.clear(); - CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 0, bytes); + CVectorWriter{INIT_PROTO_VERSION, vch, 0, bytes}; BOOST_CHECK((vch == std::vector{{3, 4, 5, 6}})); - CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 0, bytes); + CVectorWriter{INIT_PROTO_VERSION, vch, 0, bytes}; BOOST_CHECK((vch == std::vector{{3, 4, 5, 6}})); vch.clear(); vch.resize(4, 8); - CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 2, a, bytes, b); + CVectorWriter{INIT_PROTO_VERSION, vch, 2, a, bytes, b}; BOOST_CHECK((vch == std::vector{{8, 8, 1, 3, 4, 5, 6, 2}})); - CVectorWriter(SER_NETWORK, INIT_PROTO_VERSION, vch, 2, a, bytes, b); + CVectorWriter{INIT_PROTO_VERSION, vch, 2, a, bytes, b}; BOOST_CHECK((vch == std::vector{{8, 8, 1, 3, 4, 5, 6, 2}})); vch.clear(); } @@ -125,7 +125,7 @@ BOOST_AUTO_TEST_CASE(streams_vector_reader) { std::vector vch = {1, 255, 3, 4, 5, 6}; - SpanReader reader{SER_NETWORK, INIT_PROTO_VERSION, vch}; + SpanReader reader{INIT_PROTO_VERSION, vch}; BOOST_CHECK_EQUAL(reader.size(), 6U); BOOST_CHECK(!reader.empty()); @@ -155,7 +155,7 @@ BOOST_AUTO_TEST_CASE(streams_vector_reader) BOOST_CHECK_THROW(reader >> d, std::ios_base::failure); // Read a 4 bytes as a signed int from the beginning of the buffer. - SpanReader new_reader{SER_NETWORK, INIT_PROTO_VERSION, vch}; + SpanReader new_reader{INIT_PROTO_VERSION, vch}; new_reader >> d; BOOST_CHECK_EQUAL(d, 67370753); // 1,255,3,4 in little-endian base-256 BOOST_CHECK_EQUAL(new_reader.size(), 2U); @@ -169,7 +169,7 @@ BOOST_AUTO_TEST_CASE(streams_vector_reader) BOOST_AUTO_TEST_CASE(streams_vector_reader_rvalue) { std::vector data{0x82, 0xa7, 0x31}; - SpanReader reader{SER_NETWORK, INIT_PROTO_VERSION, data}; + SpanReader reader{INIT_PROTO_VERSION, data}; uint32_t varint = 0; // Deserialize into r-value reader >> VARINT(varint); diff --git a/src/wallet/scriptpubkeyman.h b/src/wallet/scriptpubkeyman.h index dd30e6496f..4e8e607f04 100644 --- a/src/wallet/scriptpubkeyman.h +++ b/src/wallet/scriptpubkeyman.h @@ -123,20 +123,14 @@ public: template void Serialize(Stream& s) const { - int nVersion = s.GetVersion(); - if (!(s.GetType() & SER_GETHASH)) { - s << nVersion; - } + s << int{259900}; // Unused field, writes the highest client version ever written s << nTime << vchPubKey << fInternal << m_pre_split; } template void Unserialize(Stream& s) { - int nVersion = s.GetVersion(); - if (!(s.GetType() & SER_GETHASH)) { - s >> nVersion; - } + s >> int{}; // Discard unused field s >> nTime >> vchPubKey; try { s >> fInternal; diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp index bd139e8a52..284d8bc055 100644 --- a/src/wallet/test/wallet_tests.cpp +++ b/src/wallet/test/wallet_tests.cpp @@ -760,14 +760,14 @@ bool malformed_descriptor(std::ios_base::failure e) BOOST_FIXTURE_TEST_CASE(wallet_descriptor_test, BasicTestingSetup) { std::vector malformed_record; - CVectorWriter vw(0, 0, malformed_record, 0); + CVectorWriter vw{0, malformed_record, 0}; vw << std::string("notadescriptor"); vw << uint64_t{0}; vw << int32_t{0}; vw << int32_t{0}; vw << int32_t{1}; - SpanReader vr{0, 0, malformed_record}; + SpanReader vr{0, malformed_record}; WalletDescriptor w_desc; BOOST_CHECK_EXCEPTION(vr >> w_desc, std::ios_base::failure, malformed_descriptor); }