Line data    Source code

       1             : // Copyright (c) 2014-2025 The Dash Core developers
       2             : // Distributed under the MIT/X11 software license, see the accompanying
       3             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       4             : 
       5             : #include <coinjoin/util.h>
       6             : #include <policy/fees.h>
       7             : #include <policy/policy.h>
       8             : #include <util/translation.h>
       9             : #include <wallet/fees.h>
      10             : #include <wallet/spend.h>
      11             : #include <wallet/wallet.h>
      12             : #include <wallet/walletutil.h>
      13             : 
      14             : #include <numeric>
      15             : 
      16             : using wallet::CompactTallyItem;
      17             : using wallet::CRecipient;
      18             : using wallet::CWallet;
      19             : using wallet::FEATURE_COMPRPUBKEY;
      20             : using wallet::GetDiscardRate;
      21             : using wallet::RANDOM_CHANGE_POSITION;
      22             : using wallet::WalletBatch;
      23             : 
      24         228 : inline unsigned int GetSizeOfCompactSizeDiff(uint64_t nSizePrev, uint64_t nSizeNew)
      25             : {
      26         228 :     assert(nSizePrev <= nSizeNew);
      27         228 :     return ::GetSizeOfCompactSize(nSizeNew) - ::GetSizeOfCompactSize(nSizePrev);
      28             : }
      29             : 
      30           0 : CKeyHolder::CKeyHolder(CWallet* pwallet) :
      31           0 :     reserveDestination(pwallet)
      32           0 : {
      33           0 :     auto dest_opt = reserveDestination.GetReservedDestination(false);
      34           0 :     assert(dest_opt);
      35           0 :     dest = *dest_opt;
      36           0 : }
      37             : 
      38           0 : void CKeyHolder::KeepKey()
      39             : {
      40           0 :     reserveDestination.KeepDestination();
      41           0 : }
      42             : 
      43           0 : void CKeyHolder::ReturnKey()
      44             : {
      45           0 :     reserveDestination.ReturnDestination();
      46           0 : }
      47             : 
      48           0 : CScript CKeyHolder::GetScriptForDestination() const
      49             : {
      50           0 :     return ::GetScriptForDestination(dest);
      51             : }
      52             : 
      53             : 
      54           0 : CScript CKeyHolderStorage::AddKey(CWallet* pwallet)
      55             : {
      56           0 :     auto keyHolderPtr = std::make_unique<CKeyHolder>(pwallet);
      57           0 :     auto script = keyHolderPtr->GetScriptForDestination();
      58             : 
      59           0 :     LOCK(cs_storage);
      60           0 :     storage.emplace_back(std::move(keyHolderPtr));
      61           0 :     LogPrint(BCLog::COINJOIN, "CKeyHolderStorage::%s -- storage size %lld\n", __func__, storage.size());
      62           0 :     return script;
      63           0 : }
      64             : 
      65           0 : void CKeyHolderStorage::KeepAll()
      66             : {
      67           0 :     std::vector<std::unique_ptr<CKeyHolder> > tmp;
      68             :     {
      69             :         // don't hold cs_storage while calling KeepKey(), which might lock cs_wallet
      70           0 :         LOCK(cs_storage);
      71           0 :         std::swap(storage, tmp);
      72           0 :     }
      73             : 
      74           0 :     if (!tmp.empty()) {
      75           0 :         for (const auto& key : tmp) {
      76           0 :             key->KeepKey();
      77             :         }
      78           0 :         LogPrint(BCLog::COINJOIN, "CKeyHolderStorage::%s -- %lld keys kept\n", __func__, tmp.size());
      79           0 :     }
      80           0 : }
      81             : 
      82           0 : void CKeyHolderStorage::ReturnAll()
      83             : {
      84           0 :     std::vector<std::unique_ptr<CKeyHolder> > tmp;
      85             :     {
      86             :         // don't hold cs_storage while calling ReturnKey(), which might lock cs_wallet
      87           0 :         LOCK(cs_storage);
      88           0 :         std::swap(storage, tmp);
      89           0 :     }
      90             : 
      91           0 :     if (!tmp.empty()) {
      92           0 :         for (const auto& key : tmp) {
      93           0 :             key->ReturnKey();
      94             :         }
      95           0 :         LogPrint(BCLog::COINJOIN, "CKeyHolderStorage::%s -- %lld keys returned\n", __func__, tmp.size());
      96           0 :     }
      97           0 : }
      98             : 
      99         303 : CTransactionBuilderOutput::CTransactionBuilderOutput(CTransactionBuilder* pTxBuilderIn, CWallet& wallet, CAmount nAmountIn) :
     100         101 :     pTxBuilder(pTxBuilderIn),
     101         101 :     dest(&wallet),
     102         101 :     nAmount(nAmountIn)
     103         101 : {
     104         101 :     assert(pTxBuilder);
     105         101 :     LOCK(wallet.cs_wallet);
     106         101 :     auto dest_opt = dest.GetReservedDestination(false);
     107         101 :     assert(dest_opt);
     108         101 :     script = ::GetScriptForDestination(*dest_opt);
     109         202 : }
     110             : 
     111           7 : bool CTransactionBuilderOutput::UpdateAmount(const CAmount nNewAmount)
     112             : {
     113           7 :     if (nNewAmount <= 0 || nNewAmount - nAmount > pTxBuilder->GetAmountLeft()) {
     114           3 :         return false;
     115             :     }
     116           4 :     nAmount = nNewAmount;
     117           4 :     return true;
     118           7 : }
     119             : 
     120           6 : CTransactionBuilder::CTransactionBuilder(CWallet& wallet, const CompactTallyItem& tallyItemIn) :
     121           2 :     m_wallet(wallet),
     122           2 :     dummyReserveDestination(&wallet),
     123           2 :     tallyItem(tallyItemIn)
     124           2 : {
     125             :     // Generate a feerate which will be used to consider if the remainder is dust and will go into fees or not
     126             :     coinControl.m_discard_feerate = ::GetDiscardRate(m_wallet);
     127             :     // Generate a feerate which will be used by calculations of this class and also by CWallet::CreateTransaction
     128             :     coinControl.m_feerate = std::max(GetRequiredFeeRate(m_wallet), m_wallet.m_pay_tx_fee);
     129             :     // If wallet does not have the avoid-reuse feature enabled, keep legacy
     130             :     // behavior: force change to go back to the origin address. When
     131             :     // WALLET_FLAG_AVOID_REUSE is enabled, let the wallet select a fresh
     132             :     // change destination to avoid address reuse.
     133             :     if (!m_wallet.IsWalletFlagSet(wallet::WALLET_FLAG_AVOID_REUSE)) {
     134             :         coinControl.destChange = tallyItemIn.txdest;
     135             :     }
     136             :     // Only allow tallyItems inputs for tx creation
     137             :     coinControl.m_allow_other_inputs = false;
     138             :     // Create dummy tx to calculate the exact required fees upfront for accurate amount and fee calculations
     139             :     CMutableTransaction dummyTx;
     140             :     // Select all tallyItem outputs in the coinControl so that CreateTransaction knows what to use
     141             :     for (const auto& outpoint : tallyItem.outpoints) {
     142             :         coinControl.Select(outpoint);
     143             :         dummyTx.vin.emplace_back(outpoint, CScript());
     144             :     }
     145             :     // Get a comparable dummy scriptPubKey, avoid writing/flushing to the actual wallet db
     146             :     CScript dummyScript;
     147             :     {
     148             :         LOCK(m_wallet.cs_wallet);
     149             :         WalletBatch dummyBatch(m_wallet.GetDatabase(), false);
     150             :         dummyBatch.TxnBegin();
     151             :         CKey secret;
     152             :         secret.MakeNewKey(m_wallet.CanSupportFeature(FEATURE_COMPRPUBKEY));
     153             :         CPubKey dummyPubkey = secret.GetPubKey();
     154             :         dummyBatch.TxnAbort();
     155             :         dummyScript = ::GetScriptForDestination(PKHash(dummyPubkey));
     156             :         // Calculate required bytes for the dummy signed tx with tallyItem's inputs only
     157             :         nBytesBase = CalculateMaximumSignedTxSize(CTransaction(dummyTx), &m_wallet, /*coin_control=*/nullptr);
     158             :     }
     159             :     // Calculate the output size
     160             :     nBytesOutput = ::GetSerializeSize(CTxOut(0, dummyScript), PROTOCOL_VERSION);
     161             :     // Just to make sure..
     162             :     Clear();
     163           2 : }
     164             : 
     165           4 : CTransactionBuilder::~CTransactionBuilder()
     166           2 : {
     167           2 :     Clear();
     168           4 : }
     169             : 
     170           4 : void CTransactionBuilder::Clear()
     171             : {
     172           4 :     std::vector<std::unique_ptr<CTransactionBuilderOutput>> vecOutputsTmp;
     173             :     {
     174             :         // Don't hold cs_outputs while clearing the outputs which might indirectly call lock cs_wallet
     175           4 :         LOCK(cs_outputs);
     176           4 :         std::swap(vecOutputs, vecOutputsTmp);
     177           4 :         vecOutputs.clear();
     178           4 :     }
     179             : 
     180         105 :     for (auto& key : vecOutputsTmp) {
     181         101 :         if (fKeepKeys) {
     182         101 :             key->KeepKey();
     183         101 :         } else {
     184           0 :             key->ReturnKey();
     185             :         }
     186             :     }
     187             :     // Always return this key just to make sure..
     188           4 :     dummyReserveDestination.ReturnDestination();
     189           4 : }
     190             : 
     191         107 : bool CTransactionBuilder::CouldAddOutput(CAmount nAmountOutput) const
     192             : {
     193         107 :     if (nAmountOutput < 0) {
     194           2 :         return false;
     195             :     }
     196             :     // Adding another output can change the serialized size of the vout size hence + GetSizeOfCompactSizeDiff()
     197         105 :     unsigned int nBytes = GetBytesTotal() + nBytesOutput + GetSizeOfCompactSizeDiff(1);
     198         105 :     return GetAmountLeft(GetAmountInitial(), GetAmountUsed() + nAmountOutput, GetFee(nBytes)) >= 0;
     199         107 : }
     200             : 
     201           2 : bool CTransactionBuilder::CouldAddOutputs(const std::vector<CAmount>& vecOutputAmounts) const
     202             : {
     203           2 :     CAmount nAmountAdditional{0};
     204           2 :     assert(vecOutputAmounts.size() < std::numeric_limits<int>::max());
     205           2 :     int nBytesAdditional = nBytesOutput * int(vecOutputAmounts.size());
     206           8 :     for (const auto nAmountOutput : vecOutputAmounts) {
     207           6 :         if (nAmountOutput < 0) {
     208           0 :             return false;
     209             :         }
     210           6 :         nAmountAdditional += nAmountOutput;
     211             :     }
     212             :     // Adding other outputs can change the serialized size of the vout size hence + GetSizeOfCompactSizeDiff()
     213           2 :     unsigned int nBytes = GetBytesTotal() + nBytesAdditional + GetSizeOfCompactSizeDiff(vecOutputAmounts.size());
     214           2 :     return GetAmountLeft(GetAmountInitial(), GetAmountUsed() + nAmountAdditional, GetFee(nBytes)) >= 0;
     215           2 : }
     216             : 
     217         103 : CTransactionBuilderOutput* CTransactionBuilder::AddOutput(CAmount nAmountOutput)
     218             : {
     219         103 :     if (CouldAddOutput(nAmountOutput)) {
     220         101 :         LOCK(cs_outputs);
     221         101 :         vecOutputs.push_back(std::make_unique<CTransactionBuilderOutput>(this, m_wallet, nAmountOutput));
     222         101 :         return vecOutputs.back().get();
     223         101 :     }
     224           2 :     return nullptr;
     225         103 : }
     226             : 
     227         120 : unsigned int CTransactionBuilder::GetBytesTotal() const
     228             : {
     229         120 :     LOCK(cs_outputs);
     230             :     // Adding other outputs can change the serialized size of the vout size hence + GetSizeOfCompactSizeDiff()
     231         120 :     return nBytesBase + vecOutputs.size() * nBytesOutput + ::GetSizeOfCompactSizeDiff(0, vecOutputs.size());
     232         120 : }
     233             : 
     234         107 : CAmount CTransactionBuilder::GetAmountLeft(const CAmount nAmountInitial, const CAmount nAmountUsed, const CAmount nFee)
     235             : {
     236         107 :     return nAmountInitial - nAmountUsed - nFee;
     237             : }
     238             : 
     239         118 : CAmount CTransactionBuilder::GetAmountUsed() const
     240             : {
     241         118 :     LOCK(cs_outputs);
     242        5276 :     return std::accumulate(vecOutputs.begin(), vecOutputs.end(), CAmount{0}, [](const CAmount& a, const auto& b){
     243        5158 :         return a + b->GetAmount();
     244             :     });
     245         118 : }
     246             : 
     247         120 : CAmount CTransactionBuilder::GetFee(unsigned int nBytes) const
     248             : {
     249         120 :     CAmount nFeeCalc = coinControl.m_feerate->GetFee(nBytes);
     250         120 :     CAmount nRequiredFee = GetRequiredFee(m_wallet, nBytes);
     251         120 :     if (nRequiredFee > nFeeCalc) {
     252           0 :         nFeeCalc = nRequiredFee;
     253           0 :     }
     254         120 :     if (nFeeCalc > m_wallet.m_default_max_tx_fee) {
     255           0 :         nFeeCalc = m_wallet.m_default_max_tx_fee;
     256           0 :     }
     257         120 :     return nFeeCalc;
     258             : }
     259             : 
     260         108 : int CTransactionBuilder::GetSizeOfCompactSizeDiff(size_t nAdd) const
     261             : {
     262         216 :     size_t nSize = WITH_LOCK(cs_outputs, return vecOutputs.size());
     263         108 :     unsigned int ret = ::GetSizeOfCompactSizeDiff(nSize, nSize + nAdd);
     264         108 :     assert(ret <= std::numeric_limits<int>::max());
     265         108 :     return int(ret);
     266             : }
     267             : 
     268           2 : bool CTransactionBuilder::IsDust(CAmount nAmount) const
     269             : {
     270           2 :     return ::IsDust(CTxOut(nAmount, ::GetScriptForDestination(tallyItem.txdest)), coinControl.m_discard_feerate.value());
     271           0 : }
     272             : 
     273           3 : bool CTransactionBuilder::Commit(bilingual_str& strResult)
     274             : {
     275           3 :     CAmount nFeeRet = 0;
     276           3 :     int nChangePosRet{RANDOM_CHANGE_POSITION};
     277             : 
     278             :     // Transform the outputs to the format CWallet::CreateTransaction requires
     279           3 :     std::vector<CRecipient> vecSend;
     280             :     {
     281           3 :         LOCK(cs_outputs);
     282           3 :         vecSend.reserve(vecOutputs.size());
     283         105 :         for (const auto& out : vecOutputs) {
     284         102 :             vecSend.push_back((CRecipient){out->GetScript(), out->GetAmount(), false});
     285             :         }
     286           3 :     }
     287             : 
     288           3 :     CTransactionRef tx;
     289             :     {
     290           3 :         LOCK2(m_wallet.cs_wallet, ::cs_main);
     291           3 :         auto ret = wallet::CreateTransaction(m_wallet, vecSend, nChangePosRet, coinControl);
     292           3 :         if (ret) {
     293           2 :             tx = ret->tx;
     294           2 :             nFeeRet = ret->fee;
     295           2 :             nChangePosRet = ret->change_pos;
     296           2 :         } else {
     297           1 :             strResult = util::ErrorString(ret);
     298           1 :             return false;
     299             :         }
     300           3 :     }
     301             : 
     302           2 :     CAmount nAmountLeft = GetAmountLeft();
     303           2 :     bool fDust = IsDust(nAmountLeft);
     304             :     // If there is a either remainder which is considered to be dust (will be added to fee in this case) or no amount left there should be no change output, return if there is a change output.
     305           2 :     if (nChangePosRet != RANDOM_CHANGE_POSITION && fDust) {
     306           0 :         strResult = Untranslated(strprintf("Unexpected change output %s at position %d", tx->vout[nChangePosRet].ToString(), nChangePosRet));
     307           0 :         return false;
     308             :     }
     309             : 
     310             :     // If there is a remainder which is not considered to be dust it should end up in a change output, return if not.
     311           2 :     if (nChangePosRet == RANDOM_CHANGE_POSITION && !fDust) {
     312           0 :         strResult = Untranslated(strprintf("Change output missing: %d", nAmountLeft));
     313           0 :         return false;
     314             :     }
     315             : 
     316           2 :     CAmount nFeeAdditional{0};
     317           2 :     unsigned int nBytesAdditional{0};
     318             : 
     319           2 :     if (fDust) {
     320           1 :         nFeeAdditional = nAmountLeft;
     321           1 :     } else {
     322             :         // Add a change output and GetSizeOfCompactSizeDiff(1) as another output can changes the serialized size of the vout size in CTransaction
     323           1 :         nBytesAdditional = nBytesOutput + GetSizeOfCompactSizeDiff(1);
     324             :     }
     325             : 
     326             :     // If the calculated fee does not match the fee returned by CreateTransaction aka if this check fails something is wrong!
     327           2 :     CAmount nFeeCalc = GetFee(GetBytesTotal() + nBytesAdditional) + nFeeAdditional;
     328           2 :     if (nFeeRet != nFeeCalc) {
     329           0 :         strResult = Untranslated(strprintf("Fee validation failed -> nFeeRet: %d, nFeeCalc: %d, nFeeAdditional: %d, nBytesAdditional: %d, %s", nFeeRet, nFeeCalc, nFeeAdditional, nBytesAdditional, ToString()));
     330           0 :         return false;
     331             :     }
     332             : 
     333             :     {
     334           2 :         LOCK2(m_wallet.cs_wallet, ::cs_main);
     335           2 :         m_wallet.CommitTransaction(tx, {}, {});
     336           2 :     }
     337             : 
     338           2 :     fKeepKeys = true;
     339             : 
     340           2 :     strResult = Untranslated(tx->GetHash().ToString());
     341             : 
     342           2 :     return true;
     343           3 : }
     344             : 
     345           0 : std::string CTransactionBuilder::ToString() const
     346             : {
     347           0 :     return strprintf("CTransactionBuilder(Amount initial: %d, Amount left: %d, Bytes base: %d, Bytes output: %d, Bytes total: %d, Amount used: %d, Outputs: %d, Fee rate: %d, Discard fee rate: %d, Fee: %d)",
     348           0 :         GetAmountInitial(),
     349           0 :         GetAmountLeft(),
     350           0 :         nBytesBase,
     351           0 :         nBytesOutput,
     352           0 :         GetBytesTotal(),
     353           0 :         GetAmountUsed(),
     354           0 :         CountOutputs(),
     355           0 :         coinControl.m_feerate->GetFeePerK(),
     356           0 :         coinControl.m_discard_feerate->GetFeePerK(),
     357           0 :         GetFee(GetBytesTotal()));
     358             : }