Save transaction priority deltas to mempool-knots.dat

Author: luke-jr

src/init.cpp

@@ -1795,7 +1795,9 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         }
         // Load mempool from disk
         if (auto* pool{chainman.ActiveChainstate().GetMempool()}) {
-            LoadMempool(*pool, ShouldPersistMempool(args) ? MempoolPath(args) : fs::path{}, chainman.ActiveChainstate(), {});
+            LoadMempool(*pool, ShouldPersistMempool(args) ? MempoolPath(args) : fs::path{}, chainman.ActiveChainstate(), {
+                .load_knots_data = true,
+            });
             pool->SetLoadTried(!chainman.m_interrupt);
         }
     });

src/node/mempool_persist.cpp

@@ -16,6 +16,7 @@
 #include <uint256.h>
 #include <util/fs.h>
 #include <util/fs_helpers.h>
+#include <util/serfloat.h>
 #include <util/signalinterrupt.h>
 #include <util/syserror.h>
 #include <util/time.h>
@@ -38,6 +39,39 @@ namespace node {
 
 static const uint64_t MEMPOOL_DUMP_VERSION_NO_XOR_KEY{1};
 static const uint64_t MEMPOOL_DUMP_VERSION{2};
+static constexpr uint64_t MEMPOOL_KNOTS_DUMP_VERSION = 0;
+
+bool LoadMempoolKnots(CTxMemPool& pool, const fs::path& knots_filepath, FopenFn mockable_fopen_function)
+{
+    AutoFile file{mockable_fopen_function(knots_filepath, "rb")};
+    if (file.IsNull()) {
+        // Typically missing if there's nothing to save
+        return false;
+    }
+
+    try {
+        uint64_t version;
+        file >> version;
+        if (version != MEMPOOL_KNOTS_DUMP_VERSION) {
+            return false;
+        }
+
+        const unsigned int priority_deltas_count = ReadCompactSize(file);
+        uint256 txid;
+        uint64_t encoded_priority;
+        for (unsigned int i = 0; i < priority_deltas_count; ++i) {
+            Unserialize(file, txid);
+            Unserialize(file, encoded_priority);
+            const double priority = DecodeDouble(encoded_priority);
+            pool.PrioritiseTransaction(txid, priority, 0);
+        }
+    } catch (const std::exception& e) {
+        LogInfo("Failed to deserialize mempool-knots data on file: %s. Continuing anyway.\n", e.what());
+        return false;
+    }
+
+    return true;
+}
 
 bool LoadMempool(CTxMemPool& pool, const fs::path& load_path, Chainstate& active_chainstate, ImportMempoolOptions&& opts)
 {
@@ -143,6 +177,12 @@ bool LoadMempool(CTxMemPool& pool, const fs::path& load_path, Chainstate& active
         return false;
     }
 
+    if (opts.load_knots_data) {
+        auto knots_filepath = load_path;
+        knots_filepath.replace_filename("mempool-knots.dat");
+        LoadMempoolKnots(pool, knots_filepath, opts.mockable_fopen_function);
+    }
+
     LogInfo("Imported mempool transactions from file: %i succeeded, %i failed, %i expired, %i already there, %i waiting for initial broadcast\n", count, failed, expired, already_there, unbroadcast);
     return true;
 }
@@ -152,6 +192,7 @@ bool DumpMempool(const CTxMemPool& pool, const fs::path& dump_path, FopenFn mock
     auto start = SteadyClock::now();
 
     std::map<uint256, CAmount> mapDeltas;
+    std::map<uint256, double> priority_deltas;
     std::vector<TxMempoolInfo> vinfo;
     std::set<uint256> unbroadcast_txids;
 
@@ -161,6 +202,9 @@ bool DumpMempool(const CTxMemPool& pool, const fs::path& dump_path, FopenFn mock
     {
         LOCK(pool.cs);
         for (const auto &i : pool.mapDeltas) {
+            if (i.second.first) {   // priority delta
+                priority_deltas[i.first] = i.second.first;
+            }
             if (i.second.second) {  // fee delta
                 mapDeltas[i.first] = i.second.second;
             }
@@ -209,6 +253,39 @@ bool DumpMempool(const CTxMemPool& pool, const fs::path& dump_path, FopenFn mock
             throw std::runtime_error(
                 strprintf("Error closing %s: %s", fs::PathToString(file_fspath), SysErrorString(errno)));
         }
+
+        auto knots_filepath = dump_path;
+        knots_filepath.replace_filename("mempool-knots.dat");
+        LogInfo("Writing %u mempool prioritizations to file...\n", priority_deltas.size());
+        if (priority_deltas.size()) {
+            auto knots_tmppath = knots_filepath;
+            knots_tmppath += ".new";
+
+            AutoFile file{mockable_fopen_function(knots_tmppath, "wb")};
+            if (file.IsNull()) return false;
+
+            uint64_t version = MEMPOOL_KNOTS_DUMP_VERSION;
+            file << version;
+
+            WriteCompactSize(file, priority_deltas.size());
+            for (const auto& [txid, priority] : priority_deltas) {
+                Serialize(file, txid);
+                const uint64_t encoded_priority = EncodeDouble(priority);
+                Serialize(file, encoded_priority);
+            }
+
+            if (!file.Commit()) throw std::runtime_error("Commit failed");
+            if (file.fclose() != 0) {
+                throw std::runtime_error(
+                    strprintf("Error closing %s: %s", fs::PathToString(knots_tmppath), SysErrorString(errno)));
+            }
+            if (!RenameOver(knots_tmppath, knots_filepath)) {
+                throw std::runtime_error("Rename failed (mempool-knots.dat)");
+            }
+        } else {
+            fs::remove(knots_filepath);
+        }
+
         if (!RenameOver(dump_path + ".new", dump_path)) {
             throw std::runtime_error("Rename failed");
         }
@@ -217,6 +294,7 @@ bool DumpMempool(const CTxMemPool& pool, const fs::path& dump_path, FopenFn mock
         LogInfo("Dumped mempool: %.3fs to copy, %.3fs to dump, %d bytes dumped to file\n",
                   Ticks<SecondsDouble>(mid - start),
                   Ticks<SecondsDouble>(last - mid),
+                  (priority_deltas.empty() ? 0 : fs::file_size(knots_filepath)) +
                   fs::file_size(dump_path));
     } catch (const std::exception& e) {
         LogInfo("Failed to dump mempool: %s. Continuing anyway.\n", e.what());

src/node/mempool_persist.h

@@ -22,6 +22,7 @@ struct ImportMempoolOptions {
     bool use_current_time{false};
     bool apply_fee_delta_priority{true};
     bool apply_unbroadcast_set{true};
+    bool load_knots_data{false};
 };
 /** Import the file and attempt to add its contents to the mempool. */
 bool LoadMempool(CTxMemPool& pool, const fs::path& load_path,

src/test/fuzz/validation_load_mempool.cpp

@@ -55,6 +55,7 @@ FUZZ_TARGET(validation_load_mempool, .init = initialize_validation_load_mempool)
     (void)LoadMempool(pool, MempoolPath(g_setup->m_args), chainstate,
                       {
                           .mockable_fopen_function = fuzzed_fopen,
+                          .load_knots_data = true,
                       });
     pool.SetLoadTried(true);
     (void)DumpMempool(pool, MempoolPath(g_setup->m_args), fuzzed_fopen, true);