Use UTXO hasher for spending coins.

Use the UTXO hasher abstraction in the wallet and for staking (i.e.
for places where coins are spent).  The wallet gets its own instance,
which will allow for dependency injection in tests.

For now, the hasher used in the wallet is just the normal hasher, i.e.
there are no actual changes in behaviour.  In the future, the wallet
hasher can be changed accordingly for the activation of segwit light.

Author: domob1812

divi/src/CoinControlSelectionAlgorithm.cpp

@@ -1,10 +1,12 @@
 #include <CoinControlSelectionAlgorithm.h>
 #include <coincontrol.h>
+#include <wallet.h>
 #include <WalletTx.h>
 
 CoinControlSelectionAlgorithm::CoinControlSelectionAlgorithm(
-    const CCoinControl* coinControl
-    ): coinControl_(coinControl)
+    const CCoinControl* coinControl,
+    const CWallet& wallet
+    ): coinControl_(coinControl), wallet_(wallet)
 {
 }
 
@@ -20,7 +22,7 @@ std::set<COutput> CoinControlSelectionAlgorithm::SelectCoins(
         for(const COutput& out: vCoins)
         {
             if (!out.fSpendable ||
-                (!coinControl_->fAllowOtherInputs && !coinControl_->IsSelected(out.tx->GetHash(),out.i)))
+                (!coinControl_->fAllowOtherInputs && !coinControl_->IsSelected(wallet_.GetUtxoHash(*out.tx),out.i)))
             {
                 continue;
             }
@@ -31,4 +33,4 @@ std::set<COutput> CoinControlSelectionAlgorithm::SelectCoins(
     }
     fees = totalInputs - transactionToSelectCoinsFor.GetValueOut();
     return setCoinsRet;
-}
+}

divi/src/CoinControlSelectionAlgorithm.h

@@ -2,16 +2,19 @@
 #define COIN_CONTROL_COIN_SELECTOR_H
 #include <I_CoinSelectionAlgorithm.h>
 class CCoinControl;
+class CWallet;
 class CoinControlSelectionAlgorithm: public I_CoinSelectionAlgorithm
 {
 private:
     const CCoinControl* coinControl_;
+    const CWallet& wallet_;
 public:
-    CoinControlSelectionAlgorithm(
-        const CCoinControl* coinControl);
+    explicit CoinControlSelectionAlgorithm(
+        const CCoinControl* coinControl,
+        const CWallet& wallet);
     virtual std::set<COutput> SelectCoins(
         const CMutableTransaction& transactionToSelectCoinsFor,
         const std::vector<COutput>& vCoins,
         CAmount& fees) const;
 };
-#endif// COIN_CONTROL_COIN_SELECTOR_H
+#endif// COIN_CONTROL_COIN_SELECTOR_H

divi/src/PoSTransactionCreator.cpp

@@ -145,7 +145,7 @@ void PoSTransactionCreator::CombineUtxos(
     for(const StakableCoin& pcoin : stakedCoins_->asSet())
     {
         if(pcoin.GetTxOut().scriptPubKey == txNew.vout[1].scriptPubKey &&
-            pcoin.tx->GetHash() != txNew.vin[0].prevout.hash)
+            wallet_.GetUtxoHash(*pcoin.tx) != txNew.vin[0].prevout.hash)
         {
             if(pcoin.GetTxOut().nValue + nCredit > nCombineThreshold)
                 continue;

divi/src/rpcmasternode.cpp

@@ -102,7 +102,7 @@ Value allocatefunds(const Array& params, bool fHelp)
     SendMoney(acctAddr.Get(), CMasternode::GetTierCollateralAmount(nMasternodeTier), wtx);
 
     Object obj;
-    obj.push_back(Pair("txhash", wtx.GetHash().GetHex()));
+    obj.push_back(Pair("txhash", pwalletMain->GetUtxoHash(wtx).GetHex()));
     return obj;
 }
 

divi/src/rpcrawtransaction.cpp

@@ -337,6 +337,8 @@ Value listunspent(const Array& params, bool fHelp)
             "[                   (array of json object)\n"
             "  {\n"
             "    \"txid\" : \"txid\",        (string) the transaction id \n"
+            "    \"baretxid\" : \"baretxid\", (string) The bare txid (without signatures)\n"
+            "    \"outputhash\" :  \"outputhash\", (string) The hash (txid or bare txid) that should be used for spending\n"
             "    \"vout\" : n,               (numeric) the vout value\n"
             "    \"address\" : \"address\",  (string) the divi address\n"
             "    \"account\" : \"account\",  (string) The associated account, or \"\" for the default account\n"
@@ -394,6 +396,8 @@ Value listunspent(const Array& params, bool fHelp)
         const CScript& pk = out.tx->vout[out.i].scriptPubKey;
         Object entry;
         entry.push_back(Pair("txid", out.tx->GetHash().GetHex()));
+        entry.push_back(Pair("baretxid", out.tx->GetBareTxid().GetHex()));
+        entry.push_back(Pair("outputhash", pwalletMain->GetUtxoHash(*out.tx).GetHex()));
         entry.push_back(Pair("vout", out.i));
         CTxDestination address;
         if (ExtractDestination(out.tx->vout[out.i].scriptPubKey, address)) {

divi/src/wallet.cpp

@@ -35,6 +35,7 @@
 #include <Logging.h>
 #include <StakableCoin.h>
 #include <SpentOutputTracker.h>
+#include <UtxoCheckingAndUpdating.h>
 #include <WalletTx.h>
 #include <WalletTransactionRecord.h>
 #include <StochasticSubsetSelectionAlgorithm.h>
@@ -167,10 +168,31 @@ bool WriteTxToDisk(const CWallet* walletPtr, const CWalletTx& transactionToWrite
     return CWalletDB(settings, walletPtr->strWalletFile).WriteTx(transactionToWrite.GetHash(),transactionToWrite);
 }
 
+namespace
+{
+
+/** Dummy UTXO hasher for the wallet.  For now, this just always returns
+ *  the normal txid, but we will later change it to return the proper hash
+ *  for a WalletTx.  */
+class WalletUtxoHasher : public TransactionUtxoHasher
+{
+
+public:
+
+  uint256 GetUtxoHash(const CTransaction& tx) const override
+  {
+    return tx.GetHash();
+  }
+
+};
+
+} // anonymous namespace
+
 CWallet::CWallet(const CChain& chain, const BlockMap& blockMap
     ): cs_wallet()
     , transactionRecord_(new WalletTransactionRecord(cs_wallet,strWalletFile) )
     , outputTracker_( new SpentOutputTracker(*transactionRecord_) )
+    , utxoHasher(new WalletUtxoHasher() )
     , chainActive_(chain)
     , mapBlockIndex_(blockMap)
     , orderedTransactionIndex()
@@ -334,7 +356,7 @@ CAmount CWallet::ComputeCredit(const CWalletTx& tx, const isminefilter& filter,
 {
     const CAmount maxMoneyAllowedInOutput = Params().MaxMoneyOut();
     CAmount nCredit = 0;
-    uint256 hash = tx.GetHash();
+    const uint256 hash = GetUtxoHash(tx);
     for (unsigned int i = 0; i < tx.vout.size(); i++) {
         if( (creditFilterFlags & REQUIRE_UNSPENT) && IsSpent(tx,i)) continue;
         if( (creditFilterFlags & REQUIRE_UNLOCKED) && IsLockedCoin(hash,i)) continue;
@@ -928,7 +950,7 @@ set<uint256> CWallet::GetConflicts(const uint256& txid) const
  */
 bool CWallet::IsSpent(const CWalletTx& wtx, unsigned int n) const
 {
-    return outputTracker_->IsSpent(wtx.GetHash(), n);
+    return outputTracker_->IsSpent(GetUtxoHash(wtx), n);
 }
 
 bool CWallet::EncryptWallet(const SecureString& strWalletPassphrase)
@@ -1645,7 +1667,7 @@ bool CWallet::IsAvailableForSpending(
         }
     }
 
-    const uint256 hash = pcoin->GetHash();
+    const uint256 hash = GetUtxoHash(*pcoin);
 
     if (IsSpent(*pcoin, i))
         return false;
@@ -1797,7 +1819,7 @@ bool CWallet::SelectStakeCoins(std::set<StakableCoin>& setCoins) const
             continue;
 
         //add to our stake set
-        setCoins.emplace(*out.tx, COutPoint(out.tx->GetHash(), out.i), out.tx->hashBlock);
+        setCoins.emplace(*out.tx, COutPoint(GetUtxoHash(*out.tx), out.i), out.tx->hashBlock);
         nAmountSelected += out.tx->vout[out.i].nValue;
     }
     return true;
@@ -2144,14 +2166,15 @@ static bool SetChangeOutput(
 }
 
 static CAmount AttachInputs(
+    const TransactionUtxoHasher& utxoHasher,
     const std::set<COutput>& setCoins,
     CMutableTransaction& txWithoutChange)
 {
     // Fill vin
     CAmount nValueIn = 0;
     for(const COutput& coin: setCoins)
     {
-        txWithoutChange.vin.emplace_back(coin.tx->GetHash(), coin.i);
+        txWithoutChange.vin.emplace_back(utxoHasher.GetUtxoHash(*coin.tx), coin.i);
         nValueIn += coin.Value();
     }
     return nValueIn;
@@ -2160,6 +2183,7 @@ static CAmount AttachInputs(
 static std::pair<string,bool> SelectInputsProvideSignaturesAndFees(
     const CKeyStore& walletKeyStore,
     const I_CoinSelectionAlgorithm* coinSelector,
+    const TransactionUtxoHasher& utxoHasher,
     const std::vector<COutput>& vCoins,
     CMutableTransaction& txNew,
     CReserveKey& reservekey,
@@ -2175,7 +2199,7 @@ static std::pair<string,bool> SelectInputsProvideSignaturesAndFees(
     txNew.vin.clear();
     // Choose coins to use
     std::set<COutput> setCoins = coinSelector->SelectCoins(txNew,vCoins,nFeeRet);
-    CAmount nValueIn = AttachInputs(setCoins,txNew);
+    CAmount nValueIn = AttachInputs(utxoHasher, setCoins, txNew);
     CAmount nTotalValue = totalValueToSend + nFeeRet;
     if (setCoins.empty() || nValueIn < nTotalValue)
     {
@@ -2237,7 +2261,7 @@ std::pair<std::string,bool> CWallet::CreateTransaction(
     {
         return {translate("Transaction output(s) amount too small"),false};
     }
-    return SelectInputsProvideSignaturesAndFees(*this, coinSelector,vCoins,txNew,reservekey,wtxNew);
+    return SelectInputsProvideSignaturesAndFees(*this, coinSelector, *utxoHasher, vCoins, txNew, reservekey, wtxNew);
 }
 
 /**
@@ -2312,6 +2336,11 @@ std::pair<std::string,bool> CWallet::SendMoney(
     return {std::string(""),true};
 }
 
+uint256 CWallet::GetUtxoHash(const CMerkleTx& tx) const
+{
+    return utxoHasher->GetUtxoHash(tx);
+}
+
 DBErrors CWallet::LoadWallet(bool& fFirstRunRet)
 {
     if (!fFileBacked)

divi/src/wallet.h

@@ -27,6 +27,8 @@
 #include <OutputEntry.h>
 #include <Output.h>
 
+#include <memory>
+
 class I_SignatureSizeEstimator;
 class I_CoinSelectionAlgorithm;
 class CKeyMetadata;
@@ -38,6 +40,7 @@ class CBlockIndex;
 struct StakableCoin;
 class WalletTransactionRecord;
 class SpentOutputTracker;
+class TransactionUtxoHasher;
 class BlockMap;
 class CAccountingEntry;
 class CChain;
@@ -121,6 +124,7 @@ class CWallet : public CCryptoKeyStore, public NotificationInterface, public I_K
 private:
     std::unique_ptr<WalletTransactionRecord> transactionRecord_;
     std::unique_ptr<SpentOutputTracker> outputTracker_;
+    std::unique_ptr<TransactionUtxoHasher> utxoHasher;
     const CChain& chainActive_;
     const BlockMap& mapBlockIndex_;
     int64_t orderedTransactionIndex;
@@ -220,6 +224,10 @@ class CWallet : public CCryptoKeyStore, public NotificationInterface, public I_K
     void UnlockAllCoins();
     void ListLockedCoins(CoinVector& vOutpts);
 
+    /** Returns the UTXO hash that should be used for spending outputs
+     *  from the given transaction (which should be part of the wallet).  */
+    uint256 GetUtxoHash(const CMerkleTx& tx) const;
+
     //  keystore implementation
     // Generate a new key
     CPubKey GenerateNewKey(uint32_t nAccountIndex, bool fInternal);

divi/src/walletdustcombiner.cpp

@@ -69,7 +69,7 @@ void WalletDustCombiner::CombineDust(CAmount combineThreshold)
             if (out.Value() > combineThreshold * COIN)
                 continue;
 
-            COutPoint outpt(out.tx->GetHash(), out.i);
+            COutPoint outpt(wallet_.GetUtxoHash(*out.tx), out.i);
             coinControl->Select(outpt);
             coinsToCombine.push_back(out);
             nTotalRewardsValue += out.Value();
@@ -92,7 +92,7 @@ void WalletDustCombiner::CombineDust(CAmount combineThreshold)
         CWalletTx wtx;
         std::pair<std::string,bool> txCreationResult;
         {
-            CoinControlSelectionAlgorithm coinSelectionAlgorithm(coinControl);
+            CoinControlSelectionAlgorithm coinSelectionAlgorithm(coinControl, wallet_);
             txCreationResult = wallet_.SendMoney(vecSend, wtx, ALL_SPENDABLE_COINS,&coinSelectionAlgorithm);
         }
         delete coinControl;
@@ -115,4 +115,4 @@ void combineWalletDust(const Settings& settings)
                 settings.GetArg("-combinethreshold",std::numeric_limits<int64_t>::max() ) );
         }
     }
-}
+}