Remove CHashWriter type

The type is only ever set, but never read via GetType(), so remove it.
Also, remove SerializeHash to avoid silent merge conflicts and use the
already existing GetHash() boilerplate consistently.

src/hash.h

@@ -151,13 +151,11 @@ class HashWriter
 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<typename T>
@@ -225,15 +223,6 @@ class HashedSourceWriter : public HashWriter
     }
 };
 
-/** Compute the 256-bit hash of an object's serialization. */
-template<typename T>
-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);
 

src/primitives/block.cpp

@@ -6,14 +6,12 @@
 #include <primitives/block.h>
 
 #include <hash.h>
+#include <groestlcoin.h>
 #include <tinyformat.h>
 
 uint256 CBlockHeader::GetHash() const
 {
-	XCoin::CGroestlHashWriter ss(SER_GETHASH, PROTOCOL_VERSION);	// GRS
-	ss << *this; // GRS
-	return ss.GetHash(); // GRS
-	// return SerializeHash(*this);
+    return (XCoin::CGroestlHashWriter{PROTOCOL_VERSION} << *this).GetHash();
 }
 
 std::string CBlock::ToString() const

src/primitives/transaction.cpp

@@ -7,6 +7,7 @@
 
 #include <consensus/amount.h>
 #include <hash.h>
+#include <groestlcoin.h>
 #include <script/script.h>
 #include <serialize.h>
 #include <tinyformat.h>
@@ -67,24 +68,20 @@ CMutableTransaction::CMutableTransaction(const CTransaction& tx) : vin(tx.vin),
 
 uint256 CMutableTransaction::GetHash() const
 {
-		// GRS uses single SHA256
-    return SerializeHash(*this, SER_GETHASH, SERIALIZE_TRANSACTION_NO_WITNESS);
+    return (XCoin::CGroestlHashWriter{SERIALIZE_TRANSACTION_NO_WITNESS} << *this).GetHash();
 }
 
 uint256 CTransaction::ComputeHash() const
 {
-	uint256 hash;
-			// GRS uses single SHA256
-    *const_cast<uint256*>(&hash) = SerializeHash(*this, SER_GETHASH, SERIALIZE_TRANSACTION_NO_WITNESS);
-    return hash;
+    return (XCoin::CGroestlHashWriter{SERIALIZE_TRANSACTION_NO_WITNESS} << *this).GetHash();
 }
 
 uint256 CTransaction::ComputeWitnessHash() const
 {
     if (!HasWitness()) {
         return hash;
     }
-    return SerializeHash(*this, SER_GETHASH, 0);
+    return (CHashWriter{0} << *this).GetHash();
 }
 
 CTransaction::CTransaction(const CMutableTransaction& tx) : vin(tx.vin), vout(tx.vout), nVersion(tx.nVersion), nLockTime(tx.nLockTime), hash{ComputeHash()}, m_witness_hash{ComputeWitnessHash()} {}

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.

src/test/serialize_tests.cpp

@@ -176,7 +176,7 @@ BOOST_AUTO_TEST_CASE(vector_bool)
     std::vector<bool> 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<uint8_t>(vec2.begin(), vec2.end()));
-    BOOST_CHECK(SerializeHash(vec1) == SerializeHash(vec2));
+    BOOST_CHECK((HashWriter{} << vec1).GetHash() == (HashWriter{} << vec2).GetHash());
 }
 
 BOOST_AUTO_TEST_CASE(noncanonical)

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();
 }