v31.1-roots.1 · Commit 6: [PATCH 06/17] feat(wallet): preserve Roots signing and spend controls on v31

src/rpc/blockchain.cpp

Before: src/rpc/blockchain.cpp · After: src/rpc/blockchain.cpp

File metadata

index c631a93674aa296f74871ff7c3db3b1aa12ea741..c9fff1f49e43e26fa54047e13365e54f1fb5ed11 100644

Download original patch · Release notes

Diff rows 1–130 of 130. Line numbers refer to the original before/after files.

+ Added− RemovedUnmarked lines are context.

Scroll the code area horizontally to read long lines. Before is on the left; after is on the right. Unified view fits narrow screens more easily.

src/rpc/blockchain.cpp CHANGED Viewed

@@ -2194,7 +2194,7 @@ static RPCHelpMan getblockstats()
 namespace {
 //! Search for a given set of pubkey scripts
-bool FindScriptPubKey(std::atomic<int>& scan_progress, const std::atomic<bool>& should_abort, int64_t& count, CCoinsViewCursor* cursor, const std::set<CScript>& needles, std::map<COutPoint, Coin>& out_results, std::function<void()>& interruption_point)
 {
     scan_progress = 0;
     count = 0;
@@ -2202,9 +2202,8 @@ bool FindScriptPubKey(std::atomic<int>& scan_progress, const std::atomic<bool>&
         COutPoint key;
         Coin coin;
         if (!cursor->GetKey(key) || !cursor->GetValue(coin)) return false;
-        if (++count % 8192 == 0) {
-            interruption_point();
-            if (should_abort) {
                 // allow to abort the scan via the abort reference
                 return false;
             }
@@ -2225,33 +2224,42 @@ bool FindScriptPubKey(std::atomic<int>& scan_progress, const std::atomic<bool>&
 } // namespace
 /** RAII object to prevent concurrency issue when scanning the txout set */
-static std::atomic<int> g_scan_progress;
-static std::atomic<bool> g_scan_in_progress;
-static std::atomic<bool> g_should_abort_scan;
-class CoinsViewScanReserver
-{
-private:
-    bool m_could_reserve{false};
-public:
-    explicit CoinsViewScanReserver() = default;
-    bool reserve() {
-        CHECK_NONFATAL(!m_could_reserve);
-        if (g_scan_in_progress.exchange(true)) {
-            return false;
-        }
-        CHECK_NONFATAL(g_scan_progress == 0);
-        m_could_reserve = true;
-        return true;
     }
-    ~CoinsViewScanReserver() {
-        if (m_could_reserve) {
-            g_scan_in_progress = false;
-            g_scan_progress = 0;
-        }
     }
-};
 static const auto scan_action_arg_desc = RPCArg{
     "action", RPCArg::Type::STR, RPCArg::Optional::NO, "The action to execute\n"
@@ -2358,24 +2366,24 @@ static RPCHelpMan scantxoutset()
     UniValue result(UniValue::VOBJ);
     const auto action{self.Arg<std::string_view>("action")};
     if (action == "status") {
-        CoinsViewScanReserver reserver;
         if (reserver.reserve()) {
             // no scan in progress
             return UniValue::VNULL;
         }
-        result.pushKV("progress", g_scan_progress.load());
         return result;
     } else if (action == "abort") {
-        CoinsViewScanReserver reserver;
         if (reserver.reserve()) {
             // reserve was possible which means no scan was running
             return false;
         }
         // set the abort flag
-        g_should_abort_scan = true;
         return true;
     } else if (action == "start") {
-        CoinsViewScanReserver reserver;
         if (!reserver.reserve()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Scan already in progress, use action \"abort\" or \"status\"");
         }
@@ -2403,7 +2411,7 @@ static RPCHelpMan scantxoutset()
         UniValue unspents(UniValue::VARR);
         std::vector<CTxOut> input_txos;
         std::map<COutPoint, Coin> coins;
-        g_should_abort_scan = false;
         int64_t count = 0;
         std::unique_ptr<CCoinsViewCursor> pcursor;
         const CBlockIndex* tip;
@@ -2416,7 +2424,7 @@ static RPCHelpMan scantxoutset()
             pcursor = CHECK_NONFATAL(active_chainstate.CoinsDB().Cursor());
             tip = CHECK_NONFATAL(active_chainstate.m_chain.Tip());
         }
-        bool res = FindScriptPubKey(g_scan_progress, g_should_abort_scan, count, pcursor.get(), needles, coins, node.rpc_interruption_point);
         result.pushKV("success", res);
         result.pushKV("txouts", count);
         result.pushKV("height", tip->nHeight);

 namespace {
 //! Search for a given set of pubkey scripts
+bool FindScriptPubKey(std::atomic<int>& scan_progress, const std::atomic<bool>& should_abort, int64_t& count, CCoinsViewCursor* cursor, const std::set<CScript>& needles, std::map<COutPoint, Coin>& out_results, std::function<void()>& interruption_point, const std::function<bool()>& local_should_abort = {})
 {
     scan_progress = 0;
     count = 0;
         COutPoint key;
         Coin coin;
         if (!cursor->GetKey(key) || !cursor->GetValue(coin)) return false;
+        if (rpc::scan::CheckInterruption(++count, interruption_point)) {
+            if (should_abort || (local_should_abort && local_should_abort())) {
                 // allow to abort the scan via the abort reference
                 return false;
             }
 } // namespace
 /** RAII object to prevent concurrency issue when scanning the txout set */
+std::atomic<int> rpc::scan::g_progress;
+std::atomic<bool> rpc::scan::g_in_progress;
+std::atomic<bool> rpc::scan::g_should_abort;
+bool rpc::scan::Reserver::reserve() {
+    CHECK_NONFATAL(!m_reserved);
+    if (g_in_progress.exchange(true)) return false;
+    CHECK_NONFATAL(g_progress == 0);
+    m_reserved = true;
+    return true;
+}
+rpc::scan::Reserver::~Reserver() { if (m_reserved) { g_progress = 0; g_in_progress = false; } }
+bool rpc::scan::CheckInterruption(int64_t count, const std::function<void()>& interruption) { if (count % 8192 != 0) return false; interruption(); return true; }
+using rpc::scan::Reserver;
+interfaces::ScanResult ScanUTXOSet(NodeContext& node, const std::set<CScript>& needles, std::map<COutPoint, Coin>& coins,
+                                   const std::function<bool()>& should_abort)
+{
+    Reserver reserver;
+    if (!reserver.reserve()) return interfaces::ScanResult::BUSY;
+    if (should_abort && should_abort()) return interfaces::ScanResult::ABORTED;
+    std::unique_ptr<CCoinsViewCursor> cursor;
+    {
+        ChainstateManager& chainman = EnsureChainman(node);
+        LOCK(cs_main);
+        Chainstate& chainstate = chainman.ActiveChainstate();
+        chainstate.ForceFlushStateToDisk(/*wipe_cache=*/false);
+        cursor = CHECK_NONFATAL(chainstate.CoinsDB().Cursor());
     }
+    rpc::scan::g_should_abort = false;
+    std::atomic<int> progress;
+    int64_t count;
+    if (FindScriptPubKey(progress, rpc::scan::g_should_abort, count, cursor.get(), needles, coins, node.rpc_interruption_point, should_abort)) {
+        return interfaces::ScanResult::SUCCESS;
     }
+    return rpc::scan::g_should_abort || (should_abort && should_abort()) ? interfaces::ScanResult::ABORTED : interfaces::ScanResult::UNAVAILABLE;
+}
 static const auto scan_action_arg_desc = RPCArg{
     "action", RPCArg::Type::STR, RPCArg::Optional::NO, "The action to execute\n"
     UniValue result(UniValue::VOBJ);
     const auto action{self.Arg<std::string_view>("action")};
     if (action == "status") {
+        Reserver reserver;
         if (reserver.reserve()) {
             // no scan in progress
             return UniValue::VNULL;
         }
+        result.pushKV("progress", rpc::scan::g_progress.load());
         return result;
     } else if (action == "abort") {
+        Reserver reserver;
         if (reserver.reserve()) {
             // reserve was possible which means no scan was running
             return false;
         }
         // set the abort flag
+        rpc::scan::g_should_abort = true;
         return true;
     } else if (action == "start") {
+        Reserver reserver;
         if (!reserver.reserve()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Scan already in progress, use action \"abort\" or \"status\"");
         }
         UniValue unspents(UniValue::VARR);
         std::vector<CTxOut> input_txos;
         std::map<COutPoint, Coin> coins;
+        rpc::scan::g_should_abort = false;
         int64_t count = 0;
         std::unique_ptr<CCoinsViewCursor> pcursor;
         const CBlockIndex* tip;
             pcursor = CHECK_NONFATAL(active_chainstate.CoinsDB().Cursor());
             tip = CHECK_NONFATAL(active_chainstate.m_chain.Tip());
         }
+        bool res = FindScriptPubKey(rpc::scan::g_progress, rpc::scan::g_should_abort, count, pcursor.get(), needles, coins, node.rpc_interruption_point);
         result.pushKV("success", res);
         result.pushKV("txouts", count);
         result.pushKV("height", tip->nHeight);