Index: src/test/util/setup_common.h
<+>UTF-8
===================================================================
diff --git a/src/test/util/setup_common.h b/src/test/util/setup_common.h
--- a/src/test/util/setup_common.h	(revision 5a945600451037693a032e6df94f99a666dd581f)
+++ b/src/test/util/setup_common.h	(date 1727301051076)
@@ -259,10 +259,6 @@
     return v ? os << *v
              : os << "std::nullopt";
 }
-inline std::ostream& operator<<(std::ostream& os, const std::nullopt_t)
-{
-    return os << "std::nullopt";
-}
 } // namespace std
 
 std::ostream& operator<<(std::ostream& os, const arith_uint256& num);
Index: src/common/args.cpp
<+>UTF-8
===================================================================
diff --git a/src/common/args.cpp b/src/common/args.cpp
--- a/src/common/args.cpp	(revision 5a945600451037693a032e6df94f99a666dd581f)
+++ b/src/common/args.cpp	(date 1727300363436)
@@ -56,11 +56,16 @@
  * For a more extensive discussion of this topic (and a wide range of opinions
  * on the Right Way to change this code), see PR12713.
  */
-static bool InterpretBool(const std::string& strValue)
+static bool InterpretBool(std::string_view strValue)
 {
-    if (strValue.empty())
-        return true;
-    return (LocaleIndependentAtoi<int>(strValue) != 0);
+    return strValue.empty() || LocaleIndependentAtoi<int>(strValue);
+}
+
+std::optional<int64_t> TryParseInt64(std::string_view str)
+{
+    int64_t result;
+    if (ParseInt64(str, &result)) return result;
+    return std::nullopt;
 }
 
 static std::string SettingName(const std::string& arg)
@@ -93,6 +98,56 @@
     return result;
 }
 
+std::optional<common::SettingsValue> HandleTypedArg(const KeyInfo& key, std::optional<std::string_view> value,
+                                                    unsigned int flags, std::string& error)
+{
+    if (key.negated) {
+        // If argument is typed, only allow negation with no value or with
+        // literal "1" value. Avoid calling InterpretBool and accepting
+        // other values which could be ambiguous.
+        if (value && value != "1") {
+            error = strprintf("Cannot negate -%s at the same time as setting a value ('%s').", key.name, *value);
+            return std::nullopt;
+        }
+        return false;
+    }
+    if (value) {
+        if (IsStringArg(flags) || value->empty()) return *value;
+        if (IsIntArg(flags)) {
+            if (auto parsed = TryParseInt64(*value)) return *parsed;
+        }
+        if (IsBoolArg(flags)) {
+            if (value == "0") return false;
+            if (value == "1") return true;
+        }
+        error = strprintf("Cannot set -%s value to '%s'.", key.name, *value);
+    } else {
+        if (IsBoolArg(flags)) return true;
+        error = strprintf("Cannot set -%s with no value. Please specify value with -%s=value.", key.name, key.name);
+    }
+
+    auto type_str = IsStringArg(flags) ? "a string" : IsIntArg(flags) ? "an integer" : "0 or 1";
+    error += strprintf(" It must be set to %s.", type_str);
+    return std::nullopt;
+}
+
+std::optional<common::SettingsValue> HandleUntypedArg(const KeyInfo& key, std::optional<std::string_view> value,
+                                                      unsigned int flags, std::string& error)
+{
+    if (key.negated) {
+        // Double negatives like -nofoo=0 are supported (but discouraged)
+        if (value && !InterpretBool(*value)) {
+            LogPrintf("Warning: parsed potentially confusing double-negative -%s=%s\n", key.name, *value);
+            return true;
+        }
+        return false;
+    }
+    if (value) return *value;
+    if (!DisallowElision(flags)) return "";
+    error = strprintf("Cannot set -%s with no value. Please specify value with -%s=value.", key.name, key.name);
+    return std::nullopt;
+}
+
 /**
  * Interpret settings value based on registered flags.
  *
@@ -136,52 +191,18 @@
  * - JSON numbers like `123` are returned for settings like `-setting=123` if
  *   the setting enables integer parsing with the ALLOW_INT flag.
  */
-std::optional<common::SettingsValue> InterpretValue(const KeyInfo& key, const std::string* value,
-                                                  unsigned int flags, std::string& error)
+std::optional<common::SettingsValue> InterpretValue(const KeyInfo& key, std::optional<std::string_view> value,
+                                                    unsigned int flags, std::string& error)
 {
-    // Return negated settings as false values.
-    if (key.negated) {
-        if (flags & ArgsManager::DISALLOW_NEGATION) {
-            error = strprintf("Negating of -%s is meaningless and therefore forbidden", key.name);
-            return std::nullopt;
-        }
-        if (IsTypedArg(flags)) {
-            // If argument is typed, only allow negation with no value or with
-            // literal "1" value. Avoid calling InterpretBool and accepting
-            // other values which could be ambiguous.
-            if (value && *value != "1") {
-                error = strprintf("Cannot negate -%s at the same time as setting a value ('%s').", key.name, *value);
-                return std::nullopt;
-            }
-            return false;
-        }
-        // Double negatives like -nofoo=0 are supported (but discouraged)
-        if (value && !InterpretBool(*value)) {
-            LogPrintf("Warning: parsed potentially confusing double-negative -%s=%s\n", key.name, *value);
-            return true;
-        }
-        return false;
+    // Check for disallowed negation
+    if (key.negated && DisallowNegation(flags)) {
+        error = strprintf("Negating of -%s is meaningless and therefore forbidden", key.name);
+        return std::nullopt;
     }
-    if (value) {
-        int64_t parsed_int;
-        if ((flags & ArgsManager::ALLOW_STRING) || !IsTypedArg(flags) || value->empty()) return *value;
-        if ((flags & ArgsManager::ALLOW_INT) && ParseInt64(*value, &parsed_int)) return parsed_int;
-        if ((flags & ArgsManager::ALLOW_BOOL) && *value == "0") return false;
-        if ((flags & ArgsManager::ALLOW_BOOL) && *value == "1") return true;
-        error = strprintf("Cannot set -%s value to '%s'.", key.name, *value);
-    } else {
-        if (flags & ArgsManager::ALLOW_BOOL) return true;
-        if (!(flags & ArgsManager::DISALLOW_ELISION) && !IsTypedArg(flags)) return "";
-        error = strprintf("Cannot set -%s with no value. Please specify value with -%s=value.", key.name, key.name);
-    }
-    if (flags & ArgsManager::ALLOW_STRING) {
-        error = strprintf("%s %s", error, "It must be set to a string.");
-    } else if (flags & ArgsManager::ALLOW_INT) {
-        error = strprintf("%s %s", error, "It must be set to an integer.");
-    } else if (flags & ArgsManager::ALLOW_BOOL) {
-        error = strprintf("%s %s", error, "It must be set to 0 or 1.");
-    }
-    return std::nullopt;
+
+    return IsTypedArg(flags)
+           ? HandleTypedArg(key, value, flags, error)
+           : HandleUntypedArg(key, value, flags, error);
 }
 
 //! Return string if setting is a nonempty string or number (-setting=abc,
@@ -284,10 +305,10 @@
 #endif
 
         if (key == "-") break; //bitcoin-tx using stdin
-        std::optional<std::string> val;
+        std::optional<std::string_view> val;
         size_t is_index = key.find('=');
         if (is_index != std::string::npos) {
-            val = key.substr(is_index + 1);
+            val = std::string_view{key}.substr(is_index + 1);
             key.erase(is_index);
         }
 #ifdef WIN32
@@ -330,10 +351,11 @@
             return false;
         }
 
-        std::optional<common::SettingsValue> value = InterpretValue(keyinfo, val ? &*val : nullptr, *flags, error);
-        if (!value) return false;
-
-        m_settings.command_line_options[keyinfo.name].push_back(*value);
+        if (auto value = InterpretValue(keyinfo, val, *flags, error)) {
+            m_settings.command_line_options[keyinfo.name].push_back(*value);
+        } else {
+            return false;
+        }
     }
 
     // we do not allow -includeconf from command line, only -noincludeconf
@@ -674,19 +696,19 @@
     }
 
     // Disallow flag combinations that would result in nonsensical behavior or a bad UX.
-    if ((flags & ALLOW_ANY) && (flags & (ALLOW_BOOL | ALLOW_INT | ALLOW_STRING))) {
+    if (IsAnyArg(flags) && IsTypedArg(flags)) {
         throw std::logic_error(strprintf("Bug: bad %s flags. ALLOW_{BOOL|INT|STRING} flags are incompatible with "
                                          "ALLOW_ANY (typed arguments need to be type checked)", arg_name));
     }
-    if ((flags & ALLOW_BOOL) && (flags & DISALLOW_ELISION)) {
+    if (IsBoolArg(flags) && DisallowElision(flags)) {
         throw std::logic_error(strprintf("Bug: bad %s flags. ALLOW_BOOL flag is incompatible with DISALLOW_ELISION "
                                          "(boolean arguments should not require argument values)", arg_name));
     }
-    if ((flags & ALLOW_INT) && (flags & ALLOW_STRING)) {
+    if (IsIntArg(flags) && IsStringArg(flags)) {
         throw std::logic_error(strprintf("Bug: bad %s flags. ALLOW_INT flag is incompatible with ALLOW_STRING "
                                          "(any valid integer is also a valid string)", arg_name));
     }
-    if ((flags & ALLOW_BOOL) && (flags & (ALLOW_INT | ALLOW_STRING))) {
+    if (IsBoolArg(flags) && (IsIntArg(flags) || IsStringArg(flags))) {
         throw std::logic_error(strprintf("Bug: bad %s flags. ALLOW_BOOL flag may not currently be specified with ALLOW_INT or ALLOW_STRING "
                                          "(integer and string argument values cannot currently be omitted)", arg_name));
     }
Index: src/common/config.cpp
<+>UTF-8
===================================================================
diff --git a/src/common/config.cpp b/src/common/config.cpp
--- a/src/common/config.cpp	(revision 5a945600451037693a032e6df94f99a666dd581f)
+++ b/src/common/config.cpp	(date 1727296525414)
@@ -105,11 +105,11 @@
                 error = strprintf("Multiple values specified for -%s in same section of config file.", key.name);
                 return false;
             }
-            std::optional<common::SettingsValue> value = InterpretValue(key, &option.second, *flags, error);
-            if (!value) {
-                return false;
-            }
-            m_settings.ro_config[key.section][key.name].push_back(*value);
+            if (auto value = InterpretValue(key, option.second, *flags, error)) {
+                m_settings.ro_config[key.section][key.name].push_back(*value);
+            } else {
+                return false;
+            }
         } else {
             if (ignore_invalid_keys) {
                 LogPrintf("Ignoring unknown configuration value %s\n", option.first);
Index: src/test/argsman_tests.cpp
<+>UTF-8
===================================================================
diff --git a/src/test/argsman_tests.cpp b/src/test/argsman_tests.cpp
--- a/src/test/argsman_tests.cpp	(revision 5a945600451037693a032e6df94f99a666dd581f)
+++ b/src/test/argsman_tests.cpp	(date 1727301503684)
@@ -232,7 +232,7 @@
     BOOST_CHECK_EXCEPTION(ParseOptions({"-rpcserver=yes"}), std::exception, HasReason{"Cannot set -rpcserver value to 'yes'. It must be set to 0 or 1."});
 
     // Check default dnsseed value is unset.
-    BOOST_CHECK_EQUAL(ParseOptions({}).enable_dns_seed, std::nullopt);
+    BOOST_CHECK(!ParseOptions({}).enable_dns_seed);
     // Check passing -dnsseed makes it true.
     BOOST_CHECK_EQUAL(ParseOptions({"-dnsseed"}).enable_dns_seed, true);
     // Check passing -dnsseed=1 makes it true.
@@ -242,7 +242,7 @@
     // Check passing -dnsseed=0 makes it false.
     BOOST_CHECK_EQUAL(ParseOptions({"-dnsseed=0"}).enable_dns_seed, false);
     // Check adding -dnsseed= sets it back to default.
-    BOOST_CHECK_EQUAL(ParseOptions({"-dnsseed=1", "-dnsseed="}).enable_dns_seed, std::nullopt);
+    BOOST_CHECK(!ParseOptions({"-dnsseed=1", "-dnsseed="}).enable_dns_seed);
     // Check passing invalid value.
     BOOST_CHECK_EXCEPTION(ParseOptions({"-dnsseed=yes"}), std::exception, HasReason{"Cannot set -dnsseed value to 'yes'. It must be set to 0 or 1."});
 
@@ -276,7 +276,7 @@
     // Check default assumevalid value is unset.
     BOOST_CHECK(!ParseOptions({}).assumevalid);
     // Check passing -assumevalid=<hash> makes it set that hash.
-    BOOST_CHECK_EQUAL(ParseOptions({"-assumevalid=0000111122223333444455556666777788889999aaaabbbbccccddddeeeeffff"}).assumevalid.value().ToString(), "0000111122223333444455556666777788889999aaaabbbbccccddddeeeeffff");
+    BOOST_CHECK_EQUAL(ParseOptions({"-assumevalid=0000111122223333444455556666777788889999aaaabbbbccccddddeeeeffff"}).assumevalid, uint256{"0000111122223333444455556666777788889999aaaabbbbccccddddeeeeffff"});
     // Check passing -noassumevalid makes it not assumevalid.
     BOOST_CHECK(!ParseOptions({"-noassumevalid"}).assumevalid);
     // Check adding -assumevalid= sets it back to default.
Index: src/common/args.h
<+>UTF-8
===================================================================
diff --git a/src/common/args.h b/src/common/args.h
--- a/src/common/args.h	(revision 5a945600451037693a032e6df94f99a666dd581f)
+++ b/src/common/args.h	(date 1727300249024)
@@ -77,8 +77,8 @@
 
 KeyInfo InterpretKey(std::string key);
 
-std::optional<common::SettingsValue> InterpretValue(const KeyInfo& key, const std::string* value,
-                                                         unsigned int flags, std::string& error);
+std::optional<common::SettingsValue> InterpretValue(const KeyInfo& key, std::optional<std::string_view> value,
+                                                    unsigned int flags, std::string& error);
 
 struct SectionInfo {
     std::string m_name;
@@ -561,12 +561,16 @@
         const std::map<std::string, std::vector<common::SettingsValue>>& args) const;
 };
 
-//! Whether the type of the argument has been specified and extra validation
-//! rules should apply.
-inline bool IsTypedArg(uint32_t flags)
-{
-    return flags & (ArgsManager::ALLOW_BOOL | ArgsManager::ALLOW_INT |  ArgsManager::ALLOW_STRING);
-}
+//! Whether the type of the argument has been specified and extra validation rules should apply.
+inline bool DisallowNegation(uint32_t flags) { return flags & ArgsManager::DISALLOW_NEGATION; }
+inline bool DisallowElision(uint32_t flags) { return flags & ArgsManager::DISALLOW_ELISION; }
+
+inline bool IsAnyArg(uint32_t flags) { return flags & ArgsManager::ALLOW_ANY; }
+inline bool IsBoolArg(uint32_t flags) { return flags & ArgsManager::ALLOW_BOOL; }
+inline bool IsIntArg(uint32_t flags) { return flags & ArgsManager::ALLOW_INT; }
+inline bool IsStringArg(uint32_t flags) { return flags & ArgsManager::ALLOW_STRING; }
+inline bool IsListArg(uint32_t flags) { return flags & ArgsManager::ALLOW_LIST; }
+inline bool IsTypedArg(uint32_t flags) { return IsBoolArg(flags) || IsIntArg(flags) || IsStringArg(flags); }
 
 extern ArgsManager gArgs;