Merge bitcoin#10165: [Wallet] Refactoring by using CInputCoin instead of std::pair

laanwj · PastaPastaPasta · commit 69b42ce6711c · 2019-06-14T01:25:59.000-05:00
c37e32a [Wallet] Prevent CInputCoin to be in a null state (NicolasDorier) f597dcb [Wallet] Simplify code using CInputCoin (NicolasDorier) e78bc45 [Wallet] Decouple CInputCoin from CWalletTx (NicolasDorier) fd44ac1 [Wallet] Rename std::pair<const CWalletTx*, unsigned int> to CInputCoin (NicolasDorier) Tree-SHA512: d24361fc514a0566bce1c3953d766dfe4fece79c549cb4db2600695a4ce08e85caa61b7717812618e523a2f2a1669877dad2752ed079e2ed2d27249f9bc8590e fix error, based on 1 0 1 6 5 fix error, based on 1 0 1 6 5
diff --git a/src/bench/coin_selection.cpp b/src/bench/coin_selection.cpp
@@ -48,7 +48,7 @@ static void CoinSelection(benchmark::State& state)
             addCoin(1000 * COIN, wallet, vCoins);
         addCoin(3 * COIN, wallet, vCoins);
 
-        std::set<std::pair<const CWalletTx*, unsigned int> > setCoinsRet;
+        std::set<CInputCoin> setCoinsRet;
         CAmount nValueRet;
         bool success = wallet.SelectCoinsMinConf(1003 * COIN, 1, 6, 0, vCoins, setCoinsRet, nValueRet);
         assert(success);
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
@@ -31,7 +31,7 @@ extern UniValue importwallet(const JSONRPCRequest& request);
 
 std::vector<std::unique_ptr<CWalletTx>> wtxn;
 
-typedef std::set<std::pair<const CWalletTx*,unsigned int> > CoinSet;
+typedef std::set<CInputCoin> CoinSet;
 
 BOOST_FIXTURE_TEST_SUITE(wallet_tests, WalletTestingSetup)
 
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
@@ -76,10 +76,10 @@ const uint256 CMerkleTx::ABANDON_HASH(uint256S("00000000000000000000000000000000
 
 struct CompareValueOnly
 {
-    bool operator()(const std::pair<CAmount, std::pair<const CWalletTx*, unsigned int> >& t1,
-                    const std::pair<CAmount, std::pair<const CWalletTx*, unsigned int> >& t2) const
+    bool operator()(const CInputCoin& t1,
+                    const CInputCoin& t2) const
     {
-        return t1.first < t2.first;
+        return t1.txout.nValue < t2.txout.nValue;
     }
 };
 
@@ -2601,7 +2601,7 @@ void CWallet::AvailableCoins(std::vector<COutput>& vCoins, bool fOnlySafe, const
     }
 }
 
-static void ApproximateBestSubset(const std::vector<std::pair<CAmount, std::pair<const CWalletTx*,unsigned int> > >& vValue, const CAmount& nTotalLower, const CAmount& nTargetValue,
+static void ApproximateBestSubset(const std::vector<CInputCoin>& vValue, const CAmount& nTotalLower, const CAmount& nTargetValue,
                                   std::vector<char>& vfBest, CAmount& nBest, bool fUseInstantSend = false, int iterations = 1000)
 {
     std::vector<char> vfIncluded;
@@ -2626,7 +2626,7 @@ static void ApproximateBestSubset(const std::vector<std::pair<CAmount, std::pair
         {
             for (unsigned int i = 0; i < vValue.size(); i++)
             {
-                if (fUseInstantSend && nTotal + vValue[i].first > sporkManager.GetSporkValue(SPORK_5_INSTANTSEND_MAX_VALUE)*COIN) {
+                if (fUseInstantSend && nTotal + vValue[i].txout.nValue > sporkManager.GetSporkValue(SPORK_5_INSTANTSEND_MAX_VALUE)*COIN) {
                     continue;
                 }
                 //The solver here uses a randomized algorithm,
@@ -2637,7 +2637,7 @@ static void ApproximateBestSubset(const std::vector<std::pair<CAmount, std::pair
                 //the selection random.
                 if (nPass == 0 ? insecure_rand.rand32()&1 : !vfIncluded[i])
                 {
-                    nTotal += vValue[i].first;
+                    nTotal += vValue[i].txout.nValue;
                     vfIncluded[i] = true;
                     if (nTotal >= nTargetValue)
                     {
@@ -2647,7 +2647,7 @@ static void ApproximateBestSubset(const std::vector<std::pair<CAmount, std::pair
                             nBest = nTotal;
                             vfBest = vfIncluded;
                         }
-                        nTotal -= vValue[i].first;
+                        nTotal -= vValue[i].txout.nValue;
                         vfIncluded[i] = false;
                     }
                 }
@@ -2682,7 +2682,7 @@ bool less_then_denom (const COutput& out1, const COutput& out2)
 }
 
 bool CWallet::SelectCoinsMinConf(const CAmount& nTargetValue, const int nConfMine, const int nConfTheirs, const uint64_t nMaxAncestors, std::vector<COutput> vCoins,
-                                 std::set<std::pair<const CWalletTx*,unsigned int> >& setCoinsRet, CAmount& nValueRet, AvailableCoinsType nCoinType, bool fUseInstantSend) const
+                                 std::set<CInputCoin>& setCoinsRet, CAmount& nValueRet, AvailableCoinsType nCoinType, bool fUseInstantSend) const
 {
     setCoinsRet.clear();
     nValueRet = 0;
@@ -2694,12 +2694,8 @@ bool CWallet::SelectCoinsMinConf(const CAmount& nTargetValue, const int nConfMin
     }
 
     // List of values less than target
-    std::pair<CAmount, std::pair<const CWalletTx*,unsigned int> > coinLowestLarger;
-    coinLowestLarger.first = fUseInstantSend
-                                        ? sporkManager.GetSporkValue(SPORK_5_INSTANTSEND_MAX_VALUE)*COIN
-                                        : std::numeric_limits<CAmount>::max();
-    coinLowestLarger.second.first = NULL;
-    std::vector<std::pair<CAmount, std::pair<const CWalletTx*,unsigned int> > > vValue;
+    boost::optional<CInputCoin> coinLowestLarger;
+    std::vector<CInputCoin> vValue;
     CAmount nTotalLower = 0;
 
     random_shuffle(vCoins.begin(), vCoins.end(), GetRandInt);
@@ -2741,8 +2737,10 @@ bool CWallet::SelectCoinsMinConf(const CAmount& nTargetValue, const int nConfMin
                 continue;
 
             int i = output.i;
-            CAmount n = pcoin->tx->vout[i].nValue;
-            if (tryDenom == 0 && CPrivateSend::IsDenominatedAmount(n)) continue; // we don't want denom values on first run
+
+            CInputCoin coin = CInputCoin(pcoin, i);
+
+            if (tryDenom == 0 && CPrivateSend::IsDenominatedAmount(coin.txout.nValue)) continue; // we don't want denom values on first run
 
             if (nCoinType == ONLY_DENOMINATED) {
                 // Make sure it's actually anonymized
@@ -2751,20 +2749,18 @@ bool CWallet::SelectCoinsMinConf(const CAmount& nTargetValue, const int nConfMin
                 if (nRounds < privateSendClient.nPrivateSendRounds) continue;
             }
 
-            std::pair<CAmount, std::pair<const CWalletTx*,unsigned int> > coin = std::make_pair(n, std::make_pair(pcoin, i));
-
-            if (n == nTargetValue)
+            if (coin.txout.nValue == nTargetValue)
             {
-                setCoinsRet.insert(coin.second);
-                nValueRet += coin.first;
+                setCoinsRet.insert(coin);
+                nValueRet += coin.txout.nValue;
                 return true;
             }
-            else if (n < nTargetValue + nMinChange)
+            else if (coin.txout.nValue < nTargetValue + nMinChange)
             {
                 vValue.push_back(coin);
-                nTotalLower += n;
+                nTotalLower += coin.txout.nValue;
             }
-            else if (n < coinLowestLarger.first)
+            else if (!coinLowestLarger || coin.txout.nValue < coinLowestLarger->txout.nValue)
             {
                 coinLowestLarger = coin;
             }
@@ -2774,15 +2770,15 @@ bool CWallet::SelectCoinsMinConf(const CAmount& nTargetValue, const int nConfMin
         {
             for (unsigned int i = 0; i < vValue.size(); ++i)
             {
-                setCoinsRet.insert(vValue[i].second);
-                nValueRet += vValue[i].first;
+                setCoinsRet.insert(vValue[i]);
+                nValueRet += vValue[i].txout.nValue;
             }
             return true;
         }
 
         if (nTotalLower < nTargetValue)
         {
-            if (coinLowestLarger.second.first == NULL) // there is no input larger than nTargetValue
+            if (!coinLowestLarger) // there is no input larger than nTargetValue
             {
                 if (tryDenom == 0)
                     // we didn't look at denom yet, let's do it
@@ -2791,16 +2787,15 @@ bool CWallet::SelectCoinsMinConf(const CAmount& nTargetValue, const int nConfMin
                     // we looked at everything possible and didn't find anything, no luck
                     return false;
             }
-            setCoinsRet.insert(coinLowestLarger.second);
-            nValueRet += coinLowestLarger.first;
+            setCoinsRet.insert(coinLowestLarger.get());
+            nValueRet += coinLowestLarger->txout.nValue;
             // There is no change in PS, so we know the fee beforehand,
             // can see if we exceeded the max fee and thus fail quickly.
             return nCoinType == ONLY_DENOMINATED ? (nValueRet - nTargetValue <= maxTxFee) : true;
         }
 
         // nTotalLower > nTargetValue
         break;
-
     }
 
     // Solve subset sum by stochastic approximation
@@ -2815,21 +2810,21 @@ bool CWallet::SelectCoinsMinConf(const CAmount& nTargetValue, const int nConfMin
 
     // If we have a bigger coin and (either the stochastic approximation didn't find a good solution,
     //                                   or the next bigger coin is closer), return the bigger coin
-    if (coinLowestLarger.second.first &&
-        ((nBest != nTargetValue && nBest < nTargetValue + nMinChange) || coinLowestLarger.first <= nBest))
+    if (coinLowestLarger &&
+        ((nBest != nTargetValue && nBest < nTargetValue + nMinChange) || coinLowestLarger->txout.nValue <= nBest))
     {
-        setCoinsRet.insert(coinLowestLarger.second);
-        nValueRet += coinLowestLarger.first;
+        setCoinsRet.insert(coinLowestLarger.get());
+        nValueRet += coinLowestLarger->txout.nValue;
     }
     else {
         std::string s = "CWallet::SelectCoinsMinConf best subset: ";
         for (unsigned int i = 0; i < vValue.size(); i++)
         {
             if (vfBest[i])
             {
-                setCoinsRet.insert(vValue[i].second);
-                nValueRet += vValue[i].first;
-                s += FormatMoney(vValue[i].first) + " ";
+                setCoinsRet.insert(vValue[i]);
+                nValueRet += vValue[i].txout.nValue;
+                s += FormatMoney(vValue[i].txout.nValue) + " ";
             }
         }
         LogPrint(BCLog::SELECTCOINS, "%s - total %s\n", s, FormatMoney(nBest));
@@ -2840,7 +2835,7 @@ bool CWallet::SelectCoinsMinConf(const CAmount& nTargetValue, const int nConfMin
     return nCoinType == ONLY_DENOMINATED ? (nValueRet - nTargetValue <= maxTxFee) : true;
 }
 
-bool CWallet::SelectCoins(const std::vector<COutput>& vAvailableCoins, const CAmount& nTargetValue, std::set<std::pair<const CWalletTx*,unsigned int> >& setCoinsRet, CAmount& nValueRet, const CCoinControl* coinControl, AvailableCoinsType nCoinType, bool fUseInstantSend) const
+bool CWallet::SelectCoins(const std::vector<COutput>& vAvailableCoins, const CAmount& nTargetValue, std::set<CInputCoin>& setCoinsRet, CAmount& nValueRet, const CCoinControl* coinControl, AvailableCoinsType nCoinType, bool fUseInstantSend) const
 {
     // Note: this function should never be used for "always free" tx types like dstx
 
@@ -2861,7 +2856,7 @@ bool CWallet::SelectCoins(const std::vector<COutput>& vAvailableCoins, const CAm
                 if(nRounds < privateSendClient.nPrivateSendRounds) continue;
             }
             nValueRet += out.tx->tx->vout[out.i].nValue;
-            setCoinsRet.insert(std::make_pair(out.tx, out.i));
+            setCoinsRet.insert(CInputCoin(out.tx, out.i));
 
             if (!coinControl->fRequireAllInputs && nValueRet >= nTargetValue) {
                 // stop when we added at least one input and enough inputs to have at least nTargetValue funds
@@ -2873,7 +2868,7 @@ bool CWallet::SelectCoins(const std::vector<COutput>& vAvailableCoins, const CAm
     }
 
     // calculate value from preset inputs and store them
-    std::set<std::pair<const CWalletTx*, uint32_t> > setPresetCoins;
+    std::set<CInputCoin> setPresetCoins;
     CAmount nValueFromPresetInputs = 0;
 
     std::vector<COutPoint> vPresetInputs;
@@ -2895,15 +2890,15 @@ bool CWallet::SelectCoins(const std::vector<COutput>& vAvailableCoins, const CAm
                 if (nRounds < privateSendClient.nPrivateSendRounds) continue;
             }
             nValueFromPresetInputs += pcoin->tx->vout[outpoint.n].nValue;
-            setPresetCoins.insert(std::make_pair(pcoin, outpoint.n));
+            setPresetCoins.insert(CInputCoin(pcoin, outpoint.n));
         } else
             return false; // TODO: Allow non-wallet inputs
     }
 
     // remove preset inputs from vCoins
     for (std::vector<COutput>::iterator it = vCoins.begin(); it != vCoins.end() && coinControl && coinControl->HasSelected();)
     {
-        if (setPresetCoins.count(std::make_pair(it->tx, it->i)))
+        if (setPresetCoins.count(CInputCoin(it->tx, it->i)))
             it = vCoins.erase(it);
         else
             ++it;
@@ -3435,7 +3430,7 @@ bool CWallet::CreateTransaction(const std::vector<CRecipient>& vecSend, CWalletT
     assert(txNew.nLockTime < LOCKTIME_THRESHOLD);
 
     {
-        std::set<std::pair<const CWalletTx*,unsigned int> > setCoins;
+        std::set<CInputCoin> setCoins;
         std::vector<CTxDSIn> vecTxDSInTmp;
         LOCK2(cs_main, cs_wallet);
         {
@@ -3617,9 +3612,9 @@ bool CWallet::CreateTransaction(const std::vector<CRecipient>& vecSend, CWalletT
                 // nLockTime set above actually works.
                 vecTxDSInTmp.clear();
                 for (const auto& coin : setCoins) {
-                    CTxIn txin = CTxIn(coin.first->GetHash(),coin.second,CScript(),
+                    CTxIn txin = CTxIn(coin.outpoint,CScript(),
                                               std::numeric_limits<unsigned int>::max()-1);
-                    vecTxDSInTmp.push_back(CTxDSIn(txin, coin.first->tx->vout[coin.second].scriptPubKey));
+                    vecTxDSInTmp.push_back(CTxDSIn(txin, coin.txout.scriptPubKey));
                     txNew.vin.push_back(txin);
                 }
 
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
@@ -518,7 +518,34 @@ class CWalletTx : public CMerkleTx
 };
 
 
+class CInputCoin {
+public:
+    CInputCoin(const CWalletTx* walletTx, unsigned int i)
+    {
+        if (!walletTx)
+            throw std::invalid_argument("walletTx should not be null");
+        if (i >= walletTx->tx->vout.size())
+            throw std::out_of_range("The output index is out of range");
+
+        outpoint = COutPoint(walletTx->GetHash(), i);
+        txout = walletTx->tx->vout[i];
+    }
+
+    COutPoint outpoint;
+    CTxOut txout;
 
+    bool operator<(const CInputCoin& rhs) const {
+        return outpoint < rhs.outpoint;
+    }
+
+    bool operator!=(const CInputCoin& rhs) const {
+        return outpoint != rhs.outpoint;
+    }
+
+    bool operator==(const CInputCoin& rhs) const {
+        return outpoint == rhs.outpoint;
+    }
+};
 
 class COutput
 {
@@ -680,7 +707,7 @@ class CWallet : public CCryptoKeyStore, public CValidationInterface
      * all coins from coinControl are selected; Never select unconfirmed coins
      * if they are not ours
      */
-    bool SelectCoins(const std::vector<COutput>& vAvailableCoins, const CAmount& nTargetValue, std::set<std::pair<const CWalletTx*,unsigned int> >& setCoinsRet, CAmount& nValueRet, const CCoinControl *coinControl = NULL, AvailableCoinsType nCoinType=ALL_COINS, bool fUseInstantSend = true) const;
+    bool SelectCoins(const std::vector<COutput>& vAvailableCoins, const CAmount& nTargetValue, std::set<CInputCoin>& setCoinsRet, CAmount& nValueRet, const CCoinControl *coinControl = NULL, AvailableCoinsType nCoinType=ALL_COINS, bool fUseInstantSend = true) const;
 
     CWalletDB *pwalletdbEncryption;
 
@@ -869,7 +896,7 @@ class CWallet : public CCryptoKeyStore, public CValidationInterface
      * completion the coin set and corresponding actual target value is
      * assembled
      */
-    bool SelectCoinsMinConf(const CAmount& nTargetValue, int nConfMine, int nConfTheirs, uint64_t nMaxAncestors, std::vector<COutput> vCoins, std::set<std::pair<const CWalletTx*,unsigned int> >& setCoinsRet, CAmount& nValueRet, AvailableCoinsType nCoinType=ALL_COINS, bool fUseInstantSend = false) const;
+    bool SelectCoinsMinConf(const CAmount& nTargetValue, int nConfMine, int nConfTheirs, uint64_t nMaxAncestors, std::vector<COutput> vCoins, std::set<CInputCoin>& setCoinsRet, CAmount& nValueRet, AvailableCoinsType nCoinType=ALL_COINS, bool fUseInstantSend = false) const;
 
     // Coin selection
     bool SelectPSInOutPairsByDenominations(int nDenom, CAmount nValueMin, CAmount nValueMax, std::vector< std::pair<CTxDSIn, CTxOut> >& vecPSInOutPairsRet);

Original file line number	Diff line number	Diff line change
`@@ -76,10 +76,10 @@ const uint256 CMerkleTx::ABANDON_HASH(uint256S("00000000000000000000000000000000`
`76`	`76`
`77`	`77`	`struct CompareValueOnly`
`78`	`78`	`{`
`79`		`- bool operator()(const std::pair<CAmount, std::pair<const CWalletTx*, unsigned int> >& t1,`
`80`		`- const std::pair<CAmount, std::pair<const CWalletTx*, unsigned int> >& t2) const`
	`79`	`+ bool operator()(const CInputCoin& t1,`
	`80`	`+ const CInputCoin& t2) const`
`81`	`81`	`{`
`82`		`- return t1.first < t2.first;`
	`82`	`+ return t1.txout.nValue < t2.txout.nValue;`
`83`	`83`	`}`
`84`	`84`	`};`
`85`	`85`
`@@ -2601,7 +2601,7 @@ void CWallet::AvailableCoins(std::vector<COutput>& vCoins, bool fOnlySafe, const`
`2601`	`2601`	`}`
`2602`	`2602`	`}`
`2603`	`2603`
`2604`		`-static void ApproximateBestSubset(const std::vector<std::pair<CAmount, std::pair<const CWalletTx*,unsigned int> > >& vValue, const CAmount& nTotalLower, const CAmount& nTargetValue,`
	`2604`	`+static void ApproximateBestSubset(const std::vector<CInputCoin>& vValue, const CAmount& nTotalLower, const CAmount& nTargetValue,`
`2605`	`2605`	`std::vector<char>& vfBest, CAmount& nBest, bool fUseInstantSend = false, int iterations = 1000)`
`2606`	`2606`	`{`
`2607`	`2607`	`std::vector<char> vfIncluded;`
`@@ -2626,7 +2626,7 @@ static void ApproximateBestSubset(const std::vector<std::pair<CAmount, std::pair`
`2626`	`2626`	`{`
`2627`	`2627`	`for (unsigned int i = 0; i < vValue.size(); i++)`
`2628`	`2628`	`{`
`2629`		`- if (fUseInstantSend && nTotal + vValue[i].first > sporkManager.GetSporkValue(SPORK_5_INSTANTSEND_MAX_VALUE)*COIN) {`
	`2629`	`+ if (fUseInstantSend && nTotal + vValue[i].txout.nValue > sporkManager.GetSporkValue(SPORK_5_INSTANTSEND_MAX_VALUE)*COIN) {`
`2630`	`2630`	`continue;`
`2631`	`2631`	`}`
`2632`	`2632`	`//The solver here uses a randomized algorithm,`
`@@ -2637,7 +2637,7 @@ static void ApproximateBestSubset(const std::vector<std::pair<CAmount, std::pair`
`2637`	`2637`	`//the selection random.`
`2638`	`2638`	`if (nPass == 0 ? insecure_rand.rand32()&1 : !vfIncluded[i])`
`2639`	`2639`	`{`
`2640`		`- nTotal += vValue[i].first;`
	`2640`	`+ nTotal += vValue[i].txout.nValue;`
`2641`	`2641`	`vfIncluded[i] = true;`
`2642`	`2642`	`if (nTotal >= nTargetValue)`
`2643`	`2643`	`{`
`@@ -2647,7 +2647,7 @@ static void ApproximateBestSubset(const std::vector<std::pair<CAmount, std::pair`
`2647`	`2647`	`nBest = nTotal;`
`2648`	`2648`	`vfBest = vfIncluded;`
`2649`	`2649`	`}`
`2650`		`- nTotal -= vValue[i].first;`
	`2650`	`+ nTotal -= vValue[i].txout.nValue;`
`2651`	`2651`	`vfIncluded[i] = false;`
`2652`	`2652`	`}`
`2653`	`2653`	`}`
`@@ -2682,7 +2682,7 @@ bool less_then_denom (const COutput& out1, const COutput& out2)`
`2682`	`2682`	`}`
`2683`	`2683`
`2684`	`2684`	`bool CWallet::SelectCoinsMinConf(const CAmount& nTargetValue, const int nConfMine, const int nConfTheirs, const uint64_t nMaxAncestors, std::vector<COutput> vCoins,`
`2685`		`- std::set<std::pair<const CWalletTx*,unsigned int> >& setCoinsRet, CAmount& nValueRet, AvailableCoinsType nCoinType, bool fUseInstantSend) const`
	`2685`	`+ std::set<CInputCoin>& setCoinsRet, CAmount& nValueRet, AvailableCoinsType nCoinType, bool fUseInstantSend) const`
`2686`	`2686`	`{`
`2687`	`2687`	`setCoinsRet.clear();`
`2688`	`2688`	`nValueRet = 0;`
`@@ -2694,12 +2694,8 @@ bool CWallet::SelectCoinsMinConf(const CAmount& nTargetValue, const int nConfMin`
`2694`	`2694`	`}`
`2695`	`2695`
`2696`	`2696`	`// List of values less than target`
`2697`		`- std::pair<CAmount, std::pair<const CWalletTx*,unsigned int> > coinLowestLarger;`
`2698`		`- coinLowestLarger.first = fUseInstantSend`
`2699`		`- ? sporkManager.GetSporkValue(SPORK_5_INSTANTSEND_MAX_VALUE)*COIN`
`2700`		`- : std::numeric_limits<CAmount>::max();`
`2701`		`- coinLowestLarger.second.first = NULL;`
`2702`		`- std::vector<std::pair<CAmount, std::pair<const CWalletTx*,unsigned int> > > vValue;`
	`2697`	`+ boost::optional<CInputCoin> coinLowestLarger;`
	`2698`	`+ std::vector<CInputCoin> vValue;`
`2703`	`2699`	`CAmount nTotalLower = 0;`
`2704`	`2700`
`2705`	`2701`	`random_shuffle(vCoins.begin(), vCoins.end(), GetRandInt);`
`@@ -2741,8 +2737,10 @@ bool CWallet::SelectCoinsMinConf(const CAmount& nTargetValue, const int nConfMin`
`2741`	`2737`	`continue;`
`2742`	`2738`
`2743`	`2739`	`int i = output.i;`
`2744`		`- CAmount n = pcoin->tx->vout[i].nValue;`
`2745`		`- if (tryDenom == 0 && CPrivateSend::IsDenominatedAmount(n)) continue; // we don't want denom values on first run`
	`2740`	`+`
	`2741`	`+ CInputCoin coin = CInputCoin(pcoin, i);`
	`2742`	`+`
	`2743`	`+ if (tryDenom == 0 && CPrivateSend::IsDenominatedAmount(coin.txout.nValue)) continue; // we don't want denom values on first run`
`2746`	`2744`
`2747`	`2745`	`if (nCoinType == ONLY_DENOMINATED) {`
`2748`	`2746`	`// Make sure it's actually anonymized`
`@@ -2751,20 +2749,18 @@ bool CWallet::SelectCoinsMinConf(const CAmount& nTargetValue, const int nConfMin`
`2751`	`2749`	`if (nRounds < privateSendClient.nPrivateSendRounds) continue;`
`2752`	`2750`	`}`
`2753`	`2751`
`2754`		`- std::pair<CAmount, std::pair<const CWalletTx*,unsigned int> > coin = std::make_pair(n, std::make_pair(pcoin, i));`
`2755`		`-`
`2756`		`- if (n == nTargetValue)`
	`2752`	`+ if (coin.txout.nValue == nTargetValue)`
`2757`	`2753`	`{`
`2758`		`- setCoinsRet.insert(coin.second);`
`2759`		`- nValueRet += coin.first;`
	`2754`	`+ setCoinsRet.insert(coin);`
	`2755`	`+ nValueRet += coin.txout.nValue;`
`2760`	`2756`	`return true;`
`2761`	`2757`	`}`
`2762`		`- else if (n < nTargetValue + nMinChange)`
	`2758`	`+ else if (coin.txout.nValue < nTargetValue + nMinChange)`
`2763`	`2759`	`{`
`2764`	`2760`	`vValue.push_back(coin);`
`2765`		`- nTotalLower += n;`
	`2761`	`+ nTotalLower += coin.txout.nValue;`
`2766`	`2762`	`}`
`2767`		`- else if (n < coinLowestLarger.first)`
	`2763`	`+ else if (!coinLowestLarger \|\| coin.txout.nValue < coinLowestLarger->txout.nValue)`
`2768`	`2764`	`{`
`2769`	`2765`	`coinLowestLarger = coin;`
`2770`	`2766`	`}`
`@@ -2774,15 +2770,15 @@ bool CWallet::SelectCoinsMinConf(const CAmount& nTargetValue, const int nConfMin`
`2774`	`2770`	`{`
`2775`	`2771`	`for (unsigned int i = 0; i < vValue.size(); ++i)`
`2776`	`2772`	`{`
`2777`		`- setCoinsRet.insert(vValue[i].second);`
`2778`		`- nValueRet += vValue[i].first;`
	`2773`	`+ setCoinsRet.insert(vValue[i]);`
	`2774`	`+ nValueRet += vValue[i].txout.nValue;`
`2779`	`2775`	`}`
`2780`	`2776`	`return true;`
`2781`	`2777`	`}`
`2782`	`2778`
`2783`	`2779`	`if (nTotalLower < nTargetValue)`
`2784`	`2780`	`{`
`2785`		`- if (coinLowestLarger.second.first == NULL) // there is no input larger than nTargetValue`
	`2781`	`+ if (!coinLowestLarger) // there is no input larger than nTargetValue`
`2786`	`2782`	`{`
`2787`	`2783`	`if (tryDenom == 0)`
`2788`	`2784`	`// we didn't look at denom yet, let's do it`
`@@ -2791,16 +2787,15 @@ bool CWallet::SelectCoinsMinConf(const CAmount& nTargetValue, const int nConfMin`
`2791`	`2787`	`// we looked at everything possible and didn't find anything, no luck`
`2792`	`2788`	`return false;`
`2793`	`2789`	`}`
`2794`		`- setCoinsRet.insert(coinLowestLarger.second);`
`2795`		`- nValueRet += coinLowestLarger.first;`
	`2790`	`+ setCoinsRet.insert(coinLowestLarger.get());`
	`2791`	`+ nValueRet += coinLowestLarger->txout.nValue;`
`2796`	`2792`	`// There is no change in PS, so we know the fee beforehand,`
`2797`	`2793`	`// can see if we exceeded the max fee and thus fail quickly.`
`2798`	`2794`	`return nCoinType == ONLY_DENOMINATED ? (nValueRet - nTargetValue <= maxTxFee) : true;`
`2799`	`2795`	`}`
`2800`	`2796`
`2801`	`2797`	`// nTotalLower > nTargetValue`
`2802`	`2798`	`break;`
`2803`		`-`
`2804`	`2799`	`}`
`2805`	`2800`
`2806`	`2801`	`// Solve subset sum by stochastic approximation`
`@@ -2815,21 +2810,21 @@ bool CWallet::SelectCoinsMinConf(const CAmount& nTargetValue, const int nConfMin`
`2815`	`2810`
`2816`	`2811`	`// If we have a bigger coin and (either the stochastic approximation didn't find a good solution,`
`2817`	`2812`	`// or the next bigger coin is closer), return the bigger coin`
`2818`		`- if (coinLowestLarger.second.first &&`
`2819`		`- ((nBest != nTargetValue && nBest < nTargetValue + nMinChange) \|\| coinLowestLarger.first <= nBest))`
	`2813`	`+ if (coinLowestLarger &&`
	`2814`	`+ ((nBest != nTargetValue && nBest < nTargetValue + nMinChange) \|\| coinLowestLarger->txout.nValue <= nBest))`
`2820`	`2815`	`{`
`2821`		`- setCoinsRet.insert(coinLowestLarger.second);`
`2822`		`- nValueRet += coinLowestLarger.first;`
	`2816`	`+ setCoinsRet.insert(coinLowestLarger.get());`
	`2817`	`+ nValueRet += coinLowestLarger->txout.nValue;`
`2823`	`2818`	`}`
`2824`	`2819`	`else {`
`2825`	`2820`	`std::string s = "CWallet::SelectCoinsMinConf best subset: ";`
`2826`	`2821`	`for (unsigned int i = 0; i < vValue.size(); i++)`
`2827`	`2822`	`{`
`2828`	`2823`	`if (vfBest[i])`
`2829`	`2824`	`{`
`2830`		`- setCoinsRet.insert(vValue[i].second);`
`2831`		`- nValueRet += vValue[i].first;`
`2832`		`- s += FormatMoney(vValue[i].first) + " ";`
	`2825`	`+ setCoinsRet.insert(vValue[i]);`
	`2826`	`+ nValueRet += vValue[i].txout.nValue;`
	`2827`	`+ s += FormatMoney(vValue[i].txout.nValue) + " ";`
`2833`	`2828`	`}`
`2834`	`2829`	`}`
`2835`	`2830`	`LogPrint(BCLog::SELECTCOINS, "%s - total %s\n", s, FormatMoney(nBest));`
`@@ -2840,7 +2835,7 @@ bool CWallet::SelectCoinsMinConf(const CAmount& nTargetValue, const int nConfMin`
`2840`	`2835`	`return nCoinType == ONLY_DENOMINATED ? (nValueRet - nTargetValue <= maxTxFee) : true;`
`2841`	`2836`	`}`
`2842`	`2837`
`2843`		`-bool CWallet::SelectCoins(const std::vector<COutput>& vAvailableCoins, const CAmount& nTargetValue, std::set<std::pair<const CWalletTx,unsigned int> >& setCoinsRet, CAmount& nValueRet, const CCoinControl coinControl, AvailableCoinsType nCoinType, bool fUseInstantSend) const`
	`2838`	`+bool CWallet::SelectCoins(const std::vector<COutput>& vAvailableCoins, const CAmount& nTargetValue, std::set<CInputCoin>& setCoinsRet, CAmount& nValueRet, const CCoinControl* coinControl, AvailableCoinsType nCoinType, bool fUseInstantSend) const`
`2844`	`2839`	`{`
`2845`	`2840`	`// Note: this function should never be used for "always free" tx types like dstx`
`2846`	`2841`
`@@ -2861,7 +2856,7 @@ bool CWallet::SelectCoins(const std::vector<COutput>& vAvailableCoins, const CAm`
`2861`	`2856`	`if(nRounds < privateSendClient.nPrivateSendRounds) continue;`
`2862`	`2857`	`}`
`2863`	`2858`	`nValueRet += out.tx->tx->vout[out.i].nValue;`
`2864`		`- setCoinsRet.insert(std::make_pair(out.tx, out.i));`
	`2859`	`+ setCoinsRet.insert(CInputCoin(out.tx, out.i));`
`2865`	`2860`
`2866`	`2861`	`if (!coinControl->fRequireAllInputs && nValueRet >= nTargetValue) {`
`2867`	`2862`	`// stop when we added at least one input and enough inputs to have at least nTargetValue funds`
`@@ -2873,7 +2868,7 @@ bool CWallet::SelectCoins(const std::vector<COutput>& vAvailableCoins, const CAm`
`2873`	`2868`	`}`
`2874`	`2869`
`2875`	`2870`	`// calculate value from preset inputs and store them`
`2876`		`- std::set<std::pair<const CWalletTx*, uint32_t> > setPresetCoins;`
	`2871`	`+ std::set<CInputCoin> setPresetCoins;`
`2877`	`2872`	`CAmount nValueFromPresetInputs = 0;`
`2878`	`2873`
`2879`	`2874`	`std::vector<COutPoint> vPresetInputs;`
`@@ -2895,15 +2890,15 @@ bool CWallet::SelectCoins(const std::vector<COutput>& vAvailableCoins, const CAm`
`2895`	`2890`	`if (nRounds < privateSendClient.nPrivateSendRounds) continue;`
`2896`	`2891`	`}`
`2897`	`2892`	`nValueFromPresetInputs += pcoin->tx->vout[outpoint.n].nValue;`
`2898`		`- setPresetCoins.insert(std::make_pair(pcoin, outpoint.n));`
	`2893`	`+ setPresetCoins.insert(CInputCoin(pcoin, outpoint.n));`
`2899`	`2894`	`} else`
`2900`	`2895`	`return false; // TODO: Allow non-wallet inputs`
`2901`	`2896`	`}`
`2902`	`2897`
`2903`	`2898`	`// remove preset inputs from vCoins`
`2904`	`2899`	`for (std::vector<COutput>::iterator it = vCoins.begin(); it != vCoins.end() && coinControl && coinControl->HasSelected();)`
`2905`	`2900`	`{`
`2906`		`- if (setPresetCoins.count(std::make_pair(it->tx, it->i)))`
	`2901`	`+ if (setPresetCoins.count(CInputCoin(it->tx, it->i)))`
`2907`	`2902`	`it = vCoins.erase(it);`
`2908`	`2903`	`else`
`2909`	`2904`	`++it;`
`@@ -3435,7 +3430,7 @@ bool CWallet::CreateTransaction(const std::vector<CRecipient>& vecSend, CWalletT`
`3435`	`3430`	`assert(txNew.nLockTime < LOCKTIME_THRESHOLD);`
`3436`	`3431`
`3437`	`3432`	`{`
`3438`		`- std::set<std::pair<const CWalletTx*,unsigned int> > setCoins;`
	`3433`	`+ std::set<CInputCoin> setCoins;`
`3439`	`3434`	`std::vector<CTxDSIn> vecTxDSInTmp;`
`3440`	`3435`	`LOCK2(cs_main, cs_wallet);`
`3441`	`3436`	`{`
`@@ -3617,9 +3612,9 @@ bool CWallet::CreateTransaction(const std::vector<CRecipient>& vecSend, CWalletT`
`3617`	`3612`	`// nLockTime set above actually works.`
`3618`	`3613`	`vecTxDSInTmp.clear();`
`3619`	`3614`	`for (const auto& coin : setCoins) {`
`3620`		`- CTxIn txin = CTxIn(coin.first->GetHash(),coin.second,CScript(),`
	`3615`	`+ CTxIn txin = CTxIn(coin.outpoint,CScript(),`
`3621`	`3616`	`std::numeric_limits<unsigned int>::max()-1);`
`3622`		`- vecTxDSInTmp.push_back(CTxDSIn(txin, coin.first->tx->vout[coin.second].scriptPubKey));`
	`3617`	`+ vecTxDSInTmp.push_back(CTxDSIn(txin, coin.txout.scriptPubKey));`
`3623`	`3618`	`txNew.vin.push_back(txin);`
`3624`	`3619`	`}`
`3625`	`3620`