diff --git a/src/bitcoin-util.cpp b/src/bitcoin-util.cpp
index c8f5bc50262e8..ad22ada377899 100644
--- a/src/bitcoin-util.cpp
+++ b/src/bitcoin-util.cpp
@@ -13,7 +13,12 @@
 #include <common/system.h>
 #include <compat/compat.h>
 #include <core_io.h>
+#include <deploymentinfo.h>
+#include <policy/policy.h>
+#include <script/interpreter.h>
 #include <streams.h>
+#include <univalue.h>
+#include <util/check.h>
 #include <util/exception.h>
 #include <util/strencodings.h>
 #include <util/translation.h>
@@ -34,7 +39,15 @@ static void SetupBitcoinUtilArgs(ArgsManager &argsman)
 
     argsman.AddArg("-version", "Print version and exit", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
 
+    // evalscript options
+    argsman.AddArg("-sigversion", "Specify a script sigversion (base, witness_v0, tapscript).", ArgsManager::ALLOW_ANY, OptionsCategory::COMMAND_OPTIONS);
+    argsman.AddArg("-script_flags", "Specify SCRIPT_VERIFY flags.", ArgsManager::ALLOW_ANY, OptionsCategory::COMMAND_OPTIONS);
+    argsman.AddArg("-tx", "The tx (hex encoded)", ArgsManager::ALLOW_ANY, OptionsCategory::COMMAND_OPTIONS);
+    argsman.AddArg("-input", "The index of the input being spent", ArgsManager::ALLOW_ANY, OptionsCategory::COMMAND_OPTIONS);
+    argsman.AddArg("-spent_output", "The spent prevouts (hex encode TxOut, may be specified multiple times).", ArgsManager::ALLOW_ANY, OptionsCategory::COMMAND_OPTIONS);
+
     argsman.AddCommand("grind", "Perform proof of work on hex header string");
+    argsman.AddCommand("evalscript", "Interpret a bitcoin script", {"-sigversion", "-script_flags", "-tx", "-input", "-spent_output"});
 
     SetupChainParamsBaseOptions(argsman);
 }
@@ -146,6 +159,234 @@ static int Grind(const std::vector<std::string>& args, std::string& strPrint)
     return EXIT_SUCCESS;
 }
 
+static UniValue stack2uv(const std::vector<std::vector<unsigned char>>& stack)
+{
+    UniValue result{UniValue::VARR};
+    for (const auto& v : stack) {
+        result.push_back(HexStr(v));
+    }
+    return result;
+}
+
+static std::string sigver2str(SigVersion sigver)
+{
+    switch(sigver) {
+    case SigVersion::BASE: return "base";
+    case SigVersion::WITNESS_V0: return "witness_v0";
+    case SigVersion::TAPROOT: return "taproot";
+    case SigVersion::TAPSCRIPT: return "tapscript";
+    }
+    return "unknown";
+}
+
+static uint32_t parse_verify_flags(const std::string& strFlags)
+{
+    if (strFlags.empty() || strFlags == "MANDATORY") return MANDATORY_SCRIPT_VERIFY_FLAGS;
+    if (strFlags == "STANDARD") return STANDARD_SCRIPT_VERIFY_FLAGS;
+    if (strFlags == "NONE") return 0;
+
+    unsigned int flags = 0;
+    std::vector<std::string> words = util::SplitString(strFlags, ',');
+
+    for (const std::string& word : words)
+    {
+        if (!g_verify_flag_names.count(word)) continue;
+        flags |= g_verify_flag_names.at(word);
+    }
+    return flags;
+}
+
+//! Public key to be used as internal key for dummy Taproot spends.
+static const std::vector<unsigned char> NUMS_H{ParseHex("50929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0")};
+
+namespace {
+/** Dummy signature checker which accepts all signatures. */
+class DummySignatureChecker final : public BaseSignatureChecker
+{
+public:
+    DummySignatureChecker() = default;
+    bool CheckECDSASignature(const std::vector<unsigned char>& sig, const std::vector<unsigned char>& vchPubKey, const CScript& scriptCode, SigVersion sigversion) const override { return sig.size() != 0; }
+    bool CheckSchnorrSignature(Span<const unsigned char> sig, Span<const unsigned char> pubkey, SigVersion sigversion, ScriptExecutionData& execdata, ScriptError* serror) const override { return sig.size() != 0; }
+    bool CheckLockTime(const CScriptNum& nLockTime) const override { return true; }
+    bool CheckSequence(const CScriptNum& nSequence) const override { return true; }
+};
+}
+
+static int EvalScript(const ArgsManager& argsman, const std::vector<std::string>& args, std::string& strPrint)
+{
+    UniValue result{UniValue::VOBJ};
+
+    uint32_t flags{0};
+    PrecomputedTransactionData txdata;
+    ScriptExecutionData execdata;
+
+    std::unique_ptr<const CTransaction> txTo;
+    std::unique_ptr<BaseSignatureChecker> checker;
+
+    SigVersion sigversion = SigVersion::WITNESS_V0;
+
+    if (const auto verstr = argsman.GetArg("-sigversion"); verstr.has_value()) {
+        if (*verstr == "base") {
+            sigversion = SigVersion::BASE;
+        } else if (*verstr == "witness_v0") {
+            sigversion = SigVersion::WITNESS_V0;
+        } else if (*verstr == "tapscript") {
+            sigversion = SigVersion::TAPSCRIPT;
+        } else {
+            strPrint = strprintf("Unknown -sigversion=%s", *verstr);
+            return EXIT_FAILURE;
+        }
+    }
+
+    const auto verifystr = argsman.GetArg("-script_flags");
+    flags = parse_verify_flags(verifystr.value_or(""));
+
+    CScript script{};
+    std::vector<std::vector<unsigned char> > stack{};
+    if (args.size() > 0) {
+        if (IsHex(args[0])) {
+            auto h = ParseHex(args[0]);
+            script = CScript(h.begin(), h.end());
+        } else {
+            script = ParseScript(args[0]);
+        }
+
+        for (size_t i = 1; i < args.size(); ++i) {
+            if (args[i].size() == 0) {
+                stack.push_back({});
+            } else if (IsHex(args[i])) {
+                stack.push_back(ParseHex(args[i]));
+            } else {
+                strPrint = strprintf("Initial stack element not valid hex: %s", args[i]);
+                return EXIT_FAILURE;
+            }
+        }
+    }
+
+    if (const auto txhex = argsman.GetArg("-tx"); txhex.has_value()) {
+        const int input = argsman.GetIntArg("-input", 0);
+        const auto spent_outputs_hex = argsman.GetArgs("-spent_output");
+
+        CMutableTransaction mut_tx;
+        if (!DecodeHexTx(mut_tx, *txhex)) {
+            strPrint = "Could not decode transaction from -tx argument";
+            return EXIT_FAILURE;
+        }
+        txTo = std::make_unique<CTransaction>(mut_tx);
+
+        if (spent_outputs_hex.size() != txTo->vin.size()) {
+            strPrint = "When -tx is specified, must specify exactly one -spent_output for each input";
+            return EXIT_FAILURE;
+        }
+
+        std::vector<CTxOut> spent_outputs;
+        for (const auto& outhex : spent_outputs_hex) {
+            bool ok = false;
+            if (IsHex(outhex)) {
+                CTxOut txout;
+                std::vector<unsigned char> out(ParseHex(outhex));
+                DataStream ss(out);
+                try {
+                    ss >> txout;
+                    if (ss.empty()) {
+                        spent_outputs.push_back(txout);
+                        ok = true;
+                    }
+                } catch (const std::exception&) {
+                    // fall through
+                }
+            }
+            if (!ok) {
+                strPrint = strprintf("Could not parse -spent_output=%s", outhex);
+                return EXIT_FAILURE;
+            }
+        }
+
+        const bool input_in_range = input >= 0 && static_cast<size_t>(input) < spent_outputs.size();
+        CAmount amount = (input_in_range ? spent_outputs.at(input).nValue : 0);
+        txdata.Init(*txTo, std::move(spent_outputs), /*force=*/true);
+        checker = std::make_unique<TransactionSignatureChecker>(txTo.get(), input, amount, txdata, MissingDataBehavior::ASSERT_FAIL);
+
+        if (sigversion == SigVersion::TAPSCRIPT && input >= 0 && input_in_range) {
+            const CTxIn& txin = txTo->vin.at(input);
+            execdata.m_annex_present = false;
+            if (txin.scriptWitness.stack.size() <= 1) {
+                // either key path spend or no witness, so nothing to do here
+            } else {
+                const auto& top = txin.scriptWitness.stack.back();
+                if (top.size() >= 1 && top.at(0) == 0x50) {
+                    execdata.m_annex_hash = (HashWriter{} << top).GetSHA256();
+                    execdata.m_annex_present = true;
+                }
+            }
+            execdata.m_annex_init = true;
+            execdata.m_tapleaf_hash = ComputeTapleafHash(TAPROOT_LEAF_TAPSCRIPT & TAPROOT_LEAF_MASK, script);
+            execdata.m_tapleaf_hash_init = true;
+            execdata.m_validation_weight_left = ::GetSerializeSize(stack) + ::GetSerializeSize(script) + VALIDATION_WEIGHT_OFFSET;
+            execdata.m_validation_weight_left_init = true;
+        }
+    } else {
+        checker = std::make_unique<DummySignatureChecker>();
+    }
+
+    if (sigversion == SigVersion::TAPSCRIPT && !execdata.m_annex_init) {
+        execdata.m_annex_present = false;
+        execdata.m_annex_init = true;
+        execdata.m_tapleaf_hash = uint256::ZERO;
+        execdata.m_tapleaf_hash_init = true;
+        execdata.m_validation_weight_left = ::GetSerializeSize(stack) + ::GetSerializeSize(script) + VALIDATION_WEIGHT_OFFSET;
+        execdata.m_validation_weight_left_init = true;
+    }
+
+    ScriptError serror{};
+
+    UniValue uv_flags{UniValue::VARR};
+    for (const auto& el : GetScriptFlagNames(flags)) {
+        uv_flags.push_back(el);
+    }
+    UniValue uv_script{UniValue::VOBJ};
+    ScriptToUniv(script, uv_script);
+    result.pushKV("script", uv_script);
+    result.pushKV("sigversion", sigver2str(sigversion));
+    result.pushKV("script_flags", uv_flags);
+
+    std::optional<bool> opsuccess_check;
+    if (sigversion == SigVersion::TAPSCRIPT) {
+        opsuccess_check = CheckTapscriptOpSuccess(script, flags, &serror);
+    }
+
+    bool success = (opsuccess_check.has_value() ? *opsuccess_check : EvalScript(stack, script, flags, *Assert(checker), sigversion, execdata, &serror));
+    if (opsuccess_check.has_value()) {
+         result.pushKV("opsuccess_found", true);
+    } else if (success) {
+        if (stack.empty() || !CastToBool(stack.back())) {
+            success = false;
+            serror = SCRIPT_ERR_EVAL_FALSE;
+        } else if (stack.size() > 1) {
+            if (sigversion == SigVersion::WITNESS_V0 || sigversion == SigVersion::TAPSCRIPT) {
+                success = false;
+                serror = SCRIPT_ERR_CLEANSTACK;
+            } else if ((flags & SCRIPT_VERIFY_CLEANSTACK) != 0) {
+                success = false;
+                serror = SCRIPT_ERR_CLEANSTACK;
+            }
+        }
+    }
+
+    result.pushKV("stack-after", stack2uv(stack));
+
+    result.pushKV("sigop-count", (sigversion == SigVersion::TAPSCRIPT ? 0 : script.GetSigOpCount(true)));
+
+    result.pushKV("success", success);
+    if (!success) {
+        result.pushKV("error", ScriptErrorString(serror));
+    }
+
+    strPrint = result.write(2);
+
+    return EXIT_SUCCESS;
+}
+
 MAIN_FUNCTION
 {
     ArgsManager& args = gArgs;
@@ -175,6 +416,8 @@ MAIN_FUNCTION
     try {
         if (cmd->command == "grind") {
             ret = Grind(cmd->args, strPrint);
+        } else if (cmd->command == "evalscript") {
+            ret = EvalScript(args, cmd->args, strPrint);
         } else {
             assert(false); // unknown command should be caught earlier
         }
diff --git a/src/bitcoin-wallet.cpp b/src/bitcoin-wallet.cpp
index 7d030abe97e6a..c44596c5c3072 100644
--- a/src/bitcoin-wallet.cpp
+++ b/src/bitcoin-wallet.cpp
@@ -36,19 +36,19 @@ static void SetupWalletToolArgs(ArgsManager& argsman)
     argsman.AddArg("-version", "Print version and exit", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-datadir=<dir>", "Specify data directory", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
     argsman.AddArg("-wallet=<wallet-name>", "Specify wallet name", ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY, OptionsCategory::OPTIONS);
-    argsman.AddArg("-dumpfile=<file name>", "When used with 'dump', writes out the records to this file. When used with 'createfromdump', loads the records into a new wallet.", ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_NEGATION, OptionsCategory::OPTIONS);
+    argsman.AddArg("-dumpfile=<file name>", "When used with 'dump', writes out the records to this file. When used with 'createfromdump', loads the records into a new wallet.", ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_NEGATION, OptionsCategory::COMMAND_OPTIONS);
     argsman.AddArg("-debug=<category>", "Output debugging information (default: 0).", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
-    argsman.AddArg("-descriptors", "Create descriptors wallet. Only for 'create'", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
-    argsman.AddArg("-legacy", "Create legacy wallet. Only for 'create'", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
-    argsman.AddArg("-format=<format>", "The format of the wallet file to create. Either \"bdb\" or \"sqlite\". Only used with 'createfromdump'", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
+    argsman.AddArg("-descriptors", "Create descriptors wallet.", ArgsManager::ALLOW_ANY, OptionsCategory::COMMAND_OPTIONS);
+    argsman.AddArg("-legacy", "Create legacy wallet.", ArgsManager::ALLOW_ANY, OptionsCategory::COMMAND_OPTIONS);
+    argsman.AddArg("-format=<format>", "The format of the wallet file to create. Either \"bdb\" or \"sqlite\".", ArgsManager::ALLOW_ANY, OptionsCategory::COMMAND_OPTIONS);
     argsman.AddArg("-printtoconsole", "Send trace/debug info to console (default: 1 when no -debug is true, 0 otherwise).", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
     argsman.AddArg("-withinternalbdb", "Use the internal Berkeley DB parser when dumping a Berkeley DB wallet file (default: false)", ArgsManager::ALLOW_ANY, OptionsCategory::DEBUG_TEST);
 
     argsman.AddCommand("info", "Get wallet info");
-    argsman.AddCommand("create", "Create new wallet file");
+    argsman.AddCommand("create", "Create new wallet file", {"-legacy", "-descriptors"});
     argsman.AddCommand("salvage", "Attempt to recover private keys from a corrupt wallet. Warning: 'salvage' is experimental.");
-    argsman.AddCommand("dump", "Print out all of the wallet key-value records");
-    argsman.AddCommand("createfromdump", "Create new wallet file from dumped records");
+    argsman.AddCommand("dump", "Print out all of the wallet key-value records", {"-dumpfile"});
+    argsman.AddCommand("createfromdump", "Create new wallet file from dumped records", {"-dumpfile", "-format"});
 }
 
 static std::optional<int> WalletAppInit(ArgsManager& args, int argc, char* argv[])
diff --git a/src/common/args.cpp b/src/common/args.cpp
index a37a16b62b02f..5ea5b4e25a8ea 100644
--- a/src/common/args.cpp
+++ b/src/common/args.cpp
@@ -358,6 +358,29 @@ std::optional<const ArgsManager::Command> ArgsManager::GetCommand() const
     return ret;
 }
 
+bool ArgsManager::CheckCommandOptions(const std::string& command, std::vector<std::string>* errors) const
+{
+    LOCK(cs_args);
+
+    auto command_options = m_available_args.find(OptionsCategory::COMMAND_OPTIONS);
+    if (command_options == m_available_args.end()) return true;
+
+    const std::set<std::string> dummy;
+    auto command_args = m_command_args.find(command);
+    const std::set<std::string>& valid_opts = (command_args == m_command_args.end() ? dummy : command_args->second);
+
+    bool ok = true;
+    for (const auto& opts : command_options->second) {
+        if (!IsArgSet(opts.first)) continue;
+        if (valid_opts.count(opts.first)) continue;
+        if (errors != nullptr) {
+            errors->emplace_back(strprintf("The %s option cannot be used with the '%s' command.", opts.first, command));
+            ok = false;
+        }
+    }
+    return ok;
+}
+
 std::vector<std::string> ArgsManager::GetArgs(const std::string& strArg) const
 {
     std::vector<std::string> result;
@@ -548,7 +571,7 @@ void ArgsManager::ForceSetArg(const std::string& strArg, const std::string& strV
     m_settings.forced_settings[SettingName(strArg)] = strValue;
 }
 
-void ArgsManager::AddCommand(const std::string& cmd, const std::string& help)
+void ArgsManager::AddCommand(const std::string& cmd, const std::string& help, std::set<std::string>&& options)
 {
     Assert(cmd.find('=') == std::string::npos);
     Assert(cmd.at(0) != '-');
@@ -557,6 +580,9 @@ void ArgsManager::AddCommand(const std::string& cmd, const std::string& help)
     m_accept_any_command = false; // latch to false
     std::map<std::string, Arg>& arg_map = m_available_args[OptionsCategory::COMMANDS];
     auto ret = arg_map.emplace(cmd, Arg{"", help, ArgsManager::COMMAND});
+    if (!options.empty()) {
+        m_command_args.try_emplace(cmd, std::move(options));
+    }
     Assert(ret.second); // Fail on duplicate commands
 }
 
@@ -588,14 +614,46 @@ void ArgsManager::AddHiddenArgs(const std::vector<std::string>& names)
     }
 }
 
+namespace {
+/** Helper class for iterating over COMMAND_OPTIONS applicable to a given command */
+template <typename T>
+class CommandOptionsGetter
+{
+private:
+    const typename T::const_iterator m_end;
+    const typename T::const_iterator m_iter;
+public:
+    CommandOptionsGetter(const T& available_args)
+    : m_end{available_args.end()},
+      m_iter{available_args.find(OptionsCategory::COMMAND_OPTIONS)}
+    {
+    }
+
+    template <typename Fn>
+    void Iterate(const std::set<std::string>& select, bool with_debug, Fn&& fn) const
+    {
+        if (select.empty()) return;
+        if (m_iter == m_end) return;
+        for (const auto& [cmdopt_name, cmdopt_info] : m_iter->second) {
+            if (!with_debug && (cmdopt_info.m_flags & ArgsManager::DEBUG_ONLY)) continue;
+            if (!select.count(cmdopt_name)) continue;
+            fn(cmdopt_name, cmdopt_info);
+        }
+    }
+};
+} // anonymous namespace
+
 std::string ArgsManager::GetHelpMessage() const
 {
     const bool show_debug = GetBoolArg("-help-debug", false);
 
     std::string usage;
     LOCK(cs_args);
-    for (const auto& arg_map : m_available_args) {
-        switch(arg_map.first) {
+
+    const auto command_options = CommandOptionsGetter(m_available_args);
+
+    for (const auto& [category, category_args] : m_available_args) {
+        switch(category) {
             case OptionsCategory::OPTIONS:
                 usage += HelpMessageGroup("Options:");
                 break;
@@ -635,22 +693,29 @@ std::string ArgsManager::GetHelpMessage() const
             case OptionsCategory::REGISTER_COMMANDS:
                 usage += HelpMessageGroup("Register Commands:");
                 break;
+            case OptionsCategory::COMMAND_OPTIONS:
+                break;
             default:
                 break;
         }
 
+        if (category == OptionsCategory::COMMAND_OPTIONS) continue;
+
         // When we get to the hidden options, stop
-        if (arg_map.first == OptionsCategory::HIDDEN) break;
-
-        for (const auto& arg : arg_map.second) {
-            if (show_debug || !(arg.second.m_flags & ArgsManager::DEBUG_ONLY)) {
-                std::string name;
-                if (arg.second.m_help_param.empty()) {
-                    name = arg.first;
-                } else {
-                    name = arg.first + arg.second.m_help_param;
+        if (category == OptionsCategory::HIDDEN) break;
+
+        for (const auto& [arg_name, arg_info] : category_args) {
+            if (show_debug || !(arg_info.m_flags & ArgsManager::DEBUG_ONLY)) {
+                usage += HelpMessageOpt(arg_name, arg_info.m_help_param, arg_info.m_help_text);
+
+                if (category == OptionsCategory::COMMANDS) {
+                    const auto cmd_args = m_command_args.find(arg_name);
+                    if (cmd_args != m_command_args.end()) {
+                        command_options.Iterate(cmd_args->second, show_debug, [&](const auto& cmdopt_name, const auto& cmdopt_info) {
+                            usage += HelpMessageSubOpt(cmdopt_name, cmdopt_info.m_help_param, cmdopt_info.m_help_text);
+                        });
+                    }
                 }
-                usage += HelpMessageOpt(name, arg.second.m_help_text);
             }
         }
     }
@@ -676,10 +741,11 @@ std::string HelpMessageGroup(const std::string &message) {
     return std::string(message) + std::string("\n\n");
 }
 
-std::string HelpMessageOpt(const std::string &option, const std::string &message) {
-    return std::string(optIndent,' ') + std::string(option) +
-           std::string("\n") + std::string(msgIndent,' ') +
-           FormatParagraph(message, screenWidth - msgIndent, msgIndent) +
+std::string HelpMessageOpt(const std::string& option, const std::string& help_param, const std::string &message, int indent)
+{
+    return std::string(optIndent+indent,' ') + option + help_param +
+           std::string("\n") + std::string(msgIndent+indent,' ') +
+           FormatParagraph(message, screenWidth - msgIndent - indent, msgIndent + indent) +
            std::string("\n\n");
 }
 
@@ -695,6 +761,12 @@ bool HasTestOption(const ArgsManager& args, const std::string& test_option)
     });
 }
 
+std::string HelpMessageSubOpt(const std::string& option, const std::string& help_param, const std::string &message)
+{
+
+    return HelpMessageOpt(option, help_param, message, msgIndent - optIndent);
+}
+
 fs::path GetDefaultDataDir()
 {
     // Windows:
diff --git a/src/common/args.h b/src/common/args.h
index 323a86d8dca3b..592c84d79ead6 100644
--- a/src/common/args.h
+++ b/src/common/args.h
@@ -64,6 +64,8 @@ enum class OptionsCategory {
     COMMANDS,
     REGISTER_COMMANDS,
 
+    COMMAND_OPTIONS, // Specific to one or more commands
+
     HIDDEN // Always the last option to avoid printing these in the help
 };
 
@@ -135,6 +137,7 @@ class ArgsManager
     std::string m_network GUARDED_BY(cs_args);
     std::set<std::string> m_network_only_args GUARDED_BY(cs_args);
     std::map<OptionsCategory, std::map<std::string, Arg>> m_available_args GUARDED_BY(cs_args);
+    std::map<std::string, std::set<std::string>> m_command_args GUARDED_BY(cs_args);
     bool m_accept_any_command GUARDED_BY(cs_args){true};
     std::list<SectionInfo> m_config_sections GUARDED_BY(cs_args);
     std::optional<fs::path> m_config_path GUARDED_BY(cs_args);
@@ -210,6 +213,11 @@ class ArgsManager
      */
     std::optional<const Command> GetCommand() const;
 
+    /**
+     * Check for invalid command options
+     */
+    bool CheckCommandOptions(const std::string& command, std::vector<std::string>* errors = nullptr) const;
+
     /**
      * Get blocks directory path
      *
@@ -345,9 +353,9 @@ class ArgsManager
     void AddArg(const std::string& name, const std::string& help, unsigned int flags, const OptionsCategory& cat);
 
     /**
-     * Add subcommand
+     * Add command
      */
-    void AddCommand(const std::string& cmd, const std::string& help);
+    void AddCommand(const std::string& cmd, const std::string& help, std::set<std::string>&& options={});
 
     /**
      * Add many hidden arguments
@@ -463,11 +471,23 @@ std::string HelpMessageGroup(const std::string& message);
 /**
  * Format a string to be used as option description in help messages
  *
- * @param option Option message (e.g. "-rpcuser=<user>")
+ * @param option Option name (e.g. "-rpcuser")
+ * @param help_param Help parameter (e.g. "=<user>" or "")
+ * @param message Option description (e.g. "Username for JSON-RPC connections")
+ * @param indent Additional indentation
+ * @return the formatted string
+ */
+std::string HelpMessageOpt(const std::string& option, const std::string& help_param, const std::string& message, int indent=0);
+
+/**
+ * Same as HelpMessageOpt, but indents for command-specific options
+ *
+ * @param option Option name (e.g. "-rpcuser")
+ * @param help_param Help parameter (e.g. "=<user>" or "")
  * @param message Option description (e.g. "Username for JSON-RPC connections")
  * @return the formatted string
  */
-std::string HelpMessageOpt(const std::string& option, const std::string& message);
+std::string HelpMessageSubOpt(const std::string& option, const std::string& help_param, const std::string& message);
 
 namespace common {
 #ifdef WIN32
diff --git a/src/deploymentinfo.cpp b/src/deploymentinfo.cpp
index 185a7dcb54ce7..71572496eb4af 100644
--- a/src/deploymentinfo.cpp
+++ b/src/deploymentinfo.cpp
@@ -5,6 +5,8 @@
 #include <deploymentinfo.h>
 
 #include <consensus/params.h>
+#include <script/interpreter.h>
+#include <tinyformat.h>
 
 #include <string_view>
 
@@ -52,3 +54,48 @@ std::optional<Consensus::BuriedDeployment> GetBuriedDeployment(const std::string
     }
     return std::nullopt;
 }
+
+#define FLAG_NAME(flag) {std::string(#flag), SCRIPT_VERIFY_##flag}
+const std::map<std::string, uint32_t> g_verify_flag_names{
+    FLAG_NAME(P2SH),
+    FLAG_NAME(STRICTENC),
+    FLAG_NAME(DERSIG),
+    FLAG_NAME(LOW_S),
+    FLAG_NAME(SIGPUSHONLY),
+    FLAG_NAME(MINIMALDATA),
+    FLAG_NAME(NULLDUMMY),
+    FLAG_NAME(DISCOURAGE_UPGRADABLE_NOPS),
+    FLAG_NAME(CLEANSTACK),
+    FLAG_NAME(MINIMALIF),
+    FLAG_NAME(NULLFAIL),
+    FLAG_NAME(CHECKLOCKTIMEVERIFY),
+    FLAG_NAME(CHECKSEQUENCEVERIFY),
+    FLAG_NAME(WITNESS),
+    FLAG_NAME(DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM),
+    FLAG_NAME(WITNESS_PUBKEYTYPE),
+    FLAG_NAME(CONST_SCRIPTCODE),
+    FLAG_NAME(TAPROOT),
+    FLAG_NAME(DISCOURAGE_UPGRADABLE_PUBKEYTYPE),
+    FLAG_NAME(DISCOURAGE_OP_SUCCESS),
+    FLAG_NAME(DISCOURAGE_UPGRADABLE_TAPROOT_VERSION),
+};
+#undef FLAG_NAME
+
+std::vector<std::string> GetScriptFlagNames(uint32_t flags)
+{
+    std::vector<std::string> res;
+    if (flags == SCRIPT_VERIFY_NONE) {
+        return res;
+    }
+    uint32_t leftover = flags;
+    for (const auto& [name, flag] : g_verify_flag_names) {
+        if ((flags & flag) != 0) {
+            res.push_back(name);
+            leftover &= ~flag;
+        }
+    }
+    if (leftover != 0) {
+        res.push_back(strprintf("0x%08x", leftover));
+    }
+    return res;
+}
diff --git a/src/deploymentinfo.h b/src/deploymentinfo.h
index 72ba297ea0b55..35faefcb9d3de 100644
--- a/src/deploymentinfo.h
+++ b/src/deploymentinfo.h
@@ -7,8 +7,12 @@
 
 #include <consensus/params.h>
 
+#include <cassert>
+#include <cstdint>
+#include <map>
 #include <optional>
 #include <string>
+#include <string_view>
 
 struct VBDeploymentInfo {
     /** Deployment name */
@@ -29,4 +33,8 @@ inline std::string DeploymentName(Consensus::DeploymentPos pos)
 
 std::optional<Consensus::BuriedDeployment> GetBuriedDeployment(const std::string_view deployment_name);
 
+extern const std::map<std::string, uint32_t> g_verify_flag_names;
+
+std::vector<std::string> GetScriptFlagNames(uint32_t flags);
+
 #endif // BITCOIN_DEPLOYMENTINFO_H
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 8b8576ab88d83..9400dd1ea0dd1 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -1392,6 +1392,9 @@ RPCHelpMan getdeploymentinfo()
             RPCResult::Type::OBJ, "", "", {
                 {RPCResult::Type::STR, "hash", "requested block hash (or tip)"},
                 {RPCResult::Type::NUM, "height", "requested block height (or tip)"},
+                {RPCResult::Type::ARR, "script_flags", "script verify flags for the block", {
+                    {RPCResult::Type::STR, "flag", "a script verify flag"},
+                }},
                 {RPCResult::Type::OBJ_DYN, "deployments", "", {
                     {RPCResult::Type::OBJ, "xxxx", "name of the deployment", RPCHelpForDeployment}
                 }},
@@ -1418,6 +1421,12 @@ RPCHelpMan getdeploymentinfo()
             UniValue deploymentinfo(UniValue::VOBJ);
             deploymentinfo.pushKV("hash", blockindex->GetBlockHash().ToString());
             deploymentinfo.pushKV("height", blockindex->nHeight);
+            {
+                const auto flagnames = GetScriptFlagNames(GetBlockScriptFlags(*blockindex, chainman));
+                UniValue uv_flagnames(UniValue::VARR);
+                uv_flagnames.push_backV(flagnames.begin(), flagnames.end());
+                deploymentinfo.pushKV("script_flags", uv_flagnames);
+            }
             deploymentinfo.pushKV("deployments", DeploymentInfo(blockindex, chainman));
             return deploymentinfo;
         },
diff --git a/src/script/interpreter.cpp b/src/script/interpreter.cpp
index 9d0e9b5e3cfb2..8335956aacaf6 100644
--- a/src/script/interpreter.cpp
+++ b/src/script/interpreter.cpp
@@ -1785,11 +1785,9 @@ bool GenericTransactionSignatureChecker<T>::CheckSequence(const CScriptNum& nSeq
 template class GenericTransactionSignatureChecker<CTransaction>;
 template class GenericTransactionSignatureChecker<CMutableTransaction>;
 
-static bool ExecuteWitnessScript(const Span<const valtype>& stack_span, const CScript& exec_script, unsigned int flags, SigVersion sigversion, const BaseSignatureChecker& checker, ScriptExecutionData& execdata, ScriptError* serror)
+std::optional<bool> CheckTapscriptOpSuccess(const CScript& exec_script, unsigned int flags, ScriptError* serror)
 {
-    std::vector<valtype> stack{stack_span.begin(), stack_span.end()};
-
-    if (sigversion == SigVersion::TAPSCRIPT) {
+    {
         // OP_SUCCESSx processing overrides everything, including stack element size limits
         CScript::const_iterator pc = exec_script.begin();
         while (pc < exec_script.end()) {
@@ -1806,6 +1804,19 @@ static bool ExecuteWitnessScript(const Span<const valtype>& stack_span, const CS
                 return set_success(serror);
             }
         }
+    }
+
+    return std::nullopt;
+}
+
+static bool ExecuteWitnessScript(const Span<const valtype>& stack_span, const CScript& exec_script, unsigned int flags, SigVersion sigversion, const BaseSignatureChecker& checker, ScriptExecutionData& execdata, ScriptError* serror)
+{
+    std::vector<valtype> stack{stack_span.begin(), stack_span.end()};
+
+    if (sigversion == SigVersion::TAPSCRIPT) {
+
+        auto r = CheckTapscriptOpSuccess(exec_script, flags, serror);
+        if (r.has_value()) return *r;
 
         // Tapscript enforces initial stack size limits (altstack is empty here)
         if (stack.size() > MAX_STACK_SIZE) return set_error(serror, SCRIPT_ERR_STACK_SIZE);
diff --git a/src/script/interpreter.h b/src/script/interpreter.h
index 8ba0018c23ca5..e952c32fa43ec 100644
--- a/src/script/interpreter.h
+++ b/src/script/interpreter.h
@@ -351,4 +351,7 @@ size_t CountWitnessSigOps(const CScript& scriptSig, const CScript& scriptPubKey,
 
 int FindAndDelete(CScript& script, const CScript& b);
 
+bool CastToBool(const std::vector<unsigned char>& vch);
+std::optional<bool> CheckTapscriptOpSuccess(const CScript& exec_script, unsigned int flags, ScriptError* serror);
+
 #endif // BITCOIN_SCRIPT_INTERPRETER_H
diff --git a/src/test/fuzz/script_interpreter.cpp b/src/test/fuzz/script_interpreter.cpp
index 5e76443abe072..1e8aa6be075d7 100644
--- a/src/test/fuzz/script_interpreter.cpp
+++ b/src/test/fuzz/script_interpreter.cpp
@@ -13,8 +13,6 @@
 #include <string>
 #include <vector>
 
-bool CastToBool(const std::vector<unsigned char>& vch);
-
 FUZZ_TARGET(script_interpreter)
 {
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
diff --git a/src/test/fuzz/string.cpp b/src/test/fuzz/string.cpp
index 443d7241b5464..fe048f82c6a39 100644
--- a/src/test/fuzz/string.cpp
+++ b/src/test/fuzz/string.cpp
@@ -68,7 +68,8 @@ FUZZ_TARGET(string)
     (void)HelpExampleCli(random_string_1, random_string_2);
     (void)HelpExampleRpc(random_string_1, random_string_2);
     (void)HelpMessageGroup(random_string_1);
-    (void)HelpMessageOpt(random_string_1, random_string_2);
+    (void)HelpMessageOpt(random_string_1, "", random_string_2);
+    (void)HelpMessageOpt(random_string_1, random_string_2, "");
     (void)IsDeprecatedRPCEnabled(random_string_1);
     (void)Join(random_string_vector, random_string_1);
     (void)JSONRPCError(fuzzed_data_provider.ConsumeIntegral<int>(), random_string_1);
diff --git a/src/test/script_tests.cpp b/src/test/script_tests.cpp
index c5a8f2dfbc510..d629a36994eb6 100644
--- a/src/test/script_tests.cpp
+++ b/src/test/script_tests.cpp
@@ -7,6 +7,7 @@
 
 #include <common/system.h>
 #include <core_io.h>
+#include <deploymentinfo.h>
 #include <key.h>
 #include <rpc/util.h>
 #include <script/script.h>
@@ -22,6 +23,7 @@
 #include <test/util/transaction_utils.h>
 #include <util/fs.h>
 #include <util/strencodings.h>
+#include <util/string.h>
 
 #include <cstdint>
 #include <fstream>
@@ -38,7 +40,6 @@
 static const unsigned int gFlags = SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC;
 
 unsigned int ParseScriptFlags(std::string strFlags);
-std::string FormatScriptFlags(unsigned int flags);
 
 struct ScriptErrorDesc
 {
@@ -92,6 +93,11 @@ static ScriptErrorDesc script_errors[]={
     {SCRIPT_ERR_SIG_FINDANDDELETE, "SIG_FINDANDDELETE"},
 };
 
+std::string FormatScriptFlags(uint32_t flags)
+{
+    return util::Join(GetScriptFlagNames(flags), ",");
+}
+
 static std::string FormatScriptError(ScriptError_t err)
 {
     for (const auto& se : script_errors)
@@ -1708,4 +1714,13 @@ BOOST_AUTO_TEST_CASE(compute_tapleaf)
     BOOST_CHECK_EQUAL(ComputeTapleafHash(0xc2, Span(script)), tlc2);
 }
 
+BOOST_AUTO_TEST_CASE(formatscriptflags)
+{
+    // quick check that FormatScriptFlags reports any unknown/unexpected bits
+    BOOST_CHECK_EQUAL(FormatScriptFlags(SCRIPT_VERIFY_P2SH), "P2SH");
+    BOOST_CHECK_EQUAL(FormatScriptFlags(SCRIPT_VERIFY_P2SH | (1u<<31)), "P2SH,0x80000000");
+    BOOST_CHECK_EQUAL(FormatScriptFlags(SCRIPT_VERIFY_TAPROOT | (1u<<27)), "TAPROOT,0x08000000");
+    BOOST_CHECK_EQUAL(FormatScriptFlags(1u<<26), "0x04000000");
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/transaction_tests.cpp b/src/test/transaction_tests.cpp
index 5622632e97f00..bcb9f1fafea61 100644
--- a/src/test/transaction_tests.cpp
+++ b/src/test/transaction_tests.cpp
@@ -12,6 +12,7 @@
 #include <consensus/tx_check.h>
 #include <consensus/validation.h>
 #include <core_io.h>
+#include <deploymentinfo.h>
 #include <key.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
@@ -47,29 +48,7 @@ typedef std::vector<unsigned char> valtype;
 static CFeeRate g_dust{DUST_RELAY_TX_FEE};
 static bool g_bare_multi{DEFAULT_PERMIT_BAREMULTISIG};
 
-static std::map<std::string, unsigned int> mapFlagNames = {
-    {std::string("P2SH"), (unsigned int)SCRIPT_VERIFY_P2SH},
-    {std::string("STRICTENC"), (unsigned int)SCRIPT_VERIFY_STRICTENC},
-    {std::string("DERSIG"), (unsigned int)SCRIPT_VERIFY_DERSIG},
-    {std::string("LOW_S"), (unsigned int)SCRIPT_VERIFY_LOW_S},
-    {std::string("SIGPUSHONLY"), (unsigned int)SCRIPT_VERIFY_SIGPUSHONLY},
-    {std::string("MINIMALDATA"), (unsigned int)SCRIPT_VERIFY_MINIMALDATA},
-    {std::string("NULLDUMMY"), (unsigned int)SCRIPT_VERIFY_NULLDUMMY},
-    {std::string("DISCOURAGE_UPGRADABLE_NOPS"), (unsigned int)SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS},
-    {std::string("CLEANSTACK"), (unsigned int)SCRIPT_VERIFY_CLEANSTACK},
-    {std::string("MINIMALIF"), (unsigned int)SCRIPT_VERIFY_MINIMALIF},
-    {std::string("NULLFAIL"), (unsigned int)SCRIPT_VERIFY_NULLFAIL},
-    {std::string("CHECKLOCKTIMEVERIFY"), (unsigned int)SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY},
-    {std::string("CHECKSEQUENCEVERIFY"), (unsigned int)SCRIPT_VERIFY_CHECKSEQUENCEVERIFY},
-    {std::string("WITNESS"), (unsigned int)SCRIPT_VERIFY_WITNESS},
-    {std::string("DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM"), (unsigned int)SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM},
-    {std::string("WITNESS_PUBKEYTYPE"), (unsigned int)SCRIPT_VERIFY_WITNESS_PUBKEYTYPE},
-    {std::string("CONST_SCRIPTCODE"), (unsigned int)SCRIPT_VERIFY_CONST_SCRIPTCODE},
-    {std::string("TAPROOT"), (unsigned int)SCRIPT_VERIFY_TAPROOT},
-    {std::string("DISCOURAGE_UPGRADABLE_PUBKEYTYPE"), (unsigned int)SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_PUBKEYTYPE},
-    {std::string("DISCOURAGE_OP_SUCCESS"), (unsigned int)SCRIPT_VERIFY_DISCOURAGE_OP_SUCCESS},
-    {std::string("DISCOURAGE_UPGRADABLE_TAPROOT_VERSION"), (unsigned int)SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_TAPROOT_VERSION},
-};
+static const std::map<std::string, unsigned int>& mapFlagNames = g_verify_flag_names;
 
 unsigned int ParseScriptFlags(std::string strFlags)
 {
@@ -79,9 +58,11 @@ unsigned int ParseScriptFlags(std::string strFlags)
     std::vector<std::string> words = SplitString(strFlags, ',');
     for (const std::string& word : words)
     {
-        if (!mapFlagNames.count(word))
+        if (!mapFlagNames.count(word)) {
             BOOST_ERROR("Bad test: unknown verification flag '" << word << "'");
-        flags |= mapFlagNames[word];
+            continue;
+        }
+        flags |= mapFlagNames.at(word);
     }
     return flags;
 }
@@ -96,22 +77,6 @@ bool CheckMapFlagNames()
     return standard_flags_missing == 0;
 }
 
-std::string FormatScriptFlags(unsigned int flags)
-{
-    if (flags == SCRIPT_VERIFY_NONE) {
-        return "";
-    }
-    std::string ret;
-    std::map<std::string, unsigned int>::const_iterator it = mapFlagNames.begin();
-    while (it != mapFlagNames.end()) {
-        if (flags & it->second) {
-            ret += it->first + ",";
-        }
-        it++;
-    }
-    return ret.substr(0, ret.size() - 1);
-}
-
 /*
 * Check that the input scripts of a transaction are valid/invalid as expected.
 */
diff --git a/src/validation.cpp b/src/validation.cpp
index 59beb5cbdafdd..401a22b46b1b9 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -259,9 +259,6 @@ bool CheckSequenceLocksAtTip(CBlockIndex* tip,
     return EvaluateSequenceLocks(index, {lock_points.height, lock_points.time});
 }
 
-// Returns the script flags which should be checked for a given block
-static unsigned int GetBlockScriptFlags(const CBlockIndex& block_index, const ChainstateManager& chainman);
-
 static void LimitMempoolSize(CTxMemPool& pool, CCoinsViewCache& coins_cache)
     EXCLUSIVE_LOCKS_REQUIRED(::cs_main, pool.cs)
 {
@@ -2358,7 +2355,7 @@ class WarningBitsConditionChecker : public AbstractThresholdConditionChecker
     }
 };
 
-static unsigned int GetBlockScriptFlags(const CBlockIndex& block_index, const ChainstateManager& chainman)
+unsigned int GetBlockScriptFlags(const CBlockIndex& block_index, const ChainstateManager& chainman)
 {
     const Consensus::Params& consensusparams = chainman.GetConsensus();
 
diff --git a/src/validation.h b/src/validation.h
index bc9bacf7cebf8..0933c326841f8 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -1350,4 +1350,7 @@ bool IsBIP30Repeat(const CBlockIndex& block_index);
 /** Identifies blocks which coinbase output was subsequently overwritten in the UTXO set (see BIP30) */
 bool IsBIP30Unspendable(const CBlockIndex& block_index);
 
+// Returns the script flags which should be checked for a given block
+unsigned int GetBlockScriptFlags(const CBlockIndex& block_index, const ChainstateManager& chainman);
+
 #endif // BITCOIN_VALIDATION_H
diff --git a/src/wallet/wallettool.cpp b/src/wallet/wallettool.cpp
index 10785ad3546fe..4dab9fbfb5e4b 100644
--- a/src/wallet/wallettool.cpp
+++ b/src/wallet/wallettool.cpp
@@ -112,21 +112,12 @@ static void WalletShowInfo(CWallet* wallet_instance)
 
 bool ExecuteWalletToolFunc(const ArgsManager& args, const std::string& command)
 {
-    if (args.IsArgSet("-format") && command != "createfromdump") {
-        tfm::format(std::cerr, "The -format option can only be used with the \"createfromdump\" command.\n");
-        return false;
-    }
-    if (args.IsArgSet("-dumpfile") && command != "dump" && command != "createfromdump") {
-        tfm::format(std::cerr, "The -dumpfile option can only be used with the \"dump\" and \"createfromdump\" commands.\n");
-        return false;
-    }
-    if (args.IsArgSet("-descriptors") && command != "create") {
-        tfm::format(std::cerr, "The -descriptors option can only be used with the 'create' command.\n");
-        return false;
-    }
-    if (args.IsArgSet("-legacy") && command != "create") {
-        tfm::format(std::cerr, "The -legacy option can only be used with the 'create' command.\n");
-        return false;
+    {
+        std::vector<std::string> details;
+        if (!args.CheckCommandOptions(command, &details)) {
+            tfm::format(std::cerr, "Error: Invalid arguments provided:\n%s\n", util::MakeUnorderedList(details));
+            return false;
+        }
     }
     if (command == "create" && !args.IsArgSet("-wallet")) {
         tfm::format(std::cerr, "Wallet name must be provided when creating a new wallet.\n");
diff --git a/test/functional/rpc_blockchain.py b/test/functional/rpc_blockchain.py
index 98147237b10b8..84f5eb1991715 100755
--- a/test/functional/rpc_blockchain.py
+++ b/test/functional/rpc_blockchain.py
@@ -197,6 +197,7 @@ def check_signalling_deploymentinfo_result(self, gdi_result, height, blockhash,
         assert_equal(gdi_result, {
           "hash": blockhash,
           "height": height,
+          "script_flags": ["CHECKLOCKTIMEVERIFY","CHECKSEQUENCEVERIFY","DERSIG","NULLDUMMY","P2SH","TAPROOT","WITNESS"],
           "deployments": {
             'bip34': {'type': 'buried', 'active': True, 'height': 2},
             'bip66': {'type': 'buried', 'active': True, 'height': 3},
diff --git a/test/functional/tool_wallet.py b/test/functional/tool_wallet.py
index 784a769882918..719a391a24738 100755
--- a/test/functional/tool_wallet.py
+++ b/test/functional/tool_wallet.py
@@ -356,7 +356,7 @@ def test_dump_createfromdump(self):
         self.assert_raises_tool_error('Dump file {} does not exist.'.format(non_exist_dump), '-wallet=todump', '-dumpfile={}'.format(non_exist_dump), 'createfromdump')
         wallet_path = self.nodes[0].wallets_path / "todump2"
         self.assert_raises_tool_error('Failed to create database path \'{}\'. Database already exists.'.format(wallet_path), '-wallet=todump2', '-dumpfile={}'.format(wallet_dump), 'createfromdump')
-        self.assert_raises_tool_error("The -descriptors option can only be used with the 'create' command.", '-descriptors', '-wallet=todump2', '-dumpfile={}'.format(wallet_dump), 'createfromdump')
+        self.assert_raises_tool_error("Error: Invalid arguments provided:\n- The -descriptors option cannot be used with the 'createfromdump' command.", '-descriptors', '-wallet=todump2', '-dumpfile={}'.format(wallet_dump), 'createfromdump')
 
         self.log.info('Checking createfromdump')
         self.do_tool_createfromdump("load", "wallet.dump")