Type-safe OutputHash.

This introduces a new, different type OutputHash for hashes of outputs,
e.g. in COutPoint and all related places in the code.  This type is
functionally equivalent to uint256, but it enables the compiler to ensure
that all places that should be using an UTXO hasher are actually using it.

Author: domob1812

divi/src/BlockMemoryPoolTransactionCollector.cpp

@@ -11,6 +11,7 @@
 #include <defaultValues.h>
 #include <Logging.h>
 #include <TransactionOpCounting.h>
+#include <OutputHash.h>
 #include <UtxoCheckingAndUpdating.h>
 
 #include <Settings.h>
@@ -53,7 +54,7 @@ class COrphan
 {
 public:
     const CTransaction* ptx;
-    std::set<uint256> setDependsOn;
+    std::set<OutputHash> setDependsOn;
     CFeeRate feeRate;
     double dPriority;
 
@@ -141,7 +142,7 @@ void BlockMemoryPoolTransactionCollector::ComputeTransactionPriority (
 
 void BlockMemoryPoolTransactionCollector::AddDependingTransactionsToPriorityQueue (
     DependingTransactionsMap& dependentTransactions,
-    const uint256& hash,
+    const OutputHash& hash,
     std::vector<TxPriority>& vecPriority,
     TxPriorityCompare& comparer) const
 {

divi/src/BlockMemoryPoolTransactionCollector.h

@@ -26,6 +26,7 @@ class CTxMemPool;
 class CBlockTemplate;
 class CBlockHeader;
 class CFeeRate;
+class OutputHash;
 class Settings;
 
 template <typename MutexObj>
@@ -51,7 +52,7 @@ class CChain;
 class BlockMemoryPoolTransactionCollector: public I_BlockTransactionCollector
 {
 private:
-    using DependingTransactionsMap = std::map<uint256, std::vector<std::shared_ptr<COrphan>>>;
+    using DependingTransactionsMap = std::map<OutputHash, std::vector<std::shared_ptr<COrphan>>>;
 
     CCoinsViewCache* baseCoinsViewCache_;
     const CChain& activeChain_;
@@ -80,7 +81,7 @@ class BlockMemoryPoolTransactionCollector: public I_BlockTransactionCollector
         const CTransaction* mempoolTx) const;
     void AddDependingTransactionsToPriorityQueue (
         DependingTransactionsMap& mapDependers,
-        const uint256& hash,
+        const OutputHash& hash,
         std::vector<TxPriority>& vecPriority,
         TxPriorityCompare& comparer) const;
 

divi/src/IndexDatabaseUpdates.h

@@ -3,6 +3,7 @@
 #include <vector>
 #include <utility>
 #include <addressindex.h>
+#include <OutputHash.h>
 #include <spentindex.h>
 #include <uint256.h>
 
@@ -35,7 +36,7 @@ struct IndexDatabaseUpdates
 struct TransactionLocationReference
 {
     uint256 hash;
-    uint256 utxoHash;
+    OutputHash utxoHash;
     unsigned blockHeight;
     int transactionIndex;
 

divi/src/Logging.cpp

@@ -9,6 +9,7 @@
 
 #include <DataDirectory.h>
 #include <chainparamsbase.h>
+#include <OutputHash.h>
 #include <uint256.h>
 #include <serialize.h>
 #include <Settings.h>
@@ -22,6 +23,7 @@ bool fLogIPs = false;
 
 extern Settings& settings;
 
+LOG_FORMAT_WITH_TOSTRING(OutputHash)
 LOG_FORMAT_WITH_TOSTRING(uint256)
 
 namespace

divi/src/Logging.h

@@ -50,6 +50,7 @@ template <typename T>
         } \
     };
 LOG_WITH_CONVERSION(CLockLocation)
+LOG_WITH_CONVERSION(OutputHash)
 LOG_WITH_CONVERSION(uint256)
 
 /* Defined in Logging-common.cpp.  */

divi/src/Makefile.am

@@ -246,6 +246,7 @@ BITCOIN_CORE_H = \
   BlockMemoryPoolTransactionCollector.h \
   CoinMinter.h \
   CoinMintingModule.h \
+  OutputHash.h \
   PoSTransactionCreator.h \
   PeerNotificationOfMintService.h \
   MonthlyWalletBackupCreator.h \

divi/src/MasternodeModule.cpp

@@ -434,7 +434,7 @@ void LockUpMasternodeCollateral(const Settings& settings, std::function<void(con
         {
             LogPrintf("  %s %s\n", mne.getTxHash(), mne.getOutputIndex());
             mnTxHash.SetHex(mne.getTxHash());
-            COutPoint outpoint(mnTxHash, boost::lexical_cast<unsigned int>(mne.getOutputIndex()));
+            COutPoint outpoint(OutputHash(mnTxHash), boost::lexical_cast<unsigned int>(mne.getOutputIndex()));
             walletUtxoLockingFunction(outpoint);
         }
     }

divi/src/OrphanTransactions.cpp

@@ -17,14 +17,14 @@ struct COrphanTx {
     NodeId fromPeer;
 };
 std::map<uint256, COrphanTx> mapOrphanTransactions;
-std::map<uint256, std::set<uint256> > mapOrphanTransactionsByPrev;
+std::map<OutputHash, std::set<uint256> > mapOrphanTransactionsByPrev;
 
 
 //////////////////////////////////////////////////////////////////////////////
 //
 // mapOrphanTransactions
 //
-const std::set<uint256>& GetOrphanSpendingTransactionIds(const uint256& txHash)
+const std::set<uint256>& GetOrphanSpendingTransactionIds(const OutputHash& txHash)
 {
     static std::set<uint256> emptySet;
     const auto it = mapOrphanTransactionsByPrev.find(txHash);

divi/src/OrphanTransactions.h

@@ -1,10 +1,11 @@
 #ifndef ORPHAN_TRANSACTIONS_H
 #define ORPHAN_TRANSACTIONS_H
 #include <NodeId.h>
+#include <OutputHash.h>
 #include <uint256.h>
 #include <set>
 class CTransaction;
-const std::set<uint256>& GetOrphanSpendingTransactionIds(const uint256& txHash);
+const std::set<uint256>& GetOrphanSpendingTransactionIds(const OutputHash& txHash);
 const CTransaction& GetOrphanTransaction(const uint256& txHash, NodeId& peer);
 bool OrphanTransactionIsKnown(const uint256& hash);
 bool AddOrphanTx(const CTransaction& tx, NodeId peer);

divi/src/OutputHash.h

@@ -0,0 +1,80 @@
+#ifndef OUTPUT_HASH_H
+#define OUTPUT_HASH_H
+
+#include "serialize.h"
+#include "uint256.h"
+
+/** This class is "equivalent" to a uint256, but semantically it represents
+ *  a specific use, namely the hash used for an outpoint in the UTXO set
+ *  and referred to by following transactions.  This is the normal txid
+ *  originally, but may be changed in the future e.g. with segwit-light.  */
+class OutputHash
+{
+
+private:
+
+  /** The actual hash value.  */
+  uint256 value;
+
+public:
+
+  OutputHash () = default;
+  OutputHash (const OutputHash&) = default;
+  OutputHash& operator= (const OutputHash&) = default;
+
+  explicit OutputHash (const uint256& val)
+    : value(val)
+  {}
+
+  ADD_SERIALIZE_METHODS;
+
+  template<typename Stream, typename Operation>
+  inline void SerializationOp (Stream& s, Operation ser_action,
+                               int nType, int nVersion)
+  {
+    READWRITE (value);
+  }
+
+  inline const uint256& GetValue () const
+  {
+    return value;
+  }
+
+  inline void SetNull ()
+  {
+    value.SetNull ();
+  }
+
+  inline bool IsNull () const
+  {
+    return value.IsNull ();
+  }
+
+  inline std::string ToString () const
+  {
+    return value.ToString ();
+  }
+
+  inline std::string GetHex () const
+  {
+    return value.GetHex ();
+  }
+
+  inline friend bool operator== (const OutputHash& a, const OutputHash& b)
+  {
+    return a.value == b.value;
+  }
+
+  inline friend bool operator!= (const OutputHash& a, const OutputHash& b)
+  {
+    return !(a == b);
+  }
+
+  inline friend bool operator< (const OutputHash& a, const OutputHash& b)
+  {
+    return a.value < b.value;
+  }
+
+};
+
+#endif  // OUTPUT_HASH_H