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

divi/src/SpentOutputTracker.cpp

@@ -46,7 +46,7 @@ void SpentOutputTracker::SyncMetaData(std::pair<TxSpends::iterator, TxSpends::it
  * Outpoint is spent if any non-conflicted transaction
  * spends it:
  */
-bool SpentOutputTracker::IsSpent(const uint256& hash, unsigned int n) const
+bool SpentOutputTracker::IsSpent(const OutputHash& hash, unsigned int n) const
 {
     const COutPoint outpoint(hash, n);
     std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range;

divi/src/SpentOutputTracker.h

@@ -7,7 +7,7 @@
 
 class WalletTransactionRecord;
 class COutPoint;
-class uint256;
+class OutputHash;
 class CWalletTx;
 
 class SpentOutputTracker
@@ -33,7 +33,7 @@ class SpentOutputTracker
         const CWalletTx& newlyAddedTransaction,
         int64_t orderedTransactionIndex=0,
         bool loadedFromDisk=false);
-    bool IsSpent(const uint256& hash, unsigned int n) const;
+    bool IsSpent(const OutputHash& hash, unsigned int n) const;
     std::set<uint256> GetConflictingTxHashes(const CWalletTx& tx) const;
 };
 #endif// SPENT_OUTPUT_TRACKER_H

divi/src/TransactionDiskAccessor.cpp

@@ -58,7 +58,7 @@ bool GetTransaction(const uint256& hash, CTransaction& txOut, uint256& hashBlock
             int nHeight = -1;
             {
                 CCoinsViewCache& view = *pcoinsTip;
-                const CCoins* coins = view.AccessCoins(hash);
+                const CCoins* coins = view.AccessCoins(OutputHash(hash));
                 if (coins)
                     nHeight = coins->nHeight;
             }
@@ -83,6 +83,11 @@ bool GetTransaction(const uint256& hash, CTransaction& txOut, uint256& hashBlock
     return false;
 }
 
+bool GetTransaction(const OutputHash& hash, CTransaction& txOut, uint256& hashBlock, bool fAllowSlow)
+{
+    return GetTransaction(hash.GetValue(), txOut, hashBlock, fAllowSlow);
+}
+
 bool CollateralIsExpectedAmount(const COutPoint &outpoint, int64_t expectedAmount)
 {
     CCoins coins;

divi/src/TransactionDiskAccessor.h

@@ -4,8 +4,10 @@
 class uint256;
 class CTransaction;
 class COutPoint;
+class OutputHash;
 
 /** Get transaction from mempool or disk **/
 bool GetTransaction(const uint256& hash, CTransaction& tx, uint256& hashBlock, bool fAllowSlow = false);
+bool GetTransaction(const OutputHash& hash, CTransaction& tx, uint256& hashBlock, bool fAllowSlow = false);
 bool CollateralIsExpectedAmount(const COutPoint &outpoint, int64_t expectedAmount);
-#endif // TRANSACTION_DISK_ACCESSOR_H
+#endif // TRANSACTION_DISK_ACCESSOR_H

divi/src/UtxoCheckingAndUpdating.cpp

@@ -12,9 +12,9 @@
 #include <chainparams.h>
 #include <defaultValues.h>
 
-uint256 BlockUtxoHasher::GetUtxoHash(const CTransaction& tx) const
+OutputHash BlockUtxoHasher::GetUtxoHash(const CTransaction& tx) const
 {
-    return tx.GetHash();
+    return OutputHash(tx.GetHash());
 }
 
 void UpdateCoinsWithTransaction(const CTransaction& tx, CCoinsViewCache& inputs, CTxUndo& txundo,

divi/src/UtxoCheckingAndUpdating.h

@@ -1,5 +1,7 @@
 #ifndef UTXO_CHECKING_AND_UPDATING_H
 #define UTXO_CHECKING_AND_UPDATING_H
+
+#include <OutputHash.h>
 #include <vector>
 #include <scriptCheck.h>
 #include <amount.h>
@@ -38,7 +40,7 @@ class TransactionUtxoHasher
   TransactionUtxoHasher(const TransactionUtxoHasher&) = delete;
   void operator=(const TransactionUtxoHasher&) = delete;
 
-  virtual uint256 GetUtxoHash(const CTransaction& tx) const = 0;
+  virtual OutputHash GetUtxoHash(const CTransaction& tx) const = 0;
 
 };
 
@@ -56,7 +58,7 @@ class BlockUtxoHasher : public TransactionUtxoHasher
 
 public:
 
-  uint256 GetUtxoHash(const CTransaction& tx) const override;
+  OutputHash GetUtxoHash(const CTransaction& tx) const override;
 
 };
 

divi/src/VaultManager.cpp

@@ -85,7 +85,7 @@ UnspentOutputs VaultManager::getUTXOs() const
     for(const auto& hashAndTransaction: walletTxRecord_->mapWallet)
     {
         const CWalletTx& tx = hashAndTransaction.second;
-        const uint256 hash = utxoHasher_.GetUtxoHash(tx);
+        const OutputHash hash(utxoHasher_.GetUtxoHash(tx));
         if(tx.GetNumberOfBlockConfirmations()<1) continue;
         if((tx.IsCoinBase() || tx.IsCoinStake()) && tx.GetBlocksToMaturity() > 0) continue;
         for(unsigned outputIndex = 0; outputIndex < tx.vout.size(); ++outputIndex)

divi/src/addressindex.h

@@ -15,10 +15,10 @@ struct CMempoolAddressDelta
 {
     int64_t time;
     CAmount amount;
-    uint256 prevhash;
+    OutputHash prevhash;
     unsigned int prevout;
 
-    CMempoolAddressDelta(int64_t t, CAmount a, const uint256& hash, unsigned int out) {
+    CMempoolAddressDelta(int64_t t, CAmount a, const OutputHash& hash, unsigned int out) {
         time = t;
         amount = a;
         prevhash = hash;
@@ -219,7 +219,7 @@ struct CAddressIndexIteratorHeightKey {
 struct CAddressUnspentKey {
     unsigned int type;
     uint160 hashBytes;
-    uint256 txhash;
+    OutputHash txhash;
     size_t index;
 
     size_t GetSerializeSize(int nType, int nVersion) const {
@@ -240,7 +240,7 @@ struct CAddressUnspentKey {
         index = ser_readdata32(s);
     }
 
-    CAddressUnspentKey(unsigned int addressType, uint160 addressHash, const uint256& txid, size_t indexValue) {
+    CAddressUnspentKey(unsigned int addressType, uint160 addressHash, const OutputHash& txid, size_t indexValue) {
         type = addressType;
         hashBytes = addressHash;
         txhash = txid;

divi/src/bloom.cpp

@@ -141,13 +141,13 @@ bool CBloomFilter::IsRelevantAndUpdate(const CTransaction& tx)
             if (data.size() != 0 && contains(data)) {
                 fFound = true;
                 if ((nFlags & BLOOM_UPDATE_MASK) == BLOOM_UPDATE_ALL)
-                    insert(COutPoint(hash, i));
+                    insert(COutPoint(OutputHash(hash), i));
                 else if ((nFlags & BLOOM_UPDATE_MASK) == BLOOM_UPDATE_P2PUBKEY_ONLY) {
                     txnouttype type;
                     std::vector<std::vector<unsigned char> > vSolutions;
                     if (ExtractScriptPubKeyFormat(txout.scriptPubKey, type, vSolutions) &&
                         (type == TX_PUBKEY || type == TX_MULTISIG))
-                        insert(COutPoint(hash, i));
+                        insert(COutPoint(OutputHash(hash), i));
                 }
                 break;
             }

divi/src/coincontrol.h

@@ -49,7 +49,7 @@ class CCoinControl
         return (setSelected.size() > 0);
     }
 
-    bool IsSelected(const uint256& hash, unsigned int n) const
+    bool IsSelected(const OutputHash& hash, unsigned int n) const
     {
         COutPoint outpt(hash, n);
         return (setSelected.count(outpt) > 0);