Moved the CalculateDeniabilizaitonCycles to the API too.

Author: denavila

src/interfaces/wallet.h

@@ -151,6 +151,8 @@ class Wallet
         WalletValueMap value_map,
         WalletOrderForm order_form) = 0;
 
+    virtual std::pair<unsigned int, bool> calculateDeniabilizationCycles(const COutPoint& outpoint) = 0;
+
     virtual util::Result<CTransactionRef> createDeniabilizationTransaction(const std::set<COutPoint>& inputs,
                                                                            unsigned int confirm_target,
                                                                            unsigned int deniabilization_cycles,

src/wallet/interfaces.cpp

@@ -295,6 +295,11 @@ class WalletImpl : public Wallet
         LOCK(m_wallet->cs_wallet);
         m_wallet->CommitTransaction(std::move(tx), std::move(value_map), std::move(order_form));
     }
+    std::pair<unsigned int, bool> calculateDeniabilizationCycles(const COutPoint& outpoint) override
+    {
+        LOCK(m_wallet->cs_wallet); // TODO - Do we need a lock here?
+        return CalculateDeniabilizationCycles(*m_wallet, outpoint);
+    }
     util::Result<CTransactionRef> createDeniabilizationTransaction(const std::set<COutPoint>& inputs,
                                                                    unsigned int confirm_target,
                                                                    unsigned int deniabilization_cycles,

src/wallet/spend.cpp

@@ -1337,13 +1337,83 @@ CAmount CalculateDeniabilizationFeeEstimate(const CTxDestination& shared_destina
     return deniabilizationFee;
 }
 
-util::Result<CreatedTransactionResult> CreateDeniabilizationTransaction(
-    CWallet& wallet,
-    const std::set<COutPoint>& inputs,
-    unsigned int confirm_target,
-    unsigned int deniabilization_cycles,
-    bool sign,
-    bool& insufficient_amount)
+std::pair<unsigned int, bool> CalculateDeniabilizationCycles(CWallet& wallet, const COutPoint& outpoint)
+{
+    LOCK(wallet.cs_wallet);
+    auto walletTx = wallet.GetWalletTx(outpoint.hash);
+    if (!walletTx) {
+        return std::make_pair(0, false);
+    }
+    auto tx = walletTx->tx;
+
+    if (tx->IsCoinBase()) {
+        // this is a block reward tx, so we tag it as such
+        return std::make_pair(0, true);
+    }
+
+    // an deniabilized coin is one we sent to ourselves
+    // all txIn should belong to our wallet
+    if (tx->vin.empty()) {
+        return std::make_pair(0, false);
+    }
+    for (const auto& txIn : tx->vin) {
+        if (InputIsMine(wallet, txIn) == ISMINE_NO) {
+            return std::make_pair(0, false);
+        }
+    }
+
+    // all txOut should belong to our wallet
+    Assert(outpoint.n < tx->vout.size());
+    uint n = 0;
+    for (const auto& txOut : tx->vout) {
+        if (wallet.IsMine(txOut) == ISMINE_NO) {
+            Assert(n != outpoint.n);
+            return std::make_pair(0, false);
+        }
+        n++;
+    }
+
+    uint uniqueTxOutCount = 0;
+    for (const auto& txOut : tx->vout) {
+        // check if it's a valid destination
+        CTxDestination txOutDestination;
+        if (!ExtractDestination(txOut.scriptPubKey, txOutDestination)) {
+            continue;
+        }
+
+        // don't count outputs that match any input addresses (eg it's change output)
+        bool matchesInput = false;
+        for (const auto& txIn : tx->vin) {
+            auto prevWalletTx = wallet.GetWalletTx(txIn.prevout.hash);
+            if (prevWalletTx && prevWalletTx->tx->vout[txIn.prevout.n].scriptPubKey == txOut.scriptPubKey) {
+                matchesInput = true;
+                break;
+            }
+        }
+        if (matchesInput) {
+            continue;
+        }
+
+        uniqueTxOutCount++;
+    }
+
+    // we consider two or more unique outputs an "deniabilization" of the coin
+    uint deniabilizationCycles = uniqueTxOutCount >= 2 ? 1 : 0;
+
+    // all txIn and txOut are from our wallet
+    // however if we have multiple txIn this was either an initial deniabilization of multiple UTXOs or the user manually merged deniabilized UTXOs
+    // in either case we don't need to recurse into parent transactions and we can return the calculated cycles
+    if (tx->vin.size() > 1) {
+        return std::make_pair(deniabilizationCycles, false);
+    }
+
+    const auto& txIn = tx->vin[0];
+    // now recursively calculate the deniabilization cycles of the input
+    auto inputStats = CalculateDeniabilizationCycles(wallet, txIn.prevout);
+    return std::make_pair(inputStats.first + deniabilizationCycles, inputStats.second);
+};
+
+util::Result<CreatedTransactionResult> CreateDeniabilizationTransaction(CWallet& wallet, const std::set<COutPoint>& inputs, unsigned int confirm_target, unsigned int deniabilization_cycles, bool sign, bool& insufficient_amount)
 {
     if (inputs.empty()) {
         return util::Error{_("Inputs must not be empty")};

src/wallet/spend.h

@@ -249,6 +249,13 @@ CAmount CalculateDeniabilizationFeeEstimate(const CTxDestination& shared_destina
  */
 CFeeRate CalculateDeniabilizationFeeRate(const CWallet& wallet, unsigned int confirm_target);
 
+/**
+ * Calculate how many deniabilization cycles have been performed for the given UTXO
+ * Result.first is the deniabilization cycle count
+ * Result.second indicates if the transaction chain is from a coinbase transaction (block reward)
+ */
+std::pair<unsigned int, bool> CalculateDeniabilizationCycles(CWallet& wallet, const COutPoint& outpoint);
+
 /**
  * Create a deniabilization transaction with the provided set of inputs (must share the same destination)
  * confirm_target is the confirmation target for the deniabilization transaction