wallet: Add separate balance info for non-mempool wallet txs

ajtowns · ajtowns · commit 1a5e481c0e2d · 2025-11-27T16:41:38.000+10:00
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
@@ -370,12 +370,13 @@ struct WalletBalances
     CAmount unconfirmed_balance = 0;
     CAmount immature_balance = 0;
     CAmount used_balance = 0;
+    CAmount nonmempool_balance = 0;
 
     bool balanceChanged(const WalletBalances& prev) const
     {
         return balance != prev.balance || unconfirmed_balance != prev.unconfirmed_balance ||
                immature_balance != prev.immature_balance ||
-               used_balance != prev.used_balance;
+               used_balance != prev.used_balance || nonmempool_balance != prev.nonmempool_balance;
     }
 };
 
diff --git a/src/wallet/interfaces.cpp b/src/wallet/interfaces.cpp
@@ -383,12 +383,13 @@ class WalletImpl : public Wallet
     }
     WalletBalances getBalances() override
     {
-        const auto bal = GetBalance(*m_wallet);
+        const auto bal = GetBalance(*m_wallet, /*min_depth=*/0, /*avoid_reuse=*/true, /*include_nonmempool=*/true);
         WalletBalances result;
         result.balance = bal.m_mine_trusted;
         result.unconfirmed_balance = bal.m_mine_untrusted_pending;
         result.immature_balance = bal.m_mine_immature;
         result.used_balance = bal.m_mine_used;
+        result.nonmempool_balance = bal.m_mine_nonmempool;
         return result;
     }
     bool tryGetBalances(WalletBalances& balances, uint256& block_hash) override
diff --git a/src/wallet/receive.cpp b/src/wallet/receive.cpp
@@ -242,7 +242,7 @@ bool CachedTxIsTrusted(const CWallet& wallet, const CWalletTx& wtx)
     return CachedTxIsTrusted(wallet, wtx, trusted_parents);
 }
 
-Balance GetBalance(const CWallet& wallet, const int min_depth, bool avoid_reuse)
+Balance GetBalance(const CWallet& wallet, const int min_depth, bool avoid_reuse, bool include_nonmempool)
 {
     Balance ret;
     bool allow_used_addresses = !avoid_reuse || !wallet.IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE);
@@ -255,7 +255,17 @@ Balance GetBalance(const CWallet& wallet, const int min_depth, bool avoid_reuse)
             const bool is_trusted{CachedTxIsTrusted(wallet, wtx, trusted_parents)};
             const int tx_depth{wallet.GetTxDepthInMainChain(wtx)};
 
-            if (!wallet.IsSpent(outpoint)) {
+            bool nonmempool_spent = false;
+            switch (wallet.HowSpent(outpoint)) {
+            case CWallet::SpendType::CONFIRMED:
+            case CWallet::SpendType::MEMPOOL:
+                // treat as spent; ignore
+                break;
+            case CWallet::SpendType::NONMEMPOOL:
+                if (!include_nonmempool || !allow_used_addresses) break;
+                nonmempool_spent = true;
+                [[fallthrough]];
+            case CWallet::SpendType::UNSPENT:
                 CAmount* bucket = nullptr;
 
                 // Set the amounts in the return object
@@ -274,6 +284,9 @@ Balance GetBalance(const CWallet& wallet, const int min_depth, bool avoid_reuse)
                         bucket = &ret.m_mine_used;
                     }
                     *bucket += credit_mine;
+                    if (nonmempool_spent) {
+                        ret.m_mine_nonmempool -= credit_mine;
+                    }
                 }
             }
         }
diff --git a/src/wallet/receive.h b/src/wallet/receive.h
@@ -48,8 +48,9 @@ struct Balance {
     CAmount m_mine_untrusted_pending{0}; //!< Untrusted, but in mempool (pending)
     CAmount m_mine_immature{0};          //!< Immature coinbases in the main chain
     CAmount m_mine_used{0};              //!< Trusted/untrusted/immature funds in utxos that have already been spent from (only populated if AVOID REUSE wallet flag is set)
+    CAmount m_mine_nonmempool{0};        //!< Coins spent by wallet txs that are not in the mempool
 };
-Balance GetBalance(const CWallet& wallet, int min_depth = 0, bool avoid_reuse = true);
+Balance GetBalance(const CWallet& wallet, int min_depth = 0, bool avoid_reuse = true, bool include_nonmempool = false);
 
 std::map<CTxDestination, CAmount> GetAddressBalances(const CWallet& wallet);
 std::set<std::set<CTxDestination>> GetAddressGroupings(const CWallet& wallet) EXCLUSIVE_LOCKS_REQUIRED(wallet.cs_wallet);
diff --git a/src/wallet/rpc/coins.cpp b/src/wallet/rpc/coins.cpp
@@ -413,6 +413,7 @@ RPCHelpMan getbalances()
                     {RPCResult::Type::STR_AMOUNT, "trusted", "trusted balance (outputs created by the wallet or confirmed outputs)"},
                     {RPCResult::Type::STR_AMOUNT, "untrusted_pending", "untrusted pending balance (outputs created by others that are in the mempool)"},
                     {RPCResult::Type::STR_AMOUNT, "immature", "balance from immature coinbase outputs"},
+                    {RPCResult::Type::STR_AMOUNT, "nonmempool", "sum of coins that are locked or spent by transactions not in the mempool (usually an over-estimate due to not accounting for change or spends that conflict with each other)"},
                     {RPCResult::Type::STR_AMOUNT, "used", /*optional=*/true, "(only present if avoid_reuse is set) balance from coins sent to addresses that were previously spent from (potentially privacy violating)"},
                 }},
                 RESULT_LAST_PROCESSED_BLOCK,
@@ -433,14 +434,15 @@ RPCHelpMan getbalances()
 
     LOCK(wallet.cs_wallet);
 
-    const auto bal = GetBalance(wallet, /*min_depth=*/0, /*avoid_reuse=*/true);
+    const auto bal = GetBalance(wallet, /*min_depth=*/0, /*avoid_reuse=*/true, /*include_nonmempool=*/true);
 
     UniValue balances{UniValue::VOBJ};
     {
         UniValue balances_mine{UniValue::VOBJ};
         balances_mine.pushKV("trusted", ValueFromAmount(bal.m_mine_trusted));
         balances_mine.pushKV("untrusted_pending", ValueFromAmount(bal.m_mine_untrusted_pending));
         balances_mine.pushKV("immature", ValueFromAmount(bal.m_mine_immature));
+        balances_mine.pushKV("nonmempool", ValueFromAmount(bal.m_mine_nonmempool));
         if (wallet.IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE)) {
             balances_mine.pushKV("used", ValueFromAmount(bal.m_mine_used));
         }
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
@@ -738,6 +738,29 @@ bool CWallet::IsSpent(const COutPoint& outpoint) const
     return false;
 }
 
+CWallet::SpendType CWallet::HowSpent(const COutPoint& outpoint) const
+{
+    SpendType st{SpendType::UNSPENT};
+
+    std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range;
+    range = mapTxSpends.equal_range(outpoint);
+
+    for (TxSpends::const_iterator it = range.first; it != range.second; ++it) {
+        const Txid& txid = it->second;
+        const auto mit = mapWallet.find(txid);
+        if (mit != mapWallet.end()) {
+            const auto& wtx = mit->second;
+            if (wtx.isConfirmed()) return SpendType::CONFIRMED;
+            if (wtx.InMempool()) {
+                st = SpendType::MEMPOOL;
+            } else if (!wtx.isAbandoned() && !wtx.isBlockConflicted() && !wtx.isMempoolConflicted()) {
+                if (st == SpendType::UNSPENT) st = SpendType::NONMEMPOOL;
+            }
+        }
+    }
+    return st;
+}
+
 void CWallet::AddToSpends(const COutPoint& outpoint, const Txid& txid)
 {
     mapTxSpends.insert(std::make_pair(outpoint, txid));
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
@@ -556,6 +556,13 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
     int GetTxBlocksToMaturity(const CWalletTx& wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     bool IsTxImmatureCoinBase(const CWalletTx& wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
+    enum class SpendType {
+        UNSPENT,
+        CONFIRMED,
+        MEMPOOL,
+        NONMEMPOOL,
+    };
+    SpendType HowSpent(const COutPoint& outpoint) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     bool IsSpent(const COutPoint& outpoint) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     // Whether this or any known scriptPubKey with the same single key has been spent.
diff --git a/test/functional/wallet_abandonconflict.py b/test/functional/wallet_abandonconflict.py
@@ -115,10 +115,9 @@ def run_test(self):
         # inputs are still spent, but change not received
         newbalance = alice.getbalance()
         assert_equal(newbalance, balance - signed3_change)
-        # Unconfirmed received funds that are not in mempool, also shouldn't show
-        # up in unconfirmed balance
+        # Unconfirmed received funds that are not in mempool
         balances = alice.getbalances()['mine']
-        assert_equal(balances['untrusted_pending'] + balances['trusted'], newbalance)
+        assert_equal(balances['untrusted_pending'] + balances['trusted'] + balances['nonmempool'], newbalance)
         # Also shouldn't show up in listunspent
         assert not txABC2 in [utxo["txid"] for utxo in alice.listunspent(0)]
         balance = newbalance
diff --git a/test/functional/wallet_balance.py b/test/functional/wallet_balance.py
@@ -145,10 +145,12 @@ def test_balances(*, fee_node_1=0):
             # getbalances
             expected_balances_0 = {'mine':      {'immature':          Decimal('0E-8'),
                                                  'trusted':           Decimal('9.99'),  # change from node 0's send
-                                                 'untrusted_pending': Decimal('60.0')}}
+                                                 'untrusted_pending': Decimal('60.0'),
+                                                 'nonmempool':        Decimal('0.0')}}
             expected_balances_1 = {'mine':      {'immature':          Decimal('0E-8'),
                                                  'trusted':           Decimal('0E-8'),  # node 1's send had an unsafe input
-                                                 'untrusted_pending': Decimal('30.0') - fee_node_1}}  # Doesn't include output of node 0's send since it was spent
+                                                 'untrusted_pending': Decimal('30.0') - fee_node_1,  # Doesn't include output of node 0's send since it was spent
+                                                 'nonmempool':        Decimal('0.0')}}
             balances_0 = self.nodes[0].getbalances()
             balances_1 = self.nodes[1].getbalances()
             # remove lastprocessedblock keys (they will be tested later)
diff --git a/test/functional/wallet_conflicts.py b/test/functional/wallet_conflicts.py
@@ -304,8 +304,9 @@ def test_mempool_and_block_conflicts(self):
         bob.sendrawtransaction(tx1_conflict_conflict) # kick tx1_conflict out of the mempool
         bob.sendrawtransaction(raw_tx1) #re-broadcast tx1 because it is no longer conflicted
 
-        # Now bob has no pending funds because tx1 and tx2 are spent by tx3, which hasn't been re-broadcast yet
-        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], 0)
+        # Now bob has pending funds because tx1 and tx2 are spent by tx3, which hasn't been re-broadcast yet
+        bob_bal = bob.getbalances()["mine"]
+        assert_equal(bob_bal["untrusted_pending"], -bob_bal["nonmempool"])
 
         bob.sendrawtransaction(raw_tx3)
         assert_equal(len(bob.getrawmempool()), 4) # The mempool contains: tx1, tx2, tx1_conflict_conflict, tx3
diff --git a/test/functional/wallet_migration.py b/test/functional/wallet_migration.py
@@ -8,6 +8,7 @@
 import shutil
 import struct
 import time
+from decimal import Decimal
 
 from test_framework.address import (
     key_to_p2pkh,
@@ -522,6 +523,7 @@ def test_pk_coinbases(self):
         self.generatetodescriptor(self.master_node, 1, desc)
 
         bals = wallet.getbalances()
+        bals["mine"]["nonmempool"] = Decimal('0.0')
 
         _, wallet = self.migrate_and_get_rpc("pkcb")
 
@@ -537,6 +539,7 @@ def test_encrypted(self):
         txid = default.sendtoaddress(addr, 1)
         self.generate(self.master_node, 1)
         bals = wallet.getbalances()
+        bals["mine"]["nonmempool"] = Decimal('0.0')
 
         # Use self.migrate_and_get_rpc to test this error to get everything copied over to the master node
         assert_raises_rpc_error(-4, "Error: Wallet decryption failed, the wallet passphrase was not provided or was incorrect", self.migrate_and_get_rpc, "encrypted")
@@ -577,6 +580,7 @@ def test_unloaded_by_path(self):
         txid = default.sendtoaddress(addr, 1)
         self.generate(self.master_node, 1)
         bals = wallet.getbalances()
+        bals["mine"]["nonmempool"] = Decimal('0.0')
 
         wallet.unloadwallet()
 
@@ -616,6 +620,7 @@ def test_wallet_with_relative_path(self):
         txid = default.sendtoaddress(addr, 1)
         self.generate(self.master_node, 1)
         bals = wallet.getbalances()
+        bals["mine"]["nonmempool"] = Decimal('0.0')
 
         migrate_res, wallet = self.migrate_and_get_rpc(relative_name)
 
@@ -636,6 +641,7 @@ def test_wallet_with_relative_path(self):
         self.old_node.restorewallet("relative_restored", migrate_res['backup_path'])
         wallet = self.old_node.get_wallet_rpc("relative_restored")
         assert wallet.gettransaction(txid)
+        del bals["mine"]["nonmempool"]
         assert_equal(bals, wallet.getbalances())
 
         info = wallet.getwalletinfo()
@@ -652,6 +658,7 @@ def test_wallet_with_path(self, wallet_path):
         txid = default.sendtoaddress(addr, 1)
         self.generate(self.master_node, 1)
         bals = wallet.getbalances()
+        bals["mine"]["nonmempool"] = Decimal('0.0')
 
         _, wallet = self.migrate_and_get_rpc(wallet_path)
 
@@ -1423,14 +1430,14 @@ def test_miniscript(self):
         _, wallet = self.migrate_and_get_rpc("miniscript")
 
         # The miniscript with all keys should be in the migrated wallet
-        assert_equal(wallet.getbalances()["mine"], {"trusted": 0.75, "untrusted_pending": 0, "immature": 0})
+        assert_equal(wallet.getbalances()["mine"], {"trusted": 0.75, "untrusted_pending": 0, "immature": 0, "nonmempool": 0})
         assert_equal(wallet.getaddressinfo(all_keys_addr)["ismine"], True)
         assert_equal(wallet.getaddressinfo(some_keys_addr)["ismine"], False)
 
         # The miniscript with some keys should be in the watchonly wallet
         assert "miniscript_watchonly" in self.master_node.listwallets()
         watchonly = self.master_node.get_wallet_rpc("miniscript_watchonly")
-        assert_equal(watchonly.getbalances()["mine"], {"trusted": 1, "untrusted_pending": 0, "immature": 0})
+        assert_equal(watchonly.getbalances()["mine"], {"trusted": 1, "untrusted_pending": 0, "immature": 0, "nonmempool": 0})
         assert_equal(watchonly.getaddressinfo(some_keys_addr)["ismine"], True)
         assert_equal(watchonly.getaddressinfo(all_keys_addr)["ismine"], False)
 
@@ -1479,15 +1486,15 @@ def test_taproot(self):
         res, wallet = self.migrate_and_get_rpc("taproot")
 
         # The rawtr should be migrated
-        assert_equal(wallet.getbalances()["mine"], {"trusted": 0.5, "untrusted_pending": 0, "immature": 0})
+        assert_equal(wallet.getbalances()["mine"], {"trusted": 0.5, "untrusted_pending": 0, "immature": 0, "nonmempool": 0})
         assert_equal(wallet.getaddressinfo(rawtr_addr)["ismine"], True)
         assert_equal(wallet.getaddressinfo(tr_addr)["ismine"], False)
         assert_equal(wallet.getaddressinfo(tr_script_addr)["ismine"], False)
 
         # The tr() with some keys should be in the watchonly wallet
         assert "taproot_watchonly" in self.master_node.listwallets()
         watchonly = self.master_node.get_wallet_rpc("taproot_watchonly")
-        assert_equal(watchonly.getbalances()["mine"], {"trusted": 5, "untrusted_pending": 0, "immature": 0})
+        assert_equal(watchonly.getbalances()["mine"], {"trusted": 5, "untrusted_pending": 0, "immature": 0, "nonmempool": 0})
         assert_equal(watchonly.getaddressinfo(rawtr_addr)["ismine"], False)
         assert_equal(watchonly.getaddressinfo(tr_addr)["ismine"], True)
         assert_equal(watchonly.getaddressinfo(tr_script_addr)["ismine"], True)
diff --git a/test/functional/wallet_orphanedreward.py b/test/functional/wallet_orphanedreward.py
@@ -46,6 +46,7 @@ def run_test(self):
           "trusted": 10,
           "untrusted_pending": 0,
           "immature": 0,
+          "nonmempool": 0,
         })
         # And the unconfirmed tx to be abandoned
         assert_equal(self.nodes[1].gettransaction(txid)["details"][0]["abandoned"], True)
diff --git a/test/functional/wallet_v3_txs.py b/test/functional/wallet_v3_txs.py
@@ -39,19 +39,19 @@ def wrapper(self, *args):
             func(self, *args)
         finally:
             self.generate(self.nodes[0], 1)
-            try:
-                self.alice.sendall([self.charlie.getnewaddress()])
-            except JSONRPCException as e:
-                assert "Total value of UTXO pool too low to pay for transaction" in e.error['message']
-            try:
-                self.bob.sendall([self.charlie.getnewaddress()])
-            except JSONRPCException as e:
-                assert "Total value of UTXO pool too low to pay for transaction" in e.error['message']
+            for wallet in [self.alice, self.bob]:
+                txs = set(tx["txid"] for tx in wallet.listtransactions("*", 1000) if tx["confirmations"] == 0 and not tx["abandoned"])
+                for tx in txs:
+                    wallet.abandontransaction(tx)
+                try:
+                    wallet.sendall([self.charlie.getnewaddress()])
+                except JSONRPCException as e:
+                    assert "Total value of UTXO pool too low to pay for transaction" in e.error['message']
             self.generate(self.nodes[0], 1)
 
             for wallet in [self.alice, self.bob]:
                 balance = wallet.getbalances()["mine"]
-                for balance_type in ["untrusted_pending", "trusted", "immature"]:
+                for balance_type in ["untrusted_pending", "trusted", "immature", "nonmempool"]:
                     assert_equal(balance[balance_type], 0)
 
             assert_equal(self.alice.getrawmempool(), [])

Original file line number	Diff line number	Diff line change
`@@ -370,12 +370,13 @@ struct WalletBalances`
`370`	`370`	`CAmount unconfirmed_balance = 0;`
`371`	`371`	`CAmount immature_balance = 0;`
`372`	`372`	`CAmount used_balance = 0;`
	`373`	`+ CAmount nonmempool_balance = 0;`
`373`	`374`
`374`	`375`	`bool balanceChanged(const WalletBalances& prev) const`
`375`	`376`	`{`
`376`	`377`	`return balance != prev.balance \|\| unconfirmed_balance != prev.unconfirmed_balance \|\|`
`377`	`378`	`immature_balance != prev.immature_balance \|\|`
`378`		`- used_balance != prev.used_balance;`
	`379`	`+ used_balance != prev.used_balance \|\| nonmempool_balance != prev.nonmempool_balance;`
`379`	`380`	`}`
`380`	`381`	`};`
`381`	`382`
Original file line number	Diff line number	Diff line change
`@@ -383,12 +383,13 @@ class WalletImpl : public Wallet`
`383`	`383`	`}`
`384`	`384`	`WalletBalances getBalances() override`
`385`	`385`	`{`
`386`		`- const auto bal = GetBalance(*m_wallet);`
	`386`	`+ const auto bal = GetBalance(m_wallet, /min_depth=/0, /avoid_reuse=/true, /include_nonmempool=*/true);`
`387`	`387`	`WalletBalances result;`
`388`	`388`	`result.balance = bal.m_mine_trusted;`
`389`	`389`	`result.unconfirmed_balance = bal.m_mine_untrusted_pending;`
`390`	`390`	`result.immature_balance = bal.m_mine_immature;`
`391`	`391`	`result.used_balance = bal.m_mine_used;`
	`392`	`+ result.nonmempool_balance = bal.m_mine_nonmempool;`
`392`	`393`	`return result;`
`393`	`394`	`}`
`394`	`395`	`bool tryGetBalances(WalletBalances& balances, uint256& block_hash) override`
Original file line number	Diff line number	Diff line change
`@@ -242,7 +242,7 @@ bool CachedTxIsTrusted(const CWallet& wallet, const CWalletTx& wtx)`
`242`	`242`	`return CachedTxIsTrusted(wallet, wtx, trusted_parents);`
`243`	`243`	`}`
`244`	`244`
`245`		`-Balance GetBalance(const CWallet& wallet, const int min_depth, bool avoid_reuse)`
	`245`	`+Balance GetBalance(const CWallet& wallet, const int min_depth, bool avoid_reuse, bool include_nonmempool)`
`246`	`246`	`{`
`247`	`247`	`Balance ret;`
`248`	`248`	`bool allow_used_addresses = !avoid_reuse \|\| !wallet.IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE);`
`@@ -255,7 +255,17 @@ Balance GetBalance(const CWallet& wallet, const int min_depth, bool avoid_reuse)`
`255`	`255`	`const bool is_trusted{CachedTxIsTrusted(wallet, wtx, trusted_parents)};`
`256`	`256`	`const int tx_depth{wallet.GetTxDepthInMainChain(wtx)};`
`257`	`257`
`258`		`- if (!wallet.IsSpent(outpoint)) {`
	`258`	`+ bool nonmempool_spent = false;`
	`259`	`+ switch (wallet.HowSpent(outpoint)) {`
	`260`	`+ case CWallet::SpendType::CONFIRMED:`
	`261`	`+ case CWallet::SpendType::MEMPOOL:`
	`262`	`+ // treat as spent; ignore`
	`263`	`+ break;`
	`264`	`+ case CWallet::SpendType::NONMEMPOOL:`
	`265`	`+ if (!include_nonmempool \|\| !allow_used_addresses) break;`
	`266`	`+ nonmempool_spent = true;`
	`267`	`+ [[fallthrough]];`
	`268`	`+ case CWallet::SpendType::UNSPENT:`
`259`	`269`	`CAmount* bucket = nullptr;`
`260`	`270`
`261`	`271`	`// Set the amounts in the return object`
`@@ -274,6 +284,9 @@ Balance GetBalance(const CWallet& wallet, const int min_depth, bool avoid_reuse)`
`274`	`284`	`bucket = &ret.m_mine_used;`
`275`	`285`	`}`
`276`	`286`	`*bucket += credit_mine;`
	`287`	`+ if (nonmempool_spent) {`
	`288`	`+ ret.m_mine_nonmempool -= credit_mine;`
	`289`	`+ }`
`277`	`290`	`}`
`278`	`291`	`}`
`279`	`292`	`}`