diff --git a/.clang-format b/.clang-format
index f510ba4a1..7109a2362 100644
--- a/.clang-format
+++ b/.clang-format
@@ -14,7 +14,23 @@ AlwaysBreakAfterDefinitionReturnType: All
 AlwaysBreakAfterReturnType: All
 AlwaysBreakTemplateDeclarations: 'true'
 BreakBeforeBinaryOperators: NonAssignment
-BreakBeforeBraces: Allman
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterCaseLabel: true
+  AfterClass: true
+  AfterControlStatement: true
+  AfterEnum: true
+  AfterFunction: true
+  AfterNamespace: true
+  AfterObjCDeclaration: true
+  AfterStruct: true
+  AfterUnion: true
+  AfterExternBlock: true
+  BeforeCatch: true
+  BeforeElse: true
+  SplitEmptyFunction: false
+  SplitEmptyRecord: false
+  SplitEmptyNamespace: false
 BreakBeforeTernaryOperators: 'true'
 BreakConstructorInitializersBeforeComma: 'true'
 Cpp11BracedListStyle: 'true'
diff --git a/daemon/main.cpp b/daemon/main.cpp
index 8db322a74..bd4951619 100644
--- a/daemon/main.cpp
+++ b/daemon/main.cpp
@@ -259,7 +259,8 @@ run_main_context(const fs::path confFile, const llarp::RuntimeOptions opts)
     llarp::LogInfo("Using config file: ", confFile);
 
     llarp::Config conf;
-    conf.Load(confFile, opts.isRouter, confFile.parent_path());
+    if (!conf.Load(confFile, opts.isRouter, confFile.parent_path()))
+      throw std::runtime_error{"Config file parsing failed"};
 
     ctx = std::make_shared<llarp::Context>();
     ctx->Configure(conf);
diff --git a/jni/lokinet_jni_vpnio.hpp b/jni/lokinet_jni_vpnio.hpp
index fd2f374c7..ce9cde065 100644
--- a/jni/lokinet_jni_vpnio.hpp
+++ b/jni/lokinet_jni_vpnio.hpp
@@ -133,18 +133,15 @@ struct lokinet_jni_vpnio : public lokinet::VPNIO
 {
   void
   InjectSuccess() override
-  {
-  }
+  {}
 
   void
   InjectFail() override
-  {
-  }
+  {}
 
   void
   Tick() override
-  {
-  }
+  {}
 };
 
 #endif
\ No newline at end of file
diff --git a/llarp/config/config.cpp b/llarp/config/config.cpp
index d108438fc..2e7501137 100644
--- a/llarp/config/config.cpp
+++ b/llarp/config/config.cpp
@@ -17,6 +17,7 @@
 #include <fstream>
 #include <ios>
 #include <iostream>
+#include "constants/version.hpp"
 
 namespace llarp
 {
@@ -29,51 +30,81 @@ namespace llarp
 
   constexpr int DefaultPublicPort = 1090;
 
+  using namespace config;
+
   void
   RouterConfig::defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params)
   {
-    constexpr int DefaultJobQueueSize = 1024 * 8;
-    constexpr auto DefaultNetId = "lokinet";
-    constexpr int DefaultWorkerThreads = 1;
-    constexpr int DefaultNetThreads = 1;
-    constexpr bool DefaultBlockBogons = true;
+    constexpr Default DefaultJobQueueSize{1024 * 8};
+    constexpr Default DefaultWorkerThreads{0};
+    constexpr Default DefaultBlockBogons{true};
 
-    conf.defineOption<int>("router", "job-queue-size", false, DefaultJobQueueSize, [this](int arg) {
-      if (arg < 1024)
-        throw std::invalid_argument("job-queue-size must be 1024 or greater");
+    conf.defineOption<int>(
+        "router", "job-queue-size", DefaultJobQueueSize, Hidden, [this](int arg) {
+          if (arg < 1024)
+            throw std::invalid_argument("job-queue-size must be 1024 or greater");
 
-      m_JobQueueSize = arg;
-    });
+          m_JobQueueSize = arg;
+        });
 
-    conf.defineOption<std::string>("router", "netid", false, DefaultNetId, [this](std::string arg) {
-      if (arg.size() > NetID::size())
-        throw std::invalid_argument(stringify("netid is too long, max length is ", NetID::size()));
+    conf.defineOption<std::string>(
+        "router",
+        "netid",
+        Default{llarp::DEFAULT_NETID},
+        Comment{
+            "Network ID; this is '"s + llarp::DEFAULT_NETID + "' for mainnet, 'gamma' for testnet.",
+        },
+        [this](std::string arg) {
+          if (arg.size() > NetID::size())
+            throw std::invalid_argument(
+                stringify("netid is too long, max length is ", NetID::size()));
 
-      m_netId = std::move(arg);
-    });
+          m_netId = std::move(arg);
+        });
 
     int minConnections =
         (params.isRelay ? DefaultMinConnectionsForRouter : DefaultMinConnectionsForClient);
-    conf.defineOption<int>("router", "min-connections", false, minConnections, [=](int arg) {
-      if (arg < minConnections)
-        throw std::invalid_argument(stringify("min-connections must be >= ", minConnections));
+    conf.defineOption<int>(
+        "router",
+        "min-connections",
+        Default{minConnections},
+        Comment{
+            "Minimum number of routers lokinet will attempt to maintain connections to.",
+        },
+        [=](int arg) {
+          if (arg < minConnections)
+            throw std::invalid_argument(stringify("min-connections must be >= ", minConnections));
 
-      m_minConnectedRouters = arg;
-    });
+          m_minConnectedRouters = arg;
+        });
 
     int maxConnections =
         (params.isRelay ? DefaultMaxConnectionsForRouter : DefaultMaxConnectionsForClient);
-    conf.defineOption<int>("router", "max-connections", false, maxConnections, [=](int arg) {
-      if (arg < maxConnections)
-        throw std::invalid_argument(stringify("max-connections must be >= ", maxConnections));
+    conf.defineOption<int>(
+        "router",
+        "max-connections",
+        Default{maxConnections},
+        Comment{
+            "Maximum number (hard limit) of routers lokinet will be connected to at any time.",
+        },
+        [=](int arg) {
+          if (arg < maxConnections)
+            throw std::invalid_argument(stringify("max-connections must be >= ", maxConnections));
 
-      m_maxConnectedRouters = arg;
-    });
+          m_maxConnectedRouters = arg;
+        });
 
-    conf.defineOption<std::string>("router", "nickname", false, "", AssignmentAcceptor(m_nickname));
+    conf.defineOption<std::string>("router", "nickname", Hidden, AssignmentAcceptor(m_nickname));
 
     conf.defineOption<fs::path>(
-        "router", "data-dir", false, params.defaultDataDir, [this](fs::path arg) {
+        "router",
+        "data-dir",
+        Default{params.defaultDataDir},
+        Comment{
+            "Optional directory for containing lokinet runtime data. This includes generated",
+            "private keys.",
+        },
+        [this](fs::path arg) {
           if (not fs::exists(arg))
             throw std::runtime_error(
                 stringify("Specified [router]:data-dir ", arg, " does not exist"));
@@ -81,19 +112,28 @@ namespace llarp
           m_dataDir = std::move(arg);
         });
 
-    conf.defineOption<std::string>("router", "public-ip", false, "", [this](std::string arg) {
-      if (not arg.empty())
-      {
-        llarp::LogInfo("public ip ", arg, " size ", arg.size());
+    conf.defineOption<std::string>(
+        "router",
+        "public-ip",
+        RelayOnly,
+        Comment{
+            "For complex network configurations where the detected IP is incorrect or non-public",
+            "this setting specifies the public IP at which this router is reachable. When",
+            "provided the public-port option must also be specified.",
+        },
+        [this](std::string arg) {
+          if (not arg.empty())
+          {
+            llarp::LogInfo("public ip ", arg, " size ", arg.size());
 
-        if (arg.size() > 15)
-          throw std::invalid_argument(stringify("Not a valid IPv4 addr: ", arg));
+            if (arg.size() > 15)
+              throw std::invalid_argument(stringify("Not a valid IPv4 addr: ", arg));
 
-        m_publicAddress.setAddress(arg);
-      }
-    });
+            m_publicAddress.setAddress(arg);
+          }
+        });
 
-    conf.defineOption<std::string>("router", "public-address", false, "", [this](std::string arg) {
+    conf.defineOption<std::string>("router", "public-address", Hidden, [this](std::string arg) {
       if (not arg.empty())
       {
         llarp::LogWarn(
@@ -101,7 +141,7 @@ namespace llarp
             arg,
             " is deprecated, use public-ip=",
             arg,
-            " instead.");
+            " instead to avoid this warning and avoid future configuration problems.");
 
         if (arg.size() > 15)
           throw std::invalid_argument(stringify("Not a valid IPv4 addr: ", arg));
@@ -110,49 +150,101 @@ namespace llarp
       }
     });
 
-    conf.defineOption<int>("router", "public-port", false, DefaultPublicPort, [this](int arg) {
-      if (arg <= 0 || arg > std::numeric_limits<uint16_t>::max())
-        throw std::invalid_argument("public-port must be >= 0 and <= 65536");
+    conf.defineOption<int>(
+        "router",
+        "public-port",
+        RelayOnly,
+        Default{DefaultPublicPort},
+        Comment{
+            "When specifying public-ip=, this specifies the public UDP port at which this lokinet",
+            "router is reachable. Required when public-ip is used.",
+        },
+        [this](int arg) {
+          if (arg <= 0 || arg > std::numeric_limits<uint16_t>::max())
+            throw std::invalid_argument("public-port must be >= 0 and <= 65536");
 
-      m_publicAddress.setPort(arg);
-    });
+          m_publicAddress.setPort(arg);
+        });
 
     conf.defineOption<int>(
-        "router", "worker-threads", false, DefaultWorkerThreads, [this](int arg) {
-          if (arg <= 0)
-            throw std::invalid_argument("worker-threads must be > 0");
+        "router",
+        "worker-threads",
+        DefaultWorkerThreads,
+        Comment{
+            "The number of threads available for performing cryptographic functions.",
+            "The minimum is one thread, but network performance may increase with more.",
+            "threads. Should not exceed the number of logical CPU cores.",
+            "0 means use the number of logical CPU cores detected at startup.",
+        },
+        [this](int arg) {
+          if (arg < 0)
+            throw std::invalid_argument("worker-threads must be >= 0");
 
           m_workerThreads = arg;
         });
 
-    conf.defineOption<int>("router", "net-threads", false, DefaultNetThreads, [this](int arg) {
-      if (arg <= 0)
-        throw std::invalid_argument("net-threads must be > 0");
-
-      m_numNetThreads = arg;
-    });
-
+    // Hidden option because this isn't something that should ever be turned off occasionally when
+    // doing dev/testing work.
     conf.defineOption<bool>(
-        "router", "block-bogons", false, DefaultBlockBogons, AssignmentAcceptor(m_blockBogons));
+        "router", "block-bogons", DefaultBlockBogons, Hidden, AssignmentAcceptor(m_blockBogons));
 
-    conf.defineOption<std::string>(
-        "router", "contact-file", false, "", AssignmentAcceptor(m_routerContactFile));
+    constexpr auto relative_to_datadir =
+        "An absolute path is used as-is, otherwise relative to 'data-dir'.";
 
     conf.defineOption<std::string>(
-        "router", "encryption-privkey", false, "", AssignmentAcceptor(m_encryptionKeyFile));
+        "router",
+        "contact-file",
+        RelayOnly,
+        Default{llarp::our_rc_filename},
+        AssignmentAcceptor(m_routerContactFile),
+        Comment{
+            "Filename in which to store the router contact file",
+            relative_to_datadir,
+        });
 
     conf.defineOption<std::string>(
-        "router", "ident-privkey", false, "", AssignmentAcceptor(m_identityKeyFile));
+        "router",
+        "encryption-privkey",
+        RelayOnly,
+        Default{llarp::our_enc_key_filename},
+        AssignmentAcceptor(m_encryptionKeyFile),
+        Comment{
+            "Filename in which to store the encryption private key",
+            relative_to_datadir,
+        });
 
     conf.defineOption<std::string>(
-        "router", "transport-privkey", false, "", AssignmentAcceptor(m_transportKeyFile));
+        "router",
+        "ident-privkey",
+        RelayOnly,
+        Default{llarp::our_identity_filename},
+        AssignmentAcceptor(m_identityKeyFile),
+        Comment{
+            "Filename in which to store the identity private key",
+            relative_to_datadir,
+        });
 
-    conf.defineOption<bool>(
+    conf.defineOption<std::string>(
         "router",
-        "enable-peer-stats",
-        false,
-        params.isRelay,
-        AssignmentAcceptor(m_enablePeerStats));
+        "transport-privkey",
+        RelayOnly,
+        Default{llarp::our_transport_key_filename},
+        AssignmentAcceptor(m_transportKeyFile),
+        Comment{
+            "Filename in which to store the transport private key.",
+            relative_to_datadir,
+        });
+
+    // Deprecated options:
+
+    // these weren't even ever used!
+    conf.defineOption<std::string>("router", "max-routers", Deprecated);
+    conf.defineOption<std::string>("router", "min-routers", Deprecated);
+
+    // TODO: this may have been a synonym for [router]worker-threads
+    conf.defineOption<std::string>("router", "threads", Deprecated);
+    conf.defineOption<std::string>("router", "net-threads", Deprecated);
+
     m_isRelay = params.isRelay;
   }
 
@@ -161,53 +253,91 @@ namespace llarp
   {
     (void)params;
 
-    constexpr bool DefaultProfilingValue = true;
-    static constexpr bool ReachableDefault = true;
-    static constexpr int HopsDefault = 4;
-    static constexpr int PathsDefault = 6;
+    static constexpr Default ProfilingValueDefault{false};
+    static constexpr Default ReachableDefault{true};
+    static constexpr Default HopsDefault{4};
+    static constexpr Default PathsDefault{6};
 
     conf.defineOption<std::string>(
-        "network", "type", false, "tun", AssignmentAcceptor(m_endpointType));
-
-    conf.defineOption<bool>("network", "exit", false, false, AssignmentAcceptor(m_AllowExit));
+        "network", "type", Default{"tun"}, Hidden, AssignmentAcceptor(m_endpointType));
 
     conf.defineOption<bool>(
         "network",
         "profiling",
-        false,
-        DefaultProfilingValue,
+        ProfilingValueDefault,
+        Hidden,
         AssignmentAcceptor(m_enableProfiling));
 
-    // TODO: this should be implied from [router]:data-dir
     conf.defineOption<std::string>(
         "network",
-        "profiles",
-        false,
-        m_routerProfilesFile,
-        AssignmentAcceptor(m_routerProfilesFile));
+        "strict-connect",
+        ClientOnly,
+        AssignmentAcceptor(m_strictConnect),
+        Comment{
+            "Public key of a router which will act as sole first-hop. This may be used to",
+            "provide a trusted router (consider that you are not fully anonymous with your",
+            "first hop).",
+        });
 
     conf.defineOption<std::string>(
-        "network", "strict-connect", false, "", AssignmentAcceptor(m_strictConnect));
-
-    conf.defineOption<std::string>("network", "keyfile", false, "", AssignmentAcceptor(m_keyfile));
+        "network",
+        "keyfile",
+        ClientOnly,
+        AssignmentAcceptor(m_keyfile),
+        Comment{
+            "The private key to persist address with. If not specified the address will be",
+            "ephemeral.",
+        });
 
-    conf.defineOption<std::string>("network", "auth", false, "", [this](std::string arg) {
-      if (arg.empty())
-        return;
-      m_AuthType = service::ParseAuthType(arg);
-    });
+    conf.defineOption<std::string>(
+        "network",
+        "auth",
+        ClientOnly,
+        Comment{
+            "Set the endpoint authentication mechanism.",
+            "none/whitelist/lmq",
+        },
+        [this](std::string arg) {
+          if (arg.empty())
+            return;
+          m_AuthType = service::ParseAuthType(arg);
+        });
 
-    conf.defineOption<std::string>("network", "auth-lmq", false, "", AssignmentAcceptor(m_AuthUrl));
+    conf.defineOption<std::string>(
+        "network",
+        "auth-lmq",
+        ClientOnly,
+        AssignmentAcceptor(m_AuthUrl),
+        Comment{
+            "lmq endpoint to talk to for authenticating new sessions",
+            "ipc:///var/lib/lokinet/auth.socket",
+            "tcp://127.0.0.1:5555",
+        });
 
     conf.defineOption<std::string>(
-        "network", "auth-lmq-method", false, "llarp.auth", [this](std::string arg) {
+        "network",
+        "auth-lmq-method",
+        ClientOnly,
+        Default{"llarp.auth"},
+        Comment{
+            "lmq function to call for authenticating new sessions",
+            "llarp.auth",
+        },
+        [this](std::string arg) {
           if (arg.empty())
             return;
           m_AuthMethod = std::move(arg);
         });
 
     conf.defineOption<std::string>(
-        "network", "auth-whitelist", false, true, "", [this](std::string arg) {
+        "network",
+        "auth-whitelist",
+        ClientOnly,
+        MultiValue,
+        Comment{
+            "manually add a remote endpoint by .loki address to the access whitelist",
+        },
+        [this](std::string arg) {
           service::Address addr;
           if (not addr.FromString(arg))
             throw std::invalid_argument(stringify("bad loki address: ", arg));
@@ -215,125 +345,230 @@ namespace llarp
         });
 
     conf.defineOption<bool>(
-        "network", "reachable", false, ReachableDefault, AssignmentAcceptor(m_reachable));
+        "network",
+        "reachable",
+        ClientOnly,
+        ReachableDefault,
+        AssignmentAcceptor(m_reachable),
+        Comment{
+            "Determines whether we will publish our snapp's introset to the DHT.",
+        });
 
-    conf.defineOption<int>("network", "hops", false, HopsDefault, [this](int arg) {
-      if (arg < 1 or arg > 8)
-        throw std::invalid_argument("[endpoint]:hops must be >= 1 and <= 8");
-      m_Hops = arg;
-    });
+    conf.defineOption<int>(
+        "network",
+        "hops",
+        HopsDefault,
+        Comment{
+            "Number of hops in a path. Min 1, max 8.",
+        },
+        [this](int arg) {
+          if (arg < 1 or arg > 8)
+            throw std::invalid_argument("[endpoint]:hops must be >= 1 and <= 8");
+          m_Hops = arg;
+        });
 
-    conf.defineOption<int>("network", "paths", false, PathsDefault, [this](int arg) {
-      if (arg < 2 or arg > 8)
-        throw std::invalid_argument("[endpoint]:paths must be >= 2 and <= 8");
-      m_Paths = arg;
-    });
+    conf.defineOption<int>(
+        "network",
+        "paths",
+        ClientOnly,
+        PathsDefault,
+        Comment{
+            "Number of paths to maintain at any given time.",
+        },
+        [this](int arg) {
+          if (arg < 2 or arg > 8)
+            throw std::invalid_argument("[endpoint]:paths must be >= 2 and <= 8");
+          m_Paths = arg;
+        });
 
-    conf.defineOption<std::string>("network", "exit-auth", false, "", [this](std::string arg) {
-      if (arg.empty())
-        return;
-      service::Address exit;
-      service::AuthInfo auth;
-      const auto pos = arg.find(":");
-      if (pos == std::string::npos)
-      {
-        throw std::invalid_argument(
-            "[network]:exit-auth invalid format, expects exit-address.loki:auth-code-goes-here");
-      }
-      const auto exit_str = arg.substr(0, pos);
-      auth.token = arg.substr(pos + 1);
-      if (not exit.FromString(exit_str))
-      {
-        throw std::invalid_argument("[network]:exit-auth invalid exit address");
-      }
-      m_ExitAuths.emplace(exit, auth);
-    });
+    conf.defineOption<bool>(
+        "network",
+        "exit",
+        ClientOnly,
+        Default{false},
+        AssignmentAcceptor(m_AllowExit),
+        Comment{
+            "Whether or not we should act as an exit node. Beware that this increases demand",
+            "on the server and may pose liability concerns. Enable at your own risk.",
+        });
 
-    conf.defineOption<std::string>("network", "exit-node", false, "", [this](std::string arg) {
-      if (arg.empty())
-        return;
-      service::Address exit;
-      IPRange range;
-      const auto pos = arg.find(":");
-      if (pos == std::string::npos)
-      {
-        range.FromString("0.0.0.0/0");
-      }
-      else if (not range.FromString(arg.substr(pos + 1)))
-      {
-        throw std::invalid_argument("[network]:exit-node invalid ip range for exit provided");
-      }
-      if (pos != std::string::npos)
-      {
-        arg = arg.substr(0, pos);
-      }
-      if (not exit.FromString(arg))
-      {
-        throw std::invalid_argument(stringify("[network]:exit-node bad address: ", arg));
-      }
-      m_ExitMap.Insert(range, exit);
-    });
+    // TODO: not implemented yet!
+    // TODO: define the order of precedence (e.g. is whitelist applied before blacklist?)
+    //       additionally, what's default? What if I don't whitelist anything?
+    /*
+    conf.defineOption<std::string>("network", "exit-whitelist", MultiValue, Comment{
+            "List of destination protocol:port pairs to whitelist, example: udp:*",
+            "or tcp:80. Multiple values supported.",
+        }, FIXME-acceptor);
 
-    conf.defineOption<std::string>("network", "mapaddr", false, true, "", [this](std::string arg) {
-      if (arg.empty())
-        return;
-      huint128_t ip;
-      service::Address addr;
-      const auto pos = arg.find(":");
-      if (pos == std::string::npos)
-      {
-        throw std::invalid_argument(stringify("[endpoint]:mapaddr invalid entry: ", arg));
-      }
-      std::string addrstr = arg.substr(0, pos);
-      std::string ipstr = arg.substr(pos + 1);
-      if (not ip.FromString(ipstr))
-      {
-        huint32_t ipv4;
-        if (not ipv4.FromString(ipstr))
-        {
-          throw std::invalid_argument(stringify("[endpoint]:mapaddr invalid ip: ", ipstr));
-        }
-        ip = net::ExpandV4(ipv4);
-      }
-      if (not addr.FromString(addrstr))
-      {
-        throw std::invalid_argument(stringify("[endpoint]:mapaddr invalid addresss: ", addrstr));
-      }
-      if (m_mapAddrs.find(ip) != m_mapAddrs.end())
-      {
-        throw std::invalid_argument(stringify("[endpoint]:mapaddr ip already mapped: ", ipstr));
-      }
-      m_mapAddrs[ip] = addr;
-    });
+    conf.defineOption<std::string>("network", "exit-blacklist", MultiValue, Comment{
+            "Blacklist of destinations (same format as whitelist).",
+        }, FIXME-acceptor);
+    */
 
-    conf.defineOption<std::string>("network", "ifaddr", false, "", [this](std::string arg) {
-      if (arg.empty())
-      {
-        const auto maybe = llarp::FindFreeRange();
-        if (not maybe)
-          throw std::invalid_argument("cannot determine free ip range");
-        m_ifaddr = *maybe;
-        return;
-      }
-      if (not m_ifaddr.FromString(arg))
-      {
-        throw std::invalid_argument(stringify("[network]:ifaddr invalid value: ", arg));
-      }
-    });
+    conf.defineOption<std::string>(
+        "network",
+        "exit-node",
+        ClientOnly,
+        Comment{
+            "Specify a `.loki` address and an optional ip range to use as an exit broker.",
+            "Example:",
+            "exit-node=whatever.loki # maps all exit traffic to whatever.loki",
+            "exit-node=stuff.loki:100.0.0.0/24 # maps 100.0.0.0/24 to stuff.loki",
+        },
+        [this](std::string arg) {
+          if (arg.empty())
+            return;
+          service::Address exit;
+          IPRange range;
+          const auto pos = arg.find(":");
+          if (pos == std::string::npos)
+          {
+            range.FromString("0.0.0.0/0");
+          }
+          else if (not range.FromString(arg.substr(pos + 1)))
+          {
+            throw std::invalid_argument("[network]:exit-node invalid ip range for exit provided");
+          }
+          if (pos != std::string::npos)
+          {
+            arg = arg.substr(0, pos);
+          }
+          if (not exit.FromString(arg))
+          {
+            throw std::invalid_argument(stringify("[network]:exit-node bad address: ", arg));
+          }
+          m_ExitMap.Insert(range, exit);
+        });
 
-    conf.defineOption<std::string>("network", "ifname", false, "", [this](std::string arg) {
-      if (arg.empty())
-      {
-        const auto maybe = llarp::FindFreeTun();
-        if (not maybe)
-          throw std::invalid_argument("cannot determine free interface name");
-        arg = *maybe;
-      }
-      m_ifname = arg;
-    });
+    conf.defineOption<std::string>(
+        "network",
+        "exit-auth",
+        ClientOnly,
+        Comment{
+            "Specify an optional authentication code required to use a non-public exit node.",
+            "For example:",
+            "    exit-auth=myfavouriteexit.loki:abc",
+            "uses the authentication code `abc` whenever myfavouriteexit.loki is accessed.",
+            "Can be specified multiple time to store codes for different exit nodes.",
+        },
+        [this](std::string arg) {
+          if (arg.empty())
+            return;
+          service::Address exit;
+          service::AuthInfo auth;
+          const auto pos = arg.find(":");
+          if (pos == std::string::npos)
+          {
+            throw std::invalid_argument(
+                "[network]:exit-auth invalid format, expects "
+                "exit-address.loki:auth-code-goes-here");
+          }
+          const auto exit_str = arg.substr(0, pos);
+          auth.token = arg.substr(pos + 1);
+          if (not exit.FromString(exit_str))
+          {
+            throw std::invalid_argument("[network]:exit-auth invalid exit address");
+          }
+          m_ExitAuths.emplace(exit, auth);
+        });
+
+    conf.defineOption<std::string>(
+        "network",
+        "ifname",
+        Comment{
+            "Interface name for lokinet traffic. If unset lokinet will look for a free name",
+            "lokinetN, starting at 0 (e.g. lokinet0, lokinet1, ...).",
+        },
+        [this](std::string arg) {
+          if (arg.empty())
+          {
+            const auto maybe = llarp::FindFreeTun();
+            if (not maybe)
+              throw std::invalid_argument("cannot determine free interface name");
+            arg = *maybe;
+          }
+          m_ifname = arg;
+        });
 
     conf.defineOption<std::string>(
-        "network", "blacklist-snode", false, true, "", [this](std::string arg) {
+        "network",
+        "ifaddr",
+        Comment{
+            "Local IP and range for lokinet traffic. For example, 172.16.0.1/16 to use",
+            "172.16.0.1 for this machine and 172.16.x.y for remote peers. If omitted then",
+            "lokinet will attempt to find an unused private range.",
+        },
+        [this](std::string arg) {
+          if (arg.empty())
+          {
+            const auto maybe = llarp::FindFreeRange();
+            if (not maybe)
+              throw std::invalid_argument("cannot determine free ip range");
+            m_ifaddr = *maybe;
+            return;
+          }
+          if (not m_ifaddr.FromString(arg))
+          {
+            throw std::invalid_argument(stringify("[network]:ifaddr invalid value: ", arg));
+          }
+        });
+
+    // TODO: could be useful for snodes in the future, but currently only implemented for clients:
+    conf.defineOption<std::string>(
+        "network",
+        "mapaddr",
+        ClientOnly,
+        MultiValue,
+        Comment{
+            "Map a remote `.loki` address to always use a fixed local IP. For example:",
+            "    mapaddr=whatever.loki:172.16.0.10",
+            "maps `whatever.loki` to `172.16.0.10` instead of using the next available IP.",
+            "The given IP address must be inside the range configured by ifaddr=",
+        },
+        [this](std::string arg) {
+          if (arg.empty())
+            return;
+          huint128_t ip;
+          service::Address addr;
+          const auto pos = arg.find(":");
+          if (pos == std::string::npos)
+          {
+            throw std::invalid_argument(stringify("[endpoint]:mapaddr invalid entry: ", arg));
+          }
+          std::string addrstr = arg.substr(0, pos);
+          std::string ipstr = arg.substr(pos + 1);
+          if (not ip.FromString(ipstr))
+          {
+            huint32_t ipv4;
+            if (not ipv4.FromString(ipstr))
+            {
+              throw std::invalid_argument(stringify("[endpoint]:mapaddr invalid ip: ", ipstr));
+            }
+            ip = net::ExpandV4(ipv4);
+          }
+          if (not addr.FromString(addrstr))
+          {
+            throw std::invalid_argument(
+                stringify("[endpoint]:mapaddr invalid addresss: ", addrstr));
+          }
+          if (m_mapAddrs.find(ip) != m_mapAddrs.end())
+          {
+            throw std::invalid_argument(stringify("[endpoint]:mapaddr ip already mapped: ", ipstr));
+          }
+          m_mapAddrs[ip] = addr;
+        });
+
+    conf.defineOption<std::string>(
+        "network",
+        "blacklist-snode",
+        ClientOnly,
+        MultiValue,
+        Comment{
+            "Adds a lokinet relay `.snode` address to the list of relays to avoid when",
+            "building paths. Can be specified multiple times.",
+        },
+        [this](std::string arg) {
           RouterID id;
           if (not id.FromString(arg))
             throw std::invalid_argument(stringify("Invalid RouterID: ", arg));
@@ -343,13 +578,27 @@ namespace llarp
             throw std::invalid_argument(stringify("Duplicate blacklist-snode: ", arg));
         });
 
-    conf.defineOption<std::string>("network", "srv", false, true, "", [this](std::string arg) {
-      llarp::dns::SRVData newSRV;
-      if (not newSRV.fromString(arg))
-        throw std::invalid_argument(stringify("Invalid SRV Record string: ", arg));
+    // TODO: support SRV records for routers, but for now client only
+    conf.defineOption<std::string>(
+        "network",
+        "srv",
+        ClientOnly,
+        MultiValue,
+        Comment{
+            "Specify SRV Records for services hosted on the SNApp",
+            "for more info see https://docs.loki.network/Lokinet/Guides/HostingSNApps/",
+            "srv=_service._protocol priority weight port target.loki",
+        },
+        [this](std::string arg) {
+          llarp::dns::SRVData newSRV;
+          if (not newSRV.fromString(arg))
+            throw std::invalid_argument(stringify("Invalid SRV Record string: ", arg));
+
+          m_SRVRecords.push_back(std::move(newSRV));
+        });
 
-      m_SRVRecords.push_back(std::move(newSRV));
-    });
+    // Deprecated options:
+    conf.defineOption<std::string>("network", "enabled", Deprecated);
   }
 
   void
@@ -357,16 +606,28 @@ namespace llarp
   {
     (void)params;
 
+    // Most non-linux platforms have loopback as 127.0.0.1/32, but linux uses 127.0.0.1/8 so that we
+    // can bind to other 127.* IPs to avoid conflicting with something else that may be listening on
+    // 127.0.0.1:53.
+#ifdef __linux__
+    constexpr Default DefaultDNSBind{"127.3.2.1:53"};
+#else
+    constexpr Default DefaultDNSBind{"127.0.0.1:53"};
+#endif
+
     // Default, but if we get any upstream (including upstream=, i.e. empty string) we clear it
-    constexpr auto DefaultUpstreamDNS = "1.1.1.1";
-    m_upstreamDNS.emplace_back(DefaultUpstreamDNS);
+    constexpr Default DefaultUpstreamDNS{"1.1.1.1"};
+    m_upstreamDNS.emplace_back(DefaultUpstreamDNS.val);
 
     conf.defineOption<std::string>(
         "dns",
         "upstream",
-        false,
-        true,
         DefaultUpstreamDNS,
+        MultiValue,
+        Comment{
+            "Upstream resolver(s) to use as fallback for non-loki addresses.",
+            "Multiple values accepted.",
+        },
         [=, first = true](std::string arg) mutable {
           if (first)
           {
@@ -384,14 +645,29 @@ namespace llarp
           }
         });
 
-    conf.defineOption<std::string>("dns", "bind", false, "127.3.2.1:53", [=](std::string arg) {
-      m_bind = IpAddress{std::move(arg)};
-      if (!m_bind.getPort())
-        m_bind.setPort(53);
-    });
+    conf.defineOption<std::string>(
+        "dns",
+        "bind",
+        DefaultDNSBind,
+        Comment{
+            "Address to bind to for handling DNS requests.",
+        },
+        [=](std::string arg) {
+          m_bind = IpAddress{std::move(arg)};
+          if (!m_bind.getPort())
+            m_bind.setPort(53);
+        });
 
     // Ignored option (used by the systemd service file to disable resolvconf configuration).
-    conf.defineOption<bool>("dns", "no-resolvconf", false, false);
+    conf.defineOption<bool>(
+        "dns",
+        "no-resolvconf",
+        ClientOnly,
+        Comment{
+            "Can be uncommented and set to 1 to disable resolvconf configuration of lokinet DNS.",
+            "(This is not used directly by lokinet itself, but by the lokinet init scripts",
+            "on systems which use resolveconf)",
+        });
   }
 
   LinksConfig::LinkInfo
@@ -437,13 +713,46 @@ namespace llarp
   {
     (void)params;
 
-    constexpr auto DefaultOutboundLinkValue = "0";
+    constexpr Default DefaultOutboundLinkValue{"0"};
 
-    conf.defineOption<std::string>(
-        "bind", "*", false, false, DefaultOutboundLinkValue, [this](std::string arg) {
-          m_OutboundLink = LinkInfoFromINIValues("*", arg);
+    conf.addSectionComments(
+        "bind",
+        {
+            "This section specifies network interface names and/or IPs as keys, and",
+            "ports as values to control the address(es) on which Lokinet listens for",
+            "incoming data.",
+            "",
+            "Examples:",
+            "",
+            "    eth0=1090",
+            "    0.0.0.0=1090",
+            "    1.2.3.4=1090",
+            "",
+            "The first bind to port 1090 on the network interface 'eth0'; the second binds",
+            "to port 1090 on all local network interfaces; and the third example binds to",
+            "port 1090 on the given IP address.",
+            "",
+            "If a private range IP address (or an interface with a private IP) is given, or",
+            "if the 0.0.0.0 all-address IP is given then you must also specify the",
+            "public-ip= and public-port= settings in the [router] section with a public",
+            "address at which this router can be reached.",
+            ""
+            "Typically this section can be left blank: if no inbound bind addresses are",
+            "configured then lokinet will search for a local network interface with a public",
+            "IP address and use that (with port 1090).",
         });
 
+    conf.defineOption<std::string>(
+        "bind",
+        "*",
+        DefaultOutboundLinkValue,
+        Comment{
+            "Specify a source port for **outgoing** Lokinet traffic, for example if you want to",
+            "set up custom firewall rules based on the originating port. Typically this should",
+            "be left unset to automatically choose random source ports.",
+        },
+        [this](std::string arg) { m_OutboundLink = LinkInfoFromINIValues("*", arg); });
+
     if (std::string best_if; GetBestNetIF(best_if))
       m_InboundLinks.push_back(LinkInfoFromINIValues(best_if, std::to_string(DefaultPublicPort)));
 
@@ -495,24 +804,39 @@ namespace llarp
   void
   ApiConfig::defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params)
   {
-    constexpr auto DefaultRPCBindAddr = "tcp://127.0.0.1:1190";
+    constexpr Default DefaultRPCBindAddr{"tcp://127.0.0.1:1190"};
 
     conf.defineOption<bool>(
-        "api", "enabled", false, not params.isRelay, AssignmentAcceptor(m_enableRPCServer));
+        "api",
+        "enabled",
+        Default{not params.isRelay},
+        AssignmentAcceptor(m_enableRPCServer),
+        Comment{
+            "Determines whether or not the LMQ JSON API is enabled. Defaults ",
+        });
 
     conf.defineOption<std::string>(
-        "api", "bind", false, DefaultRPCBindAddr, [this](std::string arg) {
+        "api",
+        "bind",
+        DefaultRPCBindAddr,
+        [this](std::string arg) {
           if (arg.empty())
           {
-            arg = DefaultRPCBindAddr;
+            arg = DefaultRPCBindAddr.val;
           }
           if (arg.find("://") == std::string::npos)
           {
             arg = "tcp://" + arg;
           }
           m_rpcBindAddr = std::move(arg);
+        },
+        Comment{
+            "IP address and port to bind to.",
+            "Recommend localhost-only for security purposes.",
         });
 
+    conf.defineOption<std::string>("api", "authkey", Deprecated);
+
     // TODO: this was from pre-refactor:
     // TODO: add pubkey to whitelist
   }
@@ -522,33 +846,44 @@ namespace llarp
   {
     (void)params;
 
-    constexpr auto DefaultLokidRPCAddr = "tcp://127.0.0.1:22023";
-
-    conf.defineOption<std::string>(
-        "lokid", "service-node-seed", false, our_identity_filename, [this](std::string arg) {
-          if (not arg.empty())
-          {
-            usingSNSeed = true;
-            ident_keyfile = std::move(arg);
-          }
-        });
-
     conf.defineOption<bool>(
-        "lokid", "enabled", false, params.isRelay, AssignmentAcceptor(whitelistRouters));
+        "lokid",
+        "enabled",
+        RelayOnly,
+        Default{true},
+        Comment{
+            "Whether or not we should talk to lokid. Must be enabled for staked routers.",
+        },
+        AssignmentAcceptor(whitelistRouters));
 
-    conf.defineOption<std::string>("lokid", "jsonrpc", false, "", [](std::string arg) {
+    conf.defineOption<std::string>("lokid", "jsonrpc", RelayOnly, [](std::string arg) {
       if (arg.empty())
         return;
       throw std::invalid_argument(
-          "the [lokid]::jsonrpc option is deprecated please use the "
-          "[lokid]::rpc "
-          "config option instead");
+          "the [lokid]:jsonrpc option is no longer supported; please use the [lokid]:rpc config "
+          "option instead with lokid's lmq-local-control address -- typically a value such as "
+          "rpc=ipc:///var/lib/loki/lokid.sock or rpc=ipc:///home/snode/.loki/lokid.sock");
     });
 
     conf.defineOption<std::string>(
-        "lokid", "rpc", false, DefaultLokidRPCAddr, [this](std::string arg) {
-          lokidRPCAddr = lokimq::address(arg);
-        });
+        "lokid",
+        "rpc",
+        RelayOnly,
+        Comment{
+            "lokimq control address for for communicating with lokid. Depends on lokid's",
+            "lmq-local-control configuration option. By default this value should be",
+            "ipc://LOKID-DATA-DIRECTORY/lokid.sock, such as:",
+            "    rpc=ipc:///var/lib/loki/lokid.sock",
+            "    rpc=ipc:///home/USER/.loki/lokid.sock",
+            "but can use (non-default) TCP if lokid is configured that way:",
+            "    rpc=tcp://127.0.0.1:5678",
+        },
+        [this](std::string arg) { lokidRPCAddr = lokimq::address(arg); });
+
+    // Deprecated options:
+    conf.defineOption<std::string>("lokid", "username", Deprecated);
+    conf.defineOption<std::string>("lokid", "password", Deprecated);
+    conf.defineOption<std::string>("lokid", "service-node-seed", Deprecated);
   }
 
   void
@@ -557,7 +892,14 @@ namespace llarp
     (void)params;
 
     conf.defineOption<std::string>(
-        "bootstrap", "add-node", false, true, "", [this](std::string arg) {
+        "bootstrap",
+        "add-node",
+        MultiValue,
+        Comment{
+            "Specify a bootstrap file containing a signed RouterContact of a service node",
+            "which can act as a bootstrap. Can be specified multiple times.",
+        },
+        [this](std::string arg) {
           if (arg.empty())
           {
             throw std::invalid_argument("cannot use empty filename as bootstrap");
@@ -575,30 +917,59 @@ namespace llarp
   {
     (void)params;
 
-    constexpr auto DefaultLogType = "file";
-    constexpr auto DefaultLogFile = "stdout";
-    constexpr auto DefaultLogLevel = "info";
+    constexpr Default DefaultLogType{"file"};
+    constexpr Default DefaultLogFile{""};
+    constexpr Default DefaultLogLevel{"info"};
 
     conf.defineOption<std::string>(
-        "logging", "type", false, DefaultLogType, [this](std::string arg) {
+        "logging",
+        "type",
+        DefaultLogType,
+        [this](std::string arg) {
           LogType type = LogTypeFromString(arg);
           if (type == LogType::Unknown)
             throw std::invalid_argument(stringify("invalid log type: ", arg));
 
           m_logType = type;
+        },
+        Comment{
+            "Log type (format). Valid options are:",
+            "  file - plaintext formatting",
+            "  json - json-formatted log statements",
+            "  syslog - logs directed to syslog",
         });
 
     conf.defineOption<std::string>(
-        "logging", "level", false, DefaultLogLevel, [this](std::string arg) {
+        "logging",
+        "level",
+        DefaultLogLevel,
+        [this](std::string arg) {
           std::optional<LogLevel> level = LogLevelFromString(arg);
           if (not level)
             throw std::invalid_argument(stringify("invalid log level value: ", arg));
 
           m_logLevel = *level;
+        },
+        Comment{
+            "Minimum log level to print. Logging below this level will be ignored.",
+            "Valid log levels, in ascending order, are:",
+            "  trace",
+            "  debug",
+            "  info",
+            "  warn",
+            "  error",
         });
 
     conf.defineOption<std::string>(
-        "logging", "file", false, DefaultLogFile, AssignmentAcceptor(m_logFile));
+        "logging",
+        "file",
+        DefaultLogFile,
+        AssignmentAcceptor(m_logFile),
+        Comment{
+            "When using type=file this is the output filename. If given the value 'stdout' or",
+            "left empty then logging is printed as standard output rather than written to a",
+            "file.",
+        });
   }
 
   void
@@ -622,7 +993,7 @@ namespace llarp
       params.isRelay = isRelay;
       params.defaultDataDir = std::move(defaultDataDir);
 
-      ConfigDefinition conf;
+      ConfigDefinition conf{isRelay};
       initializeConfig(conf, params);
       addBackwardsCompatibleConfigOptions(conf);
       m_Parser.Clear();
@@ -662,7 +1033,7 @@ namespace llarp
       params.isRelay = isRelay;
       params.defaultDataDir = std::move(dataDir);
 
-      ConfigDefinition conf;
+      ConfigDefinition conf{isRelay};
       initializeConfig(conf, params);
 
       conf.acceptAllOptions();
@@ -693,34 +1064,15 @@ namespace llarp
   void
   Config::addBackwardsCompatibleConfigOptions(ConfigDefinition& conf)
   {
-    auto addIgnoreOption = [&](const std::string& section, const std::string& name) {
-      conf.defineOption<std::string>(section, name, false, true, "", [=](std::string arg) {
-        (void)arg;
-        LogWarn("*** WARNING: The config option [", section, "]:", name, " is deprecated");
-      });
-    };
-
-    addIgnoreOption("system", "user");
-    addIgnoreOption("system", "group");
-    addIgnoreOption("system", "pidfile");
-
-    addIgnoreOption("api", "authkey");
-
-    addIgnoreOption("netdb", "dir");
-
-    // these weren't even ever used!
-    addIgnoreOption("router", "max-routers");
-    addIgnoreOption("router", "min-routers");
-
-    // TODO: this may have been a synonym for [router]worker-threads
-    addIgnoreOption("router", "threads");
+    // These config sections don't exist anymore:
 
-    addIgnoreOption("metrics", "json-metrics-path");
+    conf.defineOption<std::string>("system", "user", Deprecated);
+    conf.defineOption<std::string>("system", "group", Deprecated);
+    conf.defineOption<std::string>("system", "pidfile", Deprecated);
 
-    addIgnoreOption("network", "enabled");
+    conf.defineOption<std::string>("netdb", "dir", Deprecated);
 
-    addIgnoreOption("lokid", "username");
-    addIgnoreOption("lokid", "password");
+    conf.defineOption<std::string>("metrics", "json-metrics-path", Deprecated);
   }
 
   void
@@ -778,57 +1130,6 @@ namespace llarp
             "Configuration for routing activity.",
         });
 
-    def.addOptionComments(
-        "router",
-        "threads",
-        {
-            "The number of threads available for performing cryptographic functions.",
-            "The minimum is one thread, but network performance may increase with more.",
-            "threads. Should not exceed the number of logical CPU cores.",
-        });
-
-    def.addOptionComments(
-        "router",
-        "data-dir",
-        {
-            "Optional directory for containing lokinet runtime data. This includes generated",
-            "private keys.",
-        });
-
-    // TODO: why did Kee want this, and/or what does it really do? Something about logs?
-    def.addOptionComments("router", "nickname", {"Router nickname. Kee wanted it."});
-
-    def.addOptionComments(
-        "router",
-        "min-connections",
-        {
-            "Minimum number of routers lokinet will attempt to maintain connections to.",
-        });
-
-    def.addOptionComments(
-        "router",
-        "max-connections",
-        {
-            "Maximum number (hard limit) of routers lokinet will be connected to at any time.",
-        });
-
-    def.addOptionComments(
-        "router",
-        "public-ip",
-        {
-            "For complex network configurations where the detected IP is incorrect or non-public",
-            "this setting specifies the public IP at which this router is reachable. When",
-            "provided the public-port option must also be specified.",
-        });
-
-    def.addOptionComments(
-        "router",
-        "public-port",
-        {
-            "When specifying public-ip=, this specifies the public UDP port at which this lokinet",
-            "router is reachable. Required when public-ip is used.",
-        });
-
     // logging
     def.addSectionComments(
         "logging",
@@ -836,29 +1137,6 @@ namespace llarp
             "logging settings",
         });
 
-    def.addOptionComments(
-        "logging",
-        "level",
-        {
-            "Minimum log level to print. Logging below this level will be ignored.",
-            "Valid log levels, in ascending order, are:",
-            "  trace",
-            "  debug",
-            "  info",
-            "  warn",
-            "  error",
-        });
-
-    def.addOptionComments(
-        "logging",
-        "type",
-        {
-            "Log type (format). Valid options are:",
-            "  file - plaintext formatting",
-            "  json - json-formatted log statements",
-            "  syslog - logs directed to syslog",
-        });
-
     // api
     def.addSectionComments(
         "api",
@@ -866,21 +1144,6 @@ namespace llarp
             "JSON API settings",
         });
 
-    def.addOptionComments(
-        "api",
-        "enabled",
-        {
-            "Determines whether or not the JSON API is enabled.",
-        });
-
-    def.addOptionComments(
-        "api",
-        "bind",
-        {
-            "IP address and port to bind to.",
-            "Recommend localhost-only for security purposes.",
-        });
-
     // dns
     def.addSectionComments(
         "dns",
@@ -888,31 +1151,6 @@ namespace llarp
             "DNS configuration",
         });
 
-    def.addOptionComments(
-        "dns",
-        "upstream",
-        {
-            "Upstream resolver(s) to use as fallback for non-loki addresses.",
-            "Multiple values accepted.",
-        });
-
-    def.addOptionComments(
-        "dns",
-        "bind",
-        {
-            "Address to bind to for handling DNS requests.",
-            "Multiple values accepted.",
-        });
-
-    def.addOptionComments(
-        "dns",
-        "no-resolvconf",
-        {
-            "Can be uncommented and set to 1 to disable resolvconf configuration of lokinet DNS.",
-            "(This is not used directly by lokinet itself, but by the lokinet init scripts",
-            "on systems which use resolveconf)",
-        });
-
     // bootstrap
     def.addSectionComments(
         "bootstrap",
@@ -920,57 +1158,12 @@ namespace llarp
             "Configure nodes that will bootstrap us onto the network",
         });
 
-    def.addOptionComments(
-        "bootstrap",
-        "add-node",
-        {
-            "Specify a bootstrap file containing a signed RouterContact of a service node",
-            "which can act as a bootstrap. Accepts multiple values.",
-        });
-
     // network
     def.addSectionComments(
         "network",
         {
             "Network settings",
         });
-
-    def.addOptionComments(
-        "network",
-        "profiles",
-        {
-            "File to contain router profiles.",
-        });
-
-    def.addOptionComments(
-        "network",
-        "strict-connect",
-        {
-            "Public key of a router which will act as sole first-hop. This may be used to",
-            "provide a trusted router (consider that you are not fully anonymous with your",
-            "first hop).",
-        });
-
-    def.addOptionComments(
-        "network",
-        "exit-node",
-        {
-            "Public key of an exit-node.",
-        });
-
-    def.addOptionComments(
-        "network",
-        "ifname",
-        {
-            "Interface name for lokinet traffic.",
-        });
-
-    def.addOptionComments(
-        "network",
-        "ifaddr",
-        {
-            "Local IP address for lokinet traffic.",
-        });
   }
 
   std::string
@@ -980,7 +1173,7 @@ namespace llarp
     params.isRelay = false;
     params.defaultDataDir = std::move(defaultDataDir);
 
-    llarp::ConfigDefinition def;
+    llarp::ConfigDefinition def{false};
     initializeConfig(def, params);
     generateCommonConfigComments(def);
 
@@ -990,102 +1183,6 @@ namespace llarp
             "Snapp settings",
         });
 
-    def.addOptionComments(
-        "network",
-        "keyfile",
-        {
-            "The private key to persist address with. If not specified the address will be",
-            "ephemeral.",
-        });
-
-    // TODO: is this redundant with / should be merged with basic client config?
-    def.addOptionComments(
-        "network",
-        "reachable",
-        {
-            "Determines whether we will publish our snapp's introset to the DHT.",
-        });
-
-    def.addOptionComments(
-        "network",
-        "hops",
-        {
-            "Number of hops in a path. Min 1, max 8.",
-        });
-
-    def.addOptionComments(
-        "network",
-        "paths",
-        {
-            "Number of paths to maintain at any given time.",
-        });
-
-    def.addOptionComments(
-        "network",
-        "blacklist-snode",
-        {
-            "Adds a `.snode` address to the blacklist.",
-        });
-
-    def.addOptionComments(
-        "network",
-        "exit-node",
-        {
-            "Specify a `.loki` address and an optional ip range to use as an exit broker.",
-            "Example:",
-            "exit-node=whatever.loki # maps all exit traffic to whatever.loki",
-            "exit-node=stuff.loki:100.0.0.0/24 # maps 100.0.0.0/24 to stuff.loki",
-        });
-
-    def.addOptionComments(
-        "network",
-        "mapaddr",
-        {
-            "Permanently map a `.loki` address to an IP owned by the snapp. Example:",
-            "mapaddr=whatever.loki:10.0.10.10 # maps `whatever.loki` to `10.0.10.10`.",
-        });
-    // extra [network] options
-    // TODO: probably better to create an [exit] section and only allow it for routers
-    def.addOptionComments(
-        "network",
-        "exit",
-        {
-            "Whether or not we should act as an exit node. Beware that this increases demand",
-            "on the server and may pose liability concerns. Enable at your own risk.",
-        });
-
-    def.addOptionComments(
-        "network",
-        "auth",
-        {
-            "Set the endpoint authentication mechanism.",
-            "none/whitelist/lmq",
-        });
-
-    def.addOptionComments(
-        "network",
-        "auth-lmq",
-        {
-            "lmq endpoint to talk to for authenticating new sessions",
-            "ipc:///var/lib/lokinet/auth.socket",
-            "tcp://127.0.0.1:5555",
-        });
-
-    def.addOptionComments(
-        "network",
-        "auth-lmq-method",
-        {
-            "lmq function to call for authenticating new sessions",
-            "llarp.auth",
-        });
-
-    def.addOptionComments(
-        "network",
-        "auth-whitelist",
-        {
-            "manually add a remote endpoint by .loki address to the access whitelist",
-        });
-
     return def.generateINIConfig(true);
   }
 
@@ -1096,7 +1193,7 @@ namespace llarp
     params.isRelay = true;
     params.defaultDataDir = std::move(defaultDataDir);
 
-    llarp::ConfigDefinition def;
+    llarp::ConfigDefinition def{true};
     initializeConfig(def, params);
     generateCommonConfigComments(def);
 
@@ -1104,63 +1201,7 @@ namespace llarp
     def.addSectionComments(
         "lokid",
         {
-            "Lokid configuration (settings for talking to lokid",
-        });
-
-    def.addOptionComments(
-        "lokid",
-        "enabled",
-        {
-            "Whether or not we should talk to lokid. Must be enabled for staked routers.",
-        });
-
-    def.addOptionComments(
-        "lokid",
-        "rpc",
-        {
-            "Host and port of running lokid's rpc that we should talk to.",
-        });
-
-    // TODO: doesn't appear to be used in the codebase
-    def.addOptionComments(
-        "lokid",
-        "service-node-seed",
-        {
-            "File containing service node's seed.",
-        });
-
-    // extra [network] options
-    // TODO: probably better to create an [exit] section and only allow it for routers
-    def.addOptionComments(
-        "network",
-        "exit",
-        {
-            "Whether or not we should act as an exit node. Beware that this increases demand",
-            "on the server and may pose liability concerns. Enable at your own risk.",
-        });
-
-    // TODO: define the order of precedence (e.g. is whitelist applied before blacklist?)
-    //       additionally, what's default? What if I don't whitelist anything?
-    def.addOptionComments(
-        "network",
-        "exit-whitelist",
-        {
-            "List of destination protocol:port pairs to whitelist, example: udp:*",
-            "or tcp:80. Multiple values supported.",
-        });
-
-    def.addOptionComments(
-        "network",
-        "exit-blacklist",
-        {
-            "Blacklist of destinations (same format as whitelist).",
-        });
-
-    def.addOptionComments(
-        "router",
-        "enable-peer-stats",
-        {
-            "Enable collection of SNode peer stats",
+            "Settings for communicating with lokid",
         });
 
     return def.generateINIConfig(true);
diff --git a/llarp/config/config.hpp b/llarp/config/config.hpp
index a960bea8b..e2387ee63 100644
--- a/llarp/config/config.hpp
+++ b/llarp/config/config.hpp
@@ -63,7 +63,6 @@ namespace llarp
     std::string m_identityKeyFile;
     std::string m_transportKeyFile;
 
-    bool m_enablePeerStats = false;
     bool m_isRelay = false;
 
     void
@@ -73,7 +72,6 @@ namespace llarp
   struct NetworkConfig
   {
     std::optional<bool> m_enableProfiling;
-    std::string m_routerProfilesFile;
     std::string m_strictConnect;
     std::string m_ifname;
     IPRange m_ifaddr;
@@ -153,7 +151,6 @@ namespace llarp
 
   struct LokidConfig
   {
-    bool usingSNSeed = false;
     bool whitelistRouters = false;
     fs::path ident_keyfile;
     lokimq::address lokidRPCAddr;
diff --git a/llarp/config/definition.cpp b/llarp/config/definition.cpp
index 7ad93c901..6ad34b885 100644
--- a/llarp/config/definition.cpp
+++ b/llarp/config/definition.cpp
@@ -1,22 +1,13 @@
 #include <config/definition.hpp>
+#include <util/logging/logger.hpp>
 
+#include <iterator>
 #include <sstream>
 #include <stdexcept>
 #include <cassert>
 
 namespace llarp
 {
-  OptionDefinitionBase::OptionDefinitionBase(
-      std::string section_, std::string name_, bool required_)
-      : section(section_), name(name_), required(required_)
-  {
-  }
-  OptionDefinitionBase::OptionDefinitionBase(
-      std::string section_, std::string name_, bool required_, bool multiValued_)
-      : section(section_), name(name_), required(required_), multiValued(multiValued_)
-  {
-  }
-
   template <>
   bool
   OptionDefinition<bool>::fromString(const std::string& input)
@@ -32,17 +23,43 @@ namespace llarp
   ConfigDefinition&
   ConfigDefinition::defineOption(OptionDefinition_ptr def)
   {
-    auto sectionItr = m_definitions.find(def->section);
-    if (sectionItr == m_definitions.end())
+    using namespace config;
+    // If explicitly deprecated or is a {client,relay} option in a {relay,client} config then add a
+    // dummy, warning option instead of this one.
+    if (def->deprecated || (relay ? def->clientOnly : def->relayOnly))
+    {
+      return defineOption<std::string>(
+          def->section,
+          def->name,
+          MultiValue,
+          Hidden,
+          [deprecated = def->deprecated,
+           relay = relay,
+           opt = "[" + def->section + "]:" + def->name](std::string_view) {
+            LogWarn(
+                "*** WARNING: The config option ",
+                opt,
+                (deprecated ? " is deprecated"
+                            : relay ? " is not valid in service node configuration files"
+                                    : " is not valid in client configuration files"),
+                " and has been ignored.");
+          });
+    }
+
+    auto [sectionItr, newSect] = m_definitions.try_emplace(def->section);
+    if (newSect)
       m_sectionOrdering.push_back(def->section);
+    auto& section = sectionItr->first;
 
-    auto& sectionDefinitions = m_definitions[def->section];
-    if (sectionDefinitions.find(def->name) != sectionDefinitions.end())
+    auto [it, added] = m_definitions[section].try_emplace(std::string{def->name}, std::move(def));
+    if (!added)
       throw std::invalid_argument(
           stringify("definition for [", def->section, "]:", def->name, " already exists"));
 
-    m_definitionOrdering[def->section].push_back(def->name);
-    sectionDefinitions[def->name] = std::move(def);
+    m_definitionOrdering[section].push_back(it->first);
+
+    if (!it->second->comments.empty())
+      addOptionComments(section, it->first, std::move(it->second->comments));
 
     return *this;
   }
@@ -153,10 +170,13 @@ namespace llarp
       const std::string& section, const std::string& name, std::vector<std::string> comments)
   {
     auto& defComments = m_definitionComments[section][name];
-    for (size_t i = 0; i < comments.size(); ++i)
-    {
-      defComments.emplace_back(std::move(comments[i]));
-    }
+    if (defComments.empty())
+      defComments = std::move(comments);
+    else
+      defComments.insert(
+          defComments.end(),
+          std::make_move_iterator(comments.begin()),
+          std::make_move_iterator(comments.end()));
   }
 
   std::string
@@ -167,41 +187,49 @@ namespace llarp
     int sectionsVisited = 0;
 
     visitSections([&](const std::string& section, const DefinitionMap&) {
-      if (sectionsVisited > 0)
-        oss << "\n\n";
-
-      // TODO: this will create empty objects as a side effect of map's operator[]
-      // TODO: this also won't handle sections which have no definition
-      for (const std::string& comment : m_sectionComments[section])
-      {
-        oss << "# " << comment << "\n";
-      }
-
-      oss << "[" << section << "]\n";
+      std::ostringstream sect_out;
 
       visitDefinitions(section, [&](const std::string& name, const OptionDefinition_ptr& def) {
-        oss << "\n";
-
+        bool has_comment = false;
         // TODO: as above, this will create empty objects
         // TODO: as above (but more important): this won't handle definitions with no entries
         //       (i.e. those handled by UndeclaredValueHandler's)
         for (const std::string& comment : m_definitionComments[section][name])
         {
-          oss << "# " << comment << "\n";
+          sect_out << "\n# " << comment;
+          has_comment = true;
         }
 
         if (useValues and def->getNumberFound() > 0)
         {
-          oss << name << "=" << def->valueAsString(false) << "\n";
+          sect_out << "\n" << name << "=" << def->valueAsString(false) << "\n";
         }
-        else
+        else if (not(def->hidden and not has_comment))
         {
+          sect_out << "\n";
           if (not def->required)
-            oss << "#";
-          oss << name << "=" << def->defaultValueAsString() << "\n";
+            sect_out << "#";
+          sect_out << name << "=" << def->defaultValueAsString() << "\n";
         }
       });
 
+      auto sect_str = sect_out.str();
+      if (sect_str.empty())
+        return;  // Skip sections with no options
+
+      if (sectionsVisited > 0)
+        oss << "\n\n";
+
+      oss << "[" << section << "]\n";
+
+      // TODO: this will create empty objects as a side effect of map's operator[]
+      // TODO: this also won't handle sections which have no definition
+      for (const std::string& comment : m_sectionComments[section])
+      {
+        oss << "# " << comment << "\n";
+      }
+      oss << "\n" << sect_str;
+
       sectionsVisited++;
     });
 
diff --git a/llarp/config/definition.hpp b/llarp/config/definition.hpp
index 749389507..1f13f987a 100644
--- a/llarp/config/definition.hpp
+++ b/llarp/config/definition.hpp
@@ -1,6 +1,9 @@
 #pragma once
 
+#include <initializer_list>
+#include <type_traits>
 #include <util/str.hpp>
+#include <util/fs.hpp>
 
 #include <iostream>
 #include <memory>
@@ -15,19 +18,111 @@
 
 namespace llarp
 {
+  namespace config
+  {
+    // Base class for the following option flag types
+    struct option_flag
+    {};
+
+    struct Required_t : option_flag
+    {};
+    struct Hidden_t : option_flag
+    {};
+    struct MultiValue_t : option_flag
+    {};
+    struct RelayOnly_t : option_flag
+    {};
+    struct ClientOnly_t : option_flag
+    {};
+    struct Deprecated_t : option_flag
+    {};
+
+    /// Value to pass for an OptionDefinition to indicate that the option is required
+    inline constexpr Required_t Required{};
+    /// Value to pass for an OptionDefinition to indicate that the option should be hidden from the
+    /// generate config file if it is unset (and has no comment).  Typically for deprecated, renamed
+    /// options that still do something, and for internal dev options that aren't usefully exposed.
+    /// (For do-nothing deprecated options use Deprecated instead).
+    inline constexpr Hidden_t Hidden{};
+    /// Value to pass for an OptionDefinition to indicate that the option takes multiple values
+    inline constexpr MultiValue_t MultiValue{};
+    /// Value to pass for an option that should only be set for relay configs. If found in a client
+    /// config it be ignored (but will produce a warning).
+    inline constexpr RelayOnly_t RelayOnly{};
+    /// Value to pass for an option that should only be set for client configs. If found in a relay
+    /// config it will be ignored (but will produce a warning).
+    inline constexpr ClientOnly_t ClientOnly{};
+    /// Value to pass for an option that is deprecated and does nothing and should be ignored (with
+    /// a deprecation warning) if specified.  Note that Deprecated implies Hidden, and that
+    /// {client,relay}-only options in a {relay,client} config are also considered Deprecated.
+    inline constexpr Deprecated_t Deprecated{};
+
+    /// Wrapper to specify a default value to an OptionDefinition
+    template <typename T>
+    struct Default
+    {
+      T val;
+      constexpr explicit Default(T val) : val{std::move(val)}
+      {}
+    };
+
+    /// Adds one or more comment lines to the option definition.
+    struct Comment
+    {
+      std::vector<std::string> comments;
+      explicit Comment(std::initializer_list<std::string> comments) : comments{std::move(comments)}
+      {}
+    };
+
+    /// A convenience function that returns an acceptor which assigns to a reference.
+    ///
+    /// Note that this holds on to the reference; it must only be used when this is safe to do. In
+    /// particular, a reference to a local variable may be problematic.
+    template <typename T>
+    auto
+    AssignmentAcceptor(T& ref)
+    {
+      return [&ref](T arg) { ref = std::move(arg); };
+    }
+
+    // C++20 backport:
+    template <typename T>
+    using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;
+
+    template <typename T>
+    constexpr bool is_default = false;
+    template <typename T>
+    constexpr bool is_default<Default<T>> = true;
+    template <typename U>
+    constexpr bool is_default<U&> = is_default<remove_cvref_t<U>>;
+
+    template <typename T, typename Option>
+    constexpr bool is_option =
+        std::is_base_of_v<
+            option_flag,
+            remove_cvref_t<
+                Option>> or std::is_same_v<Comment, Option> or is_default<Option> or std::is_invocable_v<remove_cvref_t<Option>, T>;
+  }  // namespace config
+
   /// A base class for specifying config options and their constraints. The basic to/from string
   /// type functions are provided pure-virtual. The type-aware implementations which implement these
   /// functions are templated classes. One reason for providing a non-templated base class is so
   /// that they can all be mixed into the same containers (albiet as pointers).
   struct OptionDefinitionBase
   {
-    OptionDefinitionBase(std::string section_, std::string name_, bool required_);
-    OptionDefinitionBase(
-        std::string section_, std::string name_, bool required_, bool multiValued_);
-
-    virtual ~OptionDefinitionBase()
-    {
-    }
+    template <typename... T>
+    OptionDefinitionBase(std::string section_, std::string name_, const T&...)
+        : section(std::move(section_))
+        , name(std::move(name_))
+        , required{(std::is_same_v<T, config::Required_t> || ...)}
+        , multiValued{(std::is_same_v<T, config::MultiValue_t> || ...)}
+        , deprecated{(std::is_same_v<T, config::Deprecated_t> || ...)}
+        , hidden{deprecated || (std::is_same_v<T, config::Hidden_t> || ...)}
+        , relayOnly{(std::is_same_v<T, config::RelayOnly_t> || ...)}
+        , clientOnly{(std::is_same_v<T, config::ClientOnly_t> || ...)}
+    {}
+
+    virtual ~OptionDefinitionBase() = default;
 
     /// Subclasses should provide their default value as a string
     ///
@@ -65,6 +160,13 @@ namespace llarp
     std::string name;
     bool required = false;
     bool multiValued = false;
+    bool deprecated = false;
+    bool hidden = false;
+    bool relayOnly = false;
+    bool clientOnly = false;
+    // Temporarily holds comments given during construction until the option is actually added to
+    // the owning ConfigDefinition.
+    std::vector<std::string> comments;
   };
 
   /// The primary type-aware implementation of OptionDefinitionBase, this templated class allows
@@ -84,33 +186,53 @@ namespace llarp
     /// 2) as the output in defaultValueAsString(), used to generate config files
     /// 3) as the output in valueAsString(), used to generate config files
     ///
-    /// @param acceptor_ is an optional function whose purpose is to both validate the parsed
-    ///        input and internalize it (e.g. copy it for runtime use). The acceptor should throw
-    ///        an exception with a useful message if it is not acceptable.
-    OptionDefinition(
-        std::string section_,
-        std::string name_,
-        bool required_,
-        std::optional<T> defaultValue_,
-        std::function<void(T)> acceptor_ = nullptr)
-        : OptionDefinitionBase(section_, name_, required_)
-        , defaultValue(defaultValue_)
-        , acceptor(acceptor_)
+    /// @param opts - 0 or more of config::Required, config::Hidden, config::Default{...}, etc.
+    /// tagged options or an invocable acceptor validate and internalize input (e.g. copy it for
+    /// runtime use). The acceptor should throw an exception with a useful message if it is not
+    /// acceptable.  Parameters may be passed in any order.
+    template <
+        typename... Options,
+        std::enable_if_t<(config::is_option<T, Options> && ...), int> = 0>
+    OptionDefinition(std::string section_, std::string name_, Options&&... opts)
+        : OptionDefinitionBase(section_, name_, opts...)
+    {
+      (extractDefault(std::forward<Options>(opts)), ...);
+      (extractAcceptor(std::forward<Options>(opts)), ...);
+      (extractComments(std::forward<Options>(opts)), ...);
+    }
+
+    /// Extracts a default value from an config::Default<U>; ignores anything that isn't an
+    /// config::Default<U>.
+    template <typename U>
+    void
+    extractDefault(U&& defaultValue_)
+    {
+      if constexpr (config::is_default<U>)
+      {
+        static_assert(
+            std::is_convertible_v<decltype(std::forward<U>(defaultValue_).val), T>,
+            "Cannot convert given llarp::config::Default to the required value type");
+        defaultValue = std::forward<U>(defaultValue_).val;
+      }
+    }
+
+    /// Extracts an acceptor (i.e. something callable with a `T`) from options; ignores anything
+    /// that isn't callable.
+    template <typename U>
+    void
+    extractAcceptor(U&& acceptor_)
     {
+      if constexpr (std::is_invocable_v<U, T>)
+        acceptor = std::forward<U>(acceptor_);
     }
 
-    /// As above, but also takes a bool value for multiValued.
-    OptionDefinition(
-        std::string section_,
-        std::string name_,
-        bool required_,
-        bool multiValued_,
-        std::optional<T> defaultValue_,
-        std::function<void(T)> acceptor_ = nullptr)
-        : OptionDefinitionBase(section_, name_, required_, multiValued_)
-        , defaultValue(defaultValue_)
-        , acceptor(acceptor_)
+    /// Extracts option Comments and forwards them addOptionComments.
+    template <typename U>
+    void
+    extractComments(U&& comment)
     {
+      if constexpr (std::is_same_v<config::remove_cvref_t<U>, config::Comment>)
+        comments = std::forward<U>(comment).comments;
     }
 
     /// Returns the first parsed value, if available. Otherwise, provides the default value if the
@@ -155,10 +277,14 @@ namespace llarp
     std::string
     defaultValueAsString() override
     {
-      std::ostringstream oss;
-      if (defaultValue)
-        oss << *defaultValue;
+      if (!defaultValue)
+        return "";
+
+      if constexpr (std::is_same_v<fs::path, T>)
+        return defaultValue->string();
 
+      std::ostringstream oss;
+      oss << *defaultValue;
       return oss.str();
     }
 
@@ -224,7 +350,7 @@ namespace llarp
       }
 
       // don't use default value if we are multi-valued and have no value
-      if (multiValued && parsedValues.size() == 0)
+      if (multiValued and parsedValues.size() == 0)
         return;
 
       if (acceptor)
@@ -289,11 +415,14 @@ namespace llarp
   /// calls to addConfigValue()).
   struct ConfigDefinition
   {
-    /// Spefify the parameters and type of a configuration option. The parameters are members of
+    explicit ConfigDefinition(bool relay) : relay{relay}
+    {}
+
+    /// Specify the parameters and type of a configuration option. The parameters are members of
     /// OptionDefinitionBase; the type is inferred from OptionDefinition's template parameter T.
     ///
     /// This function should be called for every option that this Configuration supports, and should
-    /// be done before any other interractions involving that option.
+    /// be done before any other interactions involving that option.
     ///
     /// @param def should be a unique_ptr to a valid subclass of OptionDefinitionBase
     /// @return `*this` for chaining calls
@@ -307,7 +436,7 @@ namespace llarp
     ConfigDefinition&
     defineOption(Params&&... args)
     {
-      return defineOption(std::make_unique<OptionDefinition<T>>(args...));
+      return defineOption(std::make_unique<OptionDefinition<T>>(std::forward<Params>(args)...));
     }
 
     /// Specify a config value for the given section and name. The value should be a valid string
@@ -416,6 +545,9 @@ namespace llarp
     generateINIConfig(bool useValues = false);
 
    private:
+    // If true skip client-only options; if false skip relay-only options.
+    bool relay;
+
     OptionDefinition_ptr&
     lookupDefinitionOrThrow(std::string_view section, std::string_view name);
     const OptionDefinition_ptr&
@@ -444,15 +576,4 @@ namespace llarp
     std::unordered_map<std::string, CommentsMap> m_definitionComments;
   };
 
-  /// A convenience acceptor which takes a reference and later assigns it in its acceptor call.
-  ///
-  /// Note that this holds on to a reference; it must only be used when this is safe to do. In
-  /// particular, a reference to a local variable may be problematic.
-  template <typename T>
-  std::function<void(T)>
-  AssignmentAcceptor(T& ref)
-  {
-    return [&](T arg) mutable { ref = std::move(arg); };
-  }
-
 }  // namespace llarp
diff --git a/llarp/config/ini.cpp b/llarp/config/ini.cpp
index 4602394ec..c5371c57a 100644
--- a/llarp/config/ini.cpp
+++ b/llarp/config/ini.cpp
@@ -72,62 +72,44 @@ namespace llarp
 
     std::string_view sectName;
     size_t lineno = 0;
-    for (const auto& line : lines)
+    for (auto line : lines)
     {
       lineno++;
-      std::string_view realLine;
-      auto comment = line.find_first_of(';');
-      if (comment == std::string_view::npos)
-        comment = line.find_first_of('#');
-      if (comment == std::string_view::npos)
-        realLine = line;
-      else
-        realLine = line.substr(0, comment);
-      // blank or commented line?
-      if (realLine.size() == 0)
+      // Trim whitespace
+      while (!line.empty() && whitespace(line.front()))
+        line.remove_prefix(1);
+      while (!line.empty() && whitespace(line.back()))
+        line.remove_suffix(1);
+
+      // Skip blank lines and comments
+      if (line.empty() or line.front() == ';' or line.front() == '#')
         continue;
-      // find delimiters
-      auto sectOpenPos = realLine.find_first_of('[');
-      auto sectClosPos = realLine.find_first_of(']');
-      auto kvDelim = realLine.find_first_of('=');
-      if (sectOpenPos != std::string_view::npos && sectClosPos != std::string_view::npos
-          && kvDelim == std::string_view::npos)
+
+      if (line.front() == '[' && line.back() == ']')
       {
         // section header
-
-        // clamp whitespaces
-        ++sectOpenPos;
-        while (whitespace(realLine[sectOpenPos]) && sectOpenPos != sectClosPos)
-          ++sectOpenPos;
-        --sectClosPos;
-        while (whitespace(realLine[sectClosPos]) && sectClosPos != sectOpenPos)
-          --sectClosPos;
-        // set section name
-        sectName = realLine.substr(sectOpenPos, sectClosPos);
+        line.remove_prefix(1);
+        line.remove_suffix(1);
+        sectName = line;
       }
-      else if (kvDelim != std::string_view::npos)
+      else if (auto kvDelim = line.find('='); kvDelim != std::string_view::npos)
       {
         // key value pair
-        std::string_view k = realLine.substr(0, kvDelim);
-        std::string_view v = realLine.substr(kvDelim + 1);
-
-        // clamp whitespaces
-        for (auto* x : {&k, &v})
-        {
-          while (!x->empty() && whitespace(x->front()))
-            x->remove_prefix(1);
-          while (!x->empty() && whitespace(x->back()))
-            x->remove_suffix(1);
-        }
-
-        if (k.size() == 0)
+        std::string_view k = line.substr(0, kvDelim);
+        std::string_view v = line.substr(kvDelim + 1);
+        // Trim inner whitespace
+        while (!k.empty() && whitespace(k.back()))
+          k.remove_suffix(1);
+        while (!v.empty() && whitespace(v.front()))
+          v.remove_prefix(1);
+
+        if (k.empty())
         {
           LogError(m_FileName, " invalid line (", lineno, "): '", line, "'");
           return false;
         }
-        SectionValues_t& sect = m_Config[std::string{sectName}];
-        LogDebug(m_FileName, ": ", sectName, ".", k, "=", v);
-        sect.emplace(k, v);
+        LogDebug(m_FileName, ": [", sectName, "]:", k, "=", v);
+        m_Config[std::string{sectName}].emplace(k, v);
       }
       else  // malformed?
       {
diff --git a/llarp/config/key_manager.cpp b/llarp/config/key_manager.cpp
index aebf41171..952559372 100644
--- a/llarp/config/key_manager.cpp
+++ b/llarp/config/key_manager.cpp
@@ -9,8 +9,7 @@
 namespace llarp
 {
   KeyManager::KeyManager() : m_initialized(false), m_needBackup(false)
-  {
-  }
+  {}
 
   bool
   KeyManager::initialize(const llarp::Config& config, bool genIfAbsent, bool isRouter)
diff --git a/llarp/context.cpp b/llarp/context.cpp
index a2ac2a8a4..6401f16a6 100644
--- a/llarp/context.cpp
+++ b/llarp/context.cpp
@@ -167,8 +167,7 @@ namespace llarp
 
   void
   Context::Reload()
-  {
-  }
+  {}
 
   void
   Context::SigINT()
diff --git a/llarp/crypto/encrypted.hpp b/llarp/crypto/encrypted.hpp
index fca2a72df..baf869467 100644
--- a/llarp/crypto/encrypted.hpp
+++ b/llarp/crypto/encrypted.hpp
@@ -56,8 +56,7 @@ namespace llarp
     }
 
     Encrypted(size_t sz) : Encrypted(nullptr, sz)
-    {
-    }
+    {}
 
     bool
     BEncode(llarp_buffer_t* buf) const
diff --git a/llarp/crypto/encrypted_frame.hpp b/llarp/crypto/encrypted_frame.hpp
index 9c7ad1b05..ba624d68f 100644
--- a/llarp/crypto/encrypted_frame.hpp
+++ b/llarp/crypto/encrypted_frame.hpp
@@ -16,14 +16,12 @@ namespace llarp
   struct EncryptedFrame : public Encrypted<EncryptedFrameSize>
   {
     EncryptedFrame() : EncryptedFrame(EncryptedFrameBodySize)
-    {
-    }
+    {}
 
     EncryptedFrame(size_t sz)
         : Encrypted<EncryptedFrameSize>(
             std::min(sz, EncryptedFrameBodySize) + EncryptedFrameOverheadSize)
-    {
-    }
+    {}
 
     void
     Resize(size_t sz)
@@ -70,8 +68,7 @@ namespace llarp
 
     AsyncFrameDecrypter(const SecretKey& secretkey, DecryptHandler h)
         : result(std::move(h)), seckey(secretkey)
-    {
-    }
+    {}
 
     DecryptHandler result;
     const SecretKey& seckey;
diff --git a/llarp/crypto/types.hpp b/llarp/crypto/types.hpp
index a7c6ecdb0..9ad68ffa7 100644
--- a/llarp/crypto/types.hpp
+++ b/llarp/crypto/types.hpp
@@ -20,16 +20,13 @@ namespace llarp
     PubKey() = default;
 
     explicit PubKey(const byte_t* ptr) : AlignedBuffer<SIZE>(ptr)
-    {
-    }
+    {}
 
     explicit PubKey(const Data& data) : AlignedBuffer<SIZE>(data)
-    {
-    }
+    {}
 
     explicit PubKey(const AlignedBuffer<SIZE>& other) : AlignedBuffer<SIZE>(other)
-    {
-    }
+    {}
 
     std::string
     ToString() const;
@@ -84,13 +81,11 @@ namespace llarp
     SecretKey() = default;
 
     explicit SecretKey(const byte_t* ptr) : AlignedBuffer<SECKEYSIZE>(ptr)
-    {
-    }
+    {}
 
     // The full data
     explicit SecretKey(const AlignedBuffer<SECKEYSIZE>& seed) : AlignedBuffer<SECKEYSIZE>(seed)
-    {
-    }
+    {}
 
     // Just the seed, we recalculate the pubkey
     explicit SecretKey(const AlignedBuffer<32>& seed)
@@ -147,12 +142,10 @@ namespace llarp
     PrivateKey() = default;
 
     explicit PrivateKey(const byte_t* ptr) : AlignedBuffer<64>(ptr)
-    {
-    }
+    {}
 
     explicit PrivateKey(const AlignedBuffer<64>& key_and_hash) : AlignedBuffer<64>(key_and_hash)
-    {
-    }
+    {}
 
     /// Returns a pointer to the beginning of the 32-byte hash which is used for
     /// pseudorandomness when signing with this private key.
@@ -195,8 +188,7 @@ namespace llarp
   struct IdentitySecret final : public AlignedBuffer<32>
   {
     IdentitySecret() : AlignedBuffer<32>()
-    {
-    }
+    {}
 
     /// no copy constructor
     explicit IdentitySecret(const IdentitySecret&) = delete;
diff --git a/llarp/dht/bucket.hpp b/llarp/dht/bucket.hpp
index 47cb6d4b6..4c9baf5ae 100644
--- a/llarp/dht/bucket.hpp
+++ b/llarp/dht/bucket.hpp
@@ -20,8 +20,7 @@ namespace llarp
       using Random_t = std::function<uint64_t()>;
 
       Bucket(const Key_t& us, Random_t r) : nodes(XorMetric(us)), random(std::move(r))
-      {
-      }
+      {}
 
       util::StatusObject
       ExtractStatus() const
diff --git a/llarp/dht/explorenetworkjob.hpp b/llarp/dht/explorenetworkjob.hpp
index 6c6b22678..c3312c83a 100644
--- a/llarp/dht/explorenetworkjob.hpp
+++ b/llarp/dht/explorenetworkjob.hpp
@@ -12,8 +12,7 @@ namespace llarp
     {
       ExploreNetworkJob(const RouterID& peer, AbstractContext* ctx)
           : TX<RouterID, RouterID>(TXOwner{}, peer, ctx)
-      {
-      }
+      {}
 
       bool
       Validate(const RouterID&) const override
diff --git a/llarp/dht/kademlia.hpp b/llarp/dht/kademlia.hpp
index aba1d625b..cc89586fe 100644
--- a/llarp/dht/kademlia.hpp
+++ b/llarp/dht/kademlia.hpp
@@ -13,8 +13,7 @@ namespace llarp
       const Key_t us;
 
       XorMetric(const Key_t& ourKey) : us(ourKey)
-      {
-      }
+      {}
 
       bool
       operator()(const Key_t& left, const Key_t& right) const
diff --git a/llarp/dht/key.hpp b/llarp/dht/key.hpp
index 804e7f040..94fd894ef 100644
--- a/llarp/dht/key.hpp
+++ b/llarp/dht/key.hpp
@@ -13,20 +13,16 @@ namespace llarp
     struct Key_t : public AlignedBuffer<32>
     {
       explicit Key_t(const byte_t* buf) : AlignedBuffer<SIZE>(buf)
-      {
-      }
+      {}
 
       explicit Key_t(const Data& data) : AlignedBuffer<SIZE>(data)
-      {
-      }
+      {}
 
       explicit Key_t(const AlignedBuffer<SIZE>& data) : AlignedBuffer<SIZE>(data)
-      {
-      }
+      {}
 
       Key_t() : AlignedBuffer<SIZE>()
-      {
-      }
+      {}
 
       /// get snode address string
       std::string
diff --git a/llarp/dht/localrouterlookup.cpp b/llarp/dht/localrouterlookup.cpp
index 11766f17d..9e8a5b172 100644
--- a/llarp/dht/localrouterlookup.cpp
+++ b/llarp/dht/localrouterlookup.cpp
@@ -16,8 +16,7 @@ namespace llarp
         const PathID_t& path, uint64_t txid, const RouterID& _target, AbstractContext* ctx)
         : RecursiveRouterLookup(TXOwner{ctx->OurKey(), txid}, _target, ctx, nullptr)
         , localPath(path)
-    {
-    }
+    {}
 
     void
     LocalRouterLookup::SendReply()
diff --git a/llarp/dht/localserviceaddresslookup.cpp b/llarp/dht/localserviceaddresslookup.cpp
index 081f20d42..e93d81ed4 100644
--- a/llarp/dht/localserviceaddresslookup.cpp
+++ b/llarp/dht/localserviceaddresslookup.cpp
@@ -20,8 +20,7 @@ namespace llarp
         __attribute__((unused)) const Key_t& askpeer)
         : ServiceAddressLookup(TXOwner{ctx->OurKey(), txid}, addr, ctx, relayOrder, nullptr)
         , localPath(pathid)
-    {
-    }
+    {}
 
     void
     LocalServiceAddressLookup::SendReply()
diff --git a/llarp/dht/localtaglookup.cpp b/llarp/dht/localtaglookup.cpp
index 5806716c5..ccb9fcdbc 100644
--- a/llarp/dht/localtaglookup.cpp
+++ b/llarp/dht/localtaglookup.cpp
@@ -13,8 +13,7 @@ namespace llarp
     LocalTagLookup::LocalTagLookup(
         const PathID_t& path, uint64_t txid, const service::Tag& _target, AbstractContext* ctx)
         : TagLookup(TXOwner{ctx->OurKey(), txid}, _target, ctx, 0), localPath(path)
-    {
-    }
+    {}
 
     void
     LocalTagLookup::SendReply()
diff --git a/llarp/dht/message.cpp b/llarp/dht/message.cpp
index f8833ab0c..5b15caf62 100644
--- a/llarp/dht/message.cpp
+++ b/llarp/dht/message.cpp
@@ -22,8 +22,7 @@ namespace llarp
       bool relayed = false;
 
       MessageDecoder(const Key_t& from, bool wasRelayed) : From(from), relayed(wasRelayed)
-      {
-      }
+      {}
 
       bool
       operator()(llarp_buffer_t* buffer, llarp_buffer_t* key)
@@ -105,8 +104,7 @@ namespace llarp
     {
       ListDecoder(bool hasRelayed, const Key_t& from, std::vector<IMessage::Ptr_t>& list)
           : relayed(hasRelayed), From(from), l(list)
-      {
-      }
+      {}
 
       bool relayed;
       const Key_t& From;
diff --git a/llarp/dht/message.hpp b/llarp/dht/message.hpp
index 9f7d9af0d..8e1ca45be 100644
--- a/llarp/dht/message.hpp
+++ b/llarp/dht/message.hpp
@@ -20,8 +20,7 @@ namespace llarp
 
       /// construct
       IMessage(const Key_t& from) : From(from)
-      {
-      }
+      {}
 
       using Ptr_t = std::unique_ptr<IMessage>;
 
diff --git a/llarp/dht/messages/findintro.hpp b/llarp/dht/messages/findintro.hpp
index 71f662625..379066b2c 100644
--- a/llarp/dht/messages/findintro.hpp
+++ b/llarp/dht/messages/findintro.hpp
@@ -26,8 +26,7 @@ namespace llarp
 
       FindIntroMessage(const llarp::service::Tag& tag, uint64_t txid)
           : IMessage({}), tagName(tag), txID(txid)
-      {
-      }
+      {}
 
       explicit FindIntroMessage(uint64_t txid, const Key_t& addr, uint64_t order)
           : IMessage({}), location(addr), txID(txid), relayOrder(order)
diff --git a/llarp/dht/messages/findname.cpp b/llarp/dht/messages/findname.cpp
index 3245252ec..360f27e15 100644
--- a/llarp/dht/messages/findname.cpp
+++ b/llarp/dht/messages/findname.cpp
@@ -11,8 +11,7 @@ namespace llarp::dht
 {
   FindNameMessage::FindNameMessage(const Key_t& from, Key_t namehash, uint64_t txid)
       : IMessage(from), NameHash(std::move(namehash)), TxID(txid)
-  {
-  }
+  {}
 
   bool
   FindNameMessage::BEncode(llarp_buffer_t* buf) const
diff --git a/llarp/dht/messages/findrouter.hpp b/llarp/dht/messages/findrouter.hpp
index a8a28e95d..dca4db9ad 100644
--- a/llarp/dht/messages/findrouter.hpp
+++ b/llarp/dht/messages/findrouter.hpp
@@ -10,14 +10,12 @@ namespace llarp
     {
       // inbound parsing
       FindRouterMessage(const Key_t& from) : IMessage(from)
-      {
-      }
+      {}
 
       // find by routerid
       FindRouterMessage(uint64_t id, const RouterID& target)
           : IMessage({}), targetKey(target), txid(id)
-      {
-      }
+      {}
 
       // exploritory
       FindRouterMessage(uint64_t id) : IMessage({}), exploritory(true), txid(id)
@@ -48,8 +46,7 @@ namespace llarp
     struct RelayedFindRouterMessage final : public FindRouterMessage
     {
       RelayedFindRouterMessage(const Key_t& from) : FindRouterMessage(from)
-      {
-      }
+      {}
 
       /// handle a relayed FindRouterMessage, do a lookup on the dht and inform
       /// the path of the result
diff --git a/llarp/dht/messages/gotintro.cpp b/llarp/dht/messages/gotintro.cpp
index b9fef9a2d..54c028631 100644
--- a/llarp/dht/messages/gotintro.cpp
+++ b/llarp/dht/messages/gotintro.cpp
@@ -15,8 +15,7 @@ namespace llarp
   {
     GotIntroMessage::GotIntroMessage(std::vector<service::EncryptedIntroSet> results, uint64_t tx)
         : IMessage({}), found(std::move(results)), txid(tx)
-    {
-    }
+    {}
 
     bool
     GotIntroMessage::HandleMessage(
diff --git a/llarp/dht/messages/gotintro.hpp b/llarp/dht/messages/gotintro.hpp
index 5c4a69277..25d125135 100644
--- a/llarp/dht/messages/gotintro.hpp
+++ b/llarp/dht/messages/gotintro.hpp
@@ -23,8 +23,7 @@ namespace llarp
       std::optional<Key_t> closer;
 
       GotIntroMessage(const Key_t& from) : IMessage(from)
-      {
-      }
+      {}
 
       GotIntroMessage(const GotIntroMessage& other)
           : IMessage(other.From), found(other.found), txid(other.txid), closer(other.closer)
@@ -35,8 +34,7 @@ namespace llarp
       /// for iterative reply
       GotIntroMessage(const Key_t& from, const Key_t& _closer, uint64_t _txid)
           : IMessage(from), txid(_txid), closer(_closer)
-      {
-      }
+      {}
 
       /// for recursive reply
       GotIntroMessage(std::vector<service::EncryptedIntroSet> results, uint64_t txid);
@@ -56,8 +54,7 @@ namespace llarp
     struct RelayedGotIntroMessage final : public GotIntroMessage
     {
       RelayedGotIntroMessage() : GotIntroMessage({})
-      {
-      }
+      {}
 
       bool
       HandleMessage(llarp_dht_context* ctx, std::vector<IMessage::Ptr_t>& replies) const override;
diff --git a/llarp/dht/messages/gotrouter.hpp b/llarp/dht/messages/gotrouter.hpp
index 6751bc649..be2e3678d 100644
--- a/llarp/dht/messages/gotrouter.hpp
+++ b/llarp/dht/messages/gotrouter.hpp
@@ -14,23 +14,19 @@ namespace llarp
     struct GotRouterMessage final : public IMessage
     {
       GotRouterMessage(const Key_t& from, bool tunneled) : IMessage(from), relayed(tunneled)
-      {
-      }
+      {}
       GotRouterMessage(
           const Key_t& from, uint64_t id, const std::vector<RouterContact>& results, bool tunneled)
           : IMessage(from), foundRCs(results), txid(id), relayed(tunneled)
-      {
-      }
+      {}
 
       GotRouterMessage(const Key_t& from, const Key_t& closer, uint64_t id, bool tunneled)
           : IMessage(from), closerTarget(new Key_t(closer)), txid(id), relayed(tunneled)
-      {
-      }
+      {}
 
       GotRouterMessage(uint64_t id, std::vector<RouterID> _near, bool tunneled)
           : IMessage({}), nearKeys(std::move(_near)), txid(id), relayed(tunneled)
-      {
-      }
+      {}
 
       /// gossip message
       GotRouterMessage(const RouterContact rc) : IMessage({}), foundRCs({rc}), txid(0)
diff --git a/llarp/dht/messages/pubintro.hpp b/llarp/dht/messages/pubintro.hpp
index 26aa95b6b..25e622dbb 100644
--- a/llarp/dht/messages/pubintro.hpp
+++ b/llarp/dht/messages/pubintro.hpp
@@ -18,8 +18,7 @@ namespace llarp
       uint64_t relayOrder = 0;
       uint64_t txID = 0;
       PublishIntroMessage(const Key_t& from, bool relayed_) : IMessage(from), relayed(relayed_)
-      {
-      }
+      {}
 
       PublishIntroMessage(
           const llarp::service::EncryptedIntroSet& introset_,
@@ -27,8 +26,7 @@ namespace llarp
           bool relayed_,
           uint64_t relayOrder_)
           : IMessage({}), introset(introset_), relayed(relayed_), relayOrder(relayOrder_), txID(tx)
-      {
-      }
+      {}
 
       ~PublishIntroMessage() override;
 
diff --git a/llarp/dht/node.hpp b/llarp/dht/node.hpp
index d6cf11785..c1bd46194 100644
--- a/llarp/dht/node.hpp
+++ b/llarp/dht/node.hpp
@@ -21,8 +21,7 @@ namespace llarp
       }
 
       RCNode(const RouterContact& other) : rc(other), ID(other.pubkey)
-      {
-      }
+      {}
 
       util::StatusObject
       ExtractStatus() const
diff --git a/llarp/dht/publishservicejob.cpp b/llarp/dht/publishservicejob.cpp
index 90bd7ab88..2990d4bea 100644
--- a/llarp/dht/publishservicejob.cpp
+++ b/llarp/dht/publishservicejob.cpp
@@ -20,8 +20,7 @@ namespace llarp
         : TX<TXOwner, service::EncryptedIntroSet>(asker, asker, ctx)
         , relayOrder(relayOrder_)
         , introset(introset_)
-    {
-    }
+    {}
 
     bool
     PublishServiceJob::Validate(const service::EncryptedIntroSet& value) const
@@ -56,8 +55,7 @@ namespace llarp
         AbstractContext* ctx,
         uint64_t relayOrder)
         : PublishServiceJob(peer, introset, ctx, relayOrder), localPath(fromID), txid(_txid)
-    {
-    }
+    {}
 
     void
     LocalPublishServiceJob::SendReply()
diff --git a/llarp/dht/taglookup.hpp b/llarp/dht/taglookup.hpp
index cc3ab398b..f723dadee 100644
--- a/llarp/dht/taglookup.hpp
+++ b/llarp/dht/taglookup.hpp
@@ -15,8 +15,7 @@ namespace llarp
       TagLookup(
           const TXOwner& asker, const service::Tag& tag, AbstractContext* ctx, uint64_t recursion)
           : TX<service::Tag, service::EncryptedIntroSet>(asker, tag, ctx), recursionDepth(recursion)
-      {
-      }
+      {}
 
       bool
       Validate(const service::EncryptedIntroSet& introset) const override;
diff --git a/llarp/dht/tx.hpp b/llarp/dht/tx.hpp
index b9550bba2..0a76d582f 100644
--- a/llarp/dht/tx.hpp
+++ b/llarp/dht/tx.hpp
@@ -26,8 +26,7 @@ namespace llarp
 
       TX(const TXOwner& asker, const K& k, AbstractContext* p)
           : target(k), parent(p), whoasked(asker)
-      {
-      }
+      {}
 
       virtual ~TX() = default;
 
diff --git a/llarp/dht/txowner.hpp b/llarp/dht/txowner.hpp
index 3f3d8e257..1d8076f12 100644
--- a/llarp/dht/txowner.hpp
+++ b/llarp/dht/txowner.hpp
@@ -22,8 +22,7 @@ namespace llarp
       operator=(const TXOwner&) = default;
 
       TXOwner(const Key_t& k, uint64_t id) : node(k), txid(id)
-      {
-      }
+      {}
 
       util::StatusObject
       ExtractStatus() const
diff --git a/llarp/dns/message.cpp b/llarp/dns/message.cpp
index 124aed046..9938d8bf1 100644
--- a/llarp/dns/message.cpp
+++ b/llarp/dns/message.cpp
@@ -55,8 +55,7 @@ namespace llarp
         , answers(std::move(other.answers))
         , authorities(std::move(other.authorities))
         , additional(std::move(other.additional))
-    {
-    }
+    {}
 
     Message::Message(const Message& other)
         : hdr_id(other.hdr_id)
@@ -65,8 +64,7 @@ namespace llarp
         , answers(other.answers)
         , authorities(other.authorities)
         , additional(other.additional)
-    {
-    }
+    {}
 
     Message::Message(const MessageHeader& hdr) : hdr_id(hdr.id), hdr_fields(hdr.fields)
     {
diff --git a/llarp/dns/question.cpp b/llarp/dns/question.cpp
index f5be6f551..bf9c859ca 100644
--- a/llarp/dns/question.cpp
+++ b/llarp/dns/question.cpp
@@ -12,12 +12,10 @@ namespace llarp
         : qname(std::move(other.qname))
         , qtype(std::move(other.qtype))
         , qclass(std::move(other.qclass))
-    {
-    }
+    {}
     Question::Question(const Question& other)
         : qname(other.qname), qtype(other.qtype), qclass(other.qclass)
-    {
-    }
+    {}
 
     bool
     Question::Encode(llarp_buffer_t* buf) const
diff --git a/llarp/dns/rr.cpp b/llarp/dns/rr.cpp
index d5c457b0f..af1210369 100644
--- a/llarp/dns/rr.cpp
+++ b/llarp/dns/rr.cpp
@@ -14,8 +14,7 @@ namespace llarp
         , rr_class(other.rr_class)
         , ttl(other.ttl)
         , rData(other.rData)
-    {
-    }
+    {}
 
     ResourceRecord::ResourceRecord(ResourceRecord&& other)
         : rr_name(std::move(other.rr_name))
@@ -23,8 +22,7 @@ namespace llarp
         , rr_class(std::move(other.rr_class))
         , ttl(std::move(other.ttl))
         , rData(std::move(other.rData))
-    {
-    }
+    {}
 
     bool
     ResourceRecord::Encode(llarp_buffer_t* buf) const
diff --git a/llarp/dns/server.cpp b/llarp/dns/server.cpp
index 848e93ed5..0f22a3082 100644
--- a/llarp/dns/server.cpp
+++ b/llarp/dns/server.cpp
@@ -31,8 +31,7 @@ namespace llarp
 
     void
     Proxy::Stop()
-    {
-    }
+    {}
 
     bool
     Proxy::Start(const IpAddress& addr, const std::vector<IpAddress>& resolvers)
@@ -137,8 +136,7 @@ namespace llarp
 
     void
     Proxy::HandleTick(llarp_udp_io*)
-    {
-    }
+    {}
 
     void
     Proxy::SendServerMessageBufferTo(const SockAddr& to, const llarp_buffer_t& buf)
diff --git a/llarp/dns/unbound_resolver.cpp b/llarp/dns/unbound_resolver.cpp
index 603a6a944..ea0f18014 100644
--- a/llarp/dns/unbound_resolver.cpp
+++ b/llarp/dns/unbound_resolver.cpp
@@ -66,8 +66,7 @@ namespace llarp::dns
       , replyFunc(reply)
       , failFunc(fail)
 #endif
-  {
-  }
+  {}
 
   // static callback
   void
diff --git a/llarp/ev/ev.hpp b/llarp/ev/ev.hpp
index defd231e5..1622dd018 100644
--- a/llarp/ev/ev.hpp
+++ b/llarp/ev/ev.hpp
@@ -101,8 +101,7 @@ namespace llarp
       {
         llarp_ev_loop_ptr loop;
         GetNow(llarp_ev_loop_ptr l) : loop(l)
-        {
-        }
+        {}
 
         llarp_time_t
         operator()() const
@@ -115,8 +114,7 @@ namespace llarp
       {
         llarp_ev_loop_ptr loop;
         PutTime(llarp_ev_loop_ptr l) : loop(l)
-        {
-        }
+        {}
         void
         operator()(WriteBuffer& buf)
         {
@@ -143,8 +141,7 @@ namespace llarp
 
     /// for tcp
     win32_ev_io(intptr_t f, LosslessWriteQueue_t* q) : fd(f), m_BlockingWriteQueue(q)
-    {
-    }
+    {}
 
     virtual void
     error()
@@ -304,8 +301,7 @@ namespace llarp
       {
         llarp_ev_loop_ptr loop;
         GetNow(llarp_ev_loop_ptr l) : loop(std::move(l))
-        {
-        }
+        {}
 
         llarp_time_t
         operator()() const
@@ -318,8 +314,7 @@ namespace llarp
       {
         llarp_ev_loop_ptr loop;
         PutTime(llarp_ev_loop_ptr l) : loop(std::move(l))
-        {
-        }
+        {}
         void
         operator()(WriteBuffer& writebuf)
         {
@@ -355,18 +350,15 @@ namespace llarp
 #endif
 
     posix_ev_io(int f) : fd(f)
-    {
-    }
+    {}
 
     /// for tun
     posix_ev_io(int f, LossyWriteQueue_t* q) : fd(f), m_LossyWriteQueue(q)
-    {
-    }
+    {}
 
     /// for tcp
     posix_ev_io(int f, LosslessWriteQueue_t* q) : fd(f), m_BlockingWriteQueue(q)
-    {
-    }
+    {}
 
     virtual void
     error()
@@ -425,8 +417,7 @@ namespace llarp
 
     virtual void
     before_flush_write()
-    {
-    }
+    {}
 
     /// called in event loop when fd is ready for writing
     /// requeues anything not written
@@ -659,8 +650,7 @@ namespace llarp
 struct llarp_fd_promise
 {
   void Set(std::pair<int, int>)
-  {
-  }
+  {}
 
   int
   Get()
@@ -673,8 +663,7 @@ struct llarp_fd_promise
 {
   using promise_val_t = std::pair<int, int>;
   llarp_fd_promise(std::promise<promise_val_t>* p) : _impl(p)
-  {
-  }
+  {}
   std::promise<promise_val_t>* _impl;
 
   void
@@ -710,8 +699,7 @@ struct llarp_ev_loop
 
   virtual void
   update_time()
-  {
-  }
+  {}
 
   virtual llarp_time_t
   time_now() const
diff --git a/llarp/ev/ev_libuv.cpp b/llarp/ev/ev_libuv.cpp
index 5f9d0d74d..e7e1a35f7 100644
--- a/llarp/ev/ev_libuv.cpp
+++ b/llarp/ev/ev_libuv.cpp
@@ -762,8 +762,7 @@ namespace libuv
 
   Loop::Loop(size_t queue_size)
       : llarp_ev_loop(), m_LogicCalls(queue_size), m_timerQueue(20), m_timerCancelQueue(20)
-  {
-  }
+  {}
 
   bool
   Loop::init()
diff --git a/llarp/ev/ev_win32.hpp b/llarp/ev/ev_win32.hpp
index ef933c726..8aa7a11e1 100644
--- a/llarp/ev/ev_win32.hpp
+++ b/llarp/ev/ev_win32.hpp
@@ -40,8 +40,7 @@ namespace llarp
     udp_listener(int fd, llarp_udp_io* u) : ev_io(fd), udp(u){};
 
     ~udp_listener()
-    {
-    }
+    {}
 
     bool
     tick();
diff --git a/llarp/ev/pipe.cpp b/llarp/ev/pipe.cpp
index 27e70fdc8..3acd3975c 100644
--- a/llarp/ev/pipe.cpp
+++ b/llarp/ev/pipe.cpp
@@ -8,8 +8,7 @@
 
 llarp_ev_pkt_pipe::llarp_ev_pkt_pipe(llarp_ev_loop_ptr loop)
     : llarp::ev_io(-1, new LosslessWriteQueue_t()), m_Loop(std::move(loop))
-{
-}
+{}
 
 bool
 llarp_ev_pkt_pipe::StartPipe()
diff --git a/llarp/ev/vpnio.hpp b/llarp/ev/vpnio.hpp
index 5aaa764ae..980bf0a2c 100644
--- a/llarp/ev/vpnio.hpp
+++ b/llarp/ev/vpnio.hpp
@@ -18,18 +18,15 @@ struct llarp_vpn_pkt_queue
 };
 
 struct llarp_vpn_pkt_writer : public llarp_vpn_pkt_queue
-{
-};
+{};
 
 struct llarp_vpn_pkt_reader : public llarp_vpn_pkt_queue
-{
-};
+{};
 
 struct llarp_vpn_io_impl
 {
   llarp_vpn_io_impl(llarp::Context* c, llarp_vpn_io* io) : ctx(c), parent(io)
-  {
-  }
+  {}
   ~llarp_vpn_io_impl() = default;
 
   llarp::Context* ctx;
diff --git a/llarp/exit/context.cpp b/llarp/exit/context.cpp
index f50ef6131..0abcf1cb3 100644
--- a/llarp/exit/context.cpp
+++ b/llarp/exit/context.cpp
@@ -7,8 +7,7 @@ namespace llarp
   namespace exit
   {
     Context::Context(AbstractRouter* r) : m_Router(r)
-    {
-    }
+    {}
     Context::~Context() = default;
 
     void
diff --git a/llarp/exit/endpoint.hpp b/llarp/exit/endpoint.hpp
index 43d1f9d83..35e4d4619 100644
--- a/llarp/exit/endpoint.hpp
+++ b/llarp/exit/endpoint.hpp
@@ -124,8 +124,7 @@ namespace llarp
       struct UpstreamBuffer
       {
         UpstreamBuffer(const llarp::net::IPPacket& p, uint64_t c) : pkt(p), counter(c)
-        {
-        }
+        {}
 
         llarp::net::IPPacket pkt;
         uint64_t counter;
diff --git a/llarp/exit/exit_messages.hpp b/llarp/exit/exit_messages.hpp
index a3bb54b15..b5a37e405 100644
--- a/llarp/exit/exit_messages.hpp
+++ b/llarp/exit/exit_messages.hpp
@@ -22,8 +22,7 @@ namespace llarp
       llarp::Signature Z;
 
       ObtainExitMessage() : IMessage()
-      {
-      }
+      {}
 
       ~ObtainExitMessage() override = default;
 
diff --git a/llarp/exit/session.hpp b/llarp/exit/session.hpp
index f33f1fee9..cab5c5d95 100644
--- a/llarp/exit/session.hpp
+++ b/llarp/exit/session.hpp
@@ -179,8 +179,7 @@ namespace llarp
           size_t hoplen,
           bool bundleRC)
           : BaseSession(snodeRouter, writepkt, r, numpaths, hoplen, bundleRC)
-      {
-      }
+      {}
 
       ~ExitSession() override = default;
 
diff --git a/llarp/handlers/null.hpp b/llarp/handlers/null.hpp
index 4ace25177..c89b596f0 100644
--- a/llarp/handlers/null.hpp
+++ b/llarp/handlers/null.hpp
@@ -12,8 +12,7 @@ namespace llarp
     {
       NullEndpoint(AbstractRouter* r, llarp::service::Context* parent)
           : llarp::service::Endpoint(r, parent)
-      {
-      }
+      {}
 
       virtual bool
       HandleInboundPacket(
diff --git a/llarp/iwp/linklayer.cpp b/llarp/iwp/linklayer.cpp
index c4f616413..a402f1d72 100644
--- a/llarp/iwp/linklayer.cpp
+++ b/llarp/iwp/linklayer.cpp
@@ -24,8 +24,7 @@ namespace llarp
         : ILinkLayer(
             keyManager, getrc, h, sign, before, est, reneg, timeout, closed, pumpDone, worker)
         , permitInbound{allowInbound}
-    {
-    }
+    {}
 
     LinkLayer::~LinkLayer() = default;
 
diff --git a/llarp/iwp/message_buffer.cpp b/llarp/iwp/message_buffer.cpp
index cda8477ab..cb3bba483 100644
--- a/llarp/iwp/message_buffer.cpp
+++ b/llarp/iwp/message_buffer.cpp
@@ -115,8 +115,7 @@ namespace llarp
 
     InboundMessage::InboundMessage(uint64_t msgid, uint16_t sz, ShortHash h, llarp_time_t now)
         : m_Data(size_t{sz}), m_Digset{std::move(h)}, m_MsgID(msgid), m_LastActiveAt{now}
-    {
-    }
+    {}
 
     void
     InboundMessage::HandleData(uint16_t idx, const llarp_buffer_t& buf, llarp_time_t now)
diff --git a/llarp/link/server.cpp b/llarp/link/server.cpp
index 40d1174e5..d41b42c2d 100644
--- a/llarp/link/server.cpp
+++ b/llarp/link/server.cpp
@@ -37,8 +37,7 @@ namespace llarp
       , QueueWork(std::move(work))
       , m_RouterEncSecret(keyManager->encryptionKey)
       , m_SecretKey(keyManager->transportKey)
-  {
-  }
+  {}
 
   ILinkLayer::~ILinkLayer() = default;
 
diff --git a/llarp/messages/discard.hpp b/llarp/messages/discard.hpp
index 0aa1b3728..2b1c97b4b 100644
--- a/llarp/messages/discard.hpp
+++ b/llarp/messages/discard.hpp
@@ -11,8 +11,7 @@ namespace llarp
   struct DiscardMessage final : public ILinkMessage
   {
     DiscardMessage() : ILinkMessage()
-    {
-    }
+    {}
 
     bool
     BEncode(llarp_buffer_t* buf) const override
diff --git a/llarp/messages/link_intro.hpp b/llarp/messages/link_intro.hpp
index d9fbdfd58..fcffa5a52 100644
--- a/llarp/messages/link_intro.hpp
+++ b/llarp/messages/link_intro.hpp
@@ -14,8 +14,7 @@ namespace llarp
     static constexpr size_t MaxSize = MAX_RC_SIZE + 256;
 
     LinkIntroMessage() : ILinkMessage()
-    {
-    }
+    {}
 
     RouterContact rc;
     KeyExchangeNonce N;
diff --git a/llarp/messages/link_message_parser.cpp b/llarp/messages/link_message_parser.cpp
index 9e00d5419..fa3302b01 100644
--- a/llarp/messages/link_message_parser.cpp
+++ b/llarp/messages/link_message_parser.cpp
@@ -30,8 +30,7 @@ namespace llarp
 
   LinkMessageParser::LinkMessageParser(AbstractRouter* _router)
       : router(_router), from(nullptr), msg(nullptr), holder(std::make_unique<msg_holder_t>())
-  {
-  }
+  {}
 
   LinkMessageParser::~LinkMessageParser() = default;
 
diff --git a/llarp/messages/relay_commit.hpp b/llarp/messages/relay_commit.hpp
index fe46ae55f..c256d54f0 100644
--- a/llarp/messages/relay_commit.hpp
+++ b/llarp/messages/relay_commit.hpp
@@ -52,8 +52,7 @@ namespace llarp
 
     LR_CommitMessage(std::array<EncryptedFrame, 8> _frames)
         : ILinkMessage(), frames(std::move(_frames))
-    {
-    }
+    {}
 
     LR_CommitMessage() = default;
 
diff --git a/llarp/messages/relay_status.cpp b/llarp/messages/relay_status.cpp
index f18de32c4..a6ef0dc44 100644
--- a/llarp/messages/relay_status.cpp
+++ b/llarp/messages/relay_status.cpp
@@ -38,8 +38,7 @@ namespace llarp
         , path(std::move(_path))
         , router(_router)
         , pathid(pathid)
-    {
-    }
+    {}
 
     ~LRSM_AsyncHandler() = default;
 
diff --git a/llarp/messages/relay_status.hpp b/llarp/messages/relay_status.hpp
index 64ea7401f..c6ac0d51d 100644
--- a/llarp/messages/relay_status.hpp
+++ b/llarp/messages/relay_status.hpp
@@ -60,8 +60,7 @@ namespace llarp
 
     LR_StatusMessage(std::array<EncryptedFrame, 8> _frames)
         : ILinkMessage(), frames(std::move(_frames))
-    {
-    }
+    {}
 
     LR_StatusMessage() = default;
 
diff --git a/llarp/net/exit_info.hpp b/llarp/net/exit_info.hpp
index 6e8feb53d..7654cdec6 100644
--- a/llarp/net/exit_info.hpp
+++ b/llarp/net/exit_info.hpp
@@ -26,8 +26,7 @@ namespace llarp
     ExitInfo() = default;
 
     ExitInfo(const PubKey& pk, const IpAddress& address) : ipAddress(address), pubkey(pk)
-    {
-    }
+    {}
 
     bool
     BEncode(llarp_buffer_t* buf) const;
diff --git a/llarp/net/ip_address.cpp b/llarp/net/ip_address.cpp
index 8305807b1..530642c54 100644
--- a/llarp/net/ip_address.cpp
+++ b/llarp/net/ip_address.cpp
@@ -11,8 +11,7 @@ namespace llarp
 
   IpAddress::IpAddress(const IpAddress& other)
       : m_empty(other.m_empty), m_ipAddress(other.m_ipAddress), m_port(other.m_port)
-  {
-  }
+  {}
 
   IpAddress::IpAddress(std::string_view str, std::optional<uint16_t> port)
   {
diff --git a/llarp/net/ip_packet.hpp b/llarp/net/ip_packet.hpp
index 88d5702a5..7281c1842 100644
--- a/llarp/net/ip_packet.hpp
+++ b/llarp/net/ip_packet.hpp
@@ -84,7 +84,8 @@ struct ipv6_header_preamble
 
 struct ipv6_header
 {
-  union {
+  union
+  {
     ipv6_header_preamble preamble;
     uint32_t flowlabel;
   } preamble;
@@ -144,8 +145,7 @@ namespace llarp
       {
         llarp_ev_loop_ptr loop;
         PutTime(llarp_ev_loop_ptr evloop) : loop(std::move(evloop))
-        {
-        }
+        {}
         void
         operator()(IPPacket& pkt) const
         {
@@ -157,8 +157,7 @@ namespace llarp
       {
         llarp_ev_loop_ptr loop;
         GetNow(llarp_ev_loop_ptr evloop) : loop(std::move(evloop))
-        {
-        }
+        {}
         llarp_time_t
         operator()() const
         {
diff --git a/llarp/net/uint128.hpp b/llarp/net/uint128.hpp
index 8f13053f5..2a9b459c0 100644
--- a/llarp/net/uint128.hpp
+++ b/llarp/net/uint128.hpp
@@ -24,13 +24,11 @@ namespace llarp
 
     // Initializes with 0s
     constexpr uint128_t() : uint128_t{0, 0}
-    {
-    }
+    {}
 
     // Initializes with least-significant value
     constexpr uint128_t(uint64_t lower) : uint128_t{0, lower}
-    {
-    }
+    {}
 
     // Initializes with upper and lower values
     constexpr uint128_t(uint64_t upper, uint64_t lower)
@@ -41,8 +39,7 @@ namespace llarp
         : lower{lower}, upper{upper}
 #endif
     // clang-format on
-    {
-    }
+    {}
 
     constexpr uint128_t(const uint128_t&) = default;
     constexpr uint128_t(uint128_t&&) = default;
diff --git a/llarp/nodedb.cpp b/llarp/nodedb.cpp
index 70c48c828..be0e39cc8 100644
--- a/llarp/nodedb.cpp
+++ b/llarp/nodedb.cpp
@@ -21,8 +21,7 @@ static const std::string RC_FILE_EXT = ".signed";
 
 llarp_nodedb::NetDBEntry::NetDBEntry(llarp::RouterContact value)
     : rc(std::move(value)), inserted(llarp::time_now_ms())
-{
-}
+{}
 
 bool
 llarp_nodedb::Remove(const llarp::RouterID& pk)
diff --git a/llarp/nodedb.hpp b/llarp/nodedb.hpp
index db18f678a..f28939251 100644
--- a/llarp/nodedb.hpp
+++ b/llarp/nodedb.hpp
@@ -32,8 +32,7 @@ struct llarp_nodedb
   explicit llarp_nodedb(const std::string rootdir, DiskCaller_t diskCaller)
       : disk(std::move(diskCaller)), nodePath(rootdir)
 
-  {
-  }
+  {}
 
   ~llarp_nodedb()
   {
diff --git a/llarp/path/path_context.cpp b/llarp/path/path_context.cpp
index f5dc54231..d7fb966b3 100644
--- a/llarp/path/path_context.cpp
+++ b/llarp/path/path_context.cpp
@@ -13,8 +13,7 @@ namespace llarp
 
     PathContext::PathContext(AbstractRouter* router)
         : m_Router(router), m_AllowTransit(false), m_PathLimits(DefaultPathBuildLimit)
-    {
-    }
+    {}
 
     void
     PathContext::AllowTransit()
@@ -358,7 +357,6 @@ namespace llarp
     }
 
     void PathContext::RemovePathSet(PathSet_ptr)
-    {
-    }
+    {}
   }  // namespace path
 }  // namespace llarp
diff --git a/llarp/path/pathset.cpp b/llarp/path/pathset.cpp
index a1088c6c4..3a21e5c90 100644
--- a/llarp/path/pathset.cpp
+++ b/llarp/path/pathset.cpp
@@ -12,8 +12,7 @@ namespace llarp
   namespace path
   {
     PathSet::PathSet(size_t num) : numPaths(num)
-    {
-    }
+    {}
 
     bool
     PathSet::ShouldBuildMore(llarp_time_t now) const
diff --git a/llarp/path/transit_hop.cpp b/llarp/path/transit_hop.cpp
index 4f497441f..5c9e3c34a 100644
--- a/llarp/path/transit_hop.cpp
+++ b/llarp/path/transit_hop.cpp
@@ -85,8 +85,7 @@ namespace llarp
 
     TransitHopInfo::TransitHopInfo(const RouterID& down, const LR_CommitRecord& record)
         : txID(record.txid), rxID(record.rxid), upstream(record.nextHop), downstream(down)
-    {
-    }
+    {}
 
     bool
     TransitHop::SendRoutingMessage(const routing::IMessage& msg, AbstractRouter* r)
diff --git a/llarp/peerstats/orm.hpp b/llarp/peerstats/orm.hpp
index 53670cd27..c81e599fb 100644
--- a/llarp/peerstats/orm.hpp
+++ b/llarp/peerstats/orm.hpp
@@ -44,8 +44,7 @@ namespace sqlite_orm
   /// llarp_time_t serialization
   template <>
   struct type_printer<llarp_time_t> : public integer_printer
-  {
-  };
+  {};
 
   template <>
   struct statement_binder<llarp_time_t>
@@ -90,8 +89,7 @@ namespace sqlite_orm
   /// RouterID serialization
   template <>
   struct type_printer<llarp::RouterID> : public text_printer
-  {
-  };
+  {};
 
   template <>
   struct statement_binder<llarp::RouterID>
diff --git a/llarp/peerstats/peer_db.cpp b/llarp/peerstats/peer_db.cpp
index 4153e0b18..58f619791 100644
--- a/llarp/peerstats/peer_db.cpp
+++ b/llarp/peerstats/peer_db.cpp
@@ -259,9 +259,6 @@ namespace llarp
   void
   PeerDb::configure(const RouterConfig& routerConfig)
   {
-    if (not routerConfig.m_enablePeerStats)
-      throw std::runtime_error("[router]:enable-peer-stats is not enabled");
-
     fs::path dbPath = routerConfig.m_dataDir / "peerstats.sqlite";
 
     loadDatabase(dbPath);
diff --git a/llarp/peerstats/types.cpp b/llarp/peerstats/types.cpp
index bf796455a..4cd793b0a 100644
--- a/llarp/peerstats/types.cpp
+++ b/llarp/peerstats/types.cpp
@@ -26,8 +26,7 @@ namespace llarp
   PeerStats::PeerStats() = default;
 
   PeerStats::PeerStats(const RouterID& routerId_) : routerId(routerId_)
-  {
-  }
+  {}
 
   PeerStats&
   PeerStats::operator+=(const PeerStats& other)
diff --git a/llarp/profiling.cpp b/llarp/profiling.cpp
index 544101392..e866cc62d 100644
--- a/llarp/profiling.cpp
+++ b/llarp/profiling.cpp
@@ -96,8 +96,7 @@ namespace llarp
   }
 
   Profiling::Profiling() : m_DisableProfiling(false)
-  {
-  }
+  {}
 
   void
   Profiling::Disable()
diff --git a/llarp/router/outbound_message_handler.cpp b/llarp/router/outbound_message_handler.cpp
index 54b1d5d14..431de0cb6 100644
--- a/llarp/router/outbound_message_handler.cpp
+++ b/llarp/router/outbound_message_handler.cpp
@@ -16,8 +16,7 @@ namespace llarp
 
   OutboundMessageHandler::OutboundMessageHandler(size_t maxQueueSize)
       : outboundQueue(maxQueueSize), removedPaths(20), removedSomePaths(false)
-  {
-  }
+  {}
 
   bool
   OutboundMessageHandler::QueueMessage(
diff --git a/llarp/router/outbound_session_maker.cpp b/llarp/router/outbound_session_maker.cpp
index c03dc34f7..1102e622f 100644
--- a/llarp/router/outbound_session_maker.cpp
+++ b/llarp/router/outbound_session_maker.cpp
@@ -27,8 +27,7 @@ namespace llarp
 
     PendingSession(RouterContact _rc, LinkLayer_ptr _link)
         : rc(std::move(_rc)), link(std::move(_link))
-    {
-    }
+    {}
   };
 
   bool
diff --git a/llarp/router/rc_gossiper.cpp b/llarp/router/rc_gossiper.cpp
index e8d535a2a..18a2877cd 100644
--- a/llarp/router/rc_gossiper.cpp
+++ b/llarp/router/rc_gossiper.cpp
@@ -14,8 +14,7 @@ namespace llarp
 
   RCGossiper::RCGossiper()
       : I_RCGossiper(), m_Filter(std::chrono::duration_cast<Time_t>(RCGossipFilterDecayInterval))
-  {
-  }
+  {}
 
   void
   RCGossiper::Init(ILinkManager* l, const RouterID& ourID, AbstractRouter* router)
diff --git a/llarp/router/router.cpp b/llarp/router/router.cpp
index bd4d611c0..fcf98ce2d 100644
--- a/llarp/router/router.cpp
+++ b/llarp/router/router.cpp
@@ -279,6 +279,9 @@ namespace llarp
     if (not StartRpcServer())
       throw std::runtime_error("Failed to start rpc server");
 
+    if (conf.router.m_workerThreads > 0)
+      m_lmq->set_general_threads(conf.router.m_workerThreads);
+
     m_lmq->start();
 
     _nodedb = nodedb;
@@ -450,12 +453,10 @@ namespace llarp
     RouterContact::BlockBogons = conf.router.m_blockBogons;
 
     // Lokid Config
-    usingSNSeed = conf.lokid.usingSNSeed;
     whitelistRouters = conf.lokid.whitelistRouters;
     lokidRPCAddr = lokimq::address(conf.lokid.lokidRPCAddr);
 
-    if (usingSNSeed)
-      ident_keyfile = conf.lokid.ident_keyfile;
+    m_isServiceNode = conf.router.m_isRelay;
 
     networkConfig = conf.network;
 
@@ -609,17 +610,15 @@ namespace llarp
     }
 
     // Network config
-    if (conf.network.m_enableProfiling.has_value() and not*conf.network.m_enableProfiling)
+    if (conf.network.m_enableProfiling.value_or(false))
     {
-      routerProfiling().Disable();
-      LogWarn("router profiling explicitly disabled");
+      LogInfo("router profiling enabled; loading from ", routerProfilesFile);
+      routerProfiling().Load(routerProfilesFile.c_str());
     }
-
-    if (!conf.network.m_routerProfilesFile.empty())
+    else
     {
-      routerProfilesFile = conf.network.m_routerProfilesFile;
-      routerProfiling().Load(routerProfilesFile.c_str());
-      llarp::LogInfo("setting profiles to ", routerProfilesFile);
+      routerProfiling().Disable();
+      LogInfo("router profiling disabled");
     }
 
     // API config
@@ -629,16 +628,12 @@ namespace llarp
     }
 
     // peer stats
-    if (conf.router.m_enablePeerStats)
+    if (IsServiceNode())
     {
       LogInfo("Initializing peerdb...");
       m_peerDb = std::make_shared<PeerDb>();
       m_peerDb->configure(conf.router);
     }
-    else if (IsServiceNode())
-    {
-      throw std::runtime_error("peer stats must be enabled when running as relay");
-    }
 
     // Logging config
     LogContext::Instance().Initialize(
diff --git a/llarp/router/router.hpp b/llarp/router/router.hpp
index 1ae81603c..2ea277d80 100644
--- a/llarp/router/router.hpp
+++ b/llarp/router/router.hpp
@@ -71,9 +71,6 @@ namespace llarp
     // our router contact
     RouterContact _rc;
 
-    /// are we using the lokid service node seed ?
-    bool usingSNSeed = false;
-
     /// should we obey the service node whitelist?
     bool whitelistRouters = false;
 
diff --git a/llarp/router_contact.cpp b/llarp/router_contact.cpp
index bce459d1d..26db5c004 100644
--- a/llarp/router_contact.cpp
+++ b/llarp/router_contact.cpp
@@ -45,8 +45,7 @@ namespace llarp
   }
 
   NetID::NetID() : NetID(DefaultValue().data())
-  {
-  }
+  {}
 
   bool
   NetID::operator==(const NetID& other) const
diff --git a/llarp/router_id.hpp b/llarp/router_id.hpp
index 71fbe5a93..81f2b34b1 100644
--- a/llarp/router_id.hpp
+++ b/llarp/router_id.hpp
@@ -13,16 +13,13 @@ namespace llarp
     using Data = std::array<byte_t, SIZE>;
 
     RouterID()
-    {
-    }
+    {}
 
     RouterID(const byte_t* buf) : AlignedBuffer<SIZE>(buf)
-    {
-    }
+    {}
 
     RouterID(const Data& data) : AlignedBuffer<SIZE>(data)
-    {
-    }
+    {}
 
     util::StatusObject
     ExtractStatus() const;
diff --git a/llarp/router_version.cpp b/llarp/router_version.cpp
index 5b9823cd7..16118825e 100644
--- a/llarp/router_version.cpp
+++ b/llarp/router_version.cpp
@@ -9,8 +9,7 @@ namespace llarp
 {
   RouterVersion::RouterVersion(const Version_t& router, uint64_t proto)
       : m_Version(router), m_ProtoVersion(proto)
-  {
-  }
+  {}
 
   bool
   RouterVersion::IsCompatableWith(const RouterVersion& other) const
diff --git a/llarp/routing/message_parser.cpp b/llarp/routing/message_parser.cpp
index 28b907863..c922748e7 100644
--- a/llarp/routing/message_parser.cpp
+++ b/llarp/routing/message_parser.cpp
@@ -31,8 +31,7 @@ namespace llarp
     };
 
     InboundMessageParser::InboundMessageParser() : m_Holder(std::make_unique<MessageHolder>())
-    {
-    }
+    {}
 
     InboundMessageParser::~InboundMessageParser() = default;
 
diff --git a/llarp/routing/path_confirm_message.cpp b/llarp/routing/path_confirm_message.cpp
index 1e568c3c5..77184e088 100644
--- a/llarp/routing/path_confirm_message.cpp
+++ b/llarp/routing/path_confirm_message.cpp
@@ -10,8 +10,7 @@ namespace llarp
   {
     PathConfirmMessage::PathConfirmMessage(llarp_time_t lifetime)
         : pathLifetime(lifetime), pathCreated(time_now_ms())
-    {
-    }
+    {}
 
     bool
     PathConfirmMessage::DecodeKey(const llarp_buffer_t& key, llarp_buffer_t* val)
diff --git a/llarp/rpc/endpoint_rpc.cpp b/llarp/rpc/endpoint_rpc.cpp
index 7c841c130..85830d507 100644
--- a/llarp/rpc/endpoint_rpc.cpp
+++ b/llarp/rpc/endpoint_rpc.cpp
@@ -14,8 +14,7 @@ namespace llarp::rpc
       , m_AuthWhitelist(std::move(whitelist))
       , m_LMQ(std::move(lmq))
       , m_Endpoint(std::move(endpoint))
-  {
-  }
+  {}
 
   void
   EndpointAuthRPC::Start()
diff --git a/llarp/rpc/rpc_server.cpp b/llarp/rpc/rpc_server.cpp
index d973bb802..b405ceda0 100644
--- a/llarp/rpc/rpc_server.cpp
+++ b/llarp/rpc/rpc_server.cpp
@@ -11,8 +11,7 @@
 namespace llarp::rpc
 {
   RpcServer::RpcServer(LMQ_ptr lmq, AbstractRouter* r) : m_LMQ(std::move(lmq)), m_Router(r)
-  {
-  }
+  {}
 
   /// maybe parse json from message paramter at index
   std::optional<nlohmann::json>
diff --git a/llarp/service/address.hpp b/llarp/service/address.hpp
index c3aa77ca3..4b6755fb1 100644
--- a/llarp/service/address.hpp
+++ b/llarp/service/address.hpp
@@ -37,8 +37,7 @@ namespace llarp
       FromString(std::string_view str, const char* tld = ".loki");
 
       Address() : AlignedBuffer<32>()
-      {
-      }
+      {}
 
       explicit Address(const std::string& str) : AlignedBuffer<32>()
       {
@@ -47,17 +46,14 @@ namespace llarp
       }
 
       explicit Address(const Data& buf) : AlignedBuffer<32>(buf)
-      {
-      }
+      {}
 
       Address(const Address& other)
           : AlignedBuffer<32>(other.as_array()), subdomain(other.subdomain)
-      {
-      }
+      {}
 
       explicit Address(const AlignedBuffer<32>& other) : AlignedBuffer<32>(other)
-      {
-      }
+      {}
 
       bool
       operator<(const Address& other) const
diff --git a/llarp/service/context.cpp b/llarp/service/context.cpp
index b1bb94577..f5b6dee98 100644
--- a/llarp/service/context.cpp
+++ b/llarp/service/context.cpp
@@ -36,8 +36,7 @@ namespace llarp
 
     }  // namespace
     Context::Context(AbstractRouter* r) : m_Router(r)
-    {
-    }
+    {}
 
     Context::~Context() = default;
 
diff --git a/llarp/service/endpoint.cpp b/llarp/service/endpoint.cpp
index a04692c99..08d2d6d3d 100644
--- a/llarp/service/endpoint.cpp
+++ b/llarp/service/endpoint.cpp
@@ -505,8 +505,7 @@ namespace llarp
           , m_IntroSet(std::move(introset))
           , m_Endpoint(parent)
           , m_relayOrder(relayOrder)
-      {
-      }
+      {}
 
       std::shared_ptr<routing::IMessage>
       BuildRequestMessage() override
diff --git a/llarp/service/hidden_service_address_lookup.cpp b/llarp/service/hidden_service_address_lookup.cpp
index 47ecd6794..47ac09784 100644
--- a/llarp/service/hidden_service_address_lookup.cpp
+++ b/llarp/service/hidden_service_address_lookup.cpp
@@ -20,8 +20,7 @@ namespace llarp
         , relayOrder(order)
         , location(l)
         , handle(std::move(h))
-    {
-    }
+    {}
 
     bool
     HiddenServiceAddressLookup::HandleIntrosetResponse(const std::set<EncryptedIntroSet>& results)
diff --git a/llarp/service/protocol.cpp b/llarp/service/protocol.cpp
index e12691bfa..d09d3d64a 100644
--- a/llarp/service/protocol.cpp
+++ b/llarp/service/protocol.cpp
@@ -19,8 +19,7 @@ namespace llarp
     }
 
     ProtocolMessage::ProtocolMessage(const ConvoTag& t) : tag(t)
-    {
-    }
+    {}
 
     ProtocolMessage::~ProtocolMessage() = default;
 
@@ -292,8 +291,7 @@ namespace llarp
           , handler(h)
           , frame(f)
           , fromIntro(recvIntro)
-      {
-      }
+      {}
 
       static void
       Work(std::shared_ptr<AsyncFrameDecrypt> self)
diff --git a/llarp/service/router_lookup_job.cpp b/llarp/service/router_lookup_job.cpp
index 395a6c1e3..76cae3712 100644
--- a/llarp/service/router_lookup_job.cpp
+++ b/llarp/service/router_lookup_job.cpp
@@ -9,8 +9,7 @@ namespace llarp
   {
     RouterLookupJob::RouterLookupJob(Endpoint* p, RouterLookupHandler h)
         : handler(std::move(h)), txid(p->GenTXID()), started(p->Now())
-    {
-    }
+    {}
 
   }  // namespace service
 }  // namespace llarp
diff --git a/llarp/service/sendcontext.cpp b/llarp/service/sendcontext.cpp
index 93392eeb0..b44757e1b 100644
--- a/llarp/service/sendcontext.cpp
+++ b/llarp/service/sendcontext.cpp
@@ -22,8 +22,7 @@ namespace llarp
         , m_Endpoint(ep)
         , createdAt(ep->Now())
         , m_SendQueue(SendContextQueueSize)
-    {
-    }
+    {}
 
     bool
     SendContext::Send(std::shared_ptr<ProtocolFrame> msg, path::Path_ptr path)
diff --git a/llarp/service/tag.hpp b/llarp/service/tag.hpp
index a2b677e1d..6bf0185f4 100644
--- a/llarp/service/tag.hpp
+++ b/llarp/service/tag.hpp
@@ -18,12 +18,10 @@ namespace llarp
     struct Tag : public AlignedBuffer<16>
     {
       Tag() : AlignedBuffer<SIZE>()
-      {
-      }
+      {}
 
       Tag(const byte_t* d) : AlignedBuffer<SIZE>(d)
-      {
-      }
+      {}
 
       Tag(const std::string& str) : Tag()
       {
diff --git a/llarp/simulation/sim_context.cpp b/llarp/simulation/sim_context.cpp
index 924192617..fc1aa1626 100644
--- a/llarp/simulation/sim_context.cpp
+++ b/llarp/simulation/sim_context.cpp
@@ -6,13 +6,11 @@ namespace llarp
   namespace simulate
   {
     Simulation::Simulation() : m_CryptoManager(new sodium::CryptoLibSodium())
-    {
-    }
+    {}
 
     void
     Simulation::NodeUp(llarp::Context*)
-    {
-    }
+    {}
 
     Node_ptr
     Simulation::AddNode(const std::string& name)
diff --git a/llarp/tooling/dht_event.hpp b/llarp/tooling/dht_event.hpp
index 45b8bb53b..c4dd5bb46 100644
--- a/llarp/tooling/dht_event.hpp
+++ b/llarp/tooling/dht_event.hpp
@@ -22,8 +22,7 @@ namespace tooling
         , introsetPubkey(introsetPubkey_)
         , relay(relay_)
         , relayIndex(relayIndex_)
-    {
-    }
+    {}
 
     std::string
     ToString() const
@@ -51,8 +50,7 @@ namespace tooling
         , location(location_)
         , txid(txid_)
         , relayOrder(relayOrder_)
-    {
-    }
+    {}
 
     std::string
     ToString() const override
@@ -79,8 +77,7 @@ namespace tooling
         , From(from_)
         , Introset(introset_)
         , TxID(txid_)
-    {
-    }
+    {}
 
     std::string
     ToString() const override
@@ -108,8 +105,7 @@ namespace tooling
         , exploritory(msg.exploritory)
         , txid(msg.txid)
         , version(msg.version)
-    {
-    }
+    {}
 
     std::string
     ToString() const override
diff --git a/llarp/tooling/hive_context.cpp b/llarp/tooling/hive_context.cpp
index 0afd1a11f..44db56bcd 100644
--- a/llarp/tooling/hive_context.cpp
+++ b/llarp/tooling/hive_context.cpp
@@ -5,8 +5,7 @@
 namespace tooling
 {
   HiveContext::HiveContext(RouterHive* hive) : m_hive(hive)
-  {
-  }
+  {}
 
   std::unique_ptr<llarp::AbstractRouter>
   HiveContext::makeRouter(llarp_ev_loop_ptr netloop, std::shared_ptr<llarp::Logic> logic)
diff --git a/llarp/tooling/hive_router.cpp b/llarp/tooling/hive_router.cpp
index 3a40e2e05..d45384eda 100644
--- a/llarp/tooling/hive_router.cpp
+++ b/llarp/tooling/hive_router.cpp
@@ -7,8 +7,7 @@ namespace tooling
   HiveRouter::HiveRouter(
       llarp_ev_loop_ptr netloop, std::shared_ptr<llarp::Logic> logic, RouterHive* hive)
       : Router(netloop, logic), m_hive(hive)
-  {
-  }
+  {}
 
   bool
   HiveRouter::disableGossipingRC_TestingOnly()
diff --git a/llarp/tooling/path_event.hpp b/llarp/tooling/path_event.hpp
index de8711cd2..f71468269 100644
--- a/llarp/tooling/path_event.hpp
+++ b/llarp/tooling/path_event.hpp
@@ -15,8 +15,7 @@ namespace tooling
         : RouterEvent("PathAttemptEvent", routerID, false)
         , hops(path->hops)
         , pathid(path->hops[0].rxID)
-    {
-    }
+    {}
 
     std::string
     ToString() const
@@ -58,8 +57,7 @@ namespace tooling
         , txid(hop->info.txID)
         , rxid(hop->info.rxID)
         , isEndpoint(routerID == nextHop ? true : false)
-    {
-    }
+    {}
 
     std::string
     ToString() const
@@ -93,8 +91,7 @@ namespace tooling
     PathStatusReceivedEvent(
         const llarp::RouterID& routerID, const llarp::PathID_t rxid_, uint64_t status_)
         : RouterEvent("PathStatusReceivedEvent", routerID, true), rxid(rxid_), status(status_)
-    {
-    }
+    {}
 
     std::string
     ToString() const
@@ -119,8 +116,7 @@ namespace tooling
         : RouterEvent("PathBuildRejectedEvent", routerID, false)
         , rxid(rxid_)
         , rejectedBy(rejectedBy_)
-    {
-    }
+    {}
 
     std::string
     ToString() const
diff --git a/llarp/tooling/peer_stats_event.hpp b/llarp/tooling/peer_stats_event.hpp
index 34d1f6519..13b063241 100644
--- a/llarp/tooling/peer_stats_event.hpp
+++ b/llarp/tooling/peer_stats_event.hpp
@@ -14,8 +14,7 @@ namespace tooling
         : RouterEvent("Link: LinkSessionEstablishedEvent", ourRouterId, false)
         , remoteId(remoteId_)
         , inbound(inbound_)
-    {
-    }
+    {}
 
     std::string
     ToString() const
@@ -31,8 +30,7 @@ namespace tooling
 
     ConnectionAttemptEvent(const llarp::RouterID& ourRouterId, const llarp::RouterID& remoteId_)
         : RouterEvent("Link: ConnectionAttemptEvent", ourRouterId, false), remoteId(remoteId_)
-    {
-    }
+    {}
 
     std::string
     ToString() const
diff --git a/llarp/tooling/rc_event.hpp b/llarp/tooling/rc_event.hpp
index b735ed4d7..36f8c31d5 100644
--- a/llarp/tooling/rc_event.hpp
+++ b/llarp/tooling/rc_event.hpp
@@ -10,8 +10,7 @@ namespace tooling
   {
     RCGossipReceivedEvent(const llarp::RouterID& routerID, const llarp::RouterContact& rc_)
         : RouterEvent("RCGossipReceivedEvent", routerID, true), rc(rc_)
-    {
-    }
+    {}
 
     std::string
     ToString() const override
@@ -33,8 +32,7 @@ namespace tooling
   {
     RCGossipSentEvent(const llarp::RouterID& routerID, const llarp::RouterContact& rc_)
         : RouterEvent("RCGossipSentEvent", routerID, true), rc(rc_)
-    {
-    }
+    {}
 
     std::string
     ToString() const override
diff --git a/llarp/tooling/router_event.hpp b/llarp/tooling/router_event.hpp
index dd4971a79..e5cb41c72 100644
--- a/llarp/tooling/router_event.hpp
+++ b/llarp/tooling/router_event.hpp
@@ -29,8 +29,7 @@ namespace tooling
   {
     RouterEvent(std::string eventType, llarp::RouterID routerID, bool triggered)
         : eventType(eventType), routerID(routerID), triggered(triggered)
-    {
-    }
+    {}
 
     virtual ~RouterEvent() = default;
 
diff --git a/llarp/util/buffer.hpp b/llarp/util/buffer.hpp
index 60c244354..b9e63d6c6 100644
--- a/llarp/util/buffer.hpp
+++ b/llarp/util/buffer.hpp
@@ -78,22 +78,19 @@ struct llarp_buffer_t
   llarp_buffer_t() = default;
 
   llarp_buffer_t(byte_t* b, byte_t* c, size_t s) : base(b), cur(c), sz(s)
-  {
-  }
+  {}
 
   llarp_buffer_t(const ManagedBuffer&) = delete;
   llarp_buffer_t(ManagedBuffer&&) = delete;
 
   template <typename T>
   llarp_buffer_t(T* buf, size_t _sz) : base(reinterpret_cast<byte_t*>(buf)), cur(base), sz(_sz)
-  {
-  }
+  {}
 
   template <typename T>
   llarp_buffer_t(const T* buf, size_t _sz)
       : base(reinterpret_cast<byte_t*>(const_cast<T*>(buf))), cur(base), sz(_sz)
-  {
-  }
+  {}
 
   /** initialize llarp_buffer_t from container */
   template <typename T>
@@ -106,8 +103,7 @@ struct llarp_buffer_t
 
   template <typename T>
   llarp_buffer_t(const T& t) : llarp_buffer_t(t.data(), t.size())
-  {
-  }
+  {}
 
   // clang-format off
   byte_t * begin()       { return base; }
@@ -204,8 +200,7 @@ struct ManagedBuffer
   ManagedBuffer() = delete;
 
   explicit ManagedBuffer(const llarp_buffer_t& b) : underlying(b)
-  {
-  }
+  {}
 
   ManagedBuffer(ManagedBuffer&&) = default;
   ManagedBuffer(const ManagedBuffer&) = default;
diff --git a/llarp/util/codel.hpp b/llarp/util/codel.hpp
index 4addc6ffe..07d96c9a1 100644
--- a/llarp/util/codel.hpp
+++ b/llarp/util/codel.hpp
@@ -42,8 +42,7 @@ namespace llarp
           , m_name(std::move(name))
           , _putTime(std::move(put))
           , _getNow(std::move(now))
-      {
-      }
+      {}
 
       size_t
       Size() EXCLUDES(m_QueueMutex)
diff --git a/llarp/util/decaying_hashset.hpp b/llarp/util/decaying_hashset.hpp
index 16a566f0c..8607832e5 100644
--- a/llarp/util/decaying_hashset.hpp
+++ b/llarp/util/decaying_hashset.hpp
@@ -14,8 +14,7 @@ namespace llarp
       using Time_t = std::chrono::milliseconds;
 
       DecayingHashSet(Time_t cacheInterval = 5s) : m_CacheInterval(cacheInterval)
-      {
-      }
+      {}
       /// determine if we have v contained in our decaying hashset
       bool
       Contains(const Val_t& v) const
diff --git a/llarp/util/decaying_hashtable.hpp b/llarp/util/decaying_hashtable.hpp
index 410f6cec0..0c6313ebb 100644
--- a/llarp/util/decaying_hashtable.hpp
+++ b/llarp/util/decaying_hashtable.hpp
@@ -9,8 +9,7 @@ namespace llarp::util
   struct DecayingHashTable
   {
     DecayingHashTable(std::chrono::milliseconds cacheInterval = 1h) : m_CacheInterval(cacheInterval)
-    {
-    }
+    {}
 
     void
     Decay(llarp_time_t now)
diff --git a/llarp/util/logging/android_logger.cpp b/llarp/util/logging/android_logger.cpp
index 9edab801d..251593ba4 100644
--- a/llarp/util/logging/android_logger.cpp
+++ b/llarp/util/logging/android_logger.cpp
@@ -37,12 +37,10 @@ namespace llarp
 
   void
   AndroidLogStream::PostLog(std::stringstream&) const
-  {
-  }
+  {}
 
   void AndroidLogStream::Tick(llarp_time_t)
-  {
-  }
+  {}
 
   void
   AndroidLogStream::Print(LogLevel lvl, const char* tag, const std::string& msg)
diff --git a/llarp/util/logging/json_logger.hpp b/llarp/util/logging/json_logger.hpp
index 6cf4ff511..556d773fa 100644
--- a/llarp/util/logging/json_logger.hpp
+++ b/llarp/util/logging/json_logger.hpp
@@ -13,8 +13,7 @@ namespace llarp
         llarp_time_t flushInterval,
         bool closeFile)
         : FileLogStream(std::move(disk), f, flushInterval, closeFile)
-    {
-    }
+    {}
 
     void
     AppendLog(
diff --git a/llarp/util/logging/logger.cpp b/llarp/util/logging/logger.cpp
index 93e108dac..b0e8113e1 100644
--- a/llarp/util/logging/logger.cpp
+++ b/llarp/util/logging/logger.cpp
@@ -46,8 +46,7 @@ namespace llarp
 
   LogContext::LogContext()
       : logStream(std::make_unique<Stream_t>(_LOGSTREAM_INIT)), started(llarp::time_now_ms())
-  {
-  }
+  {}
 
   LogContext&
   LogContext::Instance()
@@ -69,15 +68,13 @@ namespace llarp
   }
 
   log_timestamp::log_timestamp() : log_timestamp("%c %Z")
-  {
-  }
+  {}
 
   log_timestamp::log_timestamp(const char* fmt)
       : format(fmt)
       , now(llarp::time_now_ms())
       , delta(llarp::time_now_ms() - LogContext::Instance().started)
-  {
-  }
+  {}
 
   void
   SetLogLevel(LogLevel lvl)
@@ -113,7 +110,7 @@ namespace llarp
     nodeName = nickname;
 
     FILE* logfile = nullptr;
-    if (file == "stdout" or file.empty())
+    if (file == "stdout" or file == "-" or file.empty())
     {
       logfile = stdout;
     }
@@ -174,12 +171,10 @@ namespace llarp
   }
 
   LogSilencer::LogSilencer() : LogSilencer(LogContext::Instance())
-  {
-  }
+  {}
 
   LogSilencer::LogSilencer(LogContext& ctx) : parent(ctx), stream(std::move(ctx.logStream))
-  {
-  }
+  {}
 
   LogSilencer::~LogSilencer()
   {
diff --git a/llarp/util/logging/logger_internal.hpp b/llarp/util/logging/logger_internal.hpp
index 8f03d6772..35c178ae1 100644
--- a/llarp/util/logging/logger_internal.hpp
+++ b/llarp/util/logging/logger_internal.hpp
@@ -12,8 +12,7 @@ namespace llarp
   /** internal, recursion terminator */
   constexpr void
   LogAppend(std::stringstream&) noexcept
-  {
-  }
+  {}
   /** internal */
   template <typename TArg, typename... TArgs>
   void
diff --git a/llarp/util/logging/logger_syslog.hpp b/llarp/util/logging/logger_syslog.hpp
index 42ad7077b..455c4dbae 100644
--- a/llarp/util/logging/logger_syslog.hpp
+++ b/llarp/util/logging/logger_syslog.hpp
@@ -24,12 +24,10 @@ namespace llarp
 
     virtual void
     ImmediateFlush() override
-    {
-    }
+    {}
 
     void Tick(llarp_time_t) override
-    {
-    }
+    {}
   };
 }  // namespace llarp
 #endif
diff --git a/llarp/util/logging/ostream_logger.cpp b/llarp/util/logging/ostream_logger.cpp
index a8d0e13f4..f6c85bf61 100644
--- a/llarp/util/logging/ostream_logger.cpp
+++ b/llarp/util/logging/ostream_logger.cpp
@@ -5,8 +5,7 @@ namespace llarp
 {
   OStreamLogStream::OStreamLogStream(bool withColours, std::ostream& out)
       : m_withColours(withColours), m_Out(out)
-  {
-  }
+  {}
 
   void
   OStreamLogStream::PreLog(
diff --git a/llarp/util/logging/ostream_logger.hpp b/llarp/util/logging/ostream_logger.hpp
index 6858a5711..4a4aa847d 100644
--- a/llarp/util/logging/ostream_logger.hpp
+++ b/llarp/util/logging/ostream_logger.hpp
@@ -30,8 +30,7 @@ namespace llarp
     ImmediateFlush() override;
 
     void Tick(llarp_time_t) override
-    {
-    }
+    {}
 
    private:
     bool m_withColours;
diff --git a/llarp/util/logging/syslog_logger.cpp b/llarp/util/logging/syslog_logger.cpp
index 90f04ecf6..b87878104 100644
--- a/llarp/util/logging/syslog_logger.cpp
+++ b/llarp/util/logging/syslog_logger.cpp
@@ -45,8 +45,7 @@ namespace llarp
 
   void
   SysLogStream::PostLog(std::stringstream&) const
-  {
-  }
+  {}
 
 }  // namespace llarp
 #endif
diff --git a/llarp/util/meta/traits.hpp b/llarp/util/meta/traits.hpp
index 8802c04bd..64fbbd0fb 100644
--- a/llarp/util/meta/traits.hpp
+++ b/llarp/util/meta/traits.hpp
@@ -12,8 +12,7 @@ namespace llarp
   {
     /// Represents the empty type
     struct Bottom
-    {
-    };
+    {};
 
     /// Int tag
     template <size_t N>
@@ -25,8 +24,7 @@ namespace llarp
     /// Type trait representing whether a type is pointer-like
     template <typename T, typename _ = void>
     struct is_pointy : public std::false_type
-    {
-    };
+    {};
 
     // We take the following things:
     // - has element_type typedef
@@ -35,14 +33,12 @@ namespace llarp
     template <typename T>
     struct is_pointy<T, std::conditional_t<false, std::void_t<decltype(*std::declval<T>())>, void>>
         : public std::true_type
-    {
-    };
+    {};
 
     /// Type trait representing whether a type is an STL-style container
     template <typename T, typename _ = void>
     struct is_container : public std::false_type
-    {
-    };
+    {};
 
     // We take that the container has begin, end and size methods to be a
     // container.
@@ -95,8 +91,7 @@ namespace llarp
       /// meta function which always returns false
       template <typename>
       class False : public std::false_type
-      {
-      };
+      {};
 
       /// a case in the selection
       template <template <typename...> class Trait = False>
@@ -105,8 +100,7 @@ namespace llarp
        public:
         template <typename Type>
         struct Selector : public Trait<Type>::type
-        {
-        };
+        {};
 
         using Type = Case;
       };
diff --git a/llarp/util/printer.hpp b/llarp/util/printer.hpp
index 8c649af1d..95f223f92 100644
--- a/llarp/util/printer.hpp
+++ b/llarp/util/printer.hpp
@@ -18,8 +18,7 @@ namespace llarp
     std::ios_base::fmtflags m_flags;
 
     FormatFlagsGuard(std::ios_base& base) : m_base(base), m_flags(base.flags())
-    {
-    }
+    {}
 
     ~FormatFlagsGuard()
     {
diff --git a/llarp/util/thread/barrier.hpp b/llarp/util/thread/barrier.hpp
index bef9f467d..369b2b3fa 100644
--- a/llarp/util/thread/barrier.hpp
+++ b/llarp/util/thread/barrier.hpp
@@ -16,8 +16,7 @@ namespace llarp
 
      public:
       Barrier(unsigned threads) : pending{threads}
-      {
-      }
+      {}
 
       /// Returns true if *this* Block call is the one that releases all of
       /// them; returns false (i.e. after unblocking) if some other thread
diff --git a/llarp/util/thread/queue.hpp b/llarp/util/thread/queue.hpp
index 002877f48..ff8a1f0cc 100644
--- a/llarp/util/thread/queue.hpp
+++ b/llarp/util/thread/queue.hpp
@@ -127,8 +127,7 @@ namespace llarp
      public:
       QueuePushGuard(Queue<Type>& queue, uint32_t generation, uint32_t index)
           : m_queue(&queue), m_generation(generation), m_index(index)
-      {
-      }
+      {}
 
       ~QueuePushGuard();
 
@@ -150,8 +149,7 @@ namespace llarp
      public:
       QueuePopGuard(Queue<Type>& queue, uint32_t generation, uint32_t index)
           : m_queue(queue), m_generation(generation), m_index(index)
-      {
-      }
+      {}
 
       ~QueuePopGuard();
     };
diff --git a/llarp/util/thread/threading.hpp b/llarp/util/thread/threading.hpp
index 3458932e7..d1ac6edb8 100644
--- a/llarp/util/thread/threading.hpp
+++ b/llarp/util/thread/threading.hpp
@@ -67,14 +67,12 @@ namespace llarp
 #else
       void
       lock() const
-      {
-      }
+      {}
 #endif
       // Does nothing; once locked the mutex belongs to that thread forever
       void
       unlock() const
-      {
-      }
+      {}
     };
 
     /// a lock that does nothing
@@ -116,8 +114,7 @@ namespace llarp
 
      public:
       Semaphore(size_t count) : m_count(count)
-      {
-      }
+      {}
 
       void
       notify() EXCLUDES(m_mutex)
diff --git a/llarp/win32/win32_intrnl.c b/llarp/win32/win32_intrnl.c
index d6ee9c30d..f69c86658 100644
--- a/llarp/win32/win32_intrnl.c
+++ b/llarp/win32/win32_intrnl.c
@@ -58,8 +58,7 @@ SetThreadName(DWORD dwThreadID, LPCSTR szThreadName)
       RaiseException(EXCEPTION_SET_THREAD_NAME, 0, infosize, (DWORD*)&info);
     }
     __except (EXCEPTION_EXECUTE_HANDLER)
-    {
-    }
+    {}
   }
   /* clean up */
   if (hThread)
diff --git a/pybind/llarp/config.cpp b/pybind/llarp/config.cpp
index b14575013..2d901f4dd 100644
--- a/pybind/llarp/config.cpp
+++ b/pybind/llarp/config.cpp
@@ -48,13 +48,11 @@ namespace llarp
             })
         .def_readwrite("workerThreads", &RouterConfig::m_workerThreads)
         .def_readwrite("numNetThreads", &RouterConfig::m_numNetThreads)
-        .def_readwrite("JobQueueSize", &RouterConfig::m_JobQueueSize)
-        .def_readwrite("enablePeerStats", &RouterConfig::m_enablePeerStats);
+        .def_readwrite("JobQueueSize", &RouterConfig::m_JobQueueSize);
 
     py::class_<NetworkConfig>(mod, "NetworkConfig")
         .def(py::init<>())
         .def_readwrite("enableProfiling", &NetworkConfig::m_enableProfiling)
-        .def_readwrite("routerProfilesFile", &NetworkConfig::m_routerProfilesFile)
         .def_readwrite("endpointType", &NetworkConfig::m_endpointType)
         .def_readwrite("keyfile", &NetworkConfig::m_keyfile)
         .def_readwrite("endpointType", &NetworkConfig::m_endpointType)
@@ -99,7 +97,6 @@ namespace llarp
 
     py::class_<LokidConfig>(mod, "LokidConfig")
         .def(py::init<>())
-        .def_readwrite("usingSNSeed", &LokidConfig::usingSNSeed)
         .def_readwrite("whitelistRouters", &LokidConfig::whitelistRouters)
         .def_readwrite("ident_keyfile", &LokidConfig::ident_keyfile)
         .def_property(
diff --git a/pybind/llarp/handlers/pyhandler.hpp b/pybind/llarp/handlers/pyhandler.hpp
index f33104236..49bee11cd 100644
--- a/pybind/llarp/handlers/pyhandler.hpp
+++ b/pybind/llarp/handlers/pyhandler.hpp
@@ -18,8 +18,7 @@ namespace llarp
           : llarp::service::Endpoint(
               routerContext->router.get(), &routerContext->router->hiddenServiceContext())
           , OurName(std::move(name))
-      {
-      }
+      {}
       const std::string OurName;
 
       bool
diff --git a/pybind/llarp/tooling/peer_stats_event.hpp b/pybind/llarp/tooling/peer_stats_event.hpp
index 92e7c7381..860632544 100644
--- a/pybind/llarp/tooling/peer_stats_event.hpp
+++ b/pybind/llarp/tooling/peer_stats_event.hpp
@@ -14,8 +14,7 @@ namespace tooling
         : RouterEvent("Link: LinkSessionEstablishedEvent", ourRouterId, false)
         , remoteId(remoteId_)
         , inbound(inbound_)
-    {
-    }
+    {}
 
     std::string
     ToString() const
diff --git a/test/config/test_llarp_config_definition.cpp b/test/config/test_llarp_config_definition.cpp
index bc72a49f9..010789cde 100644
--- a/test/config/test_llarp_config_definition.cpp
+++ b/test/config/test_llarp_config_definition.cpp
@@ -2,9 +2,11 @@
 
 #include <catch2/catch.hpp>
 
+using namespace llarp::config;
+
 TEST_CASE("OptionDefinition int parse test", "[config]")
 {
-  llarp::OptionDefinition<int> def("foo", "bar", false, 42);
+  llarp::OptionDefinition<int> def("foo", "bar", Default{42});
 
   CHECK(def.getValue() == 42);
   CHECK(def.getNumberFound() == 0);
@@ -16,11 +18,20 @@ TEST_CASE("OptionDefinition int parse test", "[config]")
   CHECK(def.getNumberFound() == 1);
 
   CHECK(def.defaultValueAsString() == "42");
+
+  constexpr Default sqrt_625{25};
+  llarp::OptionDefinition<int> def2("a", "b", sqrt_625);
+  CHECK(def2.getValue() == 25);
+  CHECK(def2.defaultValueAsString() == "25");
+
+  CHECK_NOTHROW(def2.parseValue("99"));
+  CHECK(def2.getValue() == 99);
+  CHECK(def2.getNumberFound() == 1);
 }
 
 TEST_CASE("OptionDefinition string parse test", "[config]")
 {
-  llarp::OptionDefinition<std::string> def("foo", "bar", false, "test");
+  llarp::OptionDefinition<std::string> def("foo", "bar", Default{"test"});
 
   CHECK(def.getValue() == "test");
   CHECK(def.defaultValueAsString() == "test");
@@ -33,8 +44,7 @@ TEST_CASE("OptionDefinition string parse test", "[config]")
 TEST_CASE("OptionDefinition multiple parses test", "[config]")
 {
   {
-    llarp::OptionDefinition<int> def("foo", "bar", false, 8);
-    def.multiValued = true;
+    llarp::OptionDefinition<int> def("foo", "bar", MultiValue, Default{8});
 
     CHECK_NOTHROW(def.parseValue("9"));
     CHECK(def.getValue() == 9);
@@ -48,7 +58,7 @@ TEST_CASE("OptionDefinition multiple parses test", "[config]")
   }
 
   {
-    llarp::OptionDefinition<int> def("foo", "baz", false, 4);
+    llarp::OptionDefinition<int> def("foo", "baz", Default{4});
 
     CHECK_NOTHROW(def.parseValue("3"));
     CHECK(def.getValue() == 3);
@@ -64,11 +74,14 @@ TEST_CASE("OptionDefinition multiple parses test", "[config]")
 TEST_CASE("OptionDefinition acceptor test", "[config]")
 {
   int test = -1;
-  llarp::OptionDefinition<int> def("foo", "bar", false, 42, [&](int arg) {
+  llarp::OptionDefinition<int> def("foo", "bar", Default{42}, [&](int arg) {
     test = arg;
   });
 
   CHECK_NOTHROW(def.tryAccept());
+  CHECK(def.getValue() == 42);
+  CHECK(def.defaultValue);
+  CHECK(*def.defaultValue == 42);
   CHECK(test == 42);
 
   def.parseValue("43");
@@ -78,7 +91,7 @@ TEST_CASE("OptionDefinition acceptor test", "[config]")
 
 TEST_CASE("OptionDefinition acceptor throws test", "[config]")
 {
-  llarp::OptionDefinition<int> def("foo", "bar", false, 42, [&](int arg) {
+  llarp::OptionDefinition<int> def("foo", "bar", Default{42}, [&](int arg) {
     (void)arg;
     throw std::runtime_error("FAIL");
   });
@@ -89,7 +102,7 @@ TEST_CASE("OptionDefinition acceptor throws test", "[config]")
 TEST_CASE("OptionDefinition tryAccept missing option test", "[config]")
 {
   int unset = -1;
-  llarp::OptionDefinition<int> def("foo", "bar", true, 1, [&](int arg) {
+  llarp::OptionDefinition<int> def("foo", "bar", Required, Default{1}, [&](int arg) {
     (void)arg;
     unset = 0; // should never be called
   });
@@ -100,12 +113,11 @@ TEST_CASE("OptionDefinition tryAccept missing option test", "[config]")
 
 TEST_CASE("ConfigDefinition basic add/get test", "[config]")
 {
-  llarp::ConfigDefinition config;
+  llarp::ConfigDefinition config{true};
   config.defineOption(std::make_unique<llarp::OptionDefinition<int>>(
             "router",
             "threads",
-            false,
-            4));
+            Default{4}));
 
   CHECK(config.getConfigValue<int>("router", "threads") == 4);
 
@@ -117,29 +129,47 @@ TEST_CASE("ConfigDefinition basic add/get test", "[config]")
   CHECK(config.getConfigValue<int>("router", "threads") == 5);
 }
 
+TEST_CASE("ConfigDefinition router/client-only tests", "[config]")
+{
+  llarp::ConfigDefinition r_config{true}, c_config{false};
+  r_config.defineOption<int>("router", "abc", Default{1}, RelayOnly);
+  r_config.defineOption<int>("router", "def", Default{1}, ClientOnly);
+  r_config.defineOption<int>("router", "ghi", Default{1});
+  c_config.defineOption<int>("router", "abc", Default{1}, RelayOnly);
+  c_config.defineOption<int>("router", "def", Default{1}, ClientOnly);
+  c_config.defineOption<int>("router", "ghi", Default{1});
+
+  CHECK_NOTHROW(r_config.getConfigValue<int>("router", "abc"));
+  CHECK_THROWS(r_config.getConfigValue<int>("router", "def"));
+  CHECK_NOTHROW(r_config.getConfigValue<int>("router", "ghi"));
+
+  CHECK_THROWS(c_config.getConfigValue<int>("router", "abc"));
+  CHECK_NOTHROW(c_config.getConfigValue<int>("router", "def"));
+  CHECK_NOTHROW(c_config.getConfigValue<int>("router", "ghi"));
+}
+
 TEST_CASE("ConfigDefinition missing def test", "[config]")
 {
-  llarp::ConfigDefinition config;
+  llarp::ConfigDefinition config{true};
   CHECK_THROWS(config.addConfigValue("foo", "bar", "5"));
   CHECK_THROWS(config.getConfigValue<int>("foo", "bar") == 5);
 
   config.defineOption(std::make_unique<llarp::OptionDefinition<int>>(
             "quux",
             "bar",
-            false,
-            4));
+            Default{4}));
 
   CHECK_THROWS(config.addConfigValue("foo", "bar", "5"));
 }
 
 TEST_CASE("ConfigDefinition required test", "[config]")
 {
-  llarp::ConfigDefinition config;
+  llarp::ConfigDefinition config{true};
   config.defineOption(std::make_unique<llarp::OptionDefinition<int>>(
             "router",
             "threads",
-            true,
-            1));
+            Default{1},
+            Required));
 
   CHECK_THROWS(config.validateRequiredFields());
 
@@ -150,17 +180,17 @@ TEST_CASE("ConfigDefinition required test", "[config]")
 
 TEST_CASE("ConfigDefinition section test", "[config]")
 {
-  llarp::ConfigDefinition config;
+  llarp::ConfigDefinition config{true};
   config.defineOption(std::make_unique<llarp::OptionDefinition<int>>(
             "foo",
             "bar",
-            true,
-            1));
+            Required,
+            Default{1}));
   config.defineOption(std::make_unique<llarp::OptionDefinition<int>>(
             "goo",
             "bar",
-            true,
-            1));
+            Required,
+            Default{1}));
 
   CHECK_THROWS(config.validateRequiredFields());
 
@@ -179,13 +209,13 @@ TEST_CASE("ConfigDefinition acceptAllOptions test", "[config]")
   int fooBar = -1;
   std::string fooBaz = "";
 
-  llarp::ConfigDefinition config;
+  llarp::ConfigDefinition config{true};
   config.defineOption(std::make_unique<llarp::OptionDefinition<int>>(
-      "foo", "bar", false, 1, [&](int arg) {
+      "foo", "bar", Default{1}, [&](int arg) {
         fooBar = arg;
       }));
   config.defineOption(std::make_unique<llarp::OptionDefinition<std::string>>(
-      "foo", "baz", false, "no", [&](std::string arg) {
+      "foo", "baz", Default{"no"}, [&](std::string arg) {
         fooBaz = arg;
       }));
 
@@ -199,9 +229,9 @@ TEST_CASE("ConfigDefinition acceptAllOptions test", "[config]")
 
 TEST_CASE("ConfigDefinition acceptAllOptions exception propagation test", "[config]")
 {
-  llarp::ConfigDefinition config;
+  llarp::ConfigDefinition config{true};
   config.defineOption(std::make_unique<llarp::OptionDefinition<int>>(
-      "foo", "bar", false, 1, [&](int arg) {
+      "foo", "bar", Default{1}, [&](int arg) {
         (void)arg;
         throw std::runtime_error("FAIL");
       }));
@@ -211,14 +241,14 @@ TEST_CASE("ConfigDefinition acceptAllOptions exception propagation test", "[conf
 
 TEST_CASE("ConfigDefinition defineOptions passthrough test", "[config]")
 {
-  llarp::ConfigDefinition config;
-  config.defineOption<int>("foo", "bar", false, 1);
+  llarp::ConfigDefinition config{true};
+  config.defineOption<int>("foo", "bar", Default{1});
   CHECK(config.getConfigValue<int>("foo", "bar") == 1);
 }
 
 TEST_CASE("ConfigDefinition undeclared definition basic test", "[config]")
 {
-  llarp::ConfigDefinition config;
+  llarp::ConfigDefinition config{true};
 
   bool invoked = false;
 
@@ -237,7 +267,7 @@ TEST_CASE("ConfigDefinition undeclared definition basic test", "[config]")
 
 TEST_CASE("ConfigDefinition undeclared add more than once test", "[config]")
 {
-  llarp::ConfigDefinition config;
+  llarp::ConfigDefinition config{true};
 
   std::string calledBy = "";
 
@@ -257,7 +287,7 @@ TEST_CASE("ConfigDefinition undeclared add more than once test", "[config]")
 
 TEST_CASE("ConfigDefinition undeclared add/remove test", "[config]")
 {
-  llarp::ConfigDefinition config;
+  llarp::ConfigDefinition config{true};
 
   std::string calledBy = "";
 
@@ -289,7 +319,7 @@ TEST_CASE("ConfigDefinition undeclared add/remove test", "[config]")
 
 TEST_CASE("ConfigDefinition undeclared handler exception propagation test", "[config]")
 {
-  llarp::ConfigDefinition config;
+  llarp::ConfigDefinition config{true};
 
   config.addUndeclaredHandler("foo", [](std::string_view, std::string_view, std::string_view) {
       throw std::runtime_error("FAIL");
@@ -300,7 +330,7 @@ TEST_CASE("ConfigDefinition undeclared handler exception propagation test", "[co
 
 TEST_CASE("ConfigDefinition undeclared handler wrong section", "[config]")
 {
-  llarp::ConfigDefinition config;
+  llarp::ConfigDefinition config{true};
 
   config.addUndeclaredHandler("foo", [](std::string_view, std::string_view, std::string_view) {
       throw std::runtime_error("FAIL");
@@ -311,7 +341,7 @@ TEST_CASE("ConfigDefinition undeclared handler wrong section", "[config]")
 
 TEST_CASE("ConfigDefinition undeclared handler duplicate names", "[config]")
 {
-  llarp::ConfigDefinition config;
+  llarp::ConfigDefinition config{true};
 
   int count = 0;
 
@@ -328,10 +358,10 @@ TEST_CASE("ConfigDefinition undeclared handler duplicate names", "[config]")
 
 TEST_CASE("ConfigDefinition AssignmentAcceptor", "[config]")
 {
-  llarp::ConfigDefinition config;
+  llarp::ConfigDefinition config{true};
 
   int val = -1;
-  config.defineOption<int>("foo", "bar", false, 2, llarp::AssignmentAcceptor(val));
+  config.defineOption<int>("foo", "bar", Default{2}, AssignmentAcceptor(val));
 
   config.addConfigValue("foo", "bar", "3");
   CHECK_NOTHROW(config.acceptAllOptions());
@@ -341,10 +371,10 @@ TEST_CASE("ConfigDefinition AssignmentAcceptor", "[config]")
 
 TEST_CASE("ConfigDefinition multiple values", "[config]")
 {
-  llarp::ConfigDefinition config;
+  llarp::ConfigDefinition config{true};
 
   std::vector<int> values;
-  config.defineOption<int>("foo", "bar", false, true, 2, [&](int arg) {
+  config.defineOption<int>("foo", "bar", MultiValue, Default{2}, [&](int arg) {
     values.push_back(arg);
   });
 
@@ -361,14 +391,14 @@ TEST_CASE("ConfigDefinition multiple values", "[config]")
 
 TEST_CASE("ConfigDefinition [bind]iface regression", "[config regression]")
 {
-  llarp::ConfigDefinition config;
+  llarp::ConfigDefinition config{true};
 
   std::string val1;
   std::string undeclaredName;
   std::string undeclaredValue;
 
   config.defineOption<std::string>(
-      "bind", "*", false, false, "1090", [&](std::string arg) { val1 = arg; });
+      "bind", "*", Default{"1090"}, [&](std::string arg) { val1 = arg; });
 
   config.addUndeclaredHandler("bind", [&](std::string_view, std::string_view name, std::string_view value) {
     undeclaredName = std::string(name);
@@ -388,7 +418,7 @@ TEST_CASE("ConfigDefinition truthy/falsy bool values", "[config]")
   // truthy values
   for (auto val : {"true", "on", "yes", "1"})
   {
-    llarp::OptionDefinition<bool> def("foo", "bar", false, false);
+    llarp::OptionDefinition<bool> def("foo", "bar", Default{false});
 
     // defaults to false
     auto maybe = def.getValue();
@@ -405,7 +435,7 @@ TEST_CASE("ConfigDefinition truthy/falsy bool values", "[config]")
   // falsy values
   for (auto val : {"false", "off", "no", "0"})
   {
-    llarp::OptionDefinition<bool> def("foo", "bar", false, true);
+    llarp::OptionDefinition<bool> def("foo", "bar", Default{true});
 
     // defaults to true
     auto maybe = def.getValue();
@@ -422,7 +452,7 @@ TEST_CASE("ConfigDefinition truthy/falsy bool values", "[config]")
   // illegal values
   for (auto val : {"", " ", "TRUE", "argle", " false", "2"})
   {
-    llarp::OptionDefinition<bool> def("foo", "bar", false, true);
+    llarp::OptionDefinition<bool> def("foo", "bar", Default{true});
     CHECK_THROWS(def.parseValue(val));
   }
 }
diff --git a/test/config/test_llarp_config_output.cpp b/test/config/test_llarp_config_output.cpp
index ba8cc438a..13eb64c72 100644
--- a/test/config/test_llarp_config_output.cpp
+++ b/test/config/test_llarp_config_output.cpp
@@ -2,28 +2,28 @@
 
 #include <catch2/catch.hpp>
 
+using namespace llarp::config;
+
 TEST_CASE("ConfigDefinition simple generate test", "[config]")
 {
-  llarp::ConfigDefinition config;
+  llarp::ConfigDefinition config{true};
 
-  config.defineOption(std::make_unique<llarp::OptionDefinition<int>>(
-            "foo", "bar", true, 1));
-  config.defineOption(std::make_unique<llarp::OptionDefinition<int>>(
-            "foo", "baz", false, 2));
+  config.defineOption<int>("foo", "bar", Required, Default{1});
+  config.defineOption<int>("foo", "baz", Default{2});
   config.defineOption(std::make_unique<llarp::OptionDefinition<std::string>>(
-            "foo", "quux", true, "hello"));
+            "foo", "quux", Required, Default{"hello"}));
 
-  config.defineOption(std::make_unique<llarp::OptionDefinition<int>>(
-            "argle", "bar", true, 3));
-  config.defineOption(std::make_unique<llarp::OptionDefinition<int>>(
-            "argle", "baz", false, 4));
-  config.defineOption(std::make_unique<llarp::OptionDefinition<std::string>>(
-            "argle", "quux", true, "the quick brown fox"));
+  config.defineOption<int>("argle", "bar", RelayOnly, Required, Default{3});
+  config.defineOption<int>("argle", "baz", Default{4});
+  config.defineOption<std::string>("argle", "quux", Required, Default{"the quick brown fox"});
+
+  config.defineOption<int>("not", "for-routers", ClientOnly, Required, Default{1});
 
   std::string output = config.generateINIConfig();
 
   CHECK(output == R"raw([foo]
 
+
 bar=1
 
 #baz=2
@@ -33,6 +33,7 @@ quux=hello
 
 [argle]
 
+
 bar=3
 
 #baz=4
@@ -43,19 +44,18 @@ quux=the quick brown fox
 
 TEST_CASE("ConfigDefinition useValue test", "[config]")
 {
-  llarp::ConfigDefinition config;
+  llarp::ConfigDefinition config{true};
 
-  config.defineOption(std::make_unique<llarp::OptionDefinition<int>>(
-            "foo", "bar", true, 1));
+  config.defineOption<int>("foo", "bar", Required, Default{1});
 
-  constexpr auto expected = "[foo]\n\nbar=1\n";
+  constexpr auto expected = "[foo]\n\n\nbar=1\n";
 
   CHECK(config.generateINIConfig(false) == expected);
   CHECK(config.generateINIConfig(true) == expected);
 
   config.addConfigValue("foo", "bar", "2");
 
-  constexpr auto expectedWhenValueProvided = "[foo]\n\nbar=2\n";
+  constexpr auto expectedWhenValueProvided = "[foo]\n\n\nbar=2\n";
 
   CHECK(config.generateINIConfig(false) == expected);
   CHECK(config.generateINIConfig(true) == expectedWhenValueProvided);
@@ -63,18 +63,19 @@ TEST_CASE("ConfigDefinition useValue test", "[config]")
 
 TEST_CASE("ConfigDefinition section comments test")
 {
-  llarp::ConfigDefinition config;
+  llarp::ConfigDefinition config{true};
 
   config.addSectionComments("foo", {"test comment"});
   config.addSectionComments("foo", {"test comment 2"});
   config.defineOption(std::make_unique<llarp::OptionDefinition<int>>(
-            "foo", "bar", true, 1));
+            "foo", "bar", Required, Default{1}));
 
   std::string output = config.generateINIConfig();
 
-  CHECK(output == R"raw(# test comment
+  CHECK(output == R"raw([foo]
+# test comment
 # test comment 2
-[foo]
+
 
 bar=1
 )raw");
@@ -82,40 +83,70 @@ bar=1
 
 TEST_CASE("ConfigDefinition option comments test")
 {
-  llarp::ConfigDefinition config;
+  llarp::ConfigDefinition config{true};
 
   config.addOptionComments("foo", "bar", {"test comment 1"});
   config.addOptionComments("foo", "bar", {"test comment 2"});
-  config.defineOption(std::make_unique<llarp::OptionDefinition<int>>(
-            "foo", "bar", true, 1));
+  config.defineOption<int>("foo", "bar", Required, Default{1});
+
+  config.defineOption<std::string>("foo", "far", Default{"abc"},
+      Comment{
+        "Fill in the missing values:",
+        "___defg",
+      });
+
+  config.defineOption<int>("client", "omg", ClientOnly, Default{1}, Comment{"hi"});
+  config.defineOption<int>("relay", "ftw", RelayOnly, Default{1}, Comment{"bye"});
+
+  // has comment, so still gets shown.
+  config.defineOption<int>("foo", "old-bar", Hidden, Default{456});
+  config.addOptionComments("foo", "old-bar", {"old bar option"});
+
+  // no comment, should be omitted.
+  config.defineOption<int>("foo", "older-bar", Hidden);
 
   std::string output = config.generateINIConfig();
 
   CHECK(output == R"raw([foo]
 
+
 # test comment 1
 # test comment 2
 bar=1
+
+# Fill in the missing values:
+# ___defg
+#far=abc
+
+# old bar option
+#old-bar=456
+
+
+[relay]
+
+
+# bye
+#ftw=1
 )raw");
 }
 
 TEST_CASE("ConfigDefinition empty comments test")
 {
-  llarp::ConfigDefinition config;
+  llarp::ConfigDefinition config{true};
 
   config.addSectionComments("foo", {"section comment"});
   config.addSectionComments("foo", {""});
 
   config.addOptionComments("foo", "bar", {"option comment"});
   config.addOptionComments("foo", "bar", {""});
-  config.defineOption(std::make_unique<llarp::OptionDefinition<int>>(
-            "foo", "bar", true, 1));
+  config.defineOption<int>("foo", "bar", Required, Default{1});
 
   std::string output = config.generateINIConfig();
 
-  CHECK(output == R"raw(# section comment
+  CHECK(output == R"raw([foo]
+# section comment
 # 
-[foo]
+
 
 # option comment
 # 
@@ -125,22 +156,21 @@ bar=1
 
 TEST_CASE("ConfigDefinition multi option comments")
 {
-  llarp::ConfigDefinition config;
+  llarp::ConfigDefinition config{true};
 
   config.addSectionComments("foo", {"foo section comment"});
 
   config.addOptionComments("foo", "bar", {"foo bar option comment"});
-  config.defineOption(std::make_unique<llarp::OptionDefinition<int>>(
-            "foo", "bar", true, 1));
+  config.defineOption<int>("foo", "bar", Required, Default{1});
 
   config.addOptionComments("foo", "baz", {"foo baz option comment"});
-  config.defineOption(std::make_unique<llarp::OptionDefinition<int>>(
-            "foo", "baz", true, 1));
+  config.defineOption<int>("foo", "baz", Required, Default{1});
 
   std::string output = config.generateINIConfig();
 
-  CHECK(output == R"raw(# foo section comment
-[foo]
+  CHECK(output == R"raw([foo]
+# foo section comment
+
 
 # foo bar option comment
 bar=1
diff --git a/test/exit/test_llarp_exit_context.cpp b/test/exit/test_llarp_exit_context.cpp
index 4cb2bbb2d..ea5c33174 100644
--- a/test/exit/test_llarp_exit_context.cpp
+++ b/test/exit/test_llarp_exit_context.cpp
@@ -18,7 +18,6 @@ make_context()
   conf.network.m_endpointType = "null";
   conf.bootstrap.skipBootstrap = true;
   conf.api.m_enableRPCServer = false;
-  conf.router.m_enablePeerStats = true;
   conf.lokid.whitelistRouters = false;
   conf.router.m_publicAddress = llarp::IpAddress("1.1.1.1");
   // make a fake inbound link