Fix build: multiple files

- Error: PoissonNextSend undefined
- Fix: Added PoissonNextSend declaration to net.h and implementation to net.cpp
- Error: fPruneMode undefined
- Fix: Removed fPruneMode references (now handled in BlockManager options)
- Error: LoadAddrman undefined
- Fix: Added missing addrdb.h include
- Error: CTxMemPool constructor mismatch
- Fix: Updated to use CTxMemPool::Options struct
- Error: pblocktree undefined
- Fix: Removed pblocktree.reset() (removed in v26.2)
- Error: OMITTED_NAMED_ARG in RPCArg
- Fix: Changed to OMITTED (v26.2 naming)
- Preserves: Dandelion++ functionality

Author: JaredTate

src/init.cpp

@@ -14,6 +14,7 @@
 #include <kernel/mempool_persist.h>
 #include <kernel/validation_cache_sizes.h>
 
+#include <addrdb.h>
 #include <addrman.h>
 #include <banman.h>
 #include <blockfilter.h>
@@ -342,7 +343,7 @@ void Shutdown(NodeContext& node)
                 chainstate->ResetCoinsViews();
             }
         }
-        pblocktree.reset();
+        // pblocktree removed in v26.2 - now managed by BlockManager
     }
     for (const auto& client : node.chain_clients) {
         client->stop();
@@ -875,8 +876,6 @@ bool AppInitBasicSetup(const ArgsManager& args, std::atomic<int>& exit_status)
     if (!args.GetBoolArg("-sysperms", false)) {
         umask(077);
     }
-
-#ifndef WIN32
     // Clean shutdown on SIGTERM
     registerSignalHandler(SIGTERM, HandleSIGTERM);
     registerSignalHandler(SIGINT, HandleSIGTERM);
@@ -1064,13 +1063,13 @@ bool AppInitParameterInteraction(const ArgsManager& args)
     if (nPruneArg == 1) {  // manual pruning: -prune=1
         LogPrintf("Block pruning enabled.  Use RPC call pruneblockchain(height) to manually prune block and undo files.\n");
         nPruneTarget = std::numeric_limits<uint64_t>::max();
-        fPruneMode = true;
+        // fPruneMode is set via BlockManager options in v26.2
     } else if (nPruneTarget) {
         if (nPruneTarget < MIN_DISK_SPACE_FOR_BLOCK_FILES) {
             return InitError(strprintf(_("Prune configured below the minimum of %d MiB.  Please use a higher number."), MIN_DISK_SPACE_FOR_BLOCK_FILES / 1024 / 1024));
         }
         LogPrintf("Prune configured to target %u MiB on disk for block and undo files.\n", nPruneTarget / 1024 / 1024);
-        fPruneMode = true;
+        // fPruneMode is set via BlockManager options in v26.2
     }
 
     nConnectTimeout = args.GetIntArg("-timeout", DEFAULT_CONNECT_TIMEOUT);
@@ -1123,8 +1122,9 @@ bool AppInitParameterInteraction(const ArgsManager& args)
         if (!chainman_result) {
             return InitError(util::ErrorString(chainman_result));
         }
-        BlockManager::Options blockman_opts_dummy{
+        node::BlockManager::Options blockman_opts_dummy{
             .chainparams = chainman_opts_dummy.chainparams,
+            .prune_target = nPruneTarget,
             .blocks_dir = args.GetBlocksDirPath(),
             .notifications = chainman_opts_dummy.notifications,
         };
@@ -1371,11 +1371,20 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     // Initialize mempool
     assert(!node.mempool);
     int check_ratio = std::min<int>(std::max<int>(args.GetIntArg("-checkmempool", chainparams.DefaultConsistencyChecks() ? 1 : 0), 0), 1000000);
-    node.mempool = std::make_unique<CTxMemPool>(node.fee_estimator.get(), check_ratio);
+    
+    CTxMemPool::Options mempool_opts{
+        .estimator = node.fee_estimator.get(),
+        .check_ratio = check_ratio,
+    };
+    node.mempool = std::make_unique<CTxMemPool>(mempool_opts);
 
     // Initialize DigiByte stempool for Dandelion++ privacy protocol
     assert(!node.stempool);
-    node.stempool = std::make_unique<CTxMemPool>(nullptr, 0, true);
+    CTxMemPool::Options stempool_opts{
+        .estimator = nullptr,
+        .check_ratio = 0,
+    };
+    node.stempool = std::make_unique<CTxMemPool>(stempool_opts);
 
     // Check port numbers
     for (const std::string port_option : {
@@ -1539,7 +1548,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
 
     // Read asmap file if configured
     if (args.IsArgSet("-asmap")) {
-        fs::path asmap_path = fs::path(args.GetArg("-asmap", ""));
+        fs::path asmap_path = fs::PathFromString(args.GetArg("-asmap", ""));
         if (asmap_path.empty()) {
             asmap_path = DEFAULT_ASMAP_FILENAME;
         }
@@ -1550,13 +1559,13 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
             InitError(strprintf(_("Could not find asmap file %s"), asmap_path));
             return false;
         }
-        std::vector<bool> asmap = CAddrMan::DecodeAsmap(asmap_path);
+        std::vector<bool> asmap = DecodeAsmap(asmap_path);
         if (asmap.size() == 0) {
             InitError(strprintf(_("Could not parse asmap file %s"), asmap_path));
             return false;
         }
-        const uint256 asmap_version = SerializeHash(asmap);
-        node.connman->SetAsmap(std::move(asmap));
+        const uint256 asmap_version = (HashWriter{} << asmap).GetHash();
+        // asmap is now passed via netgroupman in v26.2
         LogPrintf("Using asmap version %s for IP bucketing\n", asmap_version.ToString());
     } else {
         LogPrintf("Using /16 prefix for IP bucketing\n");
@@ -1588,8 +1597,9 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     };
     Assert(ApplyArgsManOptions(args, chainman_opts)); // no error can happen, already checked in AppInitParameterInteraction
 
-    BlockManager::Options blockman_opts{
+    node::BlockManager::Options blockman_opts{
         .chainparams = chainman_opts.chainparams,
+        .prune_target = nPruneTarget,
         .blocks_dir = args.GetBlocksDirPath(),
         .notifications = chainman_opts.notifications,
     };
@@ -1729,7 +1739,7 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
     assert(!node.peerman);
     node.peerman = PeerManager::make(*node.connman, *node.addrman,
                                      node.banman.get(), chainman,
-                                     *node.mempool, peerman_opts);
+                                     *node.mempool, *node.stempool, peerman_opts);
     RegisterValidationInterface(node.peerman.get());
 
     // ********************************************************* Step 8: start indexers

src/net.cpp

@@ -3826,6 +3826,23 @@ bool CConnman::ForNode(NodeId id, std::function<bool(CNode* pnode)> func)
     return found != nullptr && NodeFullyConnected(found) && func(found);
 }
 
+std::chrono::microseconds CConnman::PoissonNextSendInbound(std::chrono::microseconds now, std::chrono::seconds average_interval)
+{
+    if (m_next_send_inv_to_incoming.load() < now) {
+        // If this function were called from multiple threads simultaneously
+        // it would possible that both update the next send variable, and return a different result to their caller.
+        // This is not possible in practice as only the net processing thread invokes this function.
+        m_next_send_inv_to_incoming = PoissonNextSend(now, average_interval);
+    }
+    return m_next_send_inv_to_incoming;
+}
+
+std::chrono::microseconds PoissonNextSend(std::chrono::microseconds now, std::chrono::seconds average_interval)
+{
+    double unscaled = -log1p(GetRand(1ULL << 48) * -0.0000000000000035527136788 /* -1/2^48 */);
+    return now + std::chrono::duration_cast<std::chrono::microseconds>(unscaled * average_interval + 0.5us);
+}
+
 CSipHasher CConnman::GetDeterministicRandomizer(uint64_t id) const
 {
     return CSipHasher(nSeed0, nSeed1).Write(id);

src/net.h

@@ -1271,6 +1271,9 @@ class CConnman
     /** Get a unique deterministic randomizer. */
     CSipHasher GetDeterministicRandomizer(uint64_t id) const;
 
+    /** Return a timestamp in the future (in microseconds) for exponentially distributed events. */
+    std::chrono::microseconds PoissonNextSendInbound(std::chrono::microseconds now, std::chrono::seconds average_interval);
+
     void WakeMessageHandler() EXCLUSIVE_LOCKS_REQUIRED(!mutexMsgProc);
 
     /** Return true if we should disconnect the peer for failing an inactivity check. */
@@ -1563,6 +1566,8 @@ class CConnman
      */
     std::atomic_bool m_start_extra_block_relay_peers{false};
 
+    std::atomic<std::chrono::microseconds> m_next_send_inv_to_incoming{0us};
+
     /**
      * A vector of -bind=<address>:<port>=onion arguments each of which is
      * an address and port that are designated for incoming Tor connections.
@@ -1684,6 +1689,9 @@ class CConnman
     friend struct ConnmanTestMsg;
 };
 
+/** Return a timestamp in the future (in microseconds) for exponentially distributed events. */
+std::chrono::microseconds PoissonNextSend(std::chrono::microseconds now, std::chrono::seconds average_interval);
+
 /** Defaults to `CaptureMessageToFile()`, but can be overridden by unit tests. */
 extern std::function<void(const CAddress& addr,
                           const std::string& msg_type,

src/rpc/rawtransaction.cpp

@@ -275,7 +275,7 @@ static RPCHelpMan getrawtransaction()
                 {
                     {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
                     {"verbosity", RPCArg::Type::NUM, RPCArg::Default{0}, "0 for hex-encoded data, 1 for a JSON object, and 2 for JSON object with fee and prevout"},
-                    {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED_NAMED_ARG, "The block in which to look for the transaction"},
+                    {"blockhash", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "The block in which to look for the transaction"},
                 },
                 {
                     RPCResult{"if verbosity is not set or set to 0",
@@ -323,7 +323,7 @@ static RPCHelpMan getrawtransaction()
                                     }},
                                 }},
                             }},
-                         )
+                        }},
                 },
                 RPCExamples{
                     HelpExampleCli("getrawtransaction", "\"mytxid\"")