wallet: track mempool conflicts with wallet transactions #27307

320@@ -315,7 +321,9 @@ class CWalletTx
321     template<typename T> T* state() { return std::get_if<T>(&m_state); }
322 
323     bool isAbandoned() const { return state<TxStateInactive>() && state<TxStateInactive>()->abandoned; }
324-    bool isConflicted() const { return state<TxStateConflicted>(); }
325+    bool isConflicted() const { return state<TxStateConflicted>() || state<TxStateMempoolConflicted>(); }
326+    bool isMempoolConflicted() const { return state<TxStateMempoolConflicted>(); }
327+    bool isBlockConflicted() const { return state<TxStateConflicted>(); }

214+        tx3 = bob.sendrawtransaction(raw_tx3)
215+
216+        self.disconnect_nodes(0, 1)
217+
218+        # alice has all 0 txs, bob has 3
219+        assert_equal(len(alice.getrawmempool()), 0)

1384@@ -1386,6 +1385,36 @@ void CWallet::transactionAddedToMempool(const CTransactionRef& tx) {
1385     if (it != mapWallet.end()) {
1386         RefreshMempoolStatus(it->second, chain());
1387     }
1388+
1389+    const uint256& conflict_hash = tx->GetHash();
1390+
1391+    for (const CTxIn& tx_in : tx->vin) {

336@@ -337,6 +337,9 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
337     void AddToSpends(const COutPoint& outpoint, const uint256& wtxid, WalletBatch* batch = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
338     void AddToSpends(const CWalletTx& wtx, WalletBatch* batch = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
339 
340+    // Map of wtx hash to a set of mempool conflict hashes
341+    std::map<uint256, std::set<uint256>> MempoolConflicts GUARDED_BY(cs_wallet);

179+        self.generate(self.nodes[0], 3)
180+        assert_equal(alice.getbalance(), 75)
181+
182+    def test_mempool_and_block_conflicts(self):
183+        alice = self.nodes[0].get_wallet_rpc("alice")
184+        bob = self.nodes[1].get_wallet_rpc("bob")

128@@ -123,5 +129,148 @@ def run_test(self):
129         assert_equal(former_conflicted["confirmations"], 1)
130         assert_equal(former_conflicted["blockheight"], 217)
131 
132+    def test_mempool_conflict(self):
133+        self.nodes[0].createwallet("alice")
134+        alice = self.nodes[0].get_wallet_rpc("alice")
135+
136+        self.nodes[1].createwallet("bob")
137+        bob = self.nodes[1].get_wallet_rpc("bob")

1544@@ -1482,8 +1545,8 @@ void CWallet::blockConnected(ChainstateRole role, const interfaces::BlockInfo& b
1545 
1546     // Scan block
1547     for (size_t index = 0; index < block.data->vtx.size(); index++) {
1548-        SyncTransaction(block.data->vtx[index], TxStateConfirmed{block.hash, block.height, static_cast<int>(index)});
1549         transactionRemovedFromMempool(block.data->vtx[index], MemPoolRemovalReason::BLOCK);
1550+        SyncTransaction(block.data->vtx[index], TxStateConfirmed{block.hash, block.height, static_cast<int>(index)});

189+        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], 0)
190+
191+        self.disconnect_nodes(0, 1)
192+
193+        raw_tx = alice.createrawtransaction(inputs=[unspents[0]], outputs=[{bob.getnewaddress() : 24.99999}])
194+        raw_tx1 = alice.signrawtransactionwithwallet(raw_tx)['hex']

237+        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], Decimal("24.99990000"))
238+
239+        # we will be disconnecting this block in the future
240+        tx2_conflict = alice.sendrawtransaction(tx2_conflict)
241+        assert_equal(len(alice.getrawmempool()), 1)
242+        blk = self.generate(self.nodes[0], 11, sync_fun=self.no_op)[0]

138+
139+        self.generatetoaddress(self.nodes[0], COINBASE_MATURITY + 3, alice.getnewaddress())
140+
141+        self.log.info("Test a scenario where a transaction has a mempool conflict")
142+
143+        unspents = [{"txid" : element["txid"], "vout" : element["vout"]} for element in alice.listunspent()]

751@@ -752,8 +752,7 @@ bool CWallet::IsSpent(const COutPoint& outpoint) const
752         const uint256& wtxid = it->second;
753         const auto mit = mapWallet.find(wtxid);
754         if (mit != mapWallet.end()) {
755-            int depth = GetTxDepthInMainChain(mit->second);
756-            if (depth > 0  || (depth == 0 && !mit->second.isAbandoned()))
757+            if (mit->second.isConfirmed() || mit->second.InMempool() || (mit->second.isInactive() && !mit->second.isAbandoned()))

90@@ -91,7 +91,7 @@ WalletTxStatus MakeWalletTxStatus(const CWallet& wallet, const CWalletTx& wtx)
91     WalletTxStatus result;
92     result.block_height =
93         wtx.state<TxStateConfirmed>() ? wtx.state<TxStateConfirmed>()->confirmed_block_height :
94-        wtx.state<TxStateConflicted>() ? wtx.state<TxStateConflicted>()->conflicting_block_height :

1432+    for (const CTxIn& tx_in : tx->vin) {
1433+        // If the wallet contains no transactions that spend the same prevout, continue
1434+        if (mapTxSpends.count(tx_in.prevout) == 0) continue;
1435+
1436+        std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range;
1437+        range = mapTxSpends.equal_range(tx_in.prevout);

231@@ -232,7 +232,9 @@ def run_test(self):
232         balance = newbalance
233 
234         # Invalidate the block with the double spend. B & C's 10 BTC outputs should no longer be available
235-        self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
236+        blk = self.nodes[0].getbestblockhash()
237+        self.generate(self.nodes[1], 10)

150+        tx2 = alice.signrawtransactionwithwallet(raw_tx)['hex']
151+
152+        raw_tx = alice.createrawtransaction(inputs=[unspents[2]], outputs=[{bob.getnewaddress() : 24.9899}])
153+        tx3 = alice.signrawtransactionwithwallet(raw_tx)['hex']
154+
155+        tx1 = alice.sendrawtransaction(tx1)

169+
170+        tx3 = alice.sendrawtransaction(tx3)
171+
172+        assert_equal(alice.gettransaction(tx1)["mempoolconflicts"], [])
173+
174+        # now all of alice's outputs should be considered spent

213+
214+        raw_tx = bob.createrawtransaction(inputs=[bob_unspents[0], bob_unspents[1]], outputs=[{bob.getnewaddress() : 49.999}])
215+        raw_tx3 = bob.signrawtransactionwithwallet(raw_tx)['hex']
216+        tx3 = bob.sendrawtransaction(raw_tx3)
217+
218+        # alice has 0 txs, bob has 3

222+        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], Decimal("49.99900000"))
223+
224+        # bob broadcasts tx_1 conflict
225+        tx1_conflict = bob.sendrawtransaction(tx1_conflict)
226+        assert_equal(len(alice.getrawmempool()), 0)
227+        assert_equal(len(bob.getrawmempool()), 2)

751@@ -752,8 +752,9 @@ bool CWallet::IsSpent(const COutPoint& outpoint) const
752         const uint256& wtxid = it->second;
753         const auto mit = mapWallet.find(wtxid);
754         if (mit != mapWallet.end()) {
755-            int depth = GetTxDepthInMainChain(mit->second);
756-            if (depth > 0  || (depth == 0 && !mit->second.isAbandoned()))
757+            // A transaction is considered spent if a spending transaction

52+    std::string toString() const { return strprintf("BlockConflicted (block=%s, height=%i)", conflicting_block_hash.ToString(), conflicting_block_height); }
53+};
54+
55+//! State of transaction with one or more mempool conflicts.
56+struct TxStateMempoolConflicted {
57+    std::string toString() const { return strprintf("MempoolConflicted"); }

264@@ -258,6 +265,8 @@ class CWalletTx
265     CTransactionRef tx;
266     TxState m_state;
267 
268+    std::set<uint256> mempool_conflicts;

1418@@ -1419,6 +1419,36 @@ void CWallet::transactionAddedToMempool(const CTransactionRef& tx) {
1419     if (it != mapWallet.end()) {
1420         RefreshMempoolStatus(it->second, chain());
1421     }
1422+
1423+    const uint256& conflict_hash = tx->GetHash();

1430+        range = mapTxSpends.equal_range(tx_in.prevout);
1431+
1432+        // For each wallet transaction spending this prevout...
1433+        for (TxSpends::const_iterator _it = range.first; _it != range.second; ++_it) {
1434+            // if this tx is the same as the tx which was just added to the mempool, continue
1435+            if (_it->second == conflict_hash) continue;

420@@ -417,6 +421,10 @@ static std::vector<RPCResult> TransactionDescriptionString()
421            }},
422            {RPCResult::Type::STR_HEX, "replaced_by_txid", /*optional=*/true, "Only if 'category' is 'send'. The txid if this tx was replaced."},
423            {RPCResult::Type::STR_HEX, "replaces_txid", /*optional=*/true, "Only if 'category' is 'send'. The txid if this tx replaces another."},
424+           {RPCResult::Type::ARR, "mempoolconflicts", "Conflicting transaction currently in the mempool.",

140+        self.generate(self.nodes[2], 1)
141+
142+        self.log.info("Test a scenario where a transaction has a mempool conflict")
143+
144+        unspents = alice.listunspent()
145+        assert_equal(len(unspents), 3)

168+
169+        self.log.info("Test scenario where a mempool conflict is removed")
170+
171+        alice.sendrawtransaction(tx3)
172+
173+        assert_equal(alice.gettransaction(tx1_txid)["mempoolconflicts"], [])

129@@ -123,5 +130,165 @@ def run_test(self):
130         assert_equal(former_conflicted["confirmations"], 1)
131         assert_equal(former_conflicted["blockheight"], 217)
132 
133+    def test_mempool_conflict(self):

47@@ -48,7 +48,12 @@ struct TxStateBlockConflicted {
48     int conflicting_block_height;
49 
50     explicit TxStateBlockConflicted(const uint256& block_hash, int height) : conflicting_block_hash(block_hash), conflicting_block_height(height) {}
51-    std::string toString() const { return strprintf("Conflicted (block=%s, height=%i)", conflicting_block_hash.ToString(), conflicting_block_height); }
52+    std::string toString() const { return strprintf("BlockConflicted (block=%s, height=%i)", conflicting_block_hash.ToString(), conflicting_block_height); }
53+};
54+
55+//! State of transaction with one or more mempool conflicts.

1506+
1507+                    // Remove the previously conflicting transaction from this wtx's entry
1508+                    wtx.mempool_conflicts.erase(conflict_txid);
1509+
1510+                    if (wtx.mempool_conflicts.empty()) {
1511+                        // If this wtx has no other mempool conflicts, erase this wtx entry

751@@ -752,8 +752,9 @@ bool CWallet::IsSpent(const COutPoint& outpoint) const
752         const uint256& wtxid = it->second;
753         const auto mit = mapWallet.find(wtxid);
754         if (mit != mapWallet.end()) {
755-            int depth = GetTxDepthInMainChain(mit->second);
756-            if (depth > 0  || (depth == 0 && !mit->second.isAbandoned()))
757+            // An output is considered spent if a spending transaction
758+            // is either confirmed, or in the mempool, or inactive (but not abandoned)
759+            if (mit->second.isConfirmed() || mit->second.InMempool() || (mit->second.isInactive() && !mit->second.isAbandoned()))

1432+
1433+        // For each wallet transaction spending this prevout...
1434+        for (TxSpends::const_iterator _it = range.first; _it != range.second; ++_it) {
1435+            // if this tx is the same as the tx which was just added to the mempool, continue
1436+            auto it = mapWallet.find(_it->second);
1437+            if (it->second.tx->GetWitnessHash() == conflict_wtxid) continue;

1512+                        if (wtx.isMempoolConflicted()) {
1513+                            wtx.m_state = TxStateInactive{};
1514+                            return TxUpdate::CHANGED;
1515+                        }
1516+                    }
1517+                }

162+
163+        tx2_txid = alice.sendrawtransaction(tx2)
164+
165+        # Check that the 0th unspent is now available because the transaction spending it has been replaced in the mempool
166+        assert_equal(alice.listunspent(), [unspents[0]])
167+        assert_equal(alice.getbalance(), 25)

178+        # now all of alice's outputs should be considered spent
179+        assert_equal(alice.listunspent(), [])
180+        assert_equal(alice.getbalance(), 0)
181+
182+        bob.sendall([self.nodes[2].getnewaddress()])
183+        self.generate(self.nodes[2], 1)

334@@ -335,7 +335,7 @@ class CWalletTx
335     void updateState(interfaces::Chain& chain);
336 
337     bool isAbandoned() const { return state<TxStateInactive>() && state<TxStateInactive>()->abandoned; }
338-    bool isConflicted() const { return state<TxStateConflicted>(); }
339+    bool isConflicted() const { return state<TxStateBlockConflicted>(); }

751@@ -752,8 +752,10 @@ bool CWallet::IsSpent(const COutPoint& outpoint) const
752         const uint256& wtxid = it->second;
753         const auto mit = mapWallet.find(wtxid);
754         if (mit != mapWallet.end()) {
755-            int depth = GetTxDepthInMainChain(mit->second);
756-            if (depth > 0  || (depth == 0 && !mit->second.isAbandoned()))
757+            // An output is considered spent if a spending transaction
758+            // is either confirmed, or in the mempool, or inactive (but not abandoned)

261@@ -258,6 +262,10 @@ class CWalletTx
262     CTransactionRef tx;
263     TxState m_state;
264 
265+    // Transactions that conflict directly with the tx, or
266+    // that conflict with an ancestor transaction
267+    std::set<Txid> mempool_conflicts;

754@@ -755,7 +755,7 @@ bool CWallet::IsSpent(const COutPoint& outpoint) const
755             // An output is considered spent if a spending transaction
756             // is either confirmed, or in the mempool, or inactive (but not abandoned)
757             const auto& wtx = mit->second;
758-            if (wtx.isConfirmed() || wtx.InMempool() || (wtx.isInactive() && !wtx.isAbandoned()))
759+            if (wtx.isConfirmed() || wtx.InMempool() || (wtx.isInactive() && !wtx.isAbandoned() && !wtx.isMempoolConflicted()))

342@@ -335,7 +343,9 @@ class CWalletTx
343     void updateState(interfaces::Chain& chain);
344 
345     bool isAbandoned() const { return state<TxStateInactive>() && state<TxStateInactive>()->abandoned; }
346-    bool isConflicted() const { return state<TxStateBlockConflicted>(); }
347+    bool isConflicted() const { return isBlockConflicted() || isMempoolConflicted(); }

63-    std::string toString() const { return strprintf("Inactive (abandoned=%i)", abandoned); }
64+    explicit TxStateInactive(bool abandoned = false, bool mempool_conflicted = false)
65+      : abandoned(abandoned),
66+        mempool_conflicted(mempool_conflicted)
67+        {}
68+    std::string toString() const { return strprintf("Inactive (abandoned=%i, mempool_conflicted=%i)", abandoned, mempool_conflicted); }

1442+
1443+                if (wtx.isInactive()) {
1444+                    wtx.m_state = TxStateInactive{wtx.isAbandoned(), /*mempool_conflicted=*/ true};
1445+                    return TxUpdate::CHANGED;
1446+                } else {
1447+                    return TxUpdate::UNCHANGED;

1446+                } else {
1447+                    return TxUpdate::UNCHANGED;
1448+                }
1449+            };
1450+
1451+            RecursiveUpdateTxState(_it->second, try_updating_state);

1439+            auto try_updating_state = [&](CWalletTx& wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
1440+                // Add this conflict to the wtx's entry (create one if one does not already exist)
1441+                wtx.mempool_conflicts.insert(conflict_txid);
1442+
1443+                if (wtx.isInactive()) {
1444+                    wtx.m_state = TxStateInactive{wtx.isAbandoned(), /*mempool_conflicted=*/ true};

1510+                    if (wtx.isMempoolConflicted()) {
1511+                        wtx.m_state = TxStateInactive{};
1512+                        return TxUpdate::CHANGED;
1513+                    }
1514+                }
1515+                return TxUpdate::UNCHANGED;

1429+
1430+        std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range;
1431+        range = mapTxSpends.equal_range(tx_in.prevout);
1432+
1433+        // For each wallet transaction spending this prevout...
1434+        for (TxSpends::const_iterator _it = range.first; _it != range.second; ++_it) {

1419@@ -1420,6 +1420,37 @@ void CWallet::transactionAddedToMempool(const CTransactionRef& tx) {
1420     if (it != mapWallet.end()) {
1421         RefreshMempoolStatus(it->second, chain());
1422     }
1423+
1424+    const Txid& conflict_txid = tx->GetHash();
1425+
1426+    for (const CTxIn& tx_in : tx->vin) {
1427+        // If the wallet contains no transactions that spend the same prevout, continue
1428+        if (mapTxSpends.count(tx_in.prevout) == 0) continue;

28@@ -28,6 +29,20 @@ def get_utxo_of_value(self, from_tx_id, search_value):
29         return next(tx_out["vout"] for tx_out in self.nodes[0].gettransaction(from_tx_id)["details"] if tx_out["amount"] == Decimal(f"{search_value}"))
30 
31     def run_test(self):
32+        """
33+        The following tests check the behavior of the wallet when

257@@ -258,6 +258,13 @@ class CWalletTx
258     CTransactionRef tx;
259     TxState m_state;
260 
261+    // Set of mempool transactions that conflict
262+    // directly with the transaction, or that conflict
263+    // with an ancestor transaction. This set is empty
264+    // if the transaction is confirmed, but can be
265+    // non-empty in other states.

256@@ -257,7 +257,7 @@ bool CachedTxIsTrusted(const CWallet& wallet, const CWalletTx& wtx, std::set<uin
257 {
258     AssertLockHeld(wallet.cs_wallet);
259     if (wtx.isConfirmed()) return true;
260-    if (wtx.isBlockConflicted()) return false;
261+    if (wtx.isConflicted()) return false;

1435+
1436+        // For each wallet transaction spending this prevout...
1437+        for (auto _it = range.first; _it != range.second; ++_it) {
1438+            // if this tx is the same as the tx which was just added to the mempool, continue
1439+            CWalletTx& wallet_tx = mapWallet.at(_it->second);
1440+            if (wallet_tx.tx->GetHash() == conflict_txid) continue;

1440+            if (wallet_tx.tx->GetHash() == conflict_txid) continue;
1441+
1442+            auto try_updating_state = [&](CWalletTx& wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
1443+                wtx.mempool_conflicts.insert(conflict_txid);
1444+
1445+                return TxUpdate::CHANGED;

1496+
1497+            auto try_updating_state = [&](CWalletTx& wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
1498+                // Remove the previously conflicting transaction from this wtx's entry
1499+                if (wtx.mempool_conflicts.erase(conflict_txid)) return TxUpdate::CHANGED;
1500+
1501+                return TxUpdate::UNCHANGED;

345@@ -346,7 +346,6 @@ def test_descendants_with_mempool_conflicts(self):
346         tx1_child = bob.signrawtransactionwithwallet(raw_tx)['hex']
347         tx1_child_txid = bob.sendrawtransaction(tx1_child)
348 
349-        # Currently neither tx1 nor tx1_child should have any conflicts

757@@ -758,7 +758,7 @@ bool CWallet::IsSpent(const COutPoint& outpoint) const
758             // check for the inverse condition and only consider spending
759             // transactions in known, potentially active states.
760             const auto& wtx = mit->second;
761-            if (wtx.isConfirmed() || wtx.InMempool() || (wtx.isInactive() && !wtx.isAbandoned()))
762+            if (!wtx.isAbandoned() && !wtx.isMempoolConflicted() && !wtx.isBlockConflicted())

758+            // unless the spending transaction is conflicted or
759+            // abandoned. The check below is written conservatively to
760+            // check for the inverse condition and only consider spending
761+            // transactions in known, potentially active states.
762+            const auto& wtx = mit->second;
763+            if (wtx.isConfirmed() || wtx.InMempool() || (wtx.isInactive() && !wtx.isAbandoned()))

137@@ -123,5 +138,249 @@ def run_test(self):
138         assert_equal(former_conflicted["confirmations"], 1)
139         assert_equal(former_conflicted["blockheight"], 217)
140 
141+    def test_mempool_conflict(self):

238+
239+        # create a conflict to previous tx (also spends unspents[1]), but don't broadcast, sends funds to alice
240+        raw_tx = alice.createrawtransaction(inputs=[unspents[1]], outputs=[{alice.getnewaddress() : 24.9999}])
241+        tx2_conflict = alice.signrawtransactionwithwallet(raw_tx)['hex']
242+
243+        bob_unspents = [{"txid" : element, "vout" : 0} for element in [tx1_txid, tx2_txid]]

1443+
1444+                return TxUpdate::CHANGED;
1445+            };
1446+
1447+            RecursiveUpdateTxState(nullptr, _it->second, try_updating_state);
1448+        }

296+
297+        bob.sendrawtransaction(raw_tx2)
298+        assert_equal(bob.getbalances()["mine"]["untrusted_pending"], 0)
299+
300+        bob.sendrawtransaction(tx1_conflict_conflict) # kick tx1_conflict out of the mempool
301+        bob.sendrawtransaction(raw_tx1) #re-broadcast tx1 because it is no longer conflicted

311+        bob.reconsiderblock(blk)
312+        assert_equal(alice.getbestblockhash(), bob.getbestblockhash())
313+        self.sync_mempools()
314+        self.generate(self.nodes[2], 1)
315+
316+    def test_descendants_with_mempool_conflicts(self):

517@@ -518,7 +518,7 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
518     bool IsTxInMainChain(const CWalletTx& wtx) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet)
519     {
520         AssertLockHeld(cs_wallet);
521-        return GetTxDepthInMainChain(wtx) > 0;
522+        return wtx.isConfirmed();
523     }

1367     WalletBatch batch(GetDatabase(), false);
1368+    RecursiveUpdateTxState(&batch, tx_hash, try_updating_state);
1369+}
1370+
1371+void CWallet::RecursiveUpdateTxState(WalletBatch* batch, const uint256& tx_hash, const TryUpdatingStateFn& try_updating_state) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
1372+    // Do not flush the wallet here for performance reasons

100@@ -101,7 +101,7 @@ WalletTxStatus MakeWalletTxStatus(const CWallet& wallet, const CWalletTx& wtx)
101     result.is_trusted = CachedTxIsTrusted(wallet, wtx);
102     result.is_abandoned = wtx.isAbandoned();
103     result.is_coinbase = wtx.IsCoinBase();
104-    result.is_in_main_chain = wallet.IsTxInMainChain(wtx);
105+    result.is_in_main_chain = wtx.isConfirmed();

1420@@ -1418,6 +1421,20 @@ void CWallet::transactionAddedToMempool(const CTransactionRef& tx) {
1421     if (it != mapWallet.end()) {
1422         RefreshMempoolStatus(it->second, chain());
1423     }
1424+
1425+    const Txid& conflict_txid = tx->GetHash();
1426+
1427+    for (const CTxIn& tx_in : tx->vin) {
1428+        // Mark all already spent inputs, and all txs that consumes them, as conflicted
1429+        for (auto range = mapTxSpends.equal_range(tx_in.prevout); range.first != range.second; range.first++) {

1495+
1496+        for (auto range = mapTxSpends.equal_range(tx_in.prevout); range.first != range.second; range.first++) {
1497+            const uint256& spent_id = range.first->second;
1498+
1499+            RecursiveUpdateTxState(/*batch=*/nullptr, spent_id, [&conflict_txid](CWalletTx& wtx) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
1500+                return !wtx.mempool_conflicts.erase(conflict_txid) ? TxUpdate::UNCHANGED : TxUpdate::CHANGED;

1490+            };
1491+
1492+            RecursiveUpdateTxState(nullptr, _it->second, try_updating_state);
1493+        }
1494+        */
1495+

1420@@ -1418,6 +1421,20 @@ void CWallet::transactionAddedToMempool(const CTransactionRef& tx) {
1421     if (it != mapWallet.end()) {
1422         RefreshMempoolStatus(it->second, chain());
1423     }
1424+
1425+    const Txid& conflict_txid = tx->GetHash();