ci: wip: Pr 6549

.github/workflows/build-src.yml

@@ -28,16 +28,13 @@ jobs:
         uses: actions/checkout@v4
         with:
           ref: ${{ github.event.pull_request.head.sha }}
-          fetch-depth: 0
+          fetch-depth: 50
 
       - name: Initial setup
         id: setup
         run: |
-          git config --global --add advice.detachedHead false
           git config --global --add safe.directory "$PWD"
-          GIT_HEAD="$(git rev-parse HEAD)"
-          git checkout develop
-          git checkout "${GIT_HEAD}"
+          git fetch -fu origin develop:develop
           BUILD_TARGET="${{ inputs.build-target }}"
           source ./ci/dash/matrix.sh
           echo "HOST=${HOST}" >> $GITHUB_OUTPUT
@@ -64,7 +61,7 @@ jobs:
             ${{ runner.os }}-${{ inputs.build-target }}-${{ steps.setup.outputs.HOST }}
             ${{ runner.os }}-${{ inputs.build-target }}
 
-      - name: Build source and run unit tests
+      - name: Build source
         run: |
           CCACHE_SIZE="400M"
           CACHE_DIR="/cache"
@@ -73,6 +70,15 @@ jobs:
           BUILD_TARGET="${{ inputs.build-target }}"
           source ./ci/dash/matrix.sh
           ./ci/dash/build_src.sh
+          ccache -X 9
+          ccache -c
+        shell: bash
+
+      - name: Run unit tests
+        run: |
+          BASE_OUTDIR="/output"
+          BUILD_TARGET="${{ inputs.build-target }}"
+          source ./ci/dash/matrix.sh
           ./ci/dash/test_unittests.sh
         shell: bash
 

src/interfaces/wallet.h

@@ -223,12 +223,6 @@ class Wallet
     //! Get anonymizable balance.
     virtual CAmount getAnonymizableBalance(bool fSkipDenominated, bool fSkipUnconfirmed) = 0;
 
-    //! Get anonymized balance.
-    virtual CAmount getAnonymizedBalance() = 0;
-
-    //! Get denominated balance.
-    virtual CAmount getDenominatedBalance(bool unconfirmed) = 0;
-
     //! Get normalized anonymized balance.
     virtual CAmount getNormalizedAnonymizedBalance() = 0;
 
@@ -388,6 +382,8 @@ struct WalletBalances
     CAmount watch_only_balance = 0;
     CAmount unconfirmed_watch_only_balance = 0;
     CAmount immature_watch_only_balance = 0;
+    CAmount denominated_untrusted_pending = 0;
+    CAmount denominated_trusted = 0;
 
     bool balanceChanged(const WalletBalances& prev) const
     {

src/qt/overviewpage.cpp

@@ -426,13 +426,12 @@ void OverviewPage::updateCoinJoinProgress()
 
     if (!fShowAdvancedCJUI) return;
 
-    CAmount nDenominatedConfirmedBalance;
-    CAmount nDenominatedUnconfirmedBalance;
+    const interfaces::WalletBalances balances = walletModel->wallet().getBalances();
+    CAmount nDenominatedConfirmedBalance = balances.denominated_trusted;
+    CAmount nDenominatedUnconfirmedBalance = balances.denominated_untrusted_pending;
     CAmount nNormalizedAnonymizedBalance;
     float nAverageAnonymizedRounds;
 
-    nDenominatedConfirmedBalance = walletModel->wallet().getDenominatedBalance(false);
-    nDenominatedUnconfirmedBalance = walletModel->wallet().getDenominatedBalance(true);
     nNormalizedAnonymizedBalance = walletModel->wallet().getNormalizedAnonymizedBalance();
     nAverageAnonymizedRounds = walletModel->wallet().getAverageAnonymizedRounds();
 

src/wallet/interfaces.cpp

@@ -392,6 +392,8 @@ class WalletImpl : public Wallet
             result.unconfirmed_watch_only_balance = bal.m_watchonly_untrusted_pending;
             result.immature_watch_only_balance = bal.m_watchonly_immature;
         }
+        result.denominated_untrusted_pending = bal.m_denominated_untrusted_pending;
+        result.denominated_trusted = bal.m_denominated_trusted;
         return result;
     }
     bool tryGetBalances(WalletBalances& balances, uint256& block_hash) override
@@ -412,19 +414,6 @@ class WalletImpl : public Wallet
     {
         return m_wallet->GetAnonymizableBalance(fSkipDenominated, fSkipUnconfirmed);
     }
-    CAmount getAnonymizedBalance() override
-    {
-        return m_wallet->GetBalance().m_anonymized;
-    }
-    CAmount getDenominatedBalance(bool unconfirmed) override
-    {
-        const auto bal = m_wallet->GetBalance();
-        if (unconfirmed) {
-            return bal.m_denominated_untrusted_pending;
-        } else {
-            return bal.m_denominated_trusted;
-        }
-    }
     CAmount getNormalizedAnonymizedBalance() override
     {
         return m_wallet->GetNormalizedAnonymizedBalance();
@@ -436,7 +425,7 @@ class WalletImpl : public Wallet
     CAmount getAvailableBalance(const CCoinControl& coin_control) override
     {
         if (coin_control.IsUsingCoinJoin()) {
-            return m_wallet->GetBalance(0, coin_control.m_avoid_address_reuse, false, &coin_control).m_anonymized;
+            return m_wallet->GetBalanceAnonymized(coin_control);
         } else {
             return m_wallet->GetAvailableBalance(&coin_control);
         }

src/wallet/receive.cpp

@@ -313,10 +313,23 @@ bool CWalletTx::IsTrusted() const
     return pwallet->IsTrusted(*this, trusted_parents);
 }
 
-CWallet::Balance CWallet::GetBalance(const int min_depth, const bool avoid_reuse, const bool fAddLocked, const CCoinControl* coinControl) const
+CAmount CWallet::GetBalanceAnonymized(const CCoinControl& coinControl) const
+{
+    if (!CCoinJoinClientOptions::IsEnabled()) return 0;
+
+    CAmount anonymized_amount{0};
+    LOCK(cs_wallet);
+    for (auto pcoin : GetSpendableTXs()) {
+        anonymized_amount += pcoin->GetAnonymizedCredit(coinControl);
+    }
+    return anonymized_amount;
+}
+
+CWallet::Balance CWallet::GetBalance(const int min_depth, const bool avoid_reuse, const bool fAddLocked) const
 {
     Balance ret;
     isminefilter reuse_filter = avoid_reuse ? ISMINE_NO : ISMINE_USED;
+    const bool cj_enabled = CCoinJoinClientOptions::IsEnabled();
     {
         LOCK(cs_wallet);
         std::set<uint256> trusted_parents;
@@ -337,10 +350,14 @@ CWallet::Balance CWallet::GetBalance(const int min_depth, const bool avoid_reuse
             }
             ret.m_mine_immature += wtx.GetImmatureCredit();
             ret.m_watchonly_immature += wtx.GetImmatureWatchOnlyCredit();
-            if (CCoinJoinClientOptions::IsEnabled()) {
-                ret.m_anonymized += wtx.GetAnonymizedCredit(coinControl);
-                ret.m_denominated_trusted += wtx.GetDenominatedCredit(false);
-                ret.m_denominated_untrusted_pending += wtx.GetDenominatedCredit(true);
+            if (cj_enabled) {
+                const auto balance_anonymized = wtx.GetAvailableCoinJoinCredits();
+                ret.m_anonymized += balance_anonymized.m_anonymized;
+                if (balance_anonymized.is_unconfirmed) {
+                    ret.m_denominated_untrusted_pending += balance_anonymized.m_denominated;
+                } else {
+                    ret.m_denominated_trusted += balance_anonymized.m_denominated;
+                }
             }
         }
     }

src/wallet/transaction.h

@@ -289,12 +289,21 @@ class CWalletTx
     CAmount GetImmatureWatchOnlyCredit(const bool fUseCache = true) const;
     CAmount GetChange() const;
 
+    struct CoinJoinCredits
+    {
+        CAmount m_anonymized{0};
+        CAmount m_denominated{0};
+        bool is_unconfirmed{false};
+    };
+
     // TODO: Remove "NO_THREAD_SAFETY_ANALYSIS" and replace it with the correct
     // annotation "EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)". The
     // annotation "NO_THREAD_SAFETY_ANALYSIS" was temporarily added to avoid
     // having to resolve the issue of member access into incomplete type CWallet.
-    CAmount GetAnonymizedCredit(const CCoinControl* coinControl = nullptr) const NO_THREAD_SAFETY_ANALYSIS;
-    CAmount GetDenominatedCredit(bool unconfirmed, bool fUseCache=true) const NO_THREAD_SAFETY_ANALYSIS;
+    /* Requires cs_wallet lock. */
+    CAmount GetAnonymizedCredit(const CCoinControl& coinControl) const NO_THREAD_SAFETY_ANALYSIS;
+    /* Requires cs_wallet lock. */
+    CoinJoinCredits GetAvailableCoinJoinCredits() const NO_THREAD_SAFETY_ANALYSIS;
 
     /** Get the marginal bytes if spending the specified output from this transaction */
     int GetSpendSize(unsigned int out, bool use_max_sig = false) const

src/wallet/wallet.cpp

@@ -1990,7 +1990,7 @@ std::set<uint256> CWalletTx::GetConflicts() const
     return result;
 }
 
-CAmount CWalletTx::GetAnonymizedCredit(const CCoinControl* coinControl) const
+CAmount CWalletTx::GetAnonymizedCredit(const CCoinControl& coinControl) const
 {
     if (!pwallet)
         return 0;
@@ -2001,17 +2001,14 @@ CAmount CWalletTx::GetAnonymizedCredit(const CCoinControl* coinControl) const
     if (IsCoinBase() || GetDepthInMainChain() < 0)
         return 0;
 
-    if (coinControl == nullptr && m_amounts[ANON_CREDIT].m_cached[ISMINE_SPENDABLE])
-        return m_amounts[ANON_CREDIT].m_value[ISMINE_SPENDABLE];
-
     CAmount nCredit = 0;
     uint256 hashTx = GetHash();
     for (unsigned int i = 0; i < tx->vout.size(); i++)
     {
         const CTxOut &txout = tx->vout[i];
         const COutPoint outpoint = COutPoint(hashTx, i);
 
-        if (coinControl != nullptr && coinControl->HasSelected() && !coinControl->IsSelected(outpoint)) {
+        if (coinControl.HasSelected() && !coinControl.IsSelected(outpoint)) {
             continue;
         }
 
@@ -2024,57 +2021,60 @@ CAmount CWalletTx::GetAnonymizedCredit(const CCoinControl* coinControl) const
         }
     }
 
-    if (coinControl == nullptr) {
-        m_amounts[ANON_CREDIT].Set(ISMINE_SPENDABLE, nCredit);
-    }
-
     return nCredit;
 }
 
-CAmount CWalletTx::GetDenominatedCredit(bool unconfirmed, bool fUseCache) const
+CWalletTx::CoinJoinCredits CWalletTx::GetAvailableCoinJoinCredits() const
 {
+    CWalletTx::CoinJoinCredits ret;
     if (pwallet == nullptr)
-        return 0;
+        return ret;
 
     AssertLockHeld(pwallet->cs_wallet);
 
     // Must wait until coinbase is safely deep enough in the chain before valuing it
     if (IsCoinBase() && GetBlocksToMaturity() > 0)
-        return 0;
+        return ret;
 
     int nDepth = GetDepthInMainChain();
-    if (nDepth < 0) return 0;
+    if (nDepth < 0) return ret;
 
-    bool isUnconfirmed = IsTrusted() && nDepth == 0;
-    if (unconfirmed != isUnconfirmed) return 0;
+    ret.is_unconfirmed = IsTrusted() && nDepth == 0;
 
-    if (fUseCache) {
-        if(unconfirmed && m_amounts[DENOM_UCREDIT].m_cached[ISMINE_SPENDABLE]) {
-            return m_amounts[DENOM_UCREDIT].m_value[ISMINE_SPENDABLE];
-        } else if (!unconfirmed && m_amounts[DENOM_CREDIT].m_cached[ISMINE_SPENDABLE]) {
-            return m_amounts[DENOM_CREDIT].m_value[ISMINE_SPENDABLE];
+    if (m_amounts[ANON_CREDIT].m_cached[ISMINE_SPENDABLE]) {
+        if (ret.is_unconfirmed && m_amounts[DENOM_UCREDIT].m_cached[ISMINE_SPENDABLE]) {
+            return {m_amounts[ANON_CREDIT].m_value[ISMINE_SPENDABLE], m_amounts[DENOM_UCREDIT].m_value[ISMINE_SPENDABLE], ret.is_unconfirmed};
+        } else if (!ret.is_unconfirmed && m_amounts[DENOM_CREDIT].m_cached[ISMINE_SPENDABLE]) {
+            return {m_amounts[ANON_CREDIT].m_value[ISMINE_SPENDABLE], m_amounts[DENOM_CREDIT].m_value[ISMINE_SPENDABLE], ret.is_unconfirmed};
         }
     }
 
-    CAmount nCredit = 0;
     uint256 hashTx = GetHash();
-    for (unsigned int i = 0; i < tx->vout.size(); i++)
-    {
+    for (unsigned int i = 0; i < tx->vout.size(); i++) {
         const CTxOut &txout = tx->vout[i];
+        const COutPoint outpoint = COutPoint(hashTx, i);
 
         if (pwallet->IsSpent(hashTx, i) || !CoinJoin::IsDenominatedAmount(txout.nValue)) continue;
+        const CAmount credit = pwallet->GetCredit(txout, ISMINE_SPENDABLE);
 
-        nCredit += pwallet->GetCredit(txout, ISMINE_SPENDABLE);
-        if (!MoneyRange(nCredit))
+        if (pwallet->IsFullyMixed(outpoint)) {
+            ret.m_anonymized += credit;
+            if (!MoneyRange(ret.m_anonymized))
+                throw std::runtime_error(std::string(__func__) + ": value out of range");
+        }
+
+        ret.m_denominated += credit;
+        if (!MoneyRange(ret.m_denominated))
             throw std::runtime_error(std::string(__func__) + ": value out of range");
     }
 
-    if (unconfirmed) {
-        m_amounts[DENOM_UCREDIT].Set(ISMINE_SPENDABLE, nCredit);
+    m_amounts[ANON_CREDIT].Set(ISMINE_SPENDABLE, ret.m_anonymized);
+    if (ret.is_unconfirmed) {
+        m_amounts[DENOM_UCREDIT].Set(ISMINE_SPENDABLE, ret.m_denominated);
     } else {
-        m_amounts[DENOM_CREDIT].Set(ISMINE_SPENDABLE, nCredit);
+        m_amounts[DENOM_CREDIT].Set(ISMINE_SPENDABLE, ret.m_denominated);
     }
-    return nCredit;
+    return ret;
 }
 
 // Rebroadcast transactions from the wallet. We do this on a random timer

src/wallet/wallet.h

@@ -673,7 +673,8 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
         CAmount m_denominated_trusted{0};
         CAmount m_denominated_untrusted_pending{0};
     };
-    Balance GetBalance(const int min_depth = 0, const bool avoid_reuse = true, const bool fAddLocked = false, const CCoinControl* coinControl = nullptr) const;
+    Balance GetBalance(const int min_depth = 0, const bool avoid_reuse = true, const bool fAddLocked = false) const;
+    CAmount GetBalanceAnonymized(const CCoinControl& coinControl) const;
 
     CAmount GetAnonymizableBalance(bool fSkipDenominated = false, bool fSkipUnconfirmed = true) const;
     float GetAverageAnonymizedRounds() const;